feat: get multiple users by id (#6210)

* feat: introduce InTextQuery, and the ability to get multiple users by id

* added in query tests

* remove append call

* fix lints

internal/query/search_query.go

@@ -156,6 +156,10 @@ const (
 	columnCompareMax
 )
 
+type InTextQuery struct {
+	Column Column
+	Values []string
+}
 type TextQuery struct {
 	Column  Column
 	Text    string
@@ -167,8 +171,22 @@ var (
 	ErrInvalidCompare  = errors.New("invalid compare")
 	ErrMissingColumn   = errors.New("missing column")
 	ErrInvalidNumber   = errors.New("value is no number")
+	ErrEmptyValues     = errors.New("values array must not be empty")
 )
 
+func NewInTextQuery(col Column, values []string) (*InTextQuery, error) {
+	if len(values) == 0 {
+		return nil, ErrEmptyValues
+	}
+	if col.isZero() {
+		return nil, ErrMissingColumn
+	}
+	return &InTextQuery{
+		Column: col,
+		Values: values,
+	}, nil
+}
+
 func NewTextQuery(col Column, value string, compare TextComparison) (*TextQuery, error) {
 	if compare < 0 || compare >= textCompareMax {
 		return nil, ErrInvalidCompare
@@ -183,6 +201,15 @@ func NewTextQuery(col Column, value string, compare TextComparison) (*TextQuery,
 	}, nil
 }
 
+func (q *InTextQuery) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
+	return query.Where(q.comp())
+}
+
+func (s *InTextQuery) comp() sq.Sqlizer {
+	// This translates to an IN query
+	return sq.Eq{s.Column.identifier(): s.Values}
+}
+
 func (q *TextQuery) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
 	return query.Where(q.comp())
 }
@@ -269,7 +296,7 @@ func NewNumberQuery(c Column, value interface{}, compare NumberComparison) (*Num
 	}
 	switch reflect.TypeOf(value).Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-		//everything fine
+		// everything fine
 	default:
 		return nil, ErrInvalidNumber
 	}

internal/query/search_query_test.go

@@ -1382,3 +1382,118 @@ func TestNumberComparisonFromMethod(t *testing.T) {
 		})
 	}
 }
+
+func TestNewInTextQuery(t *testing.T) {
+	type args struct {
+		column Column
+		value  []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *InTextQuery
+		wantErr func(error) bool
+	}{
+		{
+			name: "empty values",
+			args: args{
+				column: testCol,
+				value:  []string{},
+			},
+			wantErr: func(err error) bool {
+				return errors.Is(err, ErrEmptyValues)
+			},
+		},
+		{
+			name: "no column",
+			args: args{
+				column: Column{},
+				value:  []string{"adler", "hurst"},
+			},
+			wantErr: func(err error) bool {
+				return errors.Is(err, ErrMissingColumn)
+			},
+		},
+		{
+			name: "no column name",
+			args: args{
+				column: testNoCol,
+				value:  []string{"adler", "hurst"},
+			},
+			wantErr: func(err error) bool {
+				return errors.Is(err, ErrMissingColumn)
+			},
+		},
+		{
+			name: "correct",
+			args: args{
+				column: testCol,
+				value:  []string{"adler", "hurst"},
+			},
+			want: &InTextQuery{
+				Column: testCol,
+				Values: []string{"adler", "hurst"},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := NewInTextQuery(tt.args.column, tt.args.value)
+			if err != nil && tt.wantErr == nil {
+				t.Errorf("NewTextQuery() no error expected got %v", err)
+				return
+			} else if tt.wantErr != nil && !tt.wantErr(err) {
+				t.Errorf("NewTextQuery() unexpeted error = %v", err)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewTextQuery() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestInTextQuery_comp(t *testing.T) {
+	type fields struct {
+		Column Column
+		Values []string
+	}
+	type want struct {
+		query interface{}
+		isNil bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   want
+	}{
+		{
+			name: "equals",
+			fields: fields{
+				Column: testCol,
+				Values: []string{"Adler", "Hurst"},
+			},
+			want: want{
+				query: sq.Eq{"test_table.test_col": []string{"Adler", "Hurst"}},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &InTextQuery{
+				Column: tt.fields.Column,
+				Values: tt.fields.Values,
+			}
+			query := s.comp()
+			if query == nil && tt.want.isNil {
+				return
+			} else if tt.want.isNil && query != nil {
+				t.Error("query should not be nil")
+			}
+
+			if !reflect.DeepEqual(query, tt.want.query) {
+				t.Errorf("wrong query: want: %v, (%T), got: %v, (%T)", tt.want.query, tt.want.query, query, query)
+			}
+		})
+	}
+}

internal/query/user.go

@@ -605,6 +605,10 @@ func (r *UserSearchQueries) AppendMyResourceOwnerQuery(orgID string) error {
 	return nil
 }
 
+func NewUserInUserIdsSearchQuery(values []string) (SearchQuery, error) {
+	return NewInTextQuery(UserIDCol, values)
+}
+
 func NewUserResourceOwnerSearchQuery(value string, comparison TextComparison) (SearchQuery, error) {
 	return NewTextQuery(UserResourceOwnerCol, value, comparison)
 }