@graphql-tools/federation 4.4.2 → 4.4.3-alpha-12654e24df4f034d8c7112f5052f1b37674985ae

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @graphql-tools/federation
 
+## 4.4.3-alpha-12654e24df4f034d8c7112f5052f1b37674985ae
+### Patch Changes
+
+
+
+- [#2346](https://github.com/graphql-hive/gateway/pull/2346) [`16fd346`](https://github.com/graphql-hive/gateway/commit/16fd346a18fd77e1094fe4ac2f7a6c2d8923bd68) Thanks [@copilot-swe-agent](https://github.com/apps/copilot-swe-agent)! - Fix `@requires` argument conflict when multiple computed fields in a federation subgraph require the same external field with different argument values (e.g. `price(currency: "USD")` vs `price(currency: "EUR")`).
+  
+  Previously, all `@requires` selections for computed fields in a subgraph were merged into a single entity representation. When two computed fields needed the same external field but with different argument values, the stitching engine would alias each field differently — but both aliases ended up in the same representation object. The second field would overwrite the first, so one of the computed fields would always receive the wrong value.
+  
+  **What changed:**
+  
+  - **Computed field conflict detection** — when building subschema merge configs from the supergraph SDL, the federation stitching layer now detects conflicts: two computed fields conflict when they produce the same top-level aliased field name in their `@requires` selections but with different aliases (i.e. the same external field required with different argument values).
+  
+  - **Conflict group isolation** — conflicting computed fields are separated into independent "conflict groups". Each group gets its own `SubschemaConfig` (sharing the same underlying executor/endpoint) with only its own computed fields and a deduplicated entity representation that carries only the aliased fields it actually needs. This ensures each group sends the correct representation to the subgraph and receives the right data back.
+  
+  - **Schema scoping per group** — the main `SubschemaConfig`'s schema is filtered (via `mapSchema`) to remove computed fields that were moved to a conflict group, preventing the stitching engine from incorrectly routing those fields back to the main subschema. Each conflict group's `SubschemaConfig` is likewise scoped to expose only its own computed fields.
+  
+  - **`getMergedTypeConfigFromKey` extended** — accepts an optional `keysExtraKeys` parameter so each conflict group can inject its own `extraKeys` set when building entity key functions, keeping key generation independent per group.
+  
+  - **Federation audit test enabled** — the `requires-with-argument-conflict` case in the federation compatibility test suite was previously skipped for stitching (marked `it.todo`). It now passes and the skip has been removed.
+
 ## 4.4.2
 ### Patch Changes
 

package/dist/index.cjs

@@ -1272,14 +1272,15 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
     const mergeConfig = {};
     const typeNameKeyMap = typeNameKeysBySubgraphMap.get(subgraphName);
     const unionTypeNodes = [];
+    const pendingConflictSubschemaConfigs = [];
     if (typeNameKeyMap) {
       const typeNameFieldsKeyMap = typeNameFieldsKeyBySubgraphMap.get(subgraphName);
       for (const [typeName, keys] of typeNameKeyMap) {
-        let getMergedTypeConfigFromKey2 = function(key) {
+        let getMergedTypeConfigFromKey2 = function(key, keysExtraKeys = extraKeys) {
           return {
             selectionSet: `{ ${key} }`,
             argsFromKeys: getArgsFromKeysForFederation,
-            key: getKeyFnForFederation(typeName, [key, ...extraKeys]),
+            key: getKeyFnForFederation(typeName, [key, ...keysExtraKeys]),
             fieldName: `_entities`,
             dataLoaderOptions: {
               cacheKeyFn: getCacheKeyFnFromKey(key),
@@ -1291,38 +1292,93 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
         const fieldsKeyMap = typeNameFieldsKeyMap?.get(typeName);
         const extraKeys = /* @__PURE__ */ new Set();
         if (fieldsKeyMap) {
-          const fieldsConfig = mergedTypeConfig.fields = {};
+          let aliasFieldsWithArgs2 = function(selectionSetNode) {
+            for (const selection of selectionSetNode.selections) {
+              if (selection.kind === graphql.Kind.FIELD && selection.arguments?.length) {
+                const argsHash = selection.arguments.map(
+                  (arg) => arg.name.value + // TODO: slow? faster hash?
+                  memoizedASTPrint(arg.value).replace(/[^a-zA-Z0-9]/g, "")
+                ).join("");
+                selection.alias = {
+                  kind: graphql.Kind.NAME,
+                  value: "_" + selection.name.value + "_" + argsHash
+                };
+              }
+              if ("selectionSet" in selection && selection.selectionSet) {
+                aliasFieldsWithArgs2(selection.selectionSet);
+              }
+            }
+          };
+          const mainFieldsConfig = mergedTypeConfig.fields = {};
+          const groups = [
+            {
+              extraKeys,
+              fieldsConfig: mainFieldsConfig,
+              aliasedFields: /* @__PURE__ */ new Map()
+            }
+          ];
           for (const [fieldName, fieldNameKey] of fieldsKeyMap) {
             const selectionSetNode = utils.parseSelectionSet(`{${fieldNameKey}}`);
-            (function aliasFieldsWithArgs(selectionSetNode2) {
-              for (const selection of selectionSetNode2.selections) {
-                if (selection.kind === graphql.Kind.FIELD && selection.arguments?.length) {
-                  const argsHash = selection.arguments.map(
-                    (arg) => arg.name.value + // TODO: slow? faster hash?
-                    memoizedASTPrint(arg.value).replace(
-                      /[^a-zA-Z0-9]/g,
-                      ""
-                    )
-                  ).join("");
-                  selection.alias = {
-                    kind: graphql.Kind.NAME,
-                    value: "_" + selection.name.value + "_" + argsHash
-                  };
-                }
-                if ("selectionSet" in selection && selection.selectionSet) {
-                  aliasFieldsWithArgs(selection.selectionSet);
-                }
-              }
-            })(selectionSetNode);
+            aliasFieldsWithArgs2(selectionSetNode);
             const selectionSet = graphql.print(selectionSetNode).replaceAll(/\n/g, " ").replaceAll(/\s+/g, " ");
-            extraKeys.add(
+            const extraKey = (
               // remove first and last characters (curly braces)
               selectionSet.slice(1, -1)
             );
-            fieldsConfig[fieldName] = {
+            const fieldAliasedNames = /* @__PURE__ */ new Map();
+            for (const sel of selectionSetNode.selections) {
+              if (sel.kind === graphql.Kind.FIELD && sel.alias) {
+                fieldAliasedNames.set(sel.name.value, sel.alias.value);
+              }
+            }
+            let targetGroup;
+            for (const group of groups) {
+              let hasConflict = false;
+              for (const [origName, aliasName] of fieldAliasedNames) {
+                const existingAlias = group.aliasedFields.get(origName);
+                if (existingAlias !== void 0 && existingAlias !== aliasName) {
+                  hasConflict = true;
+                  break;
+                }
+              }
+              if (!hasConflict) {
+                targetGroup = group;
+                break;
+              }
+            }
+            if (!targetGroup) {
+              const newExtraKeys = /* @__PURE__ */ new Set();
+              const newFieldsConfig = {};
+              targetGroup = {
+                extraKeys: newExtraKeys,
+                fieldsConfig: newFieldsConfig,
+                aliasedFields: /* @__PURE__ */ new Map()
+              };
+              groups.push(targetGroup);
+            }
+            targetGroup.extraKeys.add(extraKey);
+            targetGroup.fieldsConfig[fieldName] = {
               selectionSet,
               computed: true
             };
+            for (const [origName, aliasName] of fieldAliasedNames) {
+              targetGroup.aliasedFields.set(origName, aliasName);
+            }
+          }
+          for (const group of groups.slice(1)) {
+            const additionalMergeTypeConfig = {
+              fields: group.fieldsConfig
+            };
+            if (typeNameCanonicalMap.get(typeName) === subgraphName) {
+              additionalMergeTypeConfig.canonical = true;
+            }
+            pendingConflictSubschemaConfigs.push({
+              typeName,
+              // Store closure-captured values for later SubschemaConfig creation
+              // by borrowing getMergedTypeConfigFromKey with the group's extraKeys.
+              mergeTypeConfig: additionalMergeTypeConfig,
+              groupExtraKeys: group.extraKeys
+            });
           }
         }
         if (typeNameCanonicalMap.get(typeName) === subgraphName) {
@@ -1341,6 +1397,21 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
           );
           mergedTypeConfig.entryPoints = entryPoints;
         }
+        for (const pending of pendingConflictSubschemaConfigs) {
+          if (pending.typeName === typeName && !("selectionSet" in pending.mergeTypeConfig) && !("entryPoints" in pending.mergeTypeConfig)) {
+            const groupExtraKeys = pending.groupExtraKeys;
+            if (keysArr.length === 1 && keysArr[0]) {
+              Object.assign(
+                pending.mergeTypeConfig,
+                getMergedTypeConfigFromKey2(keysArr[0], groupExtraKeys)
+              );
+            } else if (keysArr.length > 1) {
+              pending.mergeTypeConfig.entryPoints = keysArr.map(
+                (key) => getMergedTypeConfigFromKey2(key, groupExtraKeys)
+              );
+            }
+          }
+        }
         unionTypeNodes.push({
           kind: graphql.Kind.NAMED_TYPE,
           name: {
@@ -1731,10 +1802,55 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
         }
       }
     }
+    let mainSchema = schema;
+    const additionalGroupFieldsByType = /* @__PURE__ */ new Map();
+    for (const {
+      typeName,
+      mergeTypeConfig
+    } of pendingConflictSubschemaConfigs) {
+      for (const [fieldName, fieldConfig] of Object.entries(
+        mergeTypeConfig.fields ?? {}
+      )) {
+        if (!fieldConfig?.computed) continue;
+        let set = additionalGroupFieldsByType.get(typeName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          additionalGroupFieldsByType.set(typeName, set);
+        }
+        set.add(fieldName);
+      }
+    }
+    if (additionalGroupFieldsByType.size > 0) {
+      mainSchema = utils.mapSchema(schema, {
+        [utils.MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
+          if (additionalGroupFieldsByType.get(typeName)?.has(fieldName)) {
+            return null;
+          }
+          return fieldConfig;
+        }
+      });
+    }
+    const allComputedFieldsByType = new Map(
+      Array.from(additionalGroupFieldsByType, ([t, s]) => [t, new Set(s)])
+    );
+    for (const [typeName, typeConfig] of Object.entries(mergeConfig)) {
+      if (!typeConfig?.fields) continue;
+      for (const [fieldName, fieldConfig] of Object.entries(
+        typeConfig.fields
+      )) {
+        if (!fieldConfig?.computed) continue;
+        let set = allComputedFieldsByType.get(typeName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          allComputedFieldsByType.set(typeName, set);
+        }
+        set.add(fieldName);
+      }
+    }
     const subschemaConfig = {
       name: subgraphName,
       endpoint,
-      schema,
+      schema: mainSchema,
       executor: executor$1,
       merge: mergeConfig,
       transforms,
@@ -1742,6 +1858,36 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
       batchingOptions: opts.batchingOptions
     };
     subschemas.push(subschemaConfig);
+    for (const {
+      typeName,
+      mergeTypeConfig
+    } of pendingConflictSubschemaConfigs) {
+      const groupOwnFields = new Set(
+        Object.entries(mergeTypeConfig.fields ?? {}).filter(([, fc]) => fc?.computed).map(([fn]) => fn)
+      );
+      const allComputedForType = allComputedFieldsByType.get(typeName) ?? /* @__PURE__ */ new Set();
+      const fieldsToRemove = new Set(
+        [...allComputedForType].filter((f) => !groupOwnFields.has(f))
+      );
+      const groupSchema = fieldsToRemove.size > 0 ? utils.mapSchema(schema, {
+        [utils.MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, type) => {
+          if (type === typeName && fieldsToRemove.has(fieldName)) {
+            return null;
+          }
+          return fieldConfig;
+        }
+      }) : schema;
+      subschemas.push({
+        name: subgraphName,
+        endpoint,
+        schema: groupSchema,
+        executor: executor$1,
+        merge: { [typeName]: mergeTypeConfig },
+        transforms,
+        batch: opts.batch,
+        batchingOptions: opts.batchingOptions
+      });
+    }
   }
   const defaultMerger = stitch.getDefaultFieldConfigMerger(true);
   const fieldConfigMerger = function(candidates) {

package/dist/index.js

@@ -1270,14 +1270,15 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
     const mergeConfig = {};
     const typeNameKeyMap = typeNameKeysBySubgraphMap.get(subgraphName);
     const unionTypeNodes = [];
+    const pendingConflictSubschemaConfigs = [];
     if (typeNameKeyMap) {
       const typeNameFieldsKeyMap = typeNameFieldsKeyBySubgraphMap.get(subgraphName);
       for (const [typeName, keys] of typeNameKeyMap) {
-        let getMergedTypeConfigFromKey2 = function(key) {
+        let getMergedTypeConfigFromKey2 = function(key, keysExtraKeys = extraKeys) {
           return {
             selectionSet: `{ ${key} }`,
             argsFromKeys: getArgsFromKeysForFederation,
-            key: getKeyFnForFederation(typeName, [key, ...extraKeys]),
+            key: getKeyFnForFederation(typeName, [key, ...keysExtraKeys]),
             fieldName: `_entities`,
             dataLoaderOptions: {
               cacheKeyFn: getCacheKeyFnFromKey(key),
@@ -1289,38 +1290,93 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
         const fieldsKeyMap = typeNameFieldsKeyMap?.get(typeName);
         const extraKeys = /* @__PURE__ */ new Set();
         if (fieldsKeyMap) {
-          const fieldsConfig = mergedTypeConfig.fields = {};
+          let aliasFieldsWithArgs2 = function(selectionSetNode) {
+            for (const selection of selectionSetNode.selections) {
+              if (selection.kind === Kind.FIELD && selection.arguments?.length) {
+                const argsHash = selection.arguments.map(
+                  (arg) => arg.name.value + // TODO: slow? faster hash?
+                  memoizedASTPrint(arg.value).replace(/[^a-zA-Z0-9]/g, "")
+                ).join("");
+                selection.alias = {
+                  kind: Kind.NAME,
+                  value: "_" + selection.name.value + "_" + argsHash
+                };
+              }
+              if ("selectionSet" in selection && selection.selectionSet) {
+                aliasFieldsWithArgs2(selection.selectionSet);
+              }
+            }
+          };
+          const mainFieldsConfig = mergedTypeConfig.fields = {};
+          const groups = [
+            {
+              extraKeys,
+              fieldsConfig: mainFieldsConfig,
+              aliasedFields: /* @__PURE__ */ new Map()
+            }
+          ];
           for (const [fieldName, fieldNameKey] of fieldsKeyMap) {
             const selectionSetNode = parseSelectionSet(`{${fieldNameKey}}`);
-            (function aliasFieldsWithArgs(selectionSetNode2) {
-              for (const selection of selectionSetNode2.selections) {
-                if (selection.kind === Kind.FIELD && selection.arguments?.length) {
-                  const argsHash = selection.arguments.map(
-                    (arg) => arg.name.value + // TODO: slow? faster hash?
-                    memoizedASTPrint(arg.value).replace(
-                      /[^a-zA-Z0-9]/g,
-                      ""
-                    )
-                  ).join("");
-                  selection.alias = {
-                    kind: Kind.NAME,
-                    value: "_" + selection.name.value + "_" + argsHash
-                  };
-                }
-                if ("selectionSet" in selection && selection.selectionSet) {
-                  aliasFieldsWithArgs(selection.selectionSet);
-                }
-              }
-            })(selectionSetNode);
+            aliasFieldsWithArgs2(selectionSetNode);
             const selectionSet = print(selectionSetNode).replaceAll(/\n/g, " ").replaceAll(/\s+/g, " ");
-            extraKeys.add(
+            const extraKey = (
               // remove first and last characters (curly braces)
               selectionSet.slice(1, -1)
             );
-            fieldsConfig[fieldName] = {
+            const fieldAliasedNames = /* @__PURE__ */ new Map();
+            for (const sel of selectionSetNode.selections) {
+              if (sel.kind === Kind.FIELD && sel.alias) {
+                fieldAliasedNames.set(sel.name.value, sel.alias.value);
+              }
+            }
+            let targetGroup;
+            for (const group of groups) {
+              let hasConflict = false;
+              for (const [origName, aliasName] of fieldAliasedNames) {
+                const existingAlias = group.aliasedFields.get(origName);
+                if (existingAlias !== void 0 && existingAlias !== aliasName) {
+                  hasConflict = true;
+                  break;
+                }
+              }
+              if (!hasConflict) {
+                targetGroup = group;
+                break;
+              }
+            }
+            if (!targetGroup) {
+              const newExtraKeys = /* @__PURE__ */ new Set();
+              const newFieldsConfig = {};
+              targetGroup = {
+                extraKeys: newExtraKeys,
+                fieldsConfig: newFieldsConfig,
+                aliasedFields: /* @__PURE__ */ new Map()
+              };
+              groups.push(targetGroup);
+            }
+            targetGroup.extraKeys.add(extraKey);
+            targetGroup.fieldsConfig[fieldName] = {
               selectionSet,
               computed: true
             };
+            for (const [origName, aliasName] of fieldAliasedNames) {
+              targetGroup.aliasedFields.set(origName, aliasName);
+            }
+          }
+          for (const group of groups.slice(1)) {
+            const additionalMergeTypeConfig = {
+              fields: group.fieldsConfig
+            };
+            if (typeNameCanonicalMap.get(typeName) === subgraphName) {
+              additionalMergeTypeConfig.canonical = true;
+            }
+            pendingConflictSubschemaConfigs.push({
+              typeName,
+              // Store closure-captured values for later SubschemaConfig creation
+              // by borrowing getMergedTypeConfigFromKey with the group's extraKeys.
+              mergeTypeConfig: additionalMergeTypeConfig,
+              groupExtraKeys: group.extraKeys
+            });
           }
         }
         if (typeNameCanonicalMap.get(typeName) === subgraphName) {
@@ -1339,6 +1395,21 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
           );
           mergedTypeConfig.entryPoints = entryPoints;
         }
+        for (const pending of pendingConflictSubschemaConfigs) {
+          if (pending.typeName === typeName && !("selectionSet" in pending.mergeTypeConfig) && !("entryPoints" in pending.mergeTypeConfig)) {
+            const groupExtraKeys = pending.groupExtraKeys;
+            if (keysArr.length === 1 && keysArr[0]) {
+              Object.assign(
+                pending.mergeTypeConfig,
+                getMergedTypeConfigFromKey2(keysArr[0], groupExtraKeys)
+              );
+            } else if (keysArr.length > 1) {
+              pending.mergeTypeConfig.entryPoints = keysArr.map(
+                (key) => getMergedTypeConfigFromKey2(key, groupExtraKeys)
+              );
+            }
+          }
+        }
         unionTypeNodes.push({
           kind: Kind.NAMED_TYPE,
           name: {
@@ -1729,10 +1800,55 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
         }
       }
     }
+    let mainSchema = schema;
+    const additionalGroupFieldsByType = /* @__PURE__ */ new Map();
+    for (const {
+      typeName,
+      mergeTypeConfig
+    } of pendingConflictSubschemaConfigs) {
+      for (const [fieldName, fieldConfig] of Object.entries(
+        mergeTypeConfig.fields ?? {}
+      )) {
+        if (!fieldConfig?.computed) continue;
+        let set = additionalGroupFieldsByType.get(typeName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          additionalGroupFieldsByType.set(typeName, set);
+        }
+        set.add(fieldName);
+      }
+    }
+    if (additionalGroupFieldsByType.size > 0) {
+      mainSchema = mapSchema(schema, {
+        [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
+          if (additionalGroupFieldsByType.get(typeName)?.has(fieldName)) {
+            return null;
+          }
+          return fieldConfig;
+        }
+      });
+    }
+    const allComputedFieldsByType = new Map(
+      Array.from(additionalGroupFieldsByType, ([t, s]) => [t, new Set(s)])
+    );
+    for (const [typeName, typeConfig] of Object.entries(mergeConfig)) {
+      if (!typeConfig?.fields) continue;
+      for (const [fieldName, fieldConfig] of Object.entries(
+        typeConfig.fields
+      )) {
+        if (!fieldConfig?.computed) continue;
+        let set = allComputedFieldsByType.get(typeName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          allComputedFieldsByType.set(typeName, set);
+        }
+        set.add(fieldName);
+      }
+    }
     const subschemaConfig = {
       name: subgraphName,
       endpoint,
-      schema,
+      schema: mainSchema,
       executor,
       merge: mergeConfig,
       transforms,
@@ -1740,6 +1856,36 @@ function getStitchingOptionsFromSupergraphSdl(opts) {
       batchingOptions: opts.batchingOptions
     };
     subschemas.push(subschemaConfig);
+    for (const {
+      typeName,
+      mergeTypeConfig
+    } of pendingConflictSubschemaConfigs) {
+      const groupOwnFields = new Set(
+        Object.entries(mergeTypeConfig.fields ?? {}).filter(([, fc]) => fc?.computed).map(([fn]) => fn)
+      );
+      const allComputedForType = allComputedFieldsByType.get(typeName) ?? /* @__PURE__ */ new Set();
+      const fieldsToRemove = new Set(
+        [...allComputedForType].filter((f) => !groupOwnFields.has(f))
+      );
+      const groupSchema = fieldsToRemove.size > 0 ? mapSchema(schema, {
+        [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, type) => {
+          if (type === typeName && fieldsToRemove.has(fieldName)) {
+            return null;
+          }
+          return fieldConfig;
+        }
+      }) : schema;
+      subschemas.push({
+        name: subgraphName,
+        endpoint,
+        schema: groupSchema,
+        executor,
+        merge: { [typeName]: mergeTypeConfig },
+        transforms,
+        batch: opts.batch,
+        batchingOptions: opts.batchingOptions
+      });
+    }
   }
   const defaultMerger = getDefaultFieldConfigMerger(true);
   const fieldConfigMerger = function(candidates) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/federation",
-  "version": "4.4.2",
+  "version": "4.4.3-alpha-12654e24df4f034d8c7112f5052f1b37674985ae",
   "type": "module",
   "description": "Useful tools to create and manipulate GraphQL schemas.",
   "repository": {