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

package/esm/stitchingDirectivesTransformer.js

@@ -1,486 +0,0 @@
-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, getProperties, getProperty } from './properties.js';
-export function stitchingDirectivesTransformer(options = {}) {
-    const { keyDirectiveName, computedDirectiveName, mergeDirectiveName, canonicalDirectiveName, pathToDirectivesInExtensions, } = {
-        ...defaultStitchingDirectiveOptions,
-        ...options,
-    };
-    return (subschemaConfig) => {
-        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 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;
-            }
-        }
-        mapSchema(schema, {
-            [MapperKind.OBJECT_TYPE]: type => {
-                const keyDirective = getDirective(schema, type, keyDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (keyDirective != null) {
-                    const selectionSet = parseSelectionSet(keyDirective['selectionSet'], {
-                        noLocation: true,
-                    });
-                    selectionSetsByType[type.name] = selectionSet;
-                }
-                const canonicalDirective = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName) => {
-                const computedDirective = getDirective(schema, fieldConfig, computedDirectiveName, pathToDirectivesInExtensions)?.[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 = getDirective(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (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)) {
-                            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 = getDirective(schema, fieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(typeName, fieldName);
-                }
-                return undefined;
-            },
-            [MapperKind.INTERFACE_TYPE]: type => {
-                const canonicalDirective = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [MapperKind.INTERFACE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                const canonicalDirective = getDirective(schema, fieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective) {
-                    setCanonicalDefinition(typeName, fieldName);
-                }
-                return undefined;
-            },
-            [MapperKind.INPUT_OBJECT_TYPE]: type => {
-                const canonicalDirective = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
-                const canonicalDirective = getDirective(schema, inputFieldConfig, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(typeName, fieldName);
-                }
-                return undefined;
-            },
-            [MapperKind.UNION_TYPE]: type => {
-                const canonicalDirective = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [MapperKind.ENUM_TYPE]: type => {
-                const canonicalDirective = getDirective(schema, type, canonicalDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (canonicalDirective != null) {
-                    setCanonicalDefinition(type.name);
-                }
-                return undefined;
-            },
-            [MapperKind.SCALAR_TYPE]: type => {
-                const canonicalDirective = 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 = 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 (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);
-            }
-        }
-        mapSchema(schema, {
-            [MapperKind.OBJECT_FIELD]: function objectFieldMapper(fieldConfig, fieldName) {
-                const mergeDirective = getDirective(schema, fieldConfig, mergeDirectiveName, pathToDirectivesInExtensions)?.[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(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
-                            ? undefined
-                            : mergeSelectionSets(...mergedSelectionSets));
-                        const additionalArgs = mergeDirective['additionalArgs'];
-                        if (additionalArgs != null) {
-                            parsedMergeArgsExpr.args = mergeDeep([
-                                parsedMergeArgsExpr.args,
-                                valueFromASTUntyped(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 = 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 = 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: 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 (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

@@ -1,115 +0,0 @@
-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) => {
-        const queryTypeName = schema.getQueryType()?.name;
-        mapSchema(schema, {
-            [MapperKind.OBJECT_TYPE]: type => {
-                const keyDirective = getDirective(schema, type, keyDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (keyDirective != null) {
-                    parseSelectionSet(keyDirective['selectionSet']);
-                }
-                return undefined;
-            },
-            [MapperKind.OBJECT_FIELD]: (fieldConfig, _fieldName, typeName) => {
-                const computedDirective = getDirective(schema, fieldConfig, computedDirectiveName, pathToDirectivesInExtensions)?.[0];
-                if (computedDirective != null) {
-                    parseSelectionSet(computedDirective['selectionSet']);
-                }
-                const mergeDirective = 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 = 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(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) {
-                        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?.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/typings/defaultStitchingDirectiveOptions.d.cts

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

package/typings/defaultStitchingDirectiveOptions.d.ts

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

package/typings/extractVariables.d.cts

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

package/typings/extractVariables.d.ts

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

package/typings/federationToStitchingSDL.d.cts

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

package/typings/federationToStitchingSDL.d.ts

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

package/typings/getSourcePaths.d.cts

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

package/typings/getSourcePaths.d.ts

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

package/typings/index.d.cts

@@ -1,3 +0,0 @@
-export * from './stitchingDirectives.cjs';
-export * from './types.cjs';
-export * from './federationToStitchingSDL.cjs';

package/typings/index.d.ts

@@ -1,3 +0,0 @@
-export * from './stitchingDirectives.js';
-export * from './types.js';
-export * from './federationToStitchingSDL.js';

package/typings/parseMergeArgsExpr.d.cts

@@ -1,3 +0,0 @@
-import { SelectionSetNode } from 'graphql';
-import { ParsedMergeArgsExpr } from './types.cjs';
-export declare function parseMergeArgsExpr(mergeArgsExpr: string, selectionSet?: SelectionSetNode): ParsedMergeArgsExpr;

package/typings/parseMergeArgsExpr.d.ts

@@ -1,3 +0,0 @@
-import { SelectionSetNode } from 'graphql';
-import { ParsedMergeArgsExpr } from './types.js';
-export declare function parseMergeArgsExpr(mergeArgsExpr: string, selectionSet?: SelectionSetNode): ParsedMergeArgsExpr;