feat: add support for multiple key directives

execution/engine/execution_engine_grpc_test.go

@@ -234,7 +234,7 @@ func TestGRPCSubgraphExecution(t *testing.T) {
 			Query:         "query UserQuery { users { id name } }",
 		}
 
-		response, err := executeOperation(t, conn, operation)
+		response, err := executeOperation(t, conn, operation, withGRPCMapping(mapping.MustDefaultGRPCMapping(t)))
 		require.NoError(t, err)
 		require.Equal(t, `{"data":{"users":[{"id":"user-1","name":"User 1"},{"id":"user-2","name":"User 2"},{"id":"user-3","name":"User 3"}]}}`, response)
 	})
@@ -255,7 +255,7 @@ func TestGRPCSubgraphExecution(t *testing.T) {
 			`,
 		}
 
-		response, err := executeOperation(t, conn, operation)
+		response, err := executeOperation(t, conn, operation, withGRPCMapping(mapping.MustDefaultGRPCMapping(t)))
 		require.NoError(t, err)
 		require.Equal(t, `{"data":{"user":{"id":"1","name":"User 1"}}}`, response)
 	})

v2/pkg/astvisitor/visitor.go

@@ -3998,3 +3998,27 @@ func (w *Walker) FieldDefinitionDirectiveArgumentValueByName(field int, directiv
 
 	return w.definition.DirectiveArgumentValueByName(directive, argumentName)
 }
+
+// InRootField returns true if the current field is a root field.
+func (w *Walker) InRootField() bool {
+	return w.CurrentKind == ast.NodeKindField &&
+		len(w.Ancestors) == 2 &&
+		w.Ancestors[0].Kind == ast.NodeKindOperationDefinition
+}
+
+// ResolveInlineFragment returns the inline fragment ref if the current field is inside of
+// an inline fragment.
+// It returns the inline fragment ref and true if the current field is inside of an inline fragment.
+// It returns -1 and false if the current field is not inside of an inline fragment.
+func (w *Walker) ResolveInlineFragment() (int, bool) {
+	if len(w.Ancestors) < 2 {
+		return -1, false
+	}
+
+	node := w.Ancestors[len(w.Ancestors)-2]
+	if node.Kind != ast.NodeKindInlineFragment {
+		return -1, false
+	}
+
+	return node.Ref, true
+}

v2/pkg/engine/datasource/graphql_datasource/graphql_datasource.go

@@ -368,11 +368,12 @@ func (p *Planner[T]) ConfigureFetch() resolve.FetchConfiguration {
 		}
 
 		dataSource, err = grpcdatasource.NewDataSource(p.grpcClient, grpcdatasource.DataSourceConfig{
-			Operation:  &opDocument,
-			Definition: p.config.schemaConfiguration.upstreamSchemaAst,
-			Mapping:    p.config.grpc.Mapping,
-			Compiler:   p.config.grpc.Compiler,
-			Disabled:   p.config.grpc.Disabled,
+			Operation:         &opDocument,
+			Definition:        p.config.schemaConfiguration.upstreamSchemaAst,
+			Mapping:           p.config.grpc.Mapping,
+			Compiler:          p.config.grpc.Compiler,
+			Disabled:          p.config.grpc.Disabled,
+			FederationConfigs: p.dataSourcePlannerConfig.RequiredFields,
 			// TODO: remove fallback logic in visitor for subgraph name and
 			// add proper error handling if the subgraph name is not set in the mapping
 			SubgraphName: p.dataSourceConfig.Name(),

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

@@ -1,5 +1,11 @@
 package grpcdatasource
 
+import (
+	"strings"
+
+	"github.com/wundergraph/graphql-go-tools/v2/pkg/lexer/runes"
+)
+
 type (
 	// RPCConfigMap is a map of RPC names to RPC configurations
 	RPCConfigMap map[string]RPCConfig
@@ -17,7 +23,7 @@ type GRPCMapping struct {
 	// SubscriptionRPCs maps GraphQL subscription fields to the corresponding gRPC RPC configurations
 	SubscriptionRPCs RPCConfigMap
 	// EntityRPCs defines how GraphQL types are resolved as entities using specific RPCs
-	EntityRPCs map[string]EntityRPCConfig
+	EntityRPCs map[string][]EntityRPCConfig
 	// Fields defines the field mappings between GraphQL types and gRPC messages
 	Fields map[string]FieldMap
 	// EnumValues defines the enum values for each enum type
@@ -121,3 +127,97 @@ func (g *GRPCMapping) ResolveEnumValue(enumName, enumValue string) (string, bool
 
 	return "", false
 }
+
+func (g *GRPCMapping) ResolveEntityRPCConfig(typeName, key string) (RPCConfig, bool) {
+	rpcConfig, ok := g.EntityRPCs[typeName]
+	if !ok {
+		return RPCConfig{}, false
+	}
+
+	for _, ei := range rpcConfig {
+		if compareKeyFields(ei.Key, key) {
+			return ei.RPCConfig, true
+		}
+
+	}
+
+	return RPCConfig{}, false
+}
+
+type keySet map[string]struct{}
+
+func (k keySet) add(keys ...string) {
+	for _, key := range keys {
+		trimmedKey := strings.TrimSpace(key)
+		if trimmedKey != "" {
+			k[trimmedKey] = struct{}{}
+		}
+	}
+}
+
+func (k keySet) equals(other keySet) bool {
+	if len(k) != len(other) {
+		return false
+	}
+
+	for key := range k {
+		if _, ok := other[key]; !ok {
+			return false
+		}
+	}
+
+	return true
+}
+
+// We compare only top level key
+func compareKeyFields(left, right string) bool {
+	if left == right {
+		return true
+	}
+
+	left = stripSelectionSets(left)
+	right = stripSelectionSets(right)
+
+	leftKeys := strings.Split(left, " ")
+	rightKeys := strings.Split(right, " ")
+
+	leftSet := make(keySet)
+	leftSet.add(leftKeys...)
+
+	rightSet := make(keySet)
+	rightSet.add(rightKeys...)
+
+	return leftSet.equals(rightSet)
+}
+
+func stripSelectionSets(keyString string) string {
+	depth := 0
+
+	var prev rune
+
+	keyString = strings.ReplaceAll(keyString, ",", " ")
+
+	var sb strings.Builder
+
+	for _, r := range keyString {
+		switch r {
+		case runes.LBRACE:
+			depth++
+		case runes.RBRACE:
+			if depth == 0 {
+				continue
+			}
+
+			depth--
+		default:
+			if depth != 0 || (r == runes.SPACE && prev == runes.SPACE) {
+				break
+			}
+
+			sb.WriteRune(r)
+			prev = r
+		}
+	}
+
+	return strings.TrimSpace(sb.String())
+}