fix: v2 human command (#3435)

* add/register human command done

* validations

* crypto

* move clientid

* keys

* fix: clientID

* remove v2 package

* tests

* tests running

* revert old code

* instance domain from ctx

* chore: rename zitadel app ids

* comments

* fix: test

internal/command/preparation/command.go

@@ -0,0 +1,80 @@
+package preparation
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore"
+)
+
+// Validation of the input values of the command and if correct returns
+// the function to create commands or if not valid an error
+type Validation func() (CreateCommands, error)
+
+// CreateCommands builds the commands
+// the filter param is an extended version of the eventstore filter method
+// it filters for events including the commands on the current context
+type CreateCommands func(context.Context, FilterToQueryReducer) ([]eventstore.Command, error)
+
+// FilterToQueryReducer is an abstraction of the eventstore method
+type FilterToQueryReducer func(ctx context.Context, queryFactory *eventstore.SearchQueryBuilder) ([]eventstore.Event, error)
+
+var (
+	//ErrNotExecutable is thrown if no command creator was created
+	ErrNotExecutable = errors.ThrowInvalidArgument(nil, "PREPA-pH70n", "Errors.Internal")
+)
+
+// PrepareCommands checks the passed validations and if ok creates the commands
+func PrepareCommands(ctx context.Context, filter FilterToQueryReducer, validations ...Validation) (cmds []eventstore.Command, err error) {
+	commanders, err := validate(validations)
+	if err != nil {
+		return nil, err
+	}
+	return create(ctx, filter, commanders)
+}
+
+func validate(validations []Validation) ([]CreateCommands, error) {
+	creators := make([]CreateCommands, 0, len(validations))
+
+	for _, validate := range validations {
+		cmds, err := validate()
+		if err != nil {
+			return nil, err
+		}
+		creators = append(creators, cmds)
+	}
+
+	if len(creators) == 0 {
+		return nil, ErrNotExecutable
+	}
+	return creators, nil
+}
+
+func create(ctx context.Context, filter FilterToQueryReducer, commanders []CreateCommands) (cmds []eventstore.Command, err error) {
+	for _, command := range commanders {
+		cmd, err := command(ctx, transactionFilter(filter, cmds))
+		if err != nil {
+			return nil, err
+		}
+		cmds = append(cmds, cmd...)
+	}
+
+	return cmds, nil
+}
+
+func transactionFilter(filter FilterToQueryReducer, commands []eventstore.Command) FilterToQueryReducer {
+	return func(ctx context.Context, query *eventstore.SearchQueryBuilder) ([]eventstore.Event, error) {
+		events, err := filter(ctx, query)
+		if err != nil {
+			return nil, err
+		}
+		for _, command := range commands {
+			event := command.(eventstore.Event)
+			if !query.Matches(event, len(events)) {
+				continue
+			}
+			events = append(events, event)
+		}
+		return events, nil
+	}
+}

internal/command/preparation/command_test.go

@@ -0,0 +1,176 @@
+package preparation
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/caos/zitadel/internal/eventstore"
+)
+
+var errTest = errors.New("test")
+
+func Test_validate(t *testing.T) {
+	type args struct {
+		validations []Validation
+	}
+	type want struct {
+		len int
+		err error
+	}
+	tests := []struct {
+		name string
+		args args
+		want want
+	}{
+		{
+			name: "no validations",
+			args: args{},
+			want: want{
+				err: ErrNotExecutable,
+			},
+		},
+		{
+			name: "error in validation",
+			args: args{
+				validations: []Validation{
+					func() (CreateCommands, error) {
+						return nil, errTest
+					},
+				},
+			},
+			want: want{
+				err: errTest,
+			},
+		},
+		{
+			name: "correct",
+			args: args{
+				validations: []Validation{
+					func() (CreateCommands, error) {
+						return func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+							return nil, nil
+						}, nil
+					},
+				},
+			},
+			want: want{
+				len: 1,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := validate(tt.args.validations)
+			if !errors.Is(err, tt.want.err) {
+				t.Errorf("validate() error = %v, wantErr %v", err, tt.want.err)
+				return
+			}
+			if len(got) != tt.want.len {
+				t.Errorf("validate() len = %v, want %v", len(got), tt.want.len)
+			}
+		})
+	}
+}
+
+func Test_create(t *testing.T) {
+	type args struct {
+		commanders []CreateCommands
+	}
+	type want struct {
+		err error
+		len int
+	}
+	tests := []struct {
+		name string
+		args args
+		want want
+	}{
+		{
+			name: "error in command",
+			want: want{
+				err: errTest,
+			},
+			args: args{
+				commanders: []CreateCommands{
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return nil, errTest
+					},
+				},
+			},
+		},
+		{
+			name: "no commands",
+			want: want{},
+			args: args{
+				commanders: []CreateCommands{
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return nil, nil
+					},
+				},
+			},
+		},
+		{
+			name: "multiple commands",
+			want: want{
+				len: 3,
+			},
+			args: args{
+				commanders: []CreateCommands{
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return []eventstore.Command{new(testCommand), new(testCommand)}, nil
+					},
+					func(_ context.Context, _ FilterToQueryReducer) ([]eventstore.Command, error) {
+						return []eventstore.Command{new(testCommand)}, nil
+					},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCmds, err := create(context.Background(), nil, tt.args.commanders)
+			if !errors.Is(err, tt.want.err) {
+				t.Errorf("create() error = %v, wantErr %v", err, tt.want.err)
+				return
+			}
+			if len(gotCmds) != tt.want.len {
+				t.Errorf("create() len = %d, want %d", len(gotCmds), tt.want.len)
+			}
+		})
+	}
+}
+
+func Test_transactionFilter(t *testing.T) {
+	type args struct {
+		filter   FilterToQueryReducer
+		commands []eventstore.Command
+	}
+	tests := []struct {
+		name string
+		args args
+		want FilterToQueryReducer
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := transactionFilter(tt.args.filter, tt.args.commands); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("transactionFilter() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+type testCommand struct {
+	eventstore.BaseEvent
+}
+
+func (c *testCommand) Data() interface{} {
+	return nil
+}
+
+func (c *testCommand) UniqueConstraints() []*eventstore.EventUniqueConstraint {
+	return nil
+}