fix(eventstore): sub queries (#1805)

* sub queries

* fix: tests

* add builder to tests

* new search query

* rename searchquerybuilder to builder

* remove comment from code

* test with multiple queries

* add filters test

* fix(contibute): listing

* add validate module

* fix: search queries

* remove unused event type in query

* ignore query if error in marshal

* go mod tidy

* update privacy policy query

* update queries

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

internal/eventstore/search_query_test.go

@@ -9,6 +9,16 @@ import (
 	"github.com/caos/zitadel/internal/eventstore/repository"
 )
 
+func testAddQuery(queryFuncs ...func(*SearchQuery) *SearchQuery) func(*SearchQueryBuilder) *SearchQueryBuilder {
+	return func(builder *SearchQueryBuilder) *SearchQueryBuilder {
+		query := builder.AddQuery()
+		for _, queryFunc := range queryFuncs {
+			queryFunc(query)
+		}
+		return query.Builder()
+	}
+}
+
 func testSetColumns(columns Columns) func(factory *SearchQueryBuilder) *SearchQueryBuilder {
 	return func(factory *SearchQueryBuilder) *SearchQueryBuilder {
 		factory = factory.Columns(columns)
@@ -23,50 +33,66 @@ func testSetLimit(limit uint64) func(factory *SearchQueryBuilder) *SearchQueryBu
 	}
 }
 
-func testSetSequence(sequence uint64) func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-	return func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-		factory = factory.SequenceGreater(sequence)
-		return factory
-	}
-}
-
-func testSetAggregateIDs(aggregateIDs ...string) func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-	return func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-		factory = factory.AggregateIDs(aggregateIDs...)
-		return factory
-	}
-}
-
-func testSetEventTypes(eventTypes ...EventType) func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-	return func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-		factory = factory.EventTypes(eventTypes...)
-		return factory
-	}
-}
-
-func testSetResourceOwner(resourceOwner string) func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-	return func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-		factory = factory.ResourceOwner(resourceOwner)
-		return factory
-	}
-}
-
-func testSetSortOrder(asc bool) func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-	return func(factory *SearchQueryBuilder) *SearchQueryBuilder {
-		if asc {
-			factory = factory.OrderAsc()
-		} else {
-			factory = factory.OrderDesc()
+func testOr(queryFuncs ...func(*SearchQuery) *SearchQuery) func(*SearchQuery) *SearchQuery {
+	return func(query *SearchQuery) *SearchQuery {
+		subQuery := query.Or()
+		for _, queryFunc := range queryFuncs {
+			queryFunc(subQuery)
 		}
-		return factory
+		return subQuery
+	}
+}
+
+func testSetAggregateTypes(types ...AggregateType) func(*SearchQuery) *SearchQuery {
+	return func(query *SearchQuery) *SearchQuery {
+		query = query.AggregateTypes(types...)
+		return query
+	}
+}
+
+func testSetSequence(sequence uint64) func(*SearchQuery) *SearchQuery {
+	return func(query *SearchQuery) *SearchQuery {
+		query = query.SequenceGreater(sequence)
+		return query
+	}
+}
+
+func testSetAggregateIDs(aggregateIDs ...string) func(*SearchQuery) *SearchQuery {
+	return func(query *SearchQuery) *SearchQuery {
+		query = query.AggregateIDs(aggregateIDs...)
+		return query
+	}
+}
+
+func testSetEventTypes(eventTypes ...EventType) func(*SearchQuery) *SearchQuery {
+	return func(query *SearchQuery) *SearchQuery {
+		query = query.EventTypes(eventTypes...)
+		return query
+	}
+}
+
+func testSetResourceOwner(resourceOwner string) func(*SearchQueryBuilder) *SearchQueryBuilder {
+	return func(builder *SearchQueryBuilder) *SearchQueryBuilder {
+		builder = builder.ResourceOwner(resourceOwner)
+		return builder
+	}
+}
+
+func testSetSortOrder(asc bool) func(*SearchQueryBuilder) *SearchQueryBuilder {
+	return func(query *SearchQueryBuilder) *SearchQueryBuilder {
+		if asc {
+			query = query.OrderAsc()
+		} else {
+			query = query.OrderDesc()
+		}
+		return query
 	}
 }
 
 func TestSearchQueryFactorySetters(t *testing.T) {
 	type args struct {
-		columns        Columns
-		aggregateTypes []AggregateType
-		setters        []func(*SearchQueryBuilder) *SearchQueryBuilder
+		columns Columns
+		setters []func(*SearchQueryBuilder) *SearchQueryBuilder
 	}
 	tests := []struct {
 		name string
@@ -76,12 +102,10 @@ func TestSearchQueryFactorySetters(t *testing.T) {
 		{
 			name: "New factory",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user", "org"},
+				columns: ColumnsEvent,
 			},
 			res: &SearchQueryBuilder{
-				columns:        repository.Columns(ColumnsEvent),
-				aggregateTypes: []AggregateType{"user", "org"},
+				columns: repository.Columns(ColumnsEvent),
 			},
 		},
 		{
@@ -105,28 +129,40 @@ func TestSearchQueryFactorySetters(t *testing.T) {
 		{
 			name: "set sequence",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testSetSequence(90)},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetSequence(90))},
 			},
 			res: &SearchQueryBuilder{
-				eventSequence: 90,
+				queries: []*SearchQuery{
+					{
+						eventSequence: 90,
+					},
+				},
 			},
 		},
 		{
 			name: "set aggregateIDs",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testSetAggregateIDs("1235", "09824")},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetAggregateIDs("1235", "09824"))},
 			},
 			res: &SearchQueryBuilder{
-				aggregateIDs: []string{"1235", "09824"},
+				queries: []*SearchQuery{
+					{
+						aggregateIDs: []string{"1235", "09824"},
+					},
+				},
 			},
 		},
 		{
 			name: "set eventTypes",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testSetEventTypes("user.created", "user.updated")},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetEventTypes("user.created", "user.updated"))},
 			},
 			res: &SearchQueryBuilder{
-				eventTypes: []EventType{"user.created", "user.updated"},
+				queries: []*SearchQuery{
+					{
+						eventTypes: []EventType{"user.created", "user.updated"},
+					},
+				},
 			},
 		},
 		{
@@ -141,34 +177,35 @@ func TestSearchQueryFactorySetters(t *testing.T) {
 		{
 			name: "default search query",
 			args: args{
-				aggregateTypes: []AggregateType{"user"},
-				setters:        []func(*SearchQueryBuilder) *SearchQueryBuilder{testSetAggregateIDs("1235", "024"), testSetSortOrder(false)},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetAggregateTypes("user"), testSetAggregateIDs("1235", "024")), testSetSortOrder(false)},
 			},
 			res: &SearchQueryBuilder{
-				aggregateTypes: []AggregateType{"user"},
-				aggregateIDs:   []string{"1235", "024"},
-				desc:           true,
+				desc: true,
+				queries: []*SearchQuery{
+					{
+						aggregateTypes: []AggregateType{"user"},
+						aggregateIDs:   []string{"1235", "024"},
+					},
+				},
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			factory := NewSearchQueryBuilder(tt.args.columns, tt.args.aggregateTypes...)
+			builder := NewSearchQueryBuilder(tt.args.columns)
 			for _, setter := range tt.args.setters {
-				factory = setter(factory)
-			}
-			if !reflect.DeepEqual(factory, tt.res) {
-				t.Errorf("NewSearchQueryFactory() = %v, want %v", factory, tt.res)
+				builder = setter(builder)
 			}
+
+			assertBuilder(t, tt.res, builder)
 		})
 	}
 }
 
 func TestSearchQueryFactoryBuild(t *testing.T) {
 	type args struct {
-		columns        Columns
-		aggregateTypes []AggregateType
-		setters        []func(*SearchQueryBuilder) *SearchQueryBuilder
+		columns Columns
+		setters []func(*SearchQueryBuilder) *SearchQueryBuilder
 	}
 	type res struct {
 		isErr func(err error) bool
@@ -182,9 +219,8 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "no aggregate types",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{},
-				setters:        []func(*SearchQueryBuilder) *SearchQueryBuilder{},
+				columns: ColumnsEvent,
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{},
 			},
 			res: res{
 				isErr: errors.IsPreconditionFailed,
@@ -194,10 +230,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "invalid column (too low)",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
 					testSetColumns(Columns(-1)),
+					testAddQuery(testSetAggregateTypes("user")),
 				},
 			},
 			res: res{
@@ -207,10 +243,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "invalid column (too high)",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
 					testSetColumns(math.MaxInt32),
+					testAddQuery(testSetAggregateTypes("uesr")),
 				},
 			},
 			res: res{
@@ -220,9 +256,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
-				setters:        []func(*SearchQueryBuilder) *SearchQueryBuilder{},
+				columns: ColumnsEvent,
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
+					testAddQuery(testSetAggregateTypes("user")),
+				},
 			},
 			res: res{
 				isErr: nil,
@@ -230,8 +267,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+						},
 					},
 				},
 			},
@@ -239,9 +278,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate types",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user", "org"},
-				setters:        []func(*SearchQueryBuilder) *SearchQueryBuilder{},
+				columns: ColumnsEvent,
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
+					testAddQuery(testSetAggregateTypes("user", "org")),
+				},
 			},
 			res: res{
 				isErr: nil,
@@ -249,8 +289,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, []repository.AggregateType{"user", "org"}, repository.OperationIn),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, []repository.AggregateType{"user", "org"}, repository.OperationIn),
+						},
 					},
 				},
 			},
@@ -258,12 +300,14 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type, limit, desc",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
 					testSetLimit(5),
 					testSetSortOrder(false),
-					testSetSequence(100),
+					testAddQuery(
+						testSetSequence(100),
+						testSetAggregateTypes("user"),
+					),
 				},
 			},
 			res: res{
@@ -272,9 +316,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    true,
 					Limit:   5,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationLess),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationLess),
+						},
 					},
 				},
 			},
@@ -282,12 +328,14 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type, limit, asc",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
 					testSetLimit(5),
 					testSetSortOrder(true),
-					testSetSequence(100),
+					testAddQuery(
+						testSetSequence(100),
+						testSetAggregateTypes("user"),
+					),
 				},
 			},
 			res: res{
@@ -296,9 +344,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   5,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationGreater),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationGreater),
+						},
 					},
 				},
 			},
@@ -306,13 +356,15 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type, limit, desc, max event sequence cols",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
 					testSetLimit(5),
 					testSetSortOrder(false),
-					testSetSequence(100),
 					testSetColumns(repository.ColumnsMaxSequence),
+					testAddQuery(
+						testSetSequence(100),
+						testSetAggregateTypes("user"),
+					),
 				},
 			},
 			res: res{
@@ -321,9 +373,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsMaxSequence,
 					Desc:    true,
 					Limit:   5,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationLess),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationLess),
+						},
 					},
 				},
 			},
@@ -331,10 +385,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type and aggregate id",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetAggregateIDs("1234"),
+					testAddQuery(
+						testSetAggregateTypes("user"),
+						testSetAggregateIDs("1234"),
+					),
 				},
 			},
 			res: res{
@@ -343,9 +399,45 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldAggregateID, "1234", repository.OperationEquals),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldAggregateID, "1234", repository.OperationEquals),
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "filter multiple aggregate type and aggregate id",
+			args: args{
+				columns: ColumnsEvent,
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
+					testAddQuery(
+						testSetAggregateTypes("user"),
+						testSetAggregateIDs("1234"),
+						testOr(
+							testSetAggregateTypes("org"),
+							testSetAggregateIDs("izu"),
+						),
+					),
+				},
+			},
+			res: res{
+				isErr: nil,
+				query: &repository.SearchQuery{
+					Columns: repository.ColumnsEvent,
+					Desc:    false,
+					Limit:   0,
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldAggregateID, "1234", repository.OperationEquals),
+						},
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("org"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldAggregateID, "izu", repository.OperationEquals),
+						},
 					},
 				},
 			},
@@ -353,10 +445,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type and aggregate ids",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetAggregateIDs("1234", "0815"),
+					testAddQuery(
+						testSetAggregateTypes("user"),
+						testSetAggregateIDs("1234", "0815"),
+					),
 				},
 			},
 			res: res{
@@ -365,9 +459,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldAggregateID, []string{"1234", "0815"}, repository.OperationIn),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldAggregateID, []string{"1234", "0815"}, repository.OperationIn),
+						},
 					},
 				},
 			},
@@ -375,10 +471,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type and sequence greater",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetSequence(8),
+					testAddQuery(
+						testSetAggregateTypes("user"),
+						testSetSequence(8),
+					),
 				},
 			},
 			res: res{
@@ -387,9 +485,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldSequence, uint64(8), repository.OperationGreater),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldSequence, uint64(8), repository.OperationGreater),
+						},
 					},
 				},
 			},
@@ -397,10 +497,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type and event type",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetEventTypes("user.created"),
+					testAddQuery(
+						testSetAggregateTypes("user"),
+						testSetEventTypes("user.created"),
+					),
 				},
 			},
 			res: res{
@@ -409,9 +511,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldEventType, repository.EventType("user.created"), repository.OperationEquals),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldEventType, repository.EventType("user.created"), repository.OperationEquals),
+						},
 					},
 				},
 			},
@@ -419,10 +523,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type and event types",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetEventTypes("user.created", "user.changed"),
+					testAddQuery(
+						testSetAggregateTypes("user"),
+						testSetEventTypes("user.created", "user.changed"),
+					),
 				},
 			},
 			res: res{
@@ -431,9 +537,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldEventType, []repository.EventType{"user.created", "user.changed"}, repository.OperationIn),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldEventType, []repository.EventType{"user.created", "user.changed"}, repository.OperationIn),
+						},
 					},
 				},
 			},
@@ -441,10 +549,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "filter aggregate type resource owner",
 			args: args{
-				columns:        ColumnsEvent,
-				aggregateTypes: []AggregateType{"user"},
+				columns: ColumnsEvent,
 				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
 					testSetResourceOwner("hodor"),
+					testAddQuery(
+						testSetAggregateTypes("user"),
+					),
 				},
 			},
 			res: res{
@@ -453,9 +563,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 					Columns: repository.ColumnsEvent,
 					Desc:    false,
 					Limit:   0,
-					Filters: []*repository.Filter{
-						repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						repository.NewFilter(repository.FieldResourceOwner, "hodor", repository.OperationEquals),
+					Filters: [][]*repository.Filter{
+						{
+							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
+							repository.NewFilter(repository.FieldResourceOwner, "hodor", repository.OperationEquals),
+						},
 					},
 				},
 			},
@@ -463,8 +575,12 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 		{
 			name: "column invalid",
 			args: args{
-				columns:        Columns(-1),
-				aggregateTypes: []AggregateType{"user"},
+				columns: Columns(-1),
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
+					testAddQuery(
+						testSetAggregateTypes("user"),
+					),
+				},
 			},
 			res: res{
 				isErr: errors.IsPreconditionFailed,
@@ -473,7 +589,7 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			factory := NewSearchQueryBuilder(tt.args.columns, tt.args.aggregateTypes...)
+			factory := NewSearchQueryBuilder(tt.args.columns)
 			for _, f := range tt.args.setters {
 				factory = f(factory)
 			}
@@ -487,9 +603,96 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
 				return
 			}
 
-			if !reflect.DeepEqual(query, tt.res.query) {
-				t.Errorf("NewSearchQueryFactory() = %+v, want %+v", factory, tt.res.query)
-			}
+			assertRepoQuery(t, tt.res.query, query)
 		})
 	}
 }
+
+func assertBuilder(t *testing.T, want, got *SearchQueryBuilder) {
+	t.Helper()
+
+	if got.columns != want.columns {
+		t.Errorf("wrong column: got: %v want: %v", got.columns, want.columns)
+	}
+	if got.desc != want.desc {
+		t.Errorf("wrong desc: got: %v want: %v", got.desc, want.desc)
+	}
+	if got.limit != want.limit {
+		t.Errorf("wrong limit: got: %v want: %v", got.limit, want.limit)
+	}
+	if got.resourceOwner != want.resourceOwner {
+		t.Errorf("wrong : got: %v want: %v", got.resourceOwner, want.resourceOwner)
+	}
+	if len(got.queries) != len(want.queries) {
+		t.Errorf("wrong length of queries: got: %v want: %v", len(got.queries), len(want.queries))
+	}
+
+	for i, query := range got.queries {
+		assertQuery(t, i, want.queries[i], query)
+	}
+}
+
+func assertQuery(t *testing.T, i int, want, got *SearchQuery) {
+	t.Helper()
+
+	if !reflect.DeepEqual(got.aggregateIDs, want.aggregateIDs) {
+		t.Errorf("wrong aggregateIDs in query %d : got: %v want: %v", i, got.aggregateIDs, want.aggregateIDs)
+	}
+	if !reflect.DeepEqual(got.aggregateTypes, want.aggregateTypes) {
+		t.Errorf("wrong aggregateTypes in query %d : got: %v want: %v", i, got.aggregateTypes, want.aggregateTypes)
+	}
+	if !reflect.DeepEqual(got.eventData, want.eventData) {
+		t.Errorf("wrong eventData in query %d : got: %v want: %v", i, got.eventData, want.eventData)
+	}
+	if got.eventSequence != want.eventSequence {
+		t.Errorf("wrong eventSequence in query %d : got: %v want: %v", i, got.eventSequence, want.eventSequence)
+	}
+	if !reflect.DeepEqual(got.eventTypes, want.eventTypes) {
+		t.Errorf("wrong eventTypes in query %d : got: %v want: %v", i, got.eventTypes, want.eventTypes)
+	}
+}
+
+func assertRepoQuery(t *testing.T, want, got *repository.SearchQuery) {
+	t.Helper()
+
+	if want == nil && got == nil {
+		return
+	}
+
+	if !reflect.DeepEqual(got.Columns, want.Columns) {
+		t.Errorf("wrong columns in query: got: %v want: %v", got.Columns, want.Columns)
+	}
+	if !reflect.DeepEqual(got.Desc, want.Desc) {
+		t.Errorf("wrong desc in query: got: %v want: %v", got.Desc, want.Desc)
+	}
+	if !reflect.DeepEqual(got.Limit, want.Limit) {
+		t.Errorf("wrong limit in query: got: %v want: %v", got.Limit, want.Limit)
+	}
+
+	if len(got.Filters) != len(want.Filters) {
+		t.Errorf("wrong length of filters: got: %v want: %v", len(got.Filters), len(want.Filters))
+	}
+
+	for filterIdx, filter := range got.Filters {
+		if len(got.Filters) != len(want.Filters) {
+			t.Errorf("wrong length of subfilters: got: %v want: %v", len(filter), len(want.Filters[filterIdx]))
+		}
+		for subFilterIdx, f := range filter {
+			assertFilters(t, subFilterIdx, want.Filters[filterIdx][subFilterIdx], f)
+		}
+	}
+}
+
+func assertFilters(t *testing.T, i int, want, got *repository.Filter) {
+	t.Helper()
+
+	if want.Field != got.Field {
+		t.Errorf("wrong field in filter %d : got: %v want: %v", i, got.Field, want.Field)
+	}
+	if want.Operation != got.Operation {
+		t.Errorf("wrong operation in filter %d : got: %v want: %v", i, got.Operation, want.Operation)
+	}
+	if !reflect.DeepEqual(want.Value, got.Value) {
+		t.Errorf("wrong value in filter %d : got: %v want: %v", i, got.Value, want.Value)
+	}
+}