feat: add composite type support for field resolvers (#1341)

This PR improves the existing functionality for field resolvers.
Currently field resolvers do not support returning any form of composite
types (interfaces and unions). This feature will be provided in this PR.

The planner will now determine the correct selection set and identify,
whether the field selections are part of an inline fragment. The calling
logic will always inline all fragments provided to the datasource,
therefore we do not need to handle fragments and spreads.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Resolver-driven execution planning with nested field-resolver support
and enhanced composite-type handling; new GraphQL fields/types (product
mascotRecommendation/stockStatus/productDetails, category
mascot/categoryStatus/metrics, TestContainer/TestDetails,
animal/owner/breed data) and matching RPCs.

* **Tests**
* Large expansion of test coverage for nested resolvers,
composite/interface/union scenarios, federation/entity lookups,
execution plan generation, stack utilities, lookups, mappings, and
nullable-field cases.

* **Chores**
* Updated mock services, RPC mappings/protos, test helpers, and internal
utilities to support the above.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

## Checklist

- [ ] I have discussed my proposed changes in an issue and have received
approval to proceed.
- [ ] I have followed the coding standards of the project.
- [ ] Tests or benchmarks have been added or updated.

<!--
Please add any additional information or context regarding your changes
here.
-->

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: Noroth

v2/pkg/ast/ast_selection.go

@@ -212,6 +212,18 @@ func (d *Document) SelectionSetHasFieldSelectionWithExactName(set int, name []by
 	return false, InvalidRef
 }
 
+// SelectionSetFieldRefs returns a list of field refs in the selection set.
+// It traverses through the field selections of the selection set and returns the actual field refs.
+func (d *Document) SelectionSetFieldRefs(set int) (refs []int) {
+	for _, selectionRef := range d.SelectionSets[set].SelectionRefs {
+		if d.Selections[selectionRef].Kind == SelectionKindField {
+			refs = append(refs, d.Selections[selectionRef].Ref)
+		}
+	}
+	return
+}
+
+// SelectionSetFieldSelections returns a list of field selection refs in the selection set.
 func (d *Document) SelectionSetFieldSelections(set int) (refs []int) {
 	for _, selectionRef := range d.SelectionSets[set].SelectionRefs {
 		if d.Selections[selectionRef].Kind == SelectionKindField {

v2/pkg/astvisitor/visitor.go

@@ -4021,6 +4021,7 @@ func (w *Walker) FieldDefinitionDirectiveArgumentValueByName(field int, directiv
 }
 
 // InRootField returns true if the current field is a root field.
+// This helper function can be used in EnterField and LeaveField.
 func (w *Walker) InRootField() bool {
 	return w.CurrentKind == ast.NodeKindField &&
 		len(w.Ancestors) == 2 &&

v2/pkg/engine/datasource/grpc_datasource/compiler.go

@@ -604,7 +604,9 @@ func (p *RPCCompiler) buildProtoMessageWithContext(inputMessage Message, rpcMess
 		val := contextList.NewElement()
 		valMsg := val.Message()
 		for fieldName, value := range data {
-			p.setMessageValue(valMsg, fieldName, value)
+			if err := p.setMessageValue(valMsg, fieldName, value); err != nil {
+				return nil, err
+			}
 		}
 
 		contextList.Append(val)
@@ -625,10 +627,10 @@ func (p *RPCCompiler) buildProtoMessageWithContext(inputMessage Message, rpcMess
 	if err != nil {
 		return nil, err
 	}
-
-	// Set the context and args fields
-	p.setMessageValue(rootMessage, contextSchemaField.Name, protoref.ValueOfList(contextList))
-	p.setMessageValue(rootMessage, argsRPCField.Name, protoref.ValueOfMessage(args))
+	// Set the args field
+	if err := p.setMessageValue(rootMessage, argsRPCField.Name, protoref.ValueOfMessage(args)); err != nil {
+		return nil, err
+	}
 
 	return rootMessage, nil
 }
@@ -736,7 +738,7 @@ func (p *RPCCompiler) resolveDataForPath(messsage protoref.Message, path ast.Pat
 	switch fd.Kind() {
 	case protoref.MessageKind:
 		if fd.IsList() {
-			return []protoref.Value{field}
+			return []protoref.Value{protoref.ValueOfList(field.List())}
 		}
 
 		return p.resolveDataForPath(field.Message(), path[1:])
@@ -835,8 +837,33 @@ func (p *RPCCompiler) newEmptyListMessageByName(msg protoref.Message, name strin
 	return msg.Mutable(msg.Descriptor().Fields().ByName(protoref.Name(name))).List()
 }
 
-func (p *RPCCompiler) setMessageValue(message protoref.Message, fieldName string, value protoref.Value) {
+func (p *RPCCompiler) setMessageValue(message protoref.Message, fieldName string, value protoref.Value) error {
+	fd := message.Descriptor().Fields().ByName(protoref.Name(fieldName))
+	if fd == nil {
+		return fmt.Errorf("field %s not found in message %s", fieldName, message.Descriptor().Name())
+	}
+
+	// If we are setting a list value here, we need to create a copy of the list
+	// because the field descriptor is included in the type check, so we cannot asign it using `Set` directly.
+	if fd.IsList() {
+		list := message.Mutable(fd).List()
+		source, ok := value.Interface().(protoref.List)
+		if !ok {
+			return fmt.Errorf("value is not a list")
+		}
+
+		p.copyListValues(source, list)
+		return nil
+	}
+
 	message.Set(message.Descriptor().Fields().ByName(protoref.Name(fieldName)), value)
+	return nil
+}
+
+func (p *RPCCompiler) copyListValues(source protoref.List, destination protoref.List) {
+	for i := range source.Len() {
+		destination.Append(source.Get(i))
+	}
 }
 
 // buildProtoMessage recursively builds a protobuf message from an RPCMessage definition