@graphql-tools/stitching-directives 3.1.13 → 3.1.14-alpha-c1f969d9556b274c8e1313a3d2a4742f231bc03a

package/dist/index.cjs

@@ -0,0 +1,1196 @@
+'use strict';
+
+var graphql = require('graphql');
+var delegate = require('@graphql-tools/delegate');
+var utils = require('@graphql-tools/utils');
+
+const defaultStitchingDirectiveOptions = {
+  keyDirectiveName: "key",
+  computedDirectiveName: "computed",
+  canonicalDirectiveName: "canonical",
+  mergeDirectiveName: "merge",
+  pathToDirectivesInExtensions: ["directives"]
+};
+
+function extractVariables(inputValue) {
+  const path = [];
+  const variablePaths = /* @__PURE__ */ Object.create(null);
+  const keyPathVisitor = {
+    enter: (_node, key) => {
+      if (typeof key === "number") {
+        path.push(key);
+      }
+    },
+    leave: (_node, key) => {
+      if (typeof key === "number") {
+        path.pop();
+      }
+    }
+  };
+  const fieldPathVisitor = {
+    enter: (node) => {
+      path.push(node.name.value);
+    },
+    leave: () => {
+      path.pop();
+    }
+  };
+  const variableVisitor = {
+    enter: (node, key) => {
+      if (typeof key === "number") {
+        variablePaths[node.name.value] = path.concat([key]);
+      } else {
+        variablePaths[node.name.value] = path.slice();
+      }
+      return {
+        kind: graphql.Kind.NULL
+      };
+    }
+  };
+  const newInputValue = graphql.visit(inputValue, {
+    [graphql.Kind.OBJECT]: keyPathVisitor,
+    [graphql.Kind.LIST]: keyPathVisitor,
+    [graphql.Kind.OBJECT_FIELD]: fieldPathVisitor,
+    [graphql.Kind.VARIABLE]: variableVisitor
+  });
+  return {
+    inputValue: newInputValue,
+    variablePaths
+  };
+}
+
+function pathsFromSelectionSet(selectionSet, path = []) {
+  const paths = [];
+  for (const selection of selectionSet.selections) {
+    const additions = pathsFromSelection(selection, path) ?? [];
+    for (const addition of additions) {
+      paths.push(addition);
+    }
+  }
+  return paths;
+}
+function pathsFromSelection(selection, path) {
+  if (selection.kind === graphql.Kind.FIELD) {
+    const responseKey = selection.alias?.value ?? selection.name.value;
+    if (selection.selectionSet) {
+      return pathsFromSelectionSet(
+        selection.selectionSet,
+        path.concat([responseKey])
+      );
+    } else {
+      return [path.concat([responseKey])];
+    }
+  } else if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+    return pathsFromSelectionSet(selection.selectionSet, path);
+  }
+  return void 0;
+}
+
+function getSourcePaths(mappingInstructions, selectionSet) {
+  const sourcePaths = [];
+  for (const mappingInstruction of mappingInstructions) {
+    const { sourcePath } = mappingInstruction;
+    if (sourcePath.length) {
+      sourcePaths.push(sourcePath);
+      continue;
+    }
+    if (selectionSet == null) {
+      continue;
+    }
+    const paths = pathsFromSelectionSet(selectionSet);
+    for (const path of paths) {
+      sourcePaths.push(path);
+    }
+    sourcePaths.push([graphql.TypeNameMetaFieldDef.name]);
+  }
+  return sourcePaths;
+}
+
+const KEY_DELIMITER = "__dot__";
+const EXPANSION_PREFIX = "__exp";
+function preparseMergeArgsExpr(mergeArgsExpr) {
+  const variableRegex = /\$[_A-Za-z][_A-Za-z0-9.]*/g;
+  const dotRegex = /\./g;
+  mergeArgsExpr = mergeArgsExpr.replace(
+    variableRegex,
+    (variable) => variable.replace(dotRegex, KEY_DELIMITER)
+  );
+  const segments = mergeArgsExpr.split("[[");
+  const expansionExpressions = /* @__PURE__ */ Object.create(null);
+  if (segments.length === 1) {
+    return { mergeArgsExpr, expansionExpressions };
+  }
+  let finalSegments = [segments[0]];
+  for (let i = 1; i < segments.length; i++) {
+    const additionalSegments = segments[i]?.split("]]");
+    if (additionalSegments?.length !== 2) {
+      throw new Error(
+        `Each opening "[[" must be matched by a closing "]]" without nesting.`
+      );
+    }
+    finalSegments = finalSegments.concat(additionalSegments);
+  }
+  let finalMergeArgsExpr = finalSegments[0];
+  for (let i = 1; i < finalSegments.length - 1; i += 2) {
+    const variableName = `${EXPANSION_PREFIX}${(i - 1) / 2 + 1}`;
+    expansionExpressions[variableName] = finalSegments[i];
+    finalMergeArgsExpr += `$${variableName}${finalSegments[i + 1]}`;
+  }
+  return { mergeArgsExpr: finalMergeArgsExpr, expansionExpressions };
+}
+
+function addProperty(object, path, value) {
+  const initialSegment = path[0];
+  if (path.length === 1) {
+    object[initialSegment] = value;
+    return;
+  }
+  let field = object[initialSegment];
+  if (field != null) {
+    addProperty(field, path.slice(1), value);
+    return;
+  }
+  if (typeof path[1] === "string") {
+    field = /* @__PURE__ */ Object.create(null);
+  } else {
+    field = [];
+  }
+  addProperty(field, path.slice(1), value);
+  object[initialSegment] = field;
+}
+function getProperty(object, path) {
+  if (!path.length || object == null) {
+    return object;
+  }
+  const newPath = path.slice();
+  const key = newPath.shift();
+  if (key == null) {
+    return;
+  }
+  const prop = object[key];
+  return getProperty(prop, newPath);
+}
+function getProperties(object, propertyTree) {
+  if (object == null) {
+    return object;
+  }
+  const newObject = /* @__PURE__ */ Object.create(null);
+  for (const key in propertyTree) {
+    const subKey = propertyTree[key];
+    if (subKey == null) {
+      newObject[key] = object[key];
+      continue;
+    }
+    const prop = object[key];
+    newObject[key] = deepMap(prop, function deepMapFn(item) {
+      return getProperties(item, subKey);
+    });
+  }
+  return newObject;
+}
+function propertyTreeFromPaths(paths) {
+  const propertyTree = /* @__PURE__ */ Object.create(null);
+  for (const path of paths) {
+    addProperty(propertyTree, path, null);
+  }
+  return propertyTree;
+}
+function deepMap(arrayOrItem, fn) {
+  if (Array.isArray(arrayOrItem)) {
+    return arrayOrItem.map(
+      (nestedArrayOrItem) => deepMap(nestedArrayOrItem, fn)
+    );
+  }
+  return fn(arrayOrItem);
+}
+
+function parseMergeArgsExpr(mergeArgsExpr, selectionSet) {
+  const { mergeArgsExpr: newMergeArgsExpr, expansionExpressions } = preparseMergeArgsExpr(mergeArgsExpr);
+  const inputValue = graphql.parseValue(`{ ${newMergeArgsExpr} }`, {
+    noLocation: true
+  });
+  const { inputValue: newInputValue, variablePaths } = extractVariables(inputValue);
+  if (!Object.keys(expansionExpressions).length) {
+    if (!Object.keys(variablePaths).length) {
+      throw new Error("Merge arguments must declare a key.");
+    }
+    const mappingInstructions = getMappingInstructions(variablePaths);
+    const usedProperties2 = propertyTreeFromPaths(
+      getSourcePaths(mappingInstructions, selectionSet)
+    );
+    return {
+      args: graphql.valueFromASTUntyped(newInputValue),
+      usedProperties: usedProperties2,
+      mappingInstructions
+    };
+  }
+  const expansionRegEx = new RegExp(`^${EXPANSION_PREFIX}[0-9]+$`);
+  for (const variableName in variablePaths) {
+    if (!variableName.match(expansionRegEx)) {
+      throw new Error(
+        "Expansions cannot be mixed with single key declarations."
+      );
+    }
+  }
+  const expansions = [];
+  const sourcePaths = [];
+  for (const variableName in expansionExpressions) {
+    const str = expansionExpressions[variableName];
+    const valuePath = variablePaths[variableName];
+    const {
+      inputValue: expansionInputValue,
+      variablePaths: expansionVariablePaths
+    } = extractVariables(graphql.parseValue(`${str}`, { noLocation: true }));
+    if (!Object.keys(expansionVariablePaths).length) {
+      throw new Error("Merge arguments must declare a key.");
+    }
+    const mappingInstructions = getMappingInstructions(expansionVariablePaths);
+    const value = graphql.valueFromASTUntyped(expansionInputValue);
+    sourcePaths.push(...getSourcePaths(mappingInstructions, selectionSet));
+    assertNotWithinList(valuePath);
+    expansions.push({
+      valuePath,
+      value,
+      mappingInstructions
+    });
+  }
+  const usedProperties = propertyTreeFromPaths(sourcePaths);
+  return {
+    args: graphql.valueFromASTUntyped(newInputValue),
+    usedProperties,
+    expansions
+  };
+}
+function getMappingInstructions(variablePaths) {
+  const mappingInstructions = [];
+  for (const keyPath in variablePaths) {
+    const valuePath = variablePaths[keyPath];
+    const splitKeyPath = keyPath.split(KEY_DELIMITER).slice(1);
+    assertNotWithinList(valuePath);
+    mappingInstructions.push({
+      destinationPath: valuePath,
+      sourcePath: splitKeyPath
+    });
+  }
+  return mappingInstructions;
+}
+function assertNotWithinList(path) {
+  for (const pathSegment of path) {
+    if (typeof pathSegment === "number") {
+      throw new Error("Insertions cannot be made into a list.");
+    }
+  }
+}
+
+function stitchingDirectivesTransformer(options = {}) {
+  const {
+    keyDirectiveName,
+    computedDirectiveName,
+    mergeDirectiveName,
+    canonicalDirectiveName,
+    pathToDirectivesInExtensions
+  } = {
+    ...defaultStitchingDirectiveOptions,
+    ...options
+  };
+  return (subschemaConfig) => {
+    const newSubschemaConfig = delegate.cloneSubschemaConfig(subschemaConfig);
+    const selectionSetsByType = /* @__PURE__ */ Object.create(null);
+    const computedFieldSelectionSets = /* @__PURE__ */ Object.create(null);
+    const mergedTypesResolversInfo = /* @__PURE__ */ Object.create(null);
+    const canonicalTypesInfo = /* @__PURE__ */ Object.create(null);
+    const selectionSetsByTypeAndEntryField = /* @__PURE__ */ Object.create(null);
+    const mergedTypesResolversInfoByEntryField = /* @__PURE__ */ Object.create(null);
+    const schema = subschemaConfig.schema;
+    function setCanonicalDefinition(typeName, fieldName) {
+      canonicalTypesInfo[typeName] = canonicalTypesInfo[typeName] || /* @__PURE__ */ Object.create(null);
+      if (fieldName) {
+        const fields = canonicalTypesInfo[typeName]?.fields ?? /* @__PURE__ */ Object.create(null);
+        canonicalTypesInfo[typeName].fields = fields;
+        fields[fieldName] = true;
+      } else {
+        canonicalTypesInfo[typeName].canonical = true;
+      }
+    }
+    utils.mapSchema(schema, {
+      [utils.MapperKind.OBJECT_TYPE]: (type) => {
+        const keyDirective = utils.getDirective(
+          schema,
+          type,
+          keyDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (keyDirective != null) {
+          const selectionSet = utils.parseSelectionSet(keyDirective["selectionSet"], {
+            noLocation: true
+          });
+          selectionSetsByType[type.name] = selectionSet;
+        }
+        const canonicalDirective = utils.getDirective(
+          schema,
+          type,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective != null) {
+          setCanonicalDefinition(type.name);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
+        const computedDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          computedDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (computedDirective != null) {
+          const selectionSet = utils.parseSelectionSet(
+            computedDirective["selectionSet"],
+            {
+              noLocation: true
+            }
+          );
+          if (!computedFieldSelectionSets[typeName]) {
+            computedFieldSelectionSets[typeName] = /* @__PURE__ */ Object.create(null);
+          }
+          computedFieldSelectionSets[typeName][fieldName] = selectionSet;
+        }
+        const mergeDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          mergeDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (mergeDirective?.["keyField"] != null) {
+          const mergeDirectiveKeyField = mergeDirective["keyField"];
+          const selectionSet = utils.parseSelectionSet(
+            `{ ${mergeDirectiveKeyField}}`,
+            {
+              noLocation: true
+            }
+          );
+          const typeNames = mergeDirective["types"];
+          const returnType = graphql.getNamedType(fieldConfig.type);
+          forEachConcreteType(schema, returnType, typeNames, (typeName2) => {
+            if (typeNames == null || typeNames.includes(typeName2)) {
+              let existingEntryFieldMap = selectionSetsByTypeAndEntryField[typeName2];
+              if (existingEntryFieldMap == null) {
+                existingEntryFieldMap = /* @__PURE__ */ Object.create(null);
+                selectionSetsByTypeAndEntryField[typeName2] = existingEntryFieldMap;
+              }
+              let existingSelectionSet = existingEntryFieldMap[fieldName];
+              if (existingSelectionSet == null) {
+                existingSelectionSet = selectionSetsByType[typeName2];
+              }
+              existingEntryFieldMap[fieldName] = existingSelectionSet ? mergeSelectionSets(existingSelectionSet, selectionSet) : selectionSet;
+            }
+          });
+        }
+        const canonicalDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective != null) {
+          setCanonicalDefinition(typeName, fieldName);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.INTERFACE_TYPE]: (type) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          type,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective) {
+          setCanonicalDefinition(type.name);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.INTERFACE_FIELD]: (fieldConfig, fieldName, typeName) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective) {
+          setCanonicalDefinition(typeName, fieldName);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.INPUT_OBJECT_TYPE]: (type) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          type,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective) {
+          setCanonicalDefinition(type.name);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          inputFieldConfig,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective != null) {
+          setCanonicalDefinition(typeName, fieldName);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.UNION_TYPE]: (type) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          type,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective != null) {
+          setCanonicalDefinition(type.name);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.ENUM_TYPE]: (type) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          type,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective != null) {
+          setCanonicalDefinition(type.name);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.SCALAR_TYPE]: (type) => {
+        const canonicalDirective = utils.getDirective(
+          schema,
+          type,
+          canonicalDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (canonicalDirective != null) {
+          setCanonicalDefinition(type.name);
+        }
+        return void 0;
+      }
+    });
+    if (subschemaConfig.merge) {
+      for (const typeName in subschemaConfig.merge) {
+        const mergedTypeConfig = subschemaConfig.merge[typeName];
+        if (mergedTypeConfig?.selectionSet) {
+          const selectionSet = utils.parseSelectionSet(
+            mergedTypeConfig.selectionSet,
+            {
+              noLocation: true
+            }
+          );
+          if (selectionSet) {
+            if (selectionSetsByType[typeName]) {
+              selectionSetsByType[typeName] = mergeSelectionSets(
+                selectionSetsByType[typeName],
+                selectionSet
+              );
+            } else {
+              selectionSetsByType[typeName] = selectionSet;
+            }
+          }
+        }
+        if (mergedTypeConfig?.fields) {
+          for (const fieldName in mergedTypeConfig.fields) {
+            const fieldConfig = mergedTypeConfig.fields[fieldName];
+            if (!fieldConfig?.selectionSet) continue;
+            const selectionSet = utils.parseSelectionSet(fieldConfig.selectionSet, {
+              noLocation: true
+            });
+            if (selectionSet) {
+              if (computedFieldSelectionSets[typeName]?.[fieldName]) {
+                computedFieldSelectionSets[typeName][fieldName] = mergeSelectionSets(
+                  computedFieldSelectionSets[typeName][fieldName],
+                  selectionSet
+                );
+              } else {
+                if (computedFieldSelectionSets[typeName] == null) {
+                  computedFieldSelectionSets[typeName] = /* @__PURE__ */ Object.create(null);
+                }
+                computedFieldSelectionSets[typeName][fieldName] = selectionSet;
+              }
+            }
+          }
+        }
+      }
+    }
+    const allSelectionSetsByType = /* @__PURE__ */ Object.create(null);
+    for (const typeName in selectionSetsByType) {
+      allSelectionSetsByType[typeName] = allSelectionSetsByType[typeName] || [];
+      const selectionSet = selectionSetsByType[typeName];
+      allSelectionSetsByType[typeName].push(selectionSet);
+    }
+    for (const typeName in computedFieldSelectionSets) {
+      const selectionSets = computedFieldSelectionSets[typeName];
+      for (const i in selectionSets) {
+        allSelectionSetsByType[typeName] = allSelectionSetsByType[typeName] || [];
+        const selectionSet = selectionSets[i];
+        allSelectionSetsByType[typeName].push(selectionSet);
+      }
+    }
+    utils.mapSchema(schema, {
+      [utils.MapperKind.OBJECT_FIELD]: function objectFieldMapper(fieldConfig, fieldName) {
+        const mergeDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          mergeDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (mergeDirective != null) {
+          const returnType = graphql.getNullableType(fieldConfig.type);
+          const returnsList = graphql.isListType(returnType);
+          const namedType = graphql.getNamedType(returnType);
+          let mergeArgsExpr = mergeDirective["argsExpr"];
+          if (mergeArgsExpr == null) {
+            const key = mergeDirective["key"];
+            const keyField = mergeDirective["keyField"];
+            const keyExpr = key != null ? buildKeyExpr(key) : keyField != null ? `$key.${keyField}` : "$key";
+            const keyArg = mergeDirective["keyArg"];
+            const argNames = keyArg == null ? [Object.keys(fieldConfig.args ?? {})[0]] : keyArg.split(".");
+            const lastArgName = argNames.pop();
+            mergeArgsExpr = returnsList ? `${lastArgName}: [[${keyExpr}]]` : `${lastArgName}: ${keyExpr}`;
+            for (const argName of argNames.reverse()) {
+              mergeArgsExpr = `${argName}: { ${mergeArgsExpr} }`;
+            }
+          }
+          const typeNames = mergeDirective["types"];
+          forEachConcreteTypeName(
+            namedType,
+            schema,
+            typeNames,
+            function generateResolveInfo(typeName) {
+              const mergedSelectionSets = [];
+              if (allSelectionSetsByType[typeName]) {
+                mergedSelectionSets.push(...allSelectionSetsByType[typeName]);
+              }
+              if (selectionSetsByTypeAndEntryField[typeName]?.[fieldName]) {
+                mergedSelectionSets.push(
+                  selectionSetsByTypeAndEntryField[typeName][fieldName]
+                );
+              }
+              const parsedMergeArgsExpr = parseMergeArgsExpr(
+                mergeArgsExpr,
+                allSelectionSetsByType[typeName] == null ? void 0 : mergeSelectionSets(...mergedSelectionSets)
+              );
+              const additionalArgs = mergeDirective["additionalArgs"];
+              if (additionalArgs != null) {
+                parsedMergeArgsExpr.args = utils.mergeDeep([
+                  parsedMergeArgsExpr.args,
+                  graphql.valueFromASTUntyped(
+                    graphql.parseValue(`{ ${additionalArgs} }`, { noLocation: true })
+                  )
+                ]);
+              }
+              if (selectionSetsByTypeAndEntryField[typeName]?.[fieldName] != null) {
+                const typeConfigByField = mergedTypesResolversInfoByEntryField[typeName] ||= /* @__PURE__ */ Object.create(null);
+                typeConfigByField[fieldName] = {
+                  fieldName,
+                  returnsList,
+                  ...parsedMergeArgsExpr
+                };
+              } else {
+                mergedTypesResolversInfo[typeName] = {
+                  fieldName,
+                  returnsList,
+                  ...parsedMergeArgsExpr
+                };
+              }
+            }
+          );
+        }
+        return void 0;
+      }
+    });
+    for (const typeName in selectionSetsByType) {
+      const selectionSet = selectionSetsByType[typeName];
+      const mergeConfig = newSubschemaConfig.merge ?? /* @__PURE__ */ Object.create(null);
+      newSubschemaConfig.merge = mergeConfig;
+      if (mergeConfig[typeName] == null) {
+        newSubschemaConfig.merge[typeName] = /* @__PURE__ */ Object.create(null);
+      }
+      const mergeTypeConfig = mergeConfig[typeName];
+      mergeTypeConfig.selectionSet = graphql.print(selectionSet);
+    }
+    for (const typeName in computedFieldSelectionSets) {
+      const selectionSets = computedFieldSelectionSets[typeName];
+      const mergeConfig = newSubschemaConfig.merge ?? /* @__PURE__ */ Object.create(null);
+      newSubschemaConfig.merge = mergeConfig;
+      if (mergeConfig[typeName] == null) {
+        mergeConfig[typeName] = /* @__PURE__ */ Object.create(null);
+      }
+      const mergeTypeConfig = newSubschemaConfig.merge[typeName];
+      const mergeTypeConfigFields = mergeTypeConfig.fields ?? /* @__PURE__ */ Object.create(null);
+      mergeTypeConfig.fields = mergeTypeConfigFields;
+      for (const fieldName in selectionSets) {
+        const selectionSet = selectionSets[fieldName];
+        const fieldConfig = mergeTypeConfigFields[fieldName] ?? /* @__PURE__ */ Object.create(null);
+        mergeTypeConfigFields[fieldName] = fieldConfig;
+        fieldConfig.selectionSet = graphql.print(selectionSet);
+        fieldConfig.computed = true;
+      }
+    }
+    for (const typeName in mergedTypesResolversInfo) {
+      const mergedTypeResolverInfo = mergedTypesResolversInfo[typeName];
+      const mergeConfig = newSubschemaConfig.merge ?? /* @__PURE__ */ Object.create(null);
+      newSubschemaConfig.merge = mergeConfig;
+      if (newSubschemaConfig.merge[typeName] == null) {
+        newSubschemaConfig.merge[typeName] = /* @__PURE__ */ Object.create(null);
+      }
+      const mergeTypeConfig = newSubschemaConfig.merge[typeName];
+      mergeTypeConfig.fieldName = mergedTypeResolverInfo.fieldName;
+      if (mergedTypeResolverInfo.returnsList) {
+        mergeTypeConfig.key = generateKeyFn(mergedTypeResolverInfo);
+        mergeTypeConfig.argsFromKeys = generateArgsFromKeysFn(
+          mergedTypeResolverInfo
+        );
+      } else {
+        mergeTypeConfig.args = generateArgsFn(mergedTypeResolverInfo);
+      }
+    }
+    for (const typeName in canonicalTypesInfo) {
+      const canonicalTypeInfo = canonicalTypesInfo[typeName];
+      const mergeConfig = newSubschemaConfig.merge ?? /* @__PURE__ */ Object.create(null);
+      newSubschemaConfig.merge = mergeConfig;
+      if (newSubschemaConfig.merge[typeName] == null) {
+        newSubschemaConfig.merge[typeName] = /* @__PURE__ */ Object.create(null);
+      }
+      const mergeTypeConfig = newSubschemaConfig.merge[typeName];
+      if (canonicalTypeInfo.canonical) {
+        mergeTypeConfig.canonical = true;
+      }
+      if (canonicalTypeInfo.fields) {
+        const mergeTypeConfigFields = mergeTypeConfig.fields ?? /* @__PURE__ */ Object.create(null);
+        mergeTypeConfig.fields = mergeTypeConfigFields;
+        for (const fieldName in canonicalTypeInfo.fields) {
+          if (mergeTypeConfigFields[fieldName] == null) {
+            mergeTypeConfigFields[fieldName] = /* @__PURE__ */ Object.create(null);
+          }
+          mergeTypeConfigFields[fieldName].canonical = true;
+        }
+      }
+    }
+    for (const typeName in mergedTypesResolversInfoByEntryField) {
+      const entryPoints = [];
+      const existingMergeConfig = newSubschemaConfig.merge?.[typeName];
+      const newMergeConfig = newSubschemaConfig.merge ||= /* @__PURE__ */ Object.create(null);
+      if (existingMergeConfig) {
+        const { fields, canonical, ...baseEntryPoint } = existingMergeConfig;
+        newMergeConfig[typeName] = {
+          fields,
+          canonical,
+          entryPoints
+        };
+        entryPoints.push(baseEntryPoint);
+      } else {
+        newMergeConfig[typeName] = {
+          entryPoints
+        };
+      }
+      for (const fieldName in mergedTypesResolversInfoByEntryField[typeName]) {
+        const mergedTypeResolverInfo = mergedTypesResolversInfoByEntryField[typeName][fieldName];
+        const newEntryPoint = {
+          fieldName,
+          selectionSet: graphql.print(
+            selectionSetsByTypeAndEntryField[typeName][fieldName]
+          )
+        };
+        if (mergedTypeResolverInfo.returnsList) {
+          newEntryPoint.key = generateKeyFn(mergedTypeResolverInfo);
+          newEntryPoint.argsFromKeys = generateArgsFromKeysFn(
+            mergedTypeResolverInfo
+          );
+        } else {
+          newEntryPoint.args = generateArgsFn(mergedTypeResolverInfo);
+        }
+        entryPoints.push(newEntryPoint);
+      }
+      if (entryPoints.length === 1) {
+        const [entryPoint] = entryPoints;
+        const { fields, canonical } = newMergeConfig[typeName];
+        newMergeConfig[typeName] = {
+          ...entryPoint,
+          fields,
+          canonical
+        };
+      }
+    }
+    return newSubschemaConfig;
+  };
+}
+function forEachConcreteType(schema, type, typeNames, fn) {
+  if (graphql.isInterfaceType(type)) {
+    for (const typeName of utils.getImplementingTypes(type.name, schema)) {
+      if (typeNames == null || typeNames.includes(typeName)) {
+        fn(typeName);
+      }
+    }
+  } else if (graphql.isUnionType(type)) {
+    for (const { name: typeName } of type.getTypes()) {
+      if (typeNames == null || typeNames.includes(typeName)) {
+        fn(typeName);
+      }
+    }
+  } else if (graphql.isObjectType(type)) {
+    fn(type.name);
+  }
+}
+function generateKeyFn(mergedTypeResolverInfo) {
+  return function keyFn(originalResult) {
+    return getProperties(originalResult, mergedTypeResolverInfo.usedProperties);
+  };
+}
+function generateArgsFromKeysFn(mergedTypeResolverInfo) {
+  const { expansions, args } = mergedTypeResolverInfo;
+  return function generateArgsFromKeys(keys) {
+    const newArgs = utils.mergeDeep([{}, args]);
+    if (expansions) {
+      for (const expansion of expansions) {
+        const mappingInstructions = expansion.mappingInstructions;
+        const expanded = [];
+        for (const key of keys) {
+          let newValue = utils.mergeDeep([{}, expansion.valuePath]);
+          for (const { destinationPath, sourcePath } of mappingInstructions) {
+            if (destinationPath.length) {
+              addProperty(
+                newValue,
+                destinationPath,
+                getProperty(key, sourcePath)
+              );
+            } else {
+              newValue = getProperty(key, sourcePath);
+            }
+          }
+          expanded.push(newValue);
+        }
+        addProperty(newArgs, expansion.valuePath, expanded);
+      }
+    }
+    return newArgs;
+  };
+}
+function generateArgsFn(mergedTypeResolverInfo) {
+  const { mappingInstructions, args, usedProperties } = mergedTypeResolverInfo;
+  return function generateArgs(originalResult) {
+    const newArgs = utils.mergeDeep([{}, args]);
+    const filteredResult = getProperties(originalResult, usedProperties);
+    if (mappingInstructions) {
+      for (const mappingInstruction of mappingInstructions) {
+        const { destinationPath, sourcePath } = mappingInstruction;
+        addProperty(
+          newArgs,
+          destinationPath,
+          getProperty(filteredResult, sourcePath)
+        );
+      }
+    }
+    return newArgs;
+  };
+}
+function buildKeyExpr(key) {
+  let mergedObject = {};
+  for (const keyDef of key) {
+    let [aliasOrKeyPath, keyPath] = keyDef.split(":");
+    let aliasPath;
+    if (keyPath == null) {
+      keyPath = aliasPath = aliasOrKeyPath;
+    } else {
+      aliasPath = aliasOrKeyPath;
+    }
+    const aliasParts = aliasPath.split(".");
+    const lastAliasPart = aliasParts.pop();
+    if (lastAliasPart == null) {
+      throw new Error(`Key "${key}" is invalid, no path provided.`);
+    }
+    let object = {
+      [lastAliasPart]: `$key.${keyPath}`
+    };
+    for (const aliasPart of aliasParts.reverse()) {
+      object = { [aliasPart]: object };
+    }
+    mergedObject = utils.mergeDeep([mergedObject, object]);
+  }
+  return JSON.stringify(mergedObject).replace(/"/g, "");
+}
+function mergeSelectionSets(...selectionSets) {
+  const normalizedSelections = /* @__PURE__ */ Object.create(null);
+  for (const selectionSet of selectionSets) {
+    for (const selection of selectionSet.selections) {
+      const normalizedSelection = graphql.print(selection);
+      normalizedSelections[normalizedSelection] = selection;
+    }
+  }
+  const newSelectionSet = {
+    kind: graphql.Kind.SELECTION_SET,
+    selections: Object.values(normalizedSelections)
+  };
+  return newSelectionSet;
+}
+function forEachConcreteTypeName(returnType, schema, typeNames, fn) {
+  if (graphql.isInterfaceType(returnType)) {
+    for (const typeName of utils.getImplementingTypes(returnType.name, schema)) {
+      if (typeNames == null || typeNames.includes(typeName)) {
+        fn(typeName);
+      }
+    }
+  } else if (graphql.isUnionType(returnType)) {
+    for (const type of returnType.getTypes()) {
+      if (typeNames == null || typeNames.includes(type.name)) {
+        fn(type.name);
+      }
+    }
+  } else if (graphql.isObjectType(returnType) && (typeNames == null || typeNames.includes(returnType.name))) {
+    fn(returnType.name);
+  }
+}
+
+const dottedNameRegEx = /^[_A-Za-z][_0-9A-Za-z]*(.[_A-Za-z][_0-9A-Za-z]*)*$/;
+function stitchingDirectivesValidator(options = {}) {
+  const {
+    keyDirectiveName,
+    computedDirectiveName,
+    mergeDirectiveName,
+    pathToDirectivesInExtensions
+  } = {
+    ...defaultStitchingDirectiveOptions,
+    ...options
+  };
+  return (schema) => {
+    const queryTypeName = schema.getQueryType()?.name;
+    utils.mapSchema(schema, {
+      [utils.MapperKind.OBJECT_TYPE]: (type) => {
+        const keyDirective = utils.getDirective(
+          schema,
+          type,
+          keyDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (keyDirective != null) {
+          utils.parseSelectionSet(keyDirective["selectionSet"]);
+        }
+        return void 0;
+      },
+      [utils.MapperKind.OBJECT_FIELD]: (fieldConfig, _fieldName, typeName) => {
+        const computedDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          computedDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (computedDirective != null) {
+          utils.parseSelectionSet(computedDirective["selectionSet"]);
+        }
+        const mergeDirective = utils.getDirective(
+          schema,
+          fieldConfig,
+          mergeDirectiveName,
+          pathToDirectivesInExtensions
+        )?.[0];
+        if (mergeDirective != null) {
+          if (typeName !== queryTypeName) {
+            throw new Error(
+              "@merge directive may be used only for root fields of the root Query type."
+            );
+          }
+          let returnType = graphql.getNullableType(fieldConfig.type);
+          if (graphql.isListType(returnType)) {
+            returnType = graphql.getNullableType(returnType.ofType);
+          }
+          if (!graphql.isNamedType(returnType)) {
+            throw new Error(
+              "@merge directive must be used on a field that returns an object or a list of objects."
+            );
+          }
+          const mergeArgsExpr = mergeDirective["argsExpr"];
+          if (mergeArgsExpr != null) {
+            parseMergeArgsExpr(mergeArgsExpr);
+          }
+          const args = Object.keys(fieldConfig.args ?? {});
+          const keyArg = mergeDirective["keyArg"];
+          if (keyArg == null) {
+            if (!mergeArgsExpr && args.length !== 1) {
+              throw new Error(
+                "Cannot use @merge directive without `keyArg` argument if resolver takes more than one argument."
+              );
+            }
+          } else if (!keyArg.match(dottedNameRegEx)) {
+            throw new Error(
+              "`keyArg` argument for @merge directive must be a set of valid GraphQL SDL names separated by periods."
+            );
+          }
+          const keyField = mergeDirective["keyField"];
+          if (keyField != null && !keyField.match(dottedNameRegEx)) {
+            throw new Error(
+              "`keyField` argument for @merge directive must be a set of valid GraphQL SDL names separated by periods."
+            );
+          }
+          const key = mergeDirective["key"];
+          if (key != null) {
+            if (keyField != null) {
+              throw new Error(
+                "Cannot use @merge directive with both `keyField` and `key` arguments."
+              );
+            }
+            for (const keyDef of key) {
+              let [aliasOrKeyPath, keyPath] = keyDef.split(":");
+              let aliasPath;
+              if (keyPath == null) {
+                keyPath = aliasPath = aliasOrKeyPath;
+              } else {
+                aliasPath = aliasOrKeyPath;
+              }
+              if (keyPath != null && !keyPath.match(dottedNameRegEx)) {
+                throw new Error(
+                  "Each partial key within the `key` argument for @merge directive must be a set of valid GraphQL SDL names separated by periods."
+                );
+              }
+              if (aliasPath != null && !aliasOrKeyPath.match(dottedNameRegEx)) {
+                throw new Error(
+                  "Each alias within the `key` argument for @merge directive must be a set of valid GraphQL SDL names separated by periods."
+                );
+              }
+            }
+          }
+          const additionalArgs = mergeDirective["additionalArgs"];
+          if (additionalArgs != null) {
+            graphql.parseValue(`{ ${additionalArgs} }`, { noLocation: true });
+          }
+          if (mergeArgsExpr != null && (keyArg != null || additionalArgs != null)) {
+            throw new Error(
+              "Cannot use @merge directive with both `argsExpr` argument and any additional argument."
+            );
+          }
+          if (!graphql.isInterfaceType(returnType) && !graphql.isUnionType(returnType) && !graphql.isObjectType(returnType)) {
+            throw new Error(
+              "@merge directive may be used only with resolver that return an object, interface, or union."
+            );
+          }
+          const typeNames = mergeDirective["types"];
+          if (typeNames != null) {
+            if (!graphql.isAbstractType(returnType)) {
+              throw new Error(
+                "Types argument can only be used with a field that returns an abstract type."
+              );
+            }
+            const implementingTypes = graphql.isInterfaceType(returnType) ? utils.getImplementingTypes(returnType.name, schema).map(
+              (typeName2) => schema.getType(typeName2)
+            ) : returnType.getTypes();
+            const implementingTypeNames = implementingTypes.map((type) => type?.name).filter(utils.isSome);
+            for (const typeName2 of typeNames) {
+              if (!implementingTypeNames.includes(typeName2)) {
+                throw new Error(
+                  `Types argument can only include only type names that implement the field return type's abstract type.`
+                );
+              }
+            }
+          }
+        }
+        return void 0;
+      }
+    });
+    return schema;
+  };
+}
+
+function stitchingDirectives(options = {}) {
+  const finalOptions = {
+    ...defaultStitchingDirectiveOptions,
+    ...options
+  };
+  const {
+    keyDirectiveName,
+    computedDirectiveName,
+    mergeDirectiveName,
+    canonicalDirectiveName
+  } = finalOptions;
+  const keyDirectiveTypeDefs = (
+    /* GraphQL */
+    `directive @${keyDirectiveName}(selectionSet: String!) on OBJECT`
+  );
+  const computedDirectiveTypeDefs = (
+    /* GraphQL */
+    `directive @${computedDirectiveName}(selectionSet: String!) on FIELD_DEFINITION`
+  );
+  const mergeDirectiveTypeDefs = (
+    /* GraphQL */
+    `directive @${mergeDirectiveName}(argsExpr: String, keyArg: String, keyField: String, key: [String!], additionalArgs: String) on FIELD_DEFINITION`
+  );
+  const canonicalDirectiveTypeDefs = (
+    /* GraphQL */
+    `directive @${canonicalDirectiveName} on OBJECT | INTERFACE | INPUT_OBJECT | UNION | ENUM | SCALAR | FIELD_DEFINITION | INPUT_FIELD_DEFINITION`
+  );
+  const keyDirective = new graphql.GraphQLDirective({
+    name: keyDirectiveName,
+    locations: ["OBJECT"],
+    args: {
+      selectionSet: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
+    }
+  });
+  const computedDirective = new graphql.GraphQLDirective({
+    name: computedDirectiveName,
+    locations: ["FIELD_DEFINITION"],
+    args: {
+      selectionSet: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
+    }
+  });
+  const mergeDirective = new graphql.GraphQLDirective({
+    name: mergeDirectiveName,
+    locations: ["FIELD_DEFINITION"],
+    args: {
+      argsExpr: { type: graphql.GraphQLString },
+      keyArg: { type: graphql.GraphQLString },
+      keyField: { type: graphql.GraphQLString },
+      key: { type: new graphql.GraphQLList(new graphql.GraphQLNonNull(graphql.GraphQLString)) },
+      additionalArgs: { type: graphql.GraphQLString }
+    }
+  });
+  const canonicalDirective = new graphql.GraphQLDirective({
+    name: canonicalDirectiveName,
+    locations: [
+      "OBJECT",
+      "INTERFACE",
+      "INPUT_OBJECT",
+      "UNION",
+      "ENUM",
+      "SCALAR",
+      "FIELD_DEFINITION",
+      "INPUT_FIELD_DEFINITION"
+    ]
+  });
+  const allStitchingDirectivesTypeDefs = [
+    keyDirectiveTypeDefs,
+    computedDirectiveTypeDefs,
+    mergeDirectiveTypeDefs,
+    canonicalDirectiveTypeDefs
+  ].join("\n");
+  return {
+    keyDirectiveTypeDefs,
+    computedDirectiveTypeDefs,
+    mergeDirectiveTypeDefs,
+    canonicalDirectiveTypeDefs,
+    stitchingDirectivesTypeDefs: allStitchingDirectivesTypeDefs,
+    // for backwards compatibility
+    allStitchingDirectivesTypeDefs,
+    keyDirective,
+    computedDirective,
+    mergeDirective,
+    canonicalDirective,
+    allStitchingDirectives: [
+      keyDirective,
+      computedDirective,
+      mergeDirective,
+      canonicalDirective
+    ],
+    stitchingDirectivesValidator: stitchingDirectivesValidator(finalOptions),
+    stitchingDirectivesTransformer: stitchingDirectivesTransformer(finalOptions)
+  };
+}
+
+const extensionKind = /Extension$/;
+const entityKinds = [
+  graphql.Kind.OBJECT_TYPE_DEFINITION,
+  graphql.Kind.OBJECT_TYPE_EXTENSION,
+  graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  graphql.Kind.INTERFACE_TYPE_EXTENSION
+];
+function isEntityKind(def) {
+  return entityKinds.includes(def.kind);
+}
+function getQueryTypeDef(definitions) {
+  const schemaDef = definitions.find(
+    (def) => def.kind === graphql.Kind.SCHEMA_DEFINITION
+  );
+  const typeName = schemaDef ? schemaDef.operationTypes.find(({ operation }) => operation === "query")?.type.name.value : "Query";
+  return definitions.find(
+    (def) => def.kind === graphql.Kind.OBJECT_TYPE_DEFINITION && def.name.value === typeName
+  );
+}
+function federationToStitchingSDL(federationSDL, stitchingConfig = stitchingDirectives()) {
+  const doc = graphql.parse(federationSDL);
+  const entityTypes = [];
+  const baseTypeNames = doc.definitions.reduce((memo, typeDef) => {
+    if (!extensionKind.test(typeDef.kind) && "name" in typeDef && typeDef.name) {
+      memo[typeDef.name.value] = true;
+    }
+    return memo;
+  }, {});
+  doc.definitions.forEach((typeDef) => {
+    if (extensionKind.test(typeDef.kind) && "name" in typeDef && typeDef.name && !baseTypeNames[typeDef.name.value]) {
+      typeDef.kind = typeDef.kind.replace(
+        extensionKind,
+        "Definition"
+      );
+    }
+    if (!isEntityKind(typeDef)) return;
+    const keyDirs = [];
+    const otherDirs = [];
+    typeDef.directives?.forEach((dir) => {
+      if (dir.name.value === "key") {
+        keyDirs.push(dir);
+      } else {
+        otherDirs.push(dir);
+      }
+    });
+    if (!keyDirs.length) return;
+    const selectionSet = `{ ${keyDirs.map((dir) => dir.arguments[0].value.value).join(" ")} }`;
+    const keyFields = graphql.parse(selectionSet).definitions[0].selectionSet.selections.map((sel) => sel.name.value);
+    const keyDir = keyDirs[0];
+    keyDir.name.value = stitchingConfig.keyDirective.name;
+    keyDir.arguments[0].name.value = "selectionSet";
+    keyDir.arguments[0].value.value = selectionSet;
+    typeDef.directives = [keyDir, ...otherDirs];
+    typeDef.fields = typeDef.fields?.filter((fieldDef) => {
+      return keyFields.includes(fieldDef.name.value) || !fieldDef.directives?.find((dir) => dir.name.value === "external");
+    });
+    typeDef.fields?.forEach((fieldDef) => {
+      fieldDef.directives = fieldDef.directives.filter(
+        (dir) => !/^(external|provides)$/.test(dir.name.value)
+      );
+      fieldDef.directives.forEach((dir) => {
+        if (dir.name.value === "requires") {
+          dir.name.value = stitchingConfig.computedDirective.name;
+          dir.arguments[0].name.value = "selectionSet";
+          dir.arguments[0].value.value = `{ ${dir.arguments[0].value.value} }`;
+        }
+      });
+    });
+    if (typeDef.kind === graphql.Kind.OBJECT_TYPE_DEFINITION || typeDef.kind === graphql.Kind.OBJECT_TYPE_EXTENSION) {
+      entityTypes.push(typeDef.name.value);
+    }
+  });
+  if (entityTypes.length) {
+    const queryDef = getQueryTypeDef(doc.definitions);
+    const entitiesSchema = graphql.parse(
+      /* GraphQL */
+      `
+      scalar _Any
+      union _Entity = ${entityTypes.filter((v, i, a) => a.indexOf(v) === i).join(" | ")}
+      type Query { _entities(representations: [_Any!]!): [_Entity]! @${stitchingConfig.mergeDirective.name} }
+    `
+    ).definitions;
+    doc.definitions.push(entitiesSchema[0]);
+    doc.definitions.push(entitiesSchema[1]);
+    if (queryDef) {
+      queryDef.fields.push(entitiesSchema[2].fields[0]);
+    } else {
+      doc.definitions.push(entitiesSchema[2]);
+    }
+  }
+  return [stitchingConfig.stitchingDirectivesTypeDefs, graphql.print(doc)].join("\n");
+}
+
+exports.federationToStitchingSDL = federationToStitchingSDL;
+exports.stitchingDirectives = stitchingDirectives;