fix(spooler): correct workers (#508)

* one concurrent task

* disable spooler

* fix: improve concurrency in spooler

* fix: dont block lock

* fix: break if lock failed

* fix: check if handler is working

* fix: worker id

* fix: test

* fix: use limit for spoolers configured in startup.yaml

* fix test

* fix: factory

* fix(key): only reduce if not expired

* fix(searchQueryFactory): check for string-slice in aggregateID

* fix(migrations): combine migrations

* fix: allow saving multiple objects in one request

* fix(eventstore): logging

* fix(eventstore): rethink insert i locks table

* fix: ignore failed tests for the moment

* fix: tuubel

* fix: for tests in io

* fix: ignore tests for io

* fix: rename concurrent tasks to workers

* fix: incomment tests and remove some tests

* fix: refert changes for io

* refactor(eventstore): combine types of sql in one file

* refactor(eventstore): logs, TODO's, tests

* fix(eventstore): sql package

* test(eventstore): add tests for search query factory

* chore: logs

* fix(spooler): optimize lock query
chore(migrations): rename locks.object_type to view_name
chore(migrations): refactor migrations

* test: incomment tests

* fix: rename PrepareSaves to PrepareBulkSave

* chore: go dependencies

* fix(migrations): add id in events table

* refactor(lock): less magic numbers

Co-authored-by: Livio Amstutz <livio.a@gmail.com>

internal/eventstore/models/search_query.go

@@ -1,90 +1,191 @@
 package models
 
 import (
+	"github.com/caos/logging"
 	"github.com/caos/zitadel/internal/errors"
 )
 
-type SearchQuery struct {
+type SearchQueryFactory struct {
+	columns        Columns
+	limit          uint64
+	desc           bool
+	aggregateTypes []AggregateType
+	aggregateIDs   []string
+	eventSequence  uint64
+	eventTypes     []EventType
+	resourceOwner  string
+}
+
+type searchQuery struct {
+	Columns Columns
 	Limit   uint64
 	Desc    bool
 	Filters []*Filter
 }
 
-func NewSearchQuery() *SearchQuery {
-	return &SearchQuery{
-		Filters: make([]*Filter, 0, 4),
+type Columns int32
+
+const (
+	Columns_Event = iota
+	Columns_Max_Sequence
+	//insert new columns-types before this columnsCount because count is needed for validation
+	columnsCount
+)
+
+//FactoryFromSearchQuery is deprecated because it's for migration purposes. use NewSearchQueryFactory
+func FactoryFromSearchQuery(query *SearchQuery) *SearchQueryFactory {
+	factory := &SearchQueryFactory{
+		columns: Columns_Event,
+		desc:    query.Desc,
+		limit:   query.Limit,
+	}
+
+	for _, filter := range query.Filters {
+		switch filter.field {
+		case Field_AggregateType:
+			factory = factory.aggregateTypesMig(filter.value.([]AggregateType)...)
+		case Field_AggregateID:
+			if aggregateID, ok := filter.value.(string); ok {
+				factory = factory.AggregateIDs(aggregateID)
+			} else if aggregateIDs, ok := filter.value.([]string); ok {
+				factory = factory.AggregateIDs(aggregateIDs...)
+			}
+		case Field_LatestSequence:
+			factory = factory.SequenceGreater(filter.value.(uint64))
+		case Field_ResourceOwner:
+			factory = factory.ResourceOwner(filter.value.(string))
+		case Field_EventType:
+			factory = factory.EventTypes(filter.value.([]EventType)...)
+		case Field_EditorService, Field_EditorUser:
+			logging.Log("MODEL-Mr0VN").WithField("value", filter.value).Panic("field not converted to factory")
+
+		}
+	}
+
+	return factory
+}
+
+func NewSearchQueryFactory(aggregateTypes ...AggregateType) *SearchQueryFactory {
+	return &SearchQueryFactory{
+		aggregateTypes: aggregateTypes,
 	}
 }
 
-func (q *SearchQuery) SetLimit(limit uint64) *SearchQuery {
-	q.Limit = limit
-	return q
+func (factory *SearchQueryFactory) Columns(columns Columns) *SearchQueryFactory {
+	factory.columns = columns
+	return factory
 }
 
-func (q *SearchQuery) OrderDesc() *SearchQuery {
-	q.Desc = true
-	return q
+func (factory *SearchQueryFactory) Limit(limit uint64) *SearchQueryFactory {
+	factory.limit = limit
+	return factory
 }
 
-func (q *SearchQuery) OrderAsc() *SearchQuery {
-	q.Desc = false
-	return q
+func (factory *SearchQueryFactory) SequenceGreater(sequence uint64) *SearchQueryFactory {
+	factory.eventSequence = sequence
+	return factory
 }
 
-func (q *SearchQuery) AggregateIDFilter(id string) *SearchQuery {
-	return q.setFilter(NewFilter(Field_AggregateID, id, Operation_Equals))
+func (factory *SearchQueryFactory) AggregateIDs(ids ...string) *SearchQueryFactory {
+	factory.aggregateIDs = ids
+	return factory
 }
 
-func (q *SearchQuery) AggregateIDsFilter(ids ...string) *SearchQuery {
-	return q.setFilter(NewFilter(Field_AggregateID, ids, Operation_In))
+func (factory *SearchQueryFactory) aggregateTypesMig(types ...AggregateType) *SearchQueryFactory {
+	factory.aggregateTypes = types
+	return factory
 }
 
-func (q *SearchQuery) AggregateTypeFilter(types ...AggregateType) *SearchQuery {
-	return q.setFilter(NewFilter(Field_AggregateType, types, Operation_In))
+func (factory *SearchQueryFactory) EventTypes(types ...EventType) *SearchQueryFactory {
+	factory.eventTypes = types
+	return factory
 }
 
-func (q *SearchQuery) EventTypesFilter(types ...EventType) *SearchQuery {
-	return q.setFilter(NewFilter(Field_EventType, types, Operation_In))
+func (factory *SearchQueryFactory) ResourceOwner(resourceOwner string) *SearchQueryFactory {
+	factory.resourceOwner = resourceOwner
+	return factory
 }
 
-func (q *SearchQuery) LatestSequenceFilter(sequence uint64) *SearchQuery {
-	if sequence == 0 {
-		return q
+func (factory *SearchQueryFactory) OrderDesc() *SearchQueryFactory {
+	factory.desc = true
+	return factory
+}
+
+func (factory *SearchQueryFactory) OrderAsc() *SearchQueryFactory {
+	factory.desc = false
+	return factory
+}
+
+func (factory *SearchQueryFactory) Build() (*searchQuery, error) {
+	if factory == nil ||
+		len(factory.aggregateTypes) < 1 ||
+		(factory.columns < 0 || factory.columns >= columnsCount) {
+		return nil, errors.ThrowPreconditionFailed(nil, "MODEL-tGAD3", "factory invalid")
+	}
+	filters := []*Filter{
+		factory.aggregateTypeFilter(),
+	}
+
+	for _, f := range []func() *Filter{
+		factory.aggregateIDFilter,
+		factory.eventSequenceFilter,
+		factory.eventTypeFilter,
+		factory.resourceOwnerFilter,
+	} {
+		if filter := f(); filter != nil {
+			filters = append(filters, filter)
+		}
+	}
+
+	return &searchQuery{
+		Columns: factory.columns,
+		Limit:   factory.limit,
+		Desc:    factory.desc,
+		Filters: filters,
+	}, nil
+}
+
+func (factory *SearchQueryFactory) aggregateIDFilter() *Filter {
+	if len(factory.aggregateIDs) < 1 {
+		return nil
+	}
+	if len(factory.aggregateIDs) == 1 {
+		return NewFilter(Field_AggregateID, factory.aggregateIDs[0], Operation_Equals)
+	}
+	return NewFilter(Field_AggregateID, factory.aggregateIDs, Operation_In)
+}
+
+func (factory *SearchQueryFactory) eventTypeFilter() *Filter {
+	if len(factory.eventTypes) < 1 {
+		return nil
+	}
+	if len(factory.eventTypes) == 1 {
+		return NewFilter(Field_EventType, factory.eventTypes[0], Operation_Equals)
+	}
+	return NewFilter(Field_EventType, factory.eventTypes, Operation_In)
+}
+
+func (factory *SearchQueryFactory) aggregateTypeFilter() *Filter {
+	if len(factory.aggregateTypes) == 1 {
+		return NewFilter(Field_AggregateType, factory.aggregateTypes[0], Operation_Equals)
+	}
+	return NewFilter(Field_AggregateType, factory.aggregateTypes, Operation_In)
+}
+
+func (factory *SearchQueryFactory) eventSequenceFilter() *Filter {
+	if factory.eventSequence == 0 {
+		return nil
 	}
 	sortOrder := Operation_Greater
-	if q.Desc {
+	if factory.desc {
 		sortOrder = Operation_Less
 	}
-	return q.setFilter(NewFilter(Field_LatestSequence, sequence, sortOrder))
+	return NewFilter(Field_LatestSequence, factory.eventSequence, sortOrder)
 }
 
-func (q *SearchQuery) ResourceOwnerFilter(resourceOwner string) *SearchQuery {
-	return q.setFilter(NewFilter(Field_ResourceOwner, resourceOwner, Operation_Equals))
-}
-
-func (q *SearchQuery) setFilter(filter *Filter) *SearchQuery {
-	for i, f := range q.Filters {
-		if f.field == filter.field {
-			q.Filters[i] = filter
-			return q
-		}
-	}
-	q.Filters = append(q.Filters, filter)
-	return q
-}
-
-func (q *SearchQuery) Validate() error {
-	if q == nil {
-		return errors.ThrowPreconditionFailed(nil, "MODEL-J5xQi", "search query is nil")
-	}
-	if len(q.Filters) == 0 {
-		return errors.ThrowPreconditionFailed(nil, "MODEL-pF3DR", "no filters set")
-	}
-	for _, filter := range q.Filters {
-		if err := filter.Validate(); err != nil {
-			return err
-		}
-	}
-
-	return nil
+func (factory *SearchQueryFactory) resourceOwnerFilter() *Filter {
+	if factory.resourceOwner == "" {
+		return nil
+	}
+	return NewFilter(Field_ResourceOwner, factory.resourceOwner, Operation_Equals)
 }

internal/eventstore/models/search_query_old.go

@@ -0,0 +1,90 @@
+package models
+
+import "github.com/caos/zitadel/internal/errors"
+
+//SearchQuery is deprecated. Use SearchQueryFactory
+type SearchQuery struct {
+	Limit   uint64
+	Desc    bool
+	Filters []*Filter
+}
+
+//NewSearchQuery is deprecated. Use SearchQueryFactory
+func NewSearchQuery() *SearchQuery {
+	return &SearchQuery{
+		Filters: make([]*Filter, 0, 4),
+	}
+}
+
+func (q *SearchQuery) SetLimit(limit uint64) *SearchQuery {
+	q.Limit = limit
+	return q
+}
+
+func (q *SearchQuery) OrderDesc() *SearchQuery {
+	q.Desc = true
+	return q
+}
+
+func (q *SearchQuery) OrderAsc() *SearchQuery {
+	q.Desc = false
+	return q
+}
+
+func (q *SearchQuery) AggregateIDFilter(id string) *SearchQuery {
+	return q.setFilter(NewFilter(Field_AggregateID, id, Operation_Equals))
+}
+
+func (q *SearchQuery) AggregateIDsFilter(ids ...string) *SearchQuery {
+	return q.setFilter(NewFilter(Field_AggregateID, ids, Operation_In))
+}
+
+func (q *SearchQuery) AggregateTypeFilter(types ...AggregateType) *SearchQuery {
+	return q.setFilter(NewFilter(Field_AggregateType, types, Operation_In))
+}
+
+func (q *SearchQuery) EventTypesFilter(types ...EventType) *SearchQuery {
+	return q.setFilter(NewFilter(Field_EventType, types, Operation_In))
+}
+
+func (q *SearchQuery) LatestSequenceFilter(sequence uint64) *SearchQuery {
+	if sequence == 0 {
+		return q
+	}
+	sortOrder := Operation_Greater
+	if q.Desc {
+		sortOrder = Operation_Less
+	}
+	return q.setFilter(NewFilter(Field_LatestSequence, sequence, sortOrder))
+}
+
+func (q *SearchQuery) ResourceOwnerFilter(resourceOwner string) *SearchQuery {
+	return q.setFilter(NewFilter(Field_ResourceOwner, resourceOwner, Operation_Equals))
+}
+
+func (q *SearchQuery) setFilter(filter *Filter) *SearchQuery {
+	for i, f := range q.Filters {
+		if f.field == filter.field {
+			q.Filters[i] = filter
+			return q
+		}
+	}
+	q.Filters = append(q.Filters, filter)
+	return q
+}
+
+func (q *SearchQuery) Validate() error {
+	if q == nil {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-J5xQi", "search query is nil")
+	}
+	if len(q.Filters) == 0 {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-pF3DR", "no filters set")
+	}
+	for _, filter := range q.Filters {
+		if err := filter.Validate(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/eventstore/models/search_query_old_test.go

@@ -0,0 +1,65 @@
+package models
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSearchQuery_setFilter(t *testing.T) {
+	type fields struct {
+		query *SearchQuery
+	}
+	type args struct {
+		filters []*Filter
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   *SearchQuery
+	}{
+		{
+			name:   "set idFilter",
+			fields: fields{query: NewSearchQuery()},
+			args: args{filters: []*Filter{
+				{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
+			}},
+			want: &SearchQuery{Filters: []*Filter{
+				{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
+			}},
+		},
+		{
+			name:   "overwrite idFilter",
+			fields: fields{query: NewSearchQuery()},
+			args: args{filters: []*Filter{
+				{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
+				{field: Field_AggregateID, operation: Operation_Equals, value: "ursli"},
+			}},
+			want: &SearchQuery{Filters: []*Filter{
+				{field: Field_AggregateID, operation: Operation_Equals, value: "ursli"},
+			}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.fields.query
+			for _, filter := range tt.args.filters {
+				got = got.setFilter(filter)
+			}
+			for _, wantFilter := range tt.want.Filters {
+				found := false
+				for _, gotFilter := range got.Filters {
+					if gotFilter.field == wantFilter.field {
+						found = true
+						if !reflect.DeepEqual(wantFilter, gotFilter) {
+							t.Errorf("filter not as expected: want: %v got %v", wantFilter, gotFilter)
+						}
+					}
+				}
+				if !found {
+					t.Errorf("filter field %v not found", wantFilter.field)
+				}
+			}
+		})
+	}
+}

internal/eventstore/models/search_query_test.go

@@ -3,62 +3,462 @@ package models
 import (
 	"reflect"
 	"testing"
+
+	"github.com/caos/zitadel/internal/errors"
 )
 
-func TestSearchQuery_setFilter(t *testing.T) {
-	type fields struct {
-		query *SearchQuery
+func testSetColumns(columns Columns) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		factory = factory.Columns(columns)
+		return factory
 	}
+}
+
+func testSetLimit(limit uint64) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		factory = factory.Limit(limit)
+		return factory
+	}
+}
+
+func testSetSequence(sequence uint64) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		factory = factory.SequenceGreater(sequence)
+		return factory
+	}
+}
+
+func testSetAggregateIDs(aggregateIDs ...string) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		factory = factory.AggregateIDs(aggregateIDs...)
+		return factory
+	}
+}
+
+func testSetEventTypes(eventTypes ...EventType) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		factory = factory.EventTypes(eventTypes...)
+		return factory
+	}
+}
+
+func testSetResourceOwner(resourceOwner string) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		factory = factory.ResourceOwner(resourceOwner)
+		return factory
+	}
+}
+
+func testSetSortOrder(asc bool) func(factory *SearchQueryFactory) *SearchQueryFactory {
+	return func(factory *SearchQueryFactory) *SearchQueryFactory {
+		if asc {
+			factory = factory.OrderAsc()
+		} else {
+			factory = factory.OrderDesc()
+		}
+		return factory
+	}
+}
+
+func TestSearchQueryFactorySetters(t *testing.T) {
 	type args struct {
-		filters []*Filter
+		aggregateTypes []AggregateType
+		setters        []func(*SearchQueryFactory) *SearchQueryFactory
 	}
 	tests := []struct {
-		name   string
-		fields fields
-		args   args
-		want   *SearchQuery
+		name string
+		args args
+		res  *SearchQueryFactory
 	}{
 		{
-			name:   "set idFilter",
-			fields: fields{query: NewSearchQuery()},
-			args: args{filters: []*Filter{
-				{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
-			}},
-			want: &SearchQuery{Filters: []*Filter{
-				{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
-			}},
+			name: "New factory",
+			args: args{
+				aggregateTypes: []AggregateType{"user", "org"},
+			},
+			res: &SearchQueryFactory{
+				aggregateTypes: []AggregateType{"user", "org"},
+			},
 		},
 		{
-			name:   "overwrite idFilter",
-			fields: fields{query: NewSearchQuery()},
-			args: args{filters: []*Filter{
-				{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
-				{field: Field_AggregateID, operation: Operation_Equals, value: "ursli"},
-			}},
-			want: &SearchQuery{Filters: []*Filter{
-				{field: Field_AggregateID, operation: Operation_Equals, value: "ursli"},
-			}},
+			name: "set columns",
+			args: args{
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetColumns(Columns_Max_Sequence)},
+			},
+			res: &SearchQueryFactory{
+				columns: Columns_Max_Sequence,
+			},
+		},
+		{
+			name: "set limit",
+			args: args{
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetLimit(100)},
+			},
+			res: &SearchQueryFactory{
+				limit: 100,
+			},
+		},
+		{
+			name: "set sequence",
+			args: args{
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetSequence(90)},
+			},
+			res: &SearchQueryFactory{
+				eventSequence: 90,
+			},
+		},
+		{
+			name: "set aggregateIDs",
+			args: args{
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetAggregateIDs("1235", "09824")},
+			},
+			res: &SearchQueryFactory{
+				aggregateIDs: []string{"1235", "09824"},
+			},
+		},
+		{
+			name: "set eventTypes",
+			args: args{
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetEventTypes("user.created", "user.updated")},
+			},
+			res: &SearchQueryFactory{
+				eventTypes: []EventType{"user.created", "user.updated"},
+			},
+		},
+		{
+			name: "set resource owner",
+			args: args{
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetResourceOwner("hodor")},
+			},
+			res: &SearchQueryFactory{
+				resourceOwner: "hodor",
+			},
+		},
+		{
+			name: "default search query",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters:        []func(*SearchQueryFactory) *SearchQueryFactory{testSetAggregateIDs("1235", "024"), testSetSortOrder(false)},
+			},
+			res: &SearchQueryFactory{
+				aggregateTypes: []AggregateType{"user"},
+				aggregateIDs:   []string{"1235", "024"},
+				desc:           true,
+			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := tt.fields.query
-			for _, filter := range tt.args.filters {
-				got = got.setFilter(filter)
+			factory := NewSearchQueryFactory(tt.args.aggregateTypes...)
+			for _, setter := range tt.args.setters {
+				factory = setter(factory)
 			}
-			for _, wantFilter := range tt.want.Filters {
-				found := false
-				for _, gotFilter := range got.Filters {
-					if gotFilter.field == wantFilter.field {
-						found = true
-						if !reflect.DeepEqual(wantFilter, gotFilter) {
-							t.Errorf("filter not as expected: want: %v got %v", wantFilter, gotFilter)
-						}
-					}
-				}
-				if !found {
-					t.Errorf("filter field %v not found", wantFilter.field)
-				}
+			if !reflect.DeepEqual(factory, tt.res) {
+				t.Errorf("NewSearchQueryFactory() = %v, want %v", factory, tt.res)
+			}
+		})
+	}
+}
+
+func TestSearchQueryFactoryBuild(t *testing.T) {
+	type args struct {
+		aggregateTypes []AggregateType
+		setters        []func(*SearchQueryFactory) *SearchQueryFactory
+	}
+	type res struct {
+		isErr func(err error) bool
+		query *searchQuery
+	}
+	tests := []struct {
+		name string
+		args args
+		res  res
+	}{
+		{
+			name: "no aggregate types",
+			args: args{
+				aggregateTypes: []AggregateType{},
+				setters:        []func(*SearchQueryFactory) *SearchQueryFactory{},
+			},
+			res: res{
+				isErr: errors.IsPreconditionFailed,
+				query: nil,
+			},
+		},
+		{
+			name: "invalid column (too low)",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetColumns(Columns(-1)),
+				},
+			},
+			res: res{
+				isErr: errors.IsPreconditionFailed,
+			},
+		},
+		{
+			name: "invalid column (too high)",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetColumns(columnsCount),
+				},
+			},
+			res: res{
+				isErr: errors.IsPreconditionFailed,
+			},
+		},
+		{
+			name: "filter aggregate type",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters:        []func(*SearchQueryFactory) *SearchQueryFactory{},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate types",
+			args: args{
+				aggregateTypes: []AggregateType{"user", "org"},
+				setters:        []func(*SearchQueryFactory) *SearchQueryFactory{},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, []AggregateType{"user", "org"}, Operation_In),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type, limit, desc",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetLimit(5),
+					testSetSortOrder(false),
+					testSetSequence(100),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    true,
+					Limit:   5,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_LatestSequence, uint64(100), Operation_Less),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type, limit, asc",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetLimit(5),
+					testSetSortOrder(true),
+					testSetSequence(100),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   5,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_LatestSequence, uint64(100), Operation_Greater),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type, limit, desc, max event sequence cols",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetLimit(5),
+					testSetSortOrder(false),
+					testSetSequence(100),
+					testSetColumns(Columns_Max_Sequence),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: Columns_Max_Sequence,
+					Desc:    true,
+					Limit:   5,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_LatestSequence, uint64(100), Operation_Less),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type and aggregate id",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetAggregateIDs("1234"),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_AggregateID, "1234", Operation_Equals),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type and aggregate ids",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetAggregateIDs("1234", "0815"),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_AggregateID, []string{"1234", "0815"}, Operation_In),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type and sequence greater",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetSequence(8),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_LatestSequence, uint64(8), Operation_Greater),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type and event type",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetEventTypes("user.created"),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_EventType, EventType("user.created"), Operation_Equals),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type and event types",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetEventTypes("user.created", "user.changed"),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_EventType, []EventType{"user.created", "user.changed"}, Operation_In),
+					},
+				},
+			},
+		},
+		{
+			name: "filter aggregate type resource owner",
+			args: args{
+				aggregateTypes: []AggregateType{"user"},
+				setters: []func(*SearchQueryFactory) *SearchQueryFactory{
+					testSetResourceOwner("hodor"),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &searchQuery{
+					Columns: 0,
+					Desc:    false,
+					Limit:   0,
+					Filters: []*Filter{
+						NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
+						NewFilter(Field_ResourceOwner, "hodor", Operation_Equals),
+					},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			factory := NewSearchQueryFactory(tt.args.aggregateTypes...)
+			for _, f := range tt.args.setters {
+				factory = f(factory)
+			}
+			query, err := factory.Build()
+			if tt.res.isErr != nil && !tt.res.isErr(err) {
+				t.Errorf("wrong error: %v", err)
+				return
+			}
+			if err != nil && tt.res.isErr == nil {
+				t.Errorf("no error expected: %v", err)
+				return
+			}
+
+			if !reflect.DeepEqual(query, tt.res.query) {
+				t.Errorf("NewSearchQueryFactory() = %v, want %v", factory, tt.res)
 			}
 		})
 	}