feat: Filter alias target (sourcenetwork#3201)

## Relevant issue(s)

Resolves sourcenetwork#3194

## Description

This PR adds alias targeting in filters. 

**Aggregate targets are not included in this PR as they require more
changes.**

## Tasks

- [x] I made sure the code is well commented, particularly
hard-to-understand areas.
- [x] I made sure the repository-held documentation is changed
accordingly.
- [x] I made sure the pull request title adheres to the conventional
commit style (the subset used in the project can be found in
[tools/configs/chglog/config.yml](tools/configs/chglog/config.yml)).
- [x] I made sure to discuss its limitations such as threats to
validity, vulnerability to mistake and misuse, robustness to
invalidation of assumptions, resource requirements, ...

## How has this been tested?

Added and updated integration tests.

Specify the platform(s) on which this was tested:
- MacOS

client/request/filter.go

@@ -13,9 +13,10 @@ package request
 import "github.com/sourcenetwork/immutable"
 
 const (
-	FilterOpOr  = "_or"
-	FilterOpAnd = "_and"
-	FilterOpNot = "_not"
+	FilterOpOr    = "_or"
+	FilterOpAnd   = "_and"
+	FilterOpNot   = "_not"
+	FilterOpAlias = "_alias"
 )
 
 // Filter contains the parsed condition map to be

internal/connor/connor.go

@@ -9,9 +9,10 @@
 package connor
 
 const (
-	AndOp = "_and"
-	OrOp  = "_or"
-	NotOp = "_not"
+	AliasOp = "_alias"
+	AndOp   = "_and"
+	OrOp    = "_or"
+	NotOp   = "_not"
 
 	AnyOp  = "_any"
 	AllOp  = "_all"
@@ -62,7 +63,7 @@ func matchWith(op string, conditions, data any) (bool, error) {
 		return anyOp(conditions, data)
 	case AllOp:
 		return all(conditions, data)
-	case EqualOp:
+	case EqualOp, AliasOp:
 		return eq(conditions, data)
 	case GreaterOrEqualOp:
 		return ge(conditions, data)

internal/connor/eq.go

@@ -34,10 +34,15 @@ func eq(condition, data any) (bool, error) {
 	switch cn := condition.(type) {
 	case map[FilterKey]any:
 		for prop, cond := range cn {
-			m, err := matchWith(prop.GetOperatorOrDefault(EqualOp), cond, prop.GetProp(data))
+			d, op, err := prop.PropertyAndOperator(data, EqualOp)
 			if err != nil {
 				return false, err
-			} else if !m {
+			}
+			m, err := matchWith(op, cond, d)
+			if err != nil {
+				return false, err
+			}
+			if !m {
 				return false, nil
 			}
 		}

internal/connor/key.go

@@ -3,12 +3,11 @@ package connor
 // FilterKey represents a type that may be used as a map key
 // in a filter.
 type FilterKey interface {
-	// GetProp returns the data that should be used with this key
-	// from the given data.
-	GetProp(data any) any
-	// GetOperatorOrDefault returns either the operator that corresponds
-	// to this key, or the given default.
-	GetOperatorOrDefault(defaultOp string) string
+	// PropertyAndOperator returns the data and operator that should be used
+	// to filter the value matching this key.
+	//
+	// If the key does not have an operator the given defaultOp will be returned.
+	PropertyAndOperator(data any, defaultOp string) (any, string, error)
 	// Equal returns true if other is equal, otherwise returns false.
 	Equal(other FilterKey) bool
 }

internal/connor/not_test.go

@@ -34,12 +34,8 @@ type operator struct {
 	Operation string
 }
 
-func (k *operator) GetProp(data any) any {
-	return data
-}
-
-func (k *operator) GetOperatorOrDefault(defaultOp string) string {
-	return k.Operation
+func (k *operator) PropertyAndOperator(data any, defaultOp string) (any, string, error) {
+	return data, k.Operation, nil
 }
 
 func (k *operator) Equal(other FilterKey) bool {

internal/core/doc.go

@@ -298,3 +298,15 @@ func (mapping *DocumentMapping) TryToFindNameFromIndex(targetIndex int) (string,
 
 	return "", false
 }
+
+// TryToFindIndexFromRenderKey returns the corresponding index of the given render key.
+//
+// Additionally, will also return true if the render key was found, and false otherwise.
+func (mapping *DocumentMapping) TryToFindIndexFromRenderKey(key string) (int, bool) {
+	for _, renderKey := range mapping.RenderKeys {
+		if renderKey.Key == key {
+			return renderKey.Index, true
+		}
+	}
+	return -1, false
+}

internal/planner/filter/copy_field.go

@@ -62,10 +62,10 @@ func traverseFilterByProperty(
 				}
 			}
 		} else if opKey, isOpKey := targetKey.(*mapper.Operator); isOpKey {
-			clauseArr, isArr := clause.([]any)
-			if isArr {
+			switch t := clause.(type) {
+			case []any:
 				resultArr := make([]any, 0)
-				for _, elementClause := range clauseArr {
+				for _, elementClause := range t {
 					elementMap, ok := elementClause.(map[connor.FilterKey]any)
 					if !ok {
 						continue
@@ -80,6 +80,14 @@ func traverseFilterByProperty(
 				} else if shouldDelete {
 					delete(result, opKey)
 				}
+
+			case map[connor.FilterKey]any:
+				resultMap := traverseFilterByProperty(keys, t, shouldDelete)
+				if len(resultMap) > 0 {
+					result[opKey] = resultMap
+				} else if shouldDelete {
+					delete(result, opKey)
+				}
 			}
 		}
 	}

internal/planner/filter/copy_field_test.go

@@ -46,6 +46,16 @@ func TestCopyField(t *testing.T) {
 				m("age", m("_gt", 55)),
 			),
 		},
+		{
+			name: "within _not",
+			inputFilter: m("_not",
+				m("age", m("_gt", 55)),
+			),
+			inputField: []mapper.Field{{Index: authorAgeInd}},
+			expectedFilter: m("_not",
+				m("age", m("_gt", 55)),
+			),
+		},
 		{
 			name: "within _or and _and",
 			inputFilter: r("_and",

internal/planner/mapper/errors.go

@@ -15,6 +15,7 @@ import "github.com/sourcenetwork/defradb/errors"
 const (
 	errInvalidFieldToGroupBy string = "invalid field value to groupBy"
 	errTypeNotFound          string = "type not found"
+	errFieldOrAliasNotFound  string = "field or alias not found"
 )
 
 var (
@@ -33,3 +34,7 @@ func NewErrInvalidFieldToGroupBy(field string) error {
 func NewErrTypeNotFound(name string) error {
 	return errors.New(errTypeNotFound, errors.NewKV("Type", name))
 }
+
+func NewErrFieldOrAliasNotFound(name string) error {
+	return errors.New(errFieldOrAliasNotFound, errors.NewKV("Name", name))
+}

internal/planner/mapper/mapper.go

@@ -992,6 +992,12 @@ func resolveInnerFilterDependencies(
 	newFields := []Requestable{}
 
 	for key, value := range source {
+		// alias fields are guarenteed to be resolved
+		// because they refer to existing fields
+		if key == request.FilterOpAlias {
+			continue
+		}
+
 		if key == request.FilterOpAnd || key == request.FilterOpOr {
 			if value == nil {
 				continue
@@ -1335,8 +1341,27 @@ func toFilterKeyValue(
 	sourceClause any,
 	mapping *core.DocumentMapping,
 ) (connor.FilterKey, any) {
+	var propIndex = -1
+	if mapping != nil {
+		// if we have a mapping available check if the
+		// source key is a field or alias (render key)
+		if indexes, ok := mapping.IndexesByName[sourceKey]; ok {
+			// If there are multiple properties of the same name we can just take the first as
+			// we have no other reasonable way of identifying which property they mean if multiple
+			// consumer specified requestables are available.  Aggregate dependencies should not
+			// impact this as they are added after selects.
+			propIndex = indexes[0]
+		} else if index, ok := mapping.TryToFindIndexFromRenderKey(sourceKey); ok {
+			propIndex = index
+		}
+	}
+
 	var returnKey connor.FilterKey
-	if strings.HasPrefix(sourceKey, "_") && sourceKey != request.DocIDFieldName {
+	if propIndex >= 0 {
+		returnKey = &PropertyIndex{
+			Index: propIndex,
+		}
+	} else if strings.HasPrefix(sourceKey, "_") {
 		returnKey = &Operator{
 			Operation: sourceKey,
 		}
@@ -1345,14 +1370,6 @@ func toFilterKeyValue(
 		if connor.IsOpSimple(sourceKey) {
 			return returnKey, sourceClause
 		}
-	} else if mapping != nil && len(mapping.IndexesByName[sourceKey]) > 0 {
-		// If there are multiple properties of the same name we can just take the first as
-		// we have no other reasonable way of identifying which property they mean if multiple
-		// consumer specified requestables are available.  Aggregate dependencies should not
-		// impact this as they are added after selects.
-		returnKey = &PropertyIndex{
-			Index: mapping.FirstIndexOfName(sourceKey),
-		}
 	} else {
 		returnKey = &ObjectProperty{
 			Name: sourceKey,

internal/planner/mapper/targetable.go

@@ -30,16 +30,11 @@ type PropertyIndex struct {
 	Index int
 }
 
-func (k *PropertyIndex) GetProp(data any) any {
+func (k *PropertyIndex) PropertyAndOperator(data any, defaultOp string) (any, string, error) {
 	if data == nil {
-		return nil
+		return nil, defaultOp, nil
 	}
-
-	return data.(core.Doc).Fields[k.Index]
-}
-
-func (k *PropertyIndex) GetOperatorOrDefault(defaultOp string) string {
-	return defaultOp
+	return data.(core.Doc).Fields[k.Index], defaultOp, nil
 }
 
 func (k *PropertyIndex) Equal(other connor.FilterKey) bool {
@@ -57,12 +52,8 @@ type Operator struct {
 	Operation string
 }
 
-func (k *Operator) GetProp(data any) any {
-	return data
-}
-
-func (k *Operator) GetOperatorOrDefault(defaultOp string) string {
-	return k.Operation
+func (k *Operator) PropertyAndOperator(data any, defaultOp string) (any, string, error) {
+	return data, k.Operation, nil
 }
 
 func (k *Operator) Equal(other connor.FilterKey) bool {
@@ -81,16 +72,15 @@ type ObjectProperty struct {
 	Name string
 }
 
-func (k *ObjectProperty) GetProp(data any) any {
+func (k *ObjectProperty) PropertyAndOperator(data any, defaultOp string) (any, string, error) {
 	if data == nil {
-		return nil
+		return nil, defaultOp, nil
 	}
-	object := data.(map[string]any)
-	return object[k.Name]
-}
-
-func (k *ObjectProperty) GetOperatorOrDefault(defaultOp string) string {
-	return defaultOp
+	docMap, ok := data.(map[string]any)
+	if !ok {
+		return nil, defaultOp, NewErrFieldOrAliasNotFound(k.Name)
+	}
+	return docMap[k.Name], defaultOp, nil
 }
 
 func (k *ObjectProperty) Equal(other connor.FilterKey) bool {
@@ -165,7 +155,7 @@ func filterObjectToMap(mapping *core.DocumentMapping, obj map[connor.FilterKey]a
 					logicMapEntries[i] = filterObjectToMap(mapping, itemMap)
 				}
 				outmap[keyType.Operation] = logicMapEntries
-			case request.FilterOpNot:
+			case request.FilterOpNot, request.FilterOpAlias:
 				itemMap, ok := v.(map[connor.FilterKey]any)
 				if ok {
 					outmap[keyType.Operation] = filterObjectToMap(mapping, itemMap)

internal/request/graphql/parser/filter.go

@@ -93,20 +93,20 @@ func parseFilterFieldsForDescriptionMap(
 	fields := make([]client.FieldDefinition, 0)
 	for k, v := range conditions {
 		switch k {
-		case "_or", "_and":
+		case request.FilterOpOr, request.FilterOpAnd:
 			conds := v.([]any)
-			parsedFileds, err := parseFilterFieldsForDescriptionSlice(conds, col)
+			parsedFields, err := parseFilterFieldsForDescriptionSlice(conds, col)
 			if err != nil {
 				return nil, err
 			}
-			fields = append(fields, parsedFileds...)
-		case "_not":
+			fields = append(fields, parsedFields...)
+		case request.FilterOpNot, request.FilterOpAlias:
 			conds := v.(map[string]any)
-			parsedFileds, err := parseFilterFieldsForDescriptionMap(conds, col)
+			parsedFields, err := parseFilterFieldsForDescriptionMap(conds, col)
 			if err != nil {
 				return nil, err
 			}
-			fields = append(fields, parsedFileds...)
+			fields = append(fields, parsedFields...)
 		default:
 			f, found := col.GetFieldByName(k)
 			if !found || f.Kind.IsObject() {

internal/request/graphql/schema/generate.go

@@ -1188,18 +1188,22 @@ func (g *Generator) genTypeFilterArgInput(obj *gql.Object) *gql.InputObject {
 		func() (gql.InputObjectConfigFieldMap, error) {
 			fields := gql.InputObjectConfigFieldMap{}
 
-			fields["_and"] = &gql.InputObjectFieldConfig{
+			fields[request.FilterOpAnd] = &gql.InputObjectFieldConfig{
 				Description: schemaTypes.AndOperatorDescription,
 				Type:        gql.NewList(gql.NewNonNull(selfRefType)),
 			}
-			fields["_or"] = &gql.InputObjectFieldConfig{
+			fields[request.FilterOpOr] = &gql.InputObjectFieldConfig{
 				Description: schemaTypes.OrOperatorDescription,
 				Type:        gql.NewList(gql.NewNonNull(selfRefType)),
 			}
-			fields["_not"] = &gql.InputObjectFieldConfig{
+			fields[request.FilterOpNot] = &gql.InputObjectFieldConfig{
 				Description: schemaTypes.NotOperatorDescription,
 				Type:        selfRefType,
 			}
+			fields[request.FilterOpAlias] = &gql.InputObjectFieldConfig{
+				Description: "The alias operator allows filters to target aliased fields.",
+				Type:        schemaTypes.JSONScalarType(),
+			}
 
 			// generate basic filter operator blocks
 			for f, field := range obj.Fields() {