@graphql-tools/stitching-directives 3.0.0-alpha-f6c67111.0 → 3.0.0-alpha-20230517123108-df347e95

package/esm/stitchingDirectivesTransformer.js

@@ -0,0 +1,419 @@
+import { getNamedType, getNullableType, isInterfaceType, isListType, isObjectType, isUnionType, Kind, parseValue, print, valueFromASTUntyped, } from 'graphql';
+import { cloneSubschemaConfig } from '@graphql-tools/delegate';
+import { getDirective, getImplementingTypes, MapperKind, mapSchema, mergeDeep, parseSelectionSet, } from '@graphql-tools/utils';
+import { defaultStitchingDirectiveOptions } from './defaultStitchingDirectiveOptions.js';
+import { parseMergeArgsExpr } from './parseMergeArgsExpr.js';
+import { addProperty, getProperty, getProperties } from './properties.js';
+import { stitchingDirectivesValidator } from './stitchingDirectivesValidator.js';
+export function stitchingDirectivesTransformer(options = {}) {
+    const { keyDirectiveName, computedDirectiveName, mergeDirectiveName, canonicalDirectiveName, pathToDirectivesInExtensions, } = {
+        ...defaultStitchingDirectiveOptions,
+        ...options,
+    };
+    return (subschemaConfig) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const newSubschemaConfig = cloneSubschemaConfig(subschemaConfig);
+        const selectionSetsByType = Object.create(null);
+        const computedFieldSelectionSets = Object.create(null);
+        const mergedTypesResolversInfo = Object.create(null);
+        const canonicalTypesInfo = Object.create(null);
+        const schema = subschemaConfig.schema;
+        // gateway should also run validation
+        stitchingDirectivesValidator(options)(schema);
+        function setCanonicalDefinition(typeName, fieldName) {
+            var _a;
+            canonicalTypesInfo[typeName] = canonicalTypesInfo[typeName] || Object.create(null);
+            if (fieldName) {
+                const fields = (_a = canonicalTypesInfo[typeName].fields) !== null && _a !== void 0 ? _a : Object.create(null);
+                canonicalTypesInfo[typeName].fields = fields;
+                fields[fieldName] = true;
+            }
+            else {
+                canonicalTypesInfo[typeName].canonical = true;
+            }
+        }
+        mapSchema(schema, {
+            [MapperKind.OBJECT_TYPE]: type => {
+                var _a, _b;
+                const keyDirective = (_a = getDirective(schema, type, keyDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (keyDirective != null) {
+                    const selectionSet = parseSelectionSet(keyDirective['selectionSet'], { noLocation: true });
+                    selectionSetsByType[type.name] = selectionSet;
+                }
+                const canonicalDirective = (_b = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _b === void 0 ? void 0 : _b[0];
+                if (canonicalDirective != null) {
+                    setCanonicalDefinition(type.name);
+                }
+                return undefined;
+            },
+            [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
+                var _a, _b, _c;
+                const computedDirective = (_a = getDirective(schema, fieldConfig, computedDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (computedDirective != null) {
+                    const selectionSet = parseSelectionSet(computedDirective['selectionSet'], { noLocation: true });
+                    if (!computedFieldSelectionSets[typeName]) {
+                        computedFieldSelectionSets[typeName] = Object.create(null);
+                    }
+                    computedFieldSelectionSets[typeName][fieldName] = selectionSet;
+                }
+                const mergeDirective = (_b = getDirective(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)) === null || _b === void 0 ? void 0 : _b[0];
+                if ((mergeDirective === null || mergeDirective === void 0 ? void 0 : mergeDirective['keyField']) != null) {
+                    const mergeDirectiveKeyField = mergeDirective['keyField'];
+                    const selectionSet = parseSelectionSet(`{ ${mergeDirectiveKeyField}}`, { noLocation: true });
+                    const typeNames = mergeDirective['types'];
+                    const returnType = getNamedType(fieldConfig.type);
+                    forEachConcreteType(schema, returnType, typeNames, typeName => {
+                        if (typeNames == null || typeNames.includes(typeName)) {
+                            const existingSelectionSet = selectionSetsByType[typeName];
+                            selectionSetsByType[typeName] = existingSelectionSet
+                                ? mergeSelectionSets(existingSelectionSet, selectionSet)
+                                : selectionSet;
+                        }
+                    });
+                }
+                const canonicalDirective = (_c = getDirective(schema, fieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _c === void 0 ? void 0 : _c[0];
+                if (canonicalDirective != null) {
+                    setCanonicalDefinition(typeName, fieldName);
+                }
+                return undefined;
+            },
+            [MapperKind.INTERFACE_TYPE]: type => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective) {
+                    setCanonicalDefinition(type.name);
+                }
+                return undefined;
+            },
+            [MapperKind.INTERFACE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, fieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective) {
+                    setCanonicalDefinition(typeName, fieldName);
+                }
+                return undefined;
+            },
+            [MapperKind.INPUT_OBJECT_TYPE]: type => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective) {
+                    setCanonicalDefinition(type.name);
+                }
+                return undefined;
+            },
+            [MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, inputFieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective != null) {
+                    setCanonicalDefinition(typeName, fieldName);
+                }
+                return undefined;
+            },
+            [MapperKind.UNION_TYPE]: type => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective != null) {
+                    setCanonicalDefinition(type.name);
+                }
+                return undefined;
+            },
+            [MapperKind.ENUM_TYPE]: type => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective != null) {
+                    setCanonicalDefinition(type.name);
+                }
+                return undefined;
+            },
+            [MapperKind.SCALAR_TYPE]: type => {
+                var _a;
+                const canonicalDirective = (_a = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (canonicalDirective != null) {
+                    setCanonicalDefinition(type.name);
+                }
+                return undefined;
+            },
+        });
+        if (subschemaConfig.merge) {
+            for (const typeName in subschemaConfig.merge) {
+                const mergedTypeConfig = subschemaConfig.merge[typeName];
+                if (mergedTypeConfig.selectionSet) {
+                    const selectionSet = 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 = parseSelectionSet(fieldConfig.selectionSet, { noLocation: true });
+                        if (selectionSet) {
+                            if ((_a = computedFieldSelectionSets[typeName]) === null || _a === void 0 ? void 0 : _a[fieldName]) {
+                                computedFieldSelectionSets[typeName][fieldName] = mergeSelectionSets(computedFieldSelectionSets[typeName][fieldName], selectionSet);
+                            }
+                            else {
+                                if (computedFieldSelectionSets[typeName] == null) {
+                                    computedFieldSelectionSets[typeName] = Object.create(null);
+                                }
+                                computedFieldSelectionSets[typeName][fieldName] = selectionSet;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const allSelectionSetsByType = 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);
+            }
+        }
+        mapSchema(schema, {
+            [MapperKind.OBJECT_FIELD]: function objectFieldMapper(fieldConfig, fieldName) {
+                var _a, _b;
+                const mergeDirective = (_a = getDirective(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (mergeDirective != null) {
+                    const returnType = getNullableType(fieldConfig.type);
+                    const returnsList = isListType(returnType);
+                    const namedType = 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((_b = fieldConfig.args) !== null && _b !== void 0 ? _b : {})[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 parsedMergeArgsExpr = parseMergeArgsExpr(mergeArgsExpr, allSelectionSetsByType[typeName] == null
+                            ? undefined
+                            : mergeSelectionSets(...allSelectionSetsByType[typeName]));
+                        const additionalArgs = mergeDirective['additionalArgs'];
+                        if (additionalArgs != null) {
+                            parsedMergeArgsExpr.args = mergeDeep([
+                                parsedMergeArgsExpr.args,
+                                valueFromASTUntyped(parseValue(`{ ${additionalArgs} }`, { noLocation: true })),
+                            ]);
+                        }
+                        mergedTypesResolversInfo[typeName] = {
+                            fieldName,
+                            returnsList,
+                            ...parsedMergeArgsExpr,
+                        };
+                    });
+                }
+                return undefined;
+            },
+        });
+        for (const typeName in selectionSetsByType) {
+            const selectionSet = selectionSetsByType[typeName];
+            const mergeConfig = (_b = newSubschemaConfig.merge) !== null && _b !== void 0 ? _b : Object.create(null);
+            newSubschemaConfig.merge = mergeConfig;
+            if (mergeConfig[typeName] == null) {
+                newSubschemaConfig.merge[typeName] = Object.create(null);
+            }
+            const mergeTypeConfig = mergeConfig[typeName];
+            mergeTypeConfig.selectionSet = print(selectionSet);
+        }
+        for (const typeName in computedFieldSelectionSets) {
+            const selectionSets = computedFieldSelectionSets[typeName];
+            const mergeConfig = (_c = newSubschemaConfig.merge) !== null && _c !== void 0 ? _c : Object.create(null);
+            newSubschemaConfig.merge = mergeConfig;
+            if (mergeConfig[typeName] == null) {
+                mergeConfig[typeName] = Object.create(null);
+            }
+            const mergeTypeConfig = newSubschemaConfig.merge[typeName];
+            const mergeTypeConfigFields = (_d = mergeTypeConfig.fields) !== null && _d !== void 0 ? _d : Object.create(null);
+            mergeTypeConfig.fields = mergeTypeConfigFields;
+            for (const fieldName in selectionSets) {
+                const selectionSet = selectionSets[fieldName];
+                const fieldConfig = (_e = mergeTypeConfigFields[fieldName]) !== null && _e !== void 0 ? _e : Object.create(null);
+                mergeTypeConfigFields[fieldName] = fieldConfig;
+                fieldConfig.selectionSet = print(selectionSet);
+                fieldConfig.computed = true;
+            }
+        }
+        for (const typeName in mergedTypesResolversInfo) {
+            const mergedTypeResolverInfo = mergedTypesResolversInfo[typeName];
+            const mergeConfig = (_f = newSubschemaConfig.merge) !== null && _f !== void 0 ? _f : Object.create(null);
+            newSubschemaConfig.merge = mergeConfig;
+            if (newSubschemaConfig.merge[typeName] == null) {
+                newSubschemaConfig.merge[typeName] = 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 = (_g = newSubschemaConfig.merge) !== null && _g !== void 0 ? _g : Object.create(null);
+            newSubschemaConfig.merge = mergeConfig;
+            if (newSubschemaConfig.merge[typeName] == null) {
+                newSubschemaConfig.merge[typeName] = Object.create(null);
+            }
+            const mergeTypeConfig = newSubschemaConfig.merge[typeName];
+            if (canonicalTypeInfo.canonical) {
+                mergeTypeConfig.canonical = true;
+            }
+            if (canonicalTypeInfo.fields) {
+                const mergeTypeConfigFields = (_h = mergeTypeConfig.fields) !== null && _h !== void 0 ? _h : Object.create(null);
+                mergeTypeConfig.fields = mergeTypeConfigFields;
+                for (const fieldName in canonicalTypeInfo.fields) {
+                    if (mergeTypeConfigFields[fieldName] == null) {
+                        mergeTypeConfigFields[fieldName] = Object.create(null);
+                    }
+                    mergeTypeConfigFields[fieldName].canonical = true;
+                }
+            }
+        }
+        return newSubschemaConfig;
+    };
+}
+function forEachConcreteType(schema, type, typeNames, fn) {
+    if (isInterfaceType(type)) {
+        for (const typeName of getImplementingTypes(type.name, schema)) {
+            if (typeNames == null || typeNames.includes(typeName)) {
+                fn(typeName);
+            }
+        }
+    }
+    else if (isUnionType(type)) {
+        for (const { name: typeName } of type.getTypes()) {
+            if (typeNames == null || typeNames.includes(typeName)) {
+                fn(typeName);
+            }
+        }
+    }
+    else if (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 = mergeDeep([{}, args]);
+        if (expansions) {
+            for (const expansion of expansions) {
+                const mappingInstructions = expansion.mappingInstructions;
+                const expanded = [];
+                for (const key of keys) {
+                    let newValue = 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 = 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 = mergeDeep([mergedObject, object]);
+    }
+    return JSON.stringify(mergedObject).replace(/"/g, '');
+}
+function mergeSelectionSets(...selectionSets) {
+    const normalizedSelections = Object.create(null);
+    for (const selectionSet of selectionSets) {
+        for (const selection of selectionSet.selections) {
+            const normalizedSelection = print(selection);
+            normalizedSelections[normalizedSelection] = selection;
+        }
+    }
+    const newSelectionSet = {
+        kind: Kind.SELECTION_SET,
+        selections: Object.values(normalizedSelections),
+    };
+    return newSelectionSet;
+}
+function forEachConcreteTypeName(returnType, schema, typeNames, fn) {
+    if (isInterfaceType(returnType)) {
+        for (const typeName of getImplementingTypes(returnType.name, schema)) {
+            if (typeNames == null || typeNames.includes(typeName)) {
+                fn(typeName);
+            }
+        }
+    }
+    else if (isUnionType(returnType)) {
+        for (const type of returnType.getTypes()) {
+            if (typeNames == null || typeNames.includes(type.name)) {
+                fn(type.name);
+            }
+        }
+    }
+    else if (isObjectType(returnType) && (typeNames == null || typeNames.includes(returnType.name))) {
+        fn(returnType.name);
+    }
+}

package/esm/stitchingDirectivesValidator.js

@@ -0,0 +1,116 @@
+import { getNullableType, isAbstractType, isInterfaceType, isListType, isNamedType, isObjectType, isUnionType, parseValue, } from 'graphql';
+import { getDirective, getImplementingTypes, isSome, MapperKind, mapSchema, parseSelectionSet, } from '@graphql-tools/utils';
+import { defaultStitchingDirectiveOptions } from './defaultStitchingDirectiveOptions.js';
+import { parseMergeArgsExpr } from './parseMergeArgsExpr.js';
+const dottedNameRegEx = /^[_A-Za-z][_0-9A-Za-z]*(.[_A-Za-z][_0-9A-Za-z]*)*$/;
+export function stitchingDirectivesValidator(options = {}) {
+    const { keyDirectiveName, computedDirectiveName, mergeDirectiveName, pathToDirectivesInExtensions } = {
+        ...defaultStitchingDirectiveOptions,
+        ...options,
+    };
+    return (schema) => {
+        var _a;
+        const queryTypeName = (_a = schema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name;
+        mapSchema(schema, {
+            [MapperKind.OBJECT_TYPE]: type => {
+                var _a;
+                const keyDirective = (_a = getDirective(schema, type, keyDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (keyDirective != null) {
+                    parseSelectionSet(keyDirective['selectionSet']);
+                }
+                return undefined;
+            },
+            [MapperKind.OBJECT_FIELD]: (fieldConfig, _fieldName, typeName) => {
+                var _a, _b, _c;
+                const computedDirective = (_a = getDirective(schema, fieldConfig, computedDirectiveName, pathToDirectivesInExtensions)) === null || _a === void 0 ? void 0 : _a[0];
+                if (computedDirective != null) {
+                    parseSelectionSet(computedDirective['selectionSet']);
+                }
+                const mergeDirective = (_b = getDirective(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)) === null || _b === void 0 ? void 0 : _b[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 = getNullableType(fieldConfig.type);
+                    if (isListType(returnType)) {
+                        returnType = getNullableType(returnType.ofType);
+                    }
+                    if (!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((_c = fieldConfig.args) !== null && _c !== void 0 ? _c : {});
+                    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.');
+                        // TODO: ideally we should check that the arg exists for the resolver
+                    }
+                    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.');
+                        // TODO: ideally we should check that it is part of the key
+                    }
+                    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.');
+                                // TODO: ideally we should check that it is part of the key
+                            }
+                            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.');
+                                // TODO: ideally we should check that the arg exists within the resolver
+                            }
+                        }
+                    }
+                    const additionalArgs = mergeDirective['additionalArgs'];
+                    if (additionalArgs != null) {
+                        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 (!isInterfaceType(returnType) && !isUnionType(returnType) && !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 (!isAbstractType(returnType)) {
+                            throw new Error('Types argument can only be used with a field that returns an abstract type.');
+                        }
+                        const implementingTypes = isInterfaceType(returnType)
+                            ? getImplementingTypes(returnType.name, schema).map(typeName => schema.getType(typeName))
+                            : returnType.getTypes();
+                        const implementingTypeNames = implementingTypes.map(type => type === null || type === void 0 ? void 0 : type.name).filter(isSome);
+                        for (const typeName of typeNames) {
+                            if (!implementingTypeNames.includes(typeName)) {
+                                throw new Error(`Types argument can only include only type names that implement the field return type's abstract type.`);
+                            }
+                        }
+                    }
+                }
+                return undefined;
+            },
+        });
+        return schema;
+    };
+}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@graphql-tools/stitching-directives",
-  "version": "3.0.0-alpha-f6c67111.0",
+  "version": "3.0.0-alpha-20230517123108-df347e95",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
-    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "9.0.0-alpha-f6c67111.0",
-    "@graphql-tools/utils": "9.0.0-alpha-f6c67111.0",
-    "tslib": "~2.3.0"
+    "@graphql-tools/delegate": "10.0.0-alpha-20230517123108-df347e95",
+    "@graphql-tools/utils": "10.0.0-alpha-20230517123108-df347e95",
+    "tslib": "^2.4.0"
   },
   "repository": {
     "type": "git",
@@ -17,20 +17,45 @@
     "directory": "packages/stitching-directives"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
-    }
+      "require": {
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./package.json": "./package.json"
   }
-}
+}

package/typings/defaultStitchingDirectiveOptions.d.cts

@@ -0,0 +1,2 @@
+import { StitchingDirectivesFinalOptions } from './types.cjs';
+export declare const defaultStitchingDirectiveOptions: StitchingDirectivesFinalOptions;

package/{defaultStitchingDirectiveOptions.d.ts → typings/defaultStitchingDirectiveOptions.d.ts}

@@ -1,2 +1,2 @@
-import { StitchingDirectivesFinalOptions } from './types';
+import { StitchingDirectivesFinalOptions } from './types.js';
 export declare const defaultStitchingDirectiveOptions: StitchingDirectivesFinalOptions;

package/typings/extractVariables.d.cts

@@ -0,0 +1,7 @@
+import { ValueNode } from 'graphql';
+type VariablePaths = Record<string, Array<string | number>>;
+export declare function extractVariables(inputValue: ValueNode): {
+    inputValue: ValueNode;
+    variablePaths: VariablePaths;
+};
+export {};

package/{extractVariables.d.ts → typings/extractVariables.d.ts}

@@ -1,5 +1,5 @@
 import { ValueNode } from 'graphql';
-declare type VariablePaths = Record<string, Array<string | number>>;
+type VariablePaths = Record<string, Array<string | number>>;
 export declare function extractVariables(inputValue: ValueNode): {
     inputValue: ValueNode;
     variablePaths: VariablePaths;

package/typings/federationToStitchingSDL.d.cts

@@ -0,0 +1,2 @@
+import { StitchingDirectivesResult } from './stitchingDirectives.cjs';
+export declare function federationToStitchingSDL(federationSDL: string, stitchingConfig?: StitchingDirectivesResult): string;

package/{federationToStitchingSDL.d.ts → typings/federationToStitchingSDL.d.ts}

@@ -1,2 +1,2 @@
-import { StitchingDirectivesResult } from './stitchingDirectives';
+import { StitchingDirectivesResult } from './stitchingDirectives.js';
 export declare function federationToStitchingSDL(federationSDL: string, stitchingConfig?: StitchingDirectivesResult): string;

package/typings/getSourcePaths.d.cts

@@ -0,0 +1,3 @@
+import { SelectionSetNode } from 'graphql';
+import { MappingInstruction } from './types.cjs';
+export declare function getSourcePaths(mappingInstructions: Array<MappingInstruction>, selectionSet?: SelectionSetNode): Array<Array<string>>;

package/{getSourcePaths.d.ts → typings/getSourcePaths.d.ts}

@@ -1,3 +1,3 @@
 import { SelectionSetNode } from 'graphql';
-import { MappingInstruction } from './types';
+import { MappingInstruction } from './types.js';
 export declare function getSourcePaths(mappingInstructions: Array<MappingInstruction>, selectionSet?: SelectionSetNode): Array<Array<string>>;