handle null gql inputs correctly

internal/planner/mapper/targetable.go

@@ -108,6 +108,9 @@ func filterObjectToMap(mapping *core.DocumentMapping, obj map[connor.FilterKey]a
 		return nil
 	}
 	for k, v := range obj {
+		if v == nil {
+			continue // ignore nil filter object values
+		}
 		switch keyType := k.(type) {
 		case *PropertyIndex:
 			subObj := v.(map[connor.FilterKey]any)

internal/request/graphql/parser/commit.go

@@ -35,31 +35,61 @@ func parseCommitSelect(
 	arguments := gql.GetArgumentValues(fieldDef.Args, field.Arguments, exe.VariableValues)
 
 	for _, argument := range field.Arguments {
-		prop := argument.Name.Value
-		if prop == request.DocIDArgName {
-			commit.DocID = immutable.Some(arguments[prop].(string))
-		} else if prop == request.Cid {
-			commit.CID = immutable.Some(arguments[prop].(string))
-		} else if prop == request.FieldIDName {
-			commit.FieldID = immutable.Some(arguments[prop].(string))
-		} else if prop == request.OrderClause {
-			conditions, err := ParseConditionsInOrder(argument.Value.(*ast.ObjectValue), arguments[prop].(map[string]any))
+		name := argument.Name.Value
+		value := arguments[name]
+
+		switch name {
+		case request.DocIDArgName:
+			if v, ok := value.(string); ok {
+				commit.DocID = immutable.Some(v)
+			}
+
+		case request.Cid:
+			if v, ok := value.(string); ok {
+				commit.CID = immutable.Some(v)
+			}
+
+		case request.FieldIDName:
+			if v, ok := value.(string); ok {
+				commit.FieldID = immutable.Some(v)
+			}
+
+		case request.OrderClause:
+			v, ok := arguments[name].(map[string]any)
+			if !ok {
+				continue // value is nil
+			}
+			conditions, err := ParseConditionsInOrder(argument.Value.(*ast.ObjectValue), v)
 			if err != nil {
 				return nil, err
 			}
 			commit.OrderBy = immutable.Some(request.OrderBy{
 				Conditions: conditions,
 			})
-		} else if prop == request.LimitClause {
-			commit.Limit = immutable.Some(uint64(arguments[prop].(int32)))
-		} else if prop == request.OffsetClause {
-			commit.Offset = immutable.Some(uint64(arguments[prop].(int32)))
-		} else if prop == request.DepthClause {
-			commit.Depth = immutable.Some(uint64(arguments[prop].(int32)))
-		} else if prop == request.GroupByClause {
-			fields := []string{}
-			for _, v := range arguments[prop].([]any) {
-				fields = append(fields, v.(string))
+
+		case request.LimitClause:
+			if v, ok := value.(int32); ok {
+				immutable.Some(uint64(v))
+			}
+
+		case request.OffsetClause:
+			if v, ok := value.(int32); ok {
+				immutable.Some(uint64(v))
+			}
+
+		case request.DepthClause:
+			if v, ok := value.(int32); ok {
+				immutable.Some(uint64(v))
+			}
+
+		case request.GroupByClause:
+			v, ok := arguments[name].([]any)
+			if !ok {
+				continue // value is nil
+			}
+			fields := make([]string, len(v))
+			for i, c := range v {
+				fields[i] = c.(string)
 			}
 			commit.GroupBy = immutable.Some(request.GroupBy{
 				Fields: fields,
@@ -91,6 +121,9 @@ func parseCommitSelect(
 	}
 
 	commit.Fields, err = parseSelectFields(exe, fieldObject, field.SelectionSet)
+	if err != nil {
+		return nil, err
+	}
 
 	return commit, err
 }

internal/request/graphql/parser/filter.go

@@ -78,16 +78,9 @@ func ParseConditionsInOrder(stmt *ast.ObjectValue, args map[string]any) ([]reque
 	for _, field := range stmt.Fields {
 		switch v := args[field.Name.Value].(type) {
 		case int: // base direction parsed (hopefully, check NameToOrderDirection)
-			var dir request.OrderDirection
-			switch v {
-			case 0:
-				dir = request.ASC
-
-			case 1:
-				dir = request.DESC
-
-			default:
-				return nil, ErrInvalidOrderDirection
+			dir, err := parseOrderDirection(v)
+			if err != nil {
+				return nil, err
 			}
 			conditions = append(conditions, request.OrderCondition{
 				Fields:    []string{field.Name.Value},
@@ -109,6 +102,9 @@ func ParseConditionsInOrder(stmt *ast.ObjectValue, args map[string]any) ([]reque
 				conditions = append(conditions, cond)
 			}
 
+		case nil:
+			continue // ignore nil filter input
+
 		default:
 			return nil, client.NewErrUnhandledType("parseConditionInOrder", v)
 		}
@@ -199,3 +195,16 @@ func parseFilterFieldsForDescriptionSlice(
 	}
 	return fields, nil
 }
+
+func parseOrderDirection(v int) (request.OrderDirection, error) {
+	switch v {
+	case 0:
+		return request.ASC, nil
+
+	case 1:
+		return request.DESC, nil
+
+	default:
+		return request.ASC, ErrInvalidOrderDirection
+	}
+}

internal/request/graphql/parser/mutation.go

@@ -95,38 +95,60 @@ func parseMutation(exe *gql.ExecutionContext, parent *gql.Object, field *ast.Fie
 		mut.Collection = strings.Join(mutNameParts[1:], "_")
 	}
 
-	// parse arguments
 	for _, argument := range field.Arguments {
-		prop := argument.Name.Value
-		// parse each individual arg type seperately
-		if prop == request.Input { // parse input
-			mut.Input = arguments[prop].(map[string]any)
-		} else if prop == request.Inputs {
-			inputsValue := arguments[prop].([]any)
-			inputs := make([]map[string]any, len(inputsValue))
-			for i, v := range inputsValue {
+		name := argument.Name.Value
+		value := arguments[name]
+
+		switch name {
+		case request.Input:
+			if v, ok := value.(map[string]any); ok {
+				mut.Input = v
+			}
+
+		case request.Inputs:
+			v, ok := value.([]any)
+			if !ok {
+				continue // value is nil
+			}
+			inputs := make([]map[string]any, len(v))
+			for i, v := range v {
 				inputs[i] = v.(map[string]any)
 			}
 			mut.Inputs = inputs
-		} else if prop == request.FilterClause { // parse filter
-			mut.Filter = immutable.Some(request.Filter{
-				Conditions: arguments[prop].(map[string]any),
-			})
-		} else if prop == request.DocIDArgName {
-			mut.DocIDs = immutable.Some([]string{arguments[prop].(string)})
-		} else if prop == request.DocIDsArgName {
-			docIDsValue := arguments[prop].([]any)
-			docIDs := make([]string, len(docIDsValue))
-			for i, v := range docIDsValue {
+
+		case request.FilterClause:
+			if v, ok := value.(map[string]any); ok {
+				mut.Filter = immutable.Some(request.Filter{Conditions: v})
+			}
+
+		case request.DocIDArgName:
+			if v, ok := value.(string); ok {
+				mut.DocIDs = immutable.Some([]string{v})
+			}
+
+		case request.DocIDsArgName:
+			v, ok := value.([]any)
+			if !ok {
+				continue // value is nil
+			}
+			docIDs := make([]string, len(v))
+			for i, v := range v {
 				docIDs[i] = v.(string)
 			}
 			mut.DocIDs = immutable.Some(docIDs)
-		} else if prop == request.EncryptDocArgName {
-			mut.Encrypt = arguments[prop].(bool)
-		} else if prop == request.EncryptFieldsArgName {
-			fieldsValue := arguments[prop].([]any)
-			fields := make([]string, len(fieldsValue))
-			for i, v := range fieldsValue {
+
+		case request.EncryptDocArgName:
+			if v, ok := value.(bool); ok {
+				mut.Encrypt = v
+			}
+
+		case request.EncryptFieldsArgName:
+			v, ok := value.([]any)
+			if !ok {
+				continue // value is nil
+			}
+			fields := make([]string, len(v))
+			for i, v := range v {
 				fields[i] = v.(string)
 			}
 			mut.EncryptFields = fields
@@ -144,5 +166,9 @@ func parseMutation(exe *gql.ExecutionContext, parent *gql.Object, field *ast.Fie
 	}
 
 	mut.Fields, err = parseSelectFields(exe, fieldObject, field.SelectionSet)
+	if err != nil {
+		return nil, err
+	}
+
 	return mut, err
 }