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

package/cjs/stitchingDirectivesTransformer.js

@@ -1,490 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stitchingDirectivesTransformer = void 0;
-const graphql_1 = require("graphql");
-const delegate_1 = require("@graphql-tools/delegate");
-const utils_1 = require("@graphql-tools/utils");
-const defaultStitchingDirectiveOptions_js_1 = require("./defaultStitchingDirectiveOptions.js");
-const parseMergeArgsExpr_js_1 = require("./parseMergeArgsExpr.js");
-const properties_js_1 = require("./properties.js");
-function stitchingDirectivesTransformer(options = {}) {
-    const { keyDirectiveName, computedDirectiveName, mergeDirectiveName, canonicalDirectiveName, pathToDirectivesInExtensions, } = {
-        ...defaultStitchingDirectiveOptions_js_1.defaultStitchingDirectiveOptions,
-        ...options,
-    };
-    return (subschemaConfig) => {
-        const newSubschemaConfig = (0, delegate_1.cloneSubschemaConfig)(subschemaConfig);
-        const selectionSetsByType = Object.create(null);
-        const computedFieldSelectionSets = Object.create(null);
-        const mergedTypesResolversInfo = Object.create(null);
-        const canonicalTypesInfo = Object.create(null);
-        const selectionSetsByTypeAndEntryField = Object.create(null);
-        const mergedTypesResolversInfoByEntryField = Object.create(null);
-        const schema = subschemaConfig.schema;
-        function setCanonicalDefinition(typeName, fieldName) {
-            canonicalTypesInfo[typeName] = canonicalTypesInfo[typeName] || Object.create(null);
-            if (fieldName) {
-                const fields = canonicalTypesInfo[typeName].fields ?? Object.create(null);
-                canonicalTypesInfo[typeName].fields = fields;
-                fields[fieldName] = true;
-            }
-            else {
-                canonicalTypesInfo[typeName].canonical = true;
-            }
-        }
-        (0, utils_1.mapSchema)(schema, {
-            [utils_1.MapperKind.OBJECT_TYPE]: type => {
-                const keyDirective = (0, utils_1.getDirective)(schema, type, keyDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (keyDirective != null) {
-                    const selectionSet = (0, utils_1.parseSelectionSet)(keyDirective['selectionSet'], {
-                        noLocation: true,
-                    });
-                    selectionSetsByType[type.name] = selectionSet;
-                }
-                const canonicalDirective = (0, utils_1.getDirective)(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
-                const computedDirective = (0, utils_1.getDirective)(schema, fieldConfig, computedDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (computedDirective != null) {
-                    const selectionSet = (0, utils_1.parseSelectionSet)(computedDirective['selectionSet'], {
-                        noLocation: true,
-                    });
-                    if (!computedFieldSelectionSets[typeName]) {
-                        computedFieldSelectionSets[typeName] = Object.create(null);
-                    }
-                    computedFieldSelectionSets[typeName][fieldName] = selectionSet;
-                }
-                const mergeDirective = (0, utils_1.getDirective)(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (mergeDirective?.['keyField'] != null) {
-                    const mergeDirectiveKeyField = mergeDirective['keyField'];
-                    const selectionSet = (0, utils_1.parseSelectionSet)(`{ ${mergeDirectiveKeyField}}`, {
-                        noLocation: true,
-                    });
-                    const typeNames = mergeDirective['types'];
-                    const returnType = (0, graphql_1.getNamedType)(fieldConfig.type);
-                    forEachConcreteType(schema, returnType, typeNames, typeName => {
-                        if (typeNames == null || typeNames.includes(typeName)) {
-                            let existingEntryFieldMap = selectionSetsByTypeAndEntryField[typeName];
-                            if (existingEntryFieldMap == null) {
-                                existingEntryFieldMap = Object.create(null);
-                                selectionSetsByTypeAndEntryField[typeName] = existingEntryFieldMap;
-                            }
-                            let existingSelectionSet = existingEntryFieldMap[fieldName];
-                            if (existingSelectionSet == null) {
-                                existingSelectionSet = selectionSetsByType[typeName];
-                            }
-                            existingEntryFieldMap[fieldName] = existingSelectionSet
-                                ? mergeSelectionSets(existingSelectionSet, selectionSet)
-                                : selectionSet;
-                        }
-                    });
-                }
-                const canonicalDirective = (0, utils_1.getDirective)(schema, fieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(typeName, fieldName);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.INTERFACE_TYPE]: type => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.INTERFACE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, fieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective) {
-                    setCanonicalDefinition(typeName, fieldName);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.INPUT_OBJECT_TYPE]: type => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, inputFieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(typeName, fieldName);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.UNION_TYPE]: type => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.ENUM_TYPE]: type => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.SCALAR_TYPE]: type => {
-                const canonicalDirective = (0, utils_1.getDirective)(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[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 = (0, utils_1.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 = (0, utils_1.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] = 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);
-            }
-        }
-        (0, utils_1.mapSchema)(schema, {
-            [utils_1.MapperKind.OBJECT_FIELD]: function objectFieldMapper(fieldConfig, fieldName) {
-                const mergeDirective = (0, utils_1.getDirective)(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (mergeDirective != null) {
-                    const returnType = (0, graphql_1.getNullableType)(fieldConfig.type);
-                    const returnsList = (0, graphql_1.isListType)(returnType);
-                    const namedType = (0, graphql_1.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 = (0, parseMergeArgsExpr_js_1.parseMergeArgsExpr)(mergeArgsExpr, allSelectionSetsByType[typeName] == null
-                            ? undefined
-                            : mergeSelectionSets(...mergedSelectionSets));
-                        const additionalArgs = mergeDirective['additionalArgs'];
-                        if (additionalArgs != null) {
-                            parsedMergeArgsExpr.args = (0, utils_1.mergeDeep)([
-                                parsedMergeArgsExpr.args,
-                                (0, graphql_1.valueFromASTUntyped)((0, graphql_1.parseValue)(`{ ${additionalArgs} }`, { noLocation: true })),
-                            ]);
-                        }
-                        if (selectionSetsByTypeAndEntryField[typeName]?.[fieldName] != null) {
-                            const typeConfigByField = (mergedTypesResolversInfoByEntryField[typeName] ||=
-                                Object.create(null));
-                            typeConfigByField[fieldName] = {
-                                fieldName,
-                                returnsList,
-                                ...parsedMergeArgsExpr,
-                            };
-                        }
-                        else {
-                            mergedTypesResolversInfo[typeName] = {
-                                fieldName,
-                                returnsList,
-                                ...parsedMergeArgsExpr,
-                            };
-                        }
-                    });
-                }
-                return undefined;
-            },
-        });
-        for (const typeName in selectionSetsByType) {
-            const selectionSet = selectionSetsByType[typeName];
-            const mergeConfig = newSubschemaConfig.merge ?? Object.create(null);
-            newSubschemaConfig.merge = mergeConfig;
-            if (mergeConfig[typeName] == null) {
-                newSubschemaConfig.merge[typeName] = Object.create(null);
-            }
-            const mergeTypeConfig = mergeConfig[typeName];
-            mergeTypeConfig.selectionSet = (0, graphql_1.print)(selectionSet);
-        }
-        for (const typeName in computedFieldSelectionSets) {
-            const selectionSets = computedFieldSelectionSets[typeName];
-            const mergeConfig = newSubschemaConfig.merge ?? Object.create(null);
-            newSubschemaConfig.merge = mergeConfig;
-            if (mergeConfig[typeName] == null) {
-                mergeConfig[typeName] = Object.create(null);
-            }
-            const mergeTypeConfig = newSubschemaConfig.merge[typeName];
-            const mergeTypeConfigFields = mergeTypeConfig.fields ?? Object.create(null);
-            mergeTypeConfig.fields = mergeTypeConfigFields;
-            for (const fieldName in selectionSets) {
-                const selectionSet = selectionSets[fieldName];
-                const fieldConfig = mergeTypeConfigFields[fieldName] ?? Object.create(null);
-                mergeTypeConfigFields[fieldName] = fieldConfig;
-                fieldConfig.selectionSet = (0, graphql_1.print)(selectionSet);
-                fieldConfig.computed = true;
-            }
-        }
-        for (const typeName in mergedTypesResolversInfo) {
-            const mergedTypeResolverInfo = mergedTypesResolversInfo[typeName];
-            const mergeConfig = newSubschemaConfig.merge ?? 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 = newSubschemaConfig.merge ?? 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 = mergeTypeConfig.fields ?? 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;
-                }
-            }
-        }
-        for (const typeName in mergedTypesResolversInfoByEntryField) {
-            const entryPoints = [];
-            const existingMergeConfig = newSubschemaConfig.merge?.[typeName];
-            const newMergeConfig = (newSubschemaConfig.merge ||= 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: (0, graphql_1.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;
-    };
-}
-exports.stitchingDirectivesTransformer = stitchingDirectivesTransformer;
-function forEachConcreteType(schema, type, typeNames, fn) {
-    if ((0, graphql_1.isInterfaceType)(type)) {
-        for (const typeName of (0, utils_1.getImplementingTypes)(type.name, schema)) {
-            if (typeNames == null || typeNames.includes(typeName)) {
-                fn(typeName);
-            }
-        }
-    }
-    else if ((0, graphql_1.isUnionType)(type)) {
-        for (const { name: typeName } of type.getTypes()) {
-            if (typeNames == null || typeNames.includes(typeName)) {
-                fn(typeName);
-            }
-        }
-    }
-    else if ((0, graphql_1.isObjectType)(type)) {
-        fn(type.name);
-    }
-}
-function generateKeyFn(mergedTypeResolverInfo) {
-    return function keyFn(originalResult) {
-        return (0, properties_js_1.getProperties)(originalResult, mergedTypeResolverInfo.usedProperties);
-    };
-}
-function generateArgsFromKeysFn(mergedTypeResolverInfo) {
-    const { expansions, args } = mergedTypeResolverInfo;
-    return function generateArgsFromKeys(keys) {
-        const newArgs = (0, utils_1.mergeDeep)([{}, args]);
-        if (expansions) {
-            for (const expansion of expansions) {
-                const mappingInstructions = expansion.mappingInstructions;
-                const expanded = [];
-                for (const key of keys) {
-                    let newValue = (0, utils_1.mergeDeep)([{}, expansion.valuePath]);
-                    for (const { destinationPath, sourcePath } of mappingInstructions) {
-                        if (destinationPath.length) {
-                            (0, properties_js_1.addProperty)(newValue, destinationPath, (0, properties_js_1.getProperty)(key, sourcePath));
-                        }
-                        else {
-                            newValue = (0, properties_js_1.getProperty)(key, sourcePath);
-                        }
-                    }
-                    expanded.push(newValue);
-                }
-                (0, properties_js_1.addProperty)(newArgs, expansion.valuePath, expanded);
-            }
-        }
-        return newArgs;
-    };
-}
-function generateArgsFn(mergedTypeResolverInfo) {
-    const { mappingInstructions, args, usedProperties } = mergedTypeResolverInfo;
-    return function generateArgs(originalResult) {
-        const newArgs = (0, utils_1.mergeDeep)([{}, args]);
-        const filteredResult = (0, properties_js_1.getProperties)(originalResult, usedProperties);
-        if (mappingInstructions) {
-            for (const mappingInstruction of mappingInstructions) {
-                const { destinationPath, sourcePath } = mappingInstruction;
-                (0, properties_js_1.addProperty)(newArgs, destinationPath, (0, properties_js_1.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 = (0, utils_1.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 = (0, graphql_1.print)(selection);
-            normalizedSelections[normalizedSelection] = selection;
-        }
-    }
-    const newSelectionSet = {
-        kind: graphql_1.Kind.SELECTION_SET,
-        selections: Object.values(normalizedSelections),
-    };
-    return newSelectionSet;
-}
-function forEachConcreteTypeName(returnType, schema, typeNames, fn) {
-    if ((0, graphql_1.isInterfaceType)(returnType)) {
-        for (const typeName of (0, utils_1.getImplementingTypes)(returnType.name, schema)) {
-            if (typeNames == null || typeNames.includes(typeName)) {
-                fn(typeName);
-            }
-        }
-    }
-    else if ((0, graphql_1.isUnionType)(returnType)) {
-        for (const type of returnType.getTypes()) {
-            if (typeNames == null || typeNames.includes(type.name)) {
-                fn(type.name);
-            }
-        }
-    }
-    else if ((0, graphql_1.isObjectType)(returnType) &&
-        (typeNames == null || typeNames.includes(returnType.name))) {
-        fn(returnType.name);
-    }
-}

package/cjs/stitchingDirectivesValidator.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stitchingDirectivesValidator = void 0;
-const graphql_1 = require("graphql");
-const utils_1 = require("@graphql-tools/utils");
-const defaultStitchingDirectiveOptions_js_1 = require("./defaultStitchingDirectiveOptions.js");
-const parseMergeArgsExpr_js_1 = require("./parseMergeArgsExpr.js");
-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_js_1.defaultStitchingDirectiveOptions,
-        ...options,
-    };
-    return (schema) => {
-        const queryTypeName = schema.getQueryType()?.name;
-        (0, utils_1.mapSchema)(schema, {
-            [utils_1.MapperKind.OBJECT_TYPE]: type => {
-                const keyDirective = (0, utils_1.getDirective)(schema, type, keyDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (keyDirective != null) {
-                    (0, utils_1.parseSelectionSet)(keyDirective['selectionSet']);
-                }
-                return undefined;
-            },
-            [utils_1.MapperKind.OBJECT_FIELD]: (fieldConfig, _fieldName, typeName) => {
-                const computedDirective = (0, utils_1.getDirective)(schema, fieldConfig, computedDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (computedDirective != null) {
-                    (0, utils_1.parseSelectionSet)(computedDirective['selectionSet']);
-                }
-                const mergeDirective = (0, utils_1.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 = (0, graphql_1.getNullableType)(fieldConfig.type);
-                    if ((0, graphql_1.isListType)(returnType)) {
-                        returnType = (0, graphql_1.getNullableType)(returnType.ofType);
-                    }
-                    if (!(0, graphql_1.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) {
-                        (0, parseMergeArgsExpr_js_1.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.');
-                        // 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) {
-                        (0, graphql_1.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 (!(0, graphql_1.isInterfaceType)(returnType) &&
-                        !(0, graphql_1.isUnionType)(returnType) &&
-                        !(0, graphql_1.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 (!(0, graphql_1.isAbstractType)(returnType)) {
-                            throw new Error('Types argument can only be used with a field that returns an abstract type.');
-                        }
-                        const implementingTypes = (0, graphql_1.isInterfaceType)(returnType)
-                            ? (0, utils_1.getImplementingTypes)(returnType.name, schema).map(typeName => schema.getType(typeName))
-                            : returnType.getTypes();
-                        const implementingTypeNames = implementingTypes.map(type => type?.name).filter(utils_1.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;
-    };
-}
-exports.stitchingDirectivesValidator = stitchingDirectivesValidator;

package/esm/defaultStitchingDirectiveOptions.js

@@ -1,7 +0,0 @@
-export const defaultStitchingDirectiveOptions = {
-    keyDirectiveName: 'key',
-    computedDirectiveName: 'computed',
-    canonicalDirectiveName: 'canonical',
-    mergeDirectiveName: 'merge',
-    pathToDirectivesInExtensions: ['directives'],
-};

package/esm/extractVariables.js

@@ -1,48 +0,0 @@
-import { Kind, visit } from 'graphql';
-export function extractVariables(inputValue) {
-    const path = [];
-    const variablePaths = 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: Kind.NULL,
-            };
-        },
-    };
-    const newInputValue = visit(inputValue, {
-        [Kind.OBJECT]: keyPathVisitor,
-        [Kind.LIST]: keyPathVisitor,
-        [Kind.OBJECT_FIELD]: fieldPathVisitor,
-        [Kind.VARIABLE]: variableVisitor,
-    });
-    return {
-        inputValue: newInputValue,
-        variablePaths,
-    };
-}