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

package/esm/federationToStitchingSDL.js

@@ -1,112 +0,0 @@
-// Taken from https://github.com/gmac/federation-to-stitching-sdl/blob/main/index.js
-import { Kind, parse, print, } from 'graphql';
-import { stitchingDirectives } from './stitchingDirectives.js';
-const extensionKind = /Extension$/;
-const entityKinds = [
-    Kind.OBJECT_TYPE_DEFINITION,
-    Kind.OBJECT_TYPE_EXTENSION,
-    Kind.INTERFACE_TYPE_DEFINITION,
-    Kind.INTERFACE_TYPE_EXTENSION,
-];
-function isEntityKind(def) {
-    return entityKinds.includes(def.kind);
-}
-function getQueryTypeDef(definitions) {
-    const schemaDef = definitions.find(def => def.kind === Kind.SCHEMA_DEFINITION);
-    const typeName = schemaDef
-        ? schemaDef.operationTypes.find(({ operation }) => operation === 'query')?.type.name.value
-        : 'Query';
-    return definitions.find(def => def.kind === Kind.OBJECT_TYPE_DEFINITION && def.name.value === typeName);
-}
-// Federation services are actually fairly complex,
-// as the `buildFederatedSchema` helper does a fair amount
-// of hidden work to setup the Federation schema specification:
-// https://www.apollographql.com/docs/federation/federation-spec/#federation-schema-specification
-export function federationToStitchingSDL(federationSDL, stitchingConfig = stitchingDirectives()) {
-    const doc = parse(federationSDL);
-    const entityTypes = [];
-    const baseTypeNames = doc.definitions.reduce((memo, typeDef) => {
-        if (!extensionKind.test(typeDef.kind) && 'name' in typeDef && typeDef.name) {
-            memo[typeDef.name.value] = true;
-        }
-        return memo;
-    }, {});
-    doc.definitions.forEach(typeDef => {
-        // Un-extend all types (remove "extends" keywords)...
-        // extended types are invalid GraphQL without a local base type to extend from.
-        // Stitching merges flat types in lieu of hierarchical extensions.
-        if (extensionKind.test(typeDef.kind) &&
-            'name' in typeDef &&
-            typeDef.name &&
-            !baseTypeNames[typeDef.name.value]) {
-            typeDef.kind = typeDef.kind.replace(extensionKind, 'Definition');
-        }
-        if (!isEntityKind(typeDef))
-            return;
-        // Find object definitions with "@key" directives;
-        // these are federated entities that get turned into merged types.
-        const keyDirs = [];
-        const otherDirs = [];
-        typeDef.directives?.forEach(dir => {
-            if (dir.name.value === 'key') {
-                keyDirs.push(dir);
-            }
-            else {
-                otherDirs.push(dir);
-            }
-        });
-        if (!keyDirs.length)
-            return;
-        // Setup stitching MergedTypeConfig for all federated entities:
-        const selectionSet = `{ ${keyDirs.map((dir) => dir.arguments[0].value.value).join(' ')} }`;
-        const keyFields = parse(selectionSet).definitions[0].selectionSet.selections.map((sel) => sel.name.value);
-        const keyDir = keyDirs[0];
-        keyDir.name.value = stitchingConfig.keyDirective.name;
-        keyDir.arguments[0].name.value = 'selectionSet';
-        keyDir.arguments[0].value.value = selectionSet;
-        typeDef.directives = [keyDir, ...otherDirs];
-        // Remove non-key "@external" fields from the type...
-        // the stitching query planner expects services to only publish their own fields.
-        // This makes "@provides" moot because the query planner can automate the logic.
-        typeDef.fields = typeDef.fields?.filter(fieldDef => {
-            return (keyFields.includes(fieldDef.name.value) ||
-                !fieldDef.directives?.find(dir => dir.name.value === 'external'));
-        });
-        // Discard remaining "@external" directives and any "@provides" directives
-        typeDef.fields?.forEach((fieldDef) => {
-            fieldDef.directives = fieldDef.directives.filter((dir) => !/^(external|provides)$/.test(dir.name.value));
-            fieldDef.directives.forEach((dir) => {
-                if (dir.name.value === 'requires') {
-                    dir.name.value = stitchingConfig.computedDirective.name;
-                    dir.arguments[0].name.value = 'selectionSet';
-                    dir.arguments[0].value.value = `{ ${dir.arguments[0].value.value} }`;
-                }
-            });
-        });
-        if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
-            typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
-            entityTypes.push(typeDef.name.value);
-        }
-    });
-    // Federation service SDLs are incomplete because they omit the federation spec itself...
-    // (https://www.apollographql.com/docs/federation/federation-spec/#federation-schema-specification)
-    // To make federation SDLs into valid and parsable GraphQL schemas,
-    // we must fill in the missing details from the specification.
-    if (entityTypes.length) {
-        const queryDef = getQueryTypeDef(doc.definitions);
-        const entitiesSchema = parse(/* GraphQL */ `
-      scalar _Any
-      union _Entity = ${entityTypes.filter((v, i, a) => a.indexOf(v) === i).join(' | ')}
-      type Query { _entities(representations: [_Any!]!): [_Entity]! @${stitchingConfig.mergeDirective.name} }
-    `).definitions;
-        doc.definitions.push(entitiesSchema[0]);
-        doc.definitions.push(entitiesSchema[1]);
-        if (queryDef) {
-            queryDef.fields.push(entitiesSchema[2].fields[0]);
-        }
-        else {
-            doc.definitions.push(entitiesSchema[2]);
-        }
-    }
-    return [stitchingConfig.stitchingDirectivesTypeDefs, print(doc)].join('\n');
-}

package/esm/getSourcePaths.js

@@ -1,21 +0,0 @@
-import { TypeNameMetaFieldDef } from 'graphql';
-import { pathsFromSelectionSet } from './pathsFromSelectionSet.js';
-export function getSourcePaths(mappingInstructions, selectionSet) {
-    const sourcePaths = [];
-    for (const mappingInstruction of mappingInstructions) {
-        const { sourcePath } = mappingInstruction;
-        if (sourcePath.length) {
-            sourcePaths.push(sourcePath);
-            continue;
-        }
-        if (selectionSet == null) {
-            continue;
-        }
-        const paths = pathsFromSelectionSet(selectionSet);
-        for (const path of paths) {
-            sourcePaths.push(path);
-        }
-        sourcePaths.push([TypeNameMetaFieldDef.name]);
-    }
-    return sourcePaths;
-}

package/esm/index.js

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

package/esm/parseMergeArgsExpr.js

@@ -1,73 +0,0 @@
-import { parseValue, valueFromASTUntyped } from 'graphql';
-import { extractVariables } from './extractVariables.js';
-import { getSourcePaths } from './getSourcePaths.js';
-import { EXPANSION_PREFIX, KEY_DELIMITER, preparseMergeArgsExpr } from './preparseMergeArgsExpr.js';
-import { propertyTreeFromPaths } from './properties.js';
-export function parseMergeArgsExpr(mergeArgsExpr, selectionSet) {
-    const { mergeArgsExpr: newMergeArgsExpr, expansionExpressions } = preparseMergeArgsExpr(mergeArgsExpr);
-    const inputValue = parseValue(`{ ${newMergeArgsExpr} }`, { noLocation: true });
-    const { inputValue: newInputValue, variablePaths } = extractVariables(inputValue);
-    if (!Object.keys(expansionExpressions).length) {
-        if (!Object.keys(variablePaths).length) {
-            throw new Error('Merge arguments must declare a key.');
-        }
-        const mappingInstructions = getMappingInstructions(variablePaths);
-        const usedProperties = propertyTreeFromPaths(getSourcePaths(mappingInstructions, selectionSet));
-        return {
-            args: valueFromASTUntyped(newInputValue),
-            usedProperties,
-            mappingInstructions,
-        };
-    }
-    const expansionRegEx = new RegExp(`^${EXPANSION_PREFIX}[0-9]+$`);
-    for (const variableName in variablePaths) {
-        if (!variableName.match(expansionRegEx)) {
-            throw new Error('Expansions cannot be mixed with single key declarations.');
-        }
-    }
-    const expansions = [];
-    const sourcePaths = [];
-    for (const variableName in expansionExpressions) {
-        const str = expansionExpressions[variableName];
-        const valuePath = variablePaths[variableName];
-        const { inputValue: expansionInputValue, variablePaths: expansionVariablePaths } = extractVariables(parseValue(`${str}`, { noLocation: true }));
-        if (!Object.keys(expansionVariablePaths).length) {
-            throw new Error('Merge arguments must declare a key.');
-        }
-        const mappingInstructions = getMappingInstructions(expansionVariablePaths);
-        const value = valueFromASTUntyped(expansionInputValue);
-        sourcePaths.push(...getSourcePaths(mappingInstructions, selectionSet));
-        assertNotWithinList(valuePath);
-        expansions.push({
-            valuePath,
-            value,
-            mappingInstructions,
-        });
-    }
-    const usedProperties = propertyTreeFromPaths(sourcePaths);
-    return {
-        args: valueFromASTUntyped(newInputValue),
-        usedProperties,
-        expansions,
-    };
-}
-function getMappingInstructions(variablePaths) {
-    const mappingInstructions = [];
-    for (const keyPath in variablePaths) {
-        const valuePath = variablePaths[keyPath];
-        const splitKeyPath = keyPath.split(KEY_DELIMITER).slice(1);
-        assertNotWithinList(valuePath);
-        mappingInstructions.push({
-            destinationPath: valuePath,
-            sourcePath: splitKeyPath,
-        });
-    }
-    return mappingInstructions;
-}
-function assertNotWithinList(path) {
-    for (const pathSegment of path) {
-        if (typeof pathSegment === 'number') {
-            throw new Error('Insertions cannot be made into a list.');
-        }
-    }
-}

package/esm/pathsFromSelectionSet.js

@@ -1,25 +0,0 @@
-import { Kind } from 'graphql';
-export function pathsFromSelectionSet(selectionSet, path = []) {
-    const paths = [];
-    for (const selection of selectionSet.selections) {
-        const additions = pathsFromSelection(selection, path) ?? [];
-        for (const addition of additions) {
-            paths.push(addition);
-        }
-    }
-    return paths;
-}
-function pathsFromSelection(selection, path) {
-    if (selection.kind === Kind.FIELD) {
-        const responseKey = selection.alias?.value ?? selection.name.value;
-        if (selection.selectionSet) {
-            return pathsFromSelectionSet(selection.selectionSet, path.concat([responseKey]));
-        }
-        else {
-            return [path.concat([responseKey])];
-        }
-    }
-    else if (selection.kind === Kind.INLINE_FRAGMENT) {
-        return pathsFromSelectionSet(selection.selectionSet, path);
-    }
-}

package/esm/preparseMergeArgsExpr.js

@@ -1,27 +0,0 @@
-export const KEY_DELIMITER = '__dot__';
-export const EXPANSION_PREFIX = '__exp';
-export function preparseMergeArgsExpr(mergeArgsExpr) {
-    const variableRegex = /\$[_A-Za-z][_A-Za-z0-9.]*/g;
-    const dotRegex = /\./g;
-    mergeArgsExpr = mergeArgsExpr.replace(variableRegex, variable => variable.replace(dotRegex, KEY_DELIMITER));
-    const segments = mergeArgsExpr.split('[[');
-    const expansionExpressions = Object.create(null);
-    if (segments.length === 1) {
-        return { mergeArgsExpr, expansionExpressions };
-    }
-    let finalSegments = [segments[0]];
-    for (let i = 1; i < segments.length; i++) {
-        const additionalSegments = segments[i].split(']]');
-        if (additionalSegments.length !== 2) {
-            throw new Error(`Each opening "[[" must be matched by a closing "]]" without nesting.`);
-        }
-        finalSegments = finalSegments.concat(additionalSegments);
-    }
-    let finalMergeArgsExpr = finalSegments[0];
-    for (let i = 1; i < finalSegments.length - 1; i += 2) {
-        const variableName = `${EXPANSION_PREFIX}${(i - 1) / 2 + 1}`;
-        expansionExpressions[variableName] = finalSegments[i];
-        finalMergeArgsExpr += `\$${variableName}${finalSegments[i + 1]}`;
-    }
-    return { mergeArgsExpr: finalMergeArgsExpr, expansionExpressions };
-}

package/esm/properties.js

@@ -1,63 +0,0 @@
-export function addProperty(object, path, value) {
-    const initialSegment = path[0];
-    if (path.length === 1) {
-        object[initialSegment] = value;
-        return;
-    }
-    let field = object[initialSegment];
-    if (field != null) {
-        addProperty(field, path.slice(1), value);
-        return;
-    }
-    if (typeof path[1] === 'string') {
-        field = Object.create(null);
-    }
-    else {
-        field = [];
-    }
-    addProperty(field, path.slice(1), value);
-    object[initialSegment] = field;
-}
-export function getProperty(object, path) {
-    if (!path.length || object == null) {
-        return object;
-    }
-    const newPath = path.slice();
-    const key = newPath.shift();
-    if (key == null) {
-        return;
-    }
-    const prop = object[key];
-    return getProperty(prop, newPath);
-}
-export function getProperties(object, propertyTree) {
-    if (object == null) {
-        return object;
-    }
-    const newObject = Object.create(null);
-    for (const key in propertyTree) {
-        const subKey = propertyTree[key];
-        if (subKey == null) {
-            newObject[key] = object[key];
-            continue;
-        }
-        const prop = object[key];
-        newObject[key] = deepMap(prop, function deepMapFn(item) {
-            return getProperties(item, subKey);
-        });
-    }
-    return newObject;
-}
-export function propertyTreeFromPaths(paths) {
-    const propertyTree = Object.create(null);
-    for (const path of paths) {
-        addProperty(propertyTree, path, null);
-    }
-    return propertyTree;
-}
-function deepMap(arrayOrItem, fn) {
-    if (Array.isArray(arrayOrItem)) {
-        return arrayOrItem.map(nestedArrayOrItem => deepMap(nestedArrayOrItem, fn));
-    }
-    return fn(arrayOrItem);
-}

package/esm/stitchingDirectives.js

@@ -1,74 +0,0 @@
-import { GraphQLDirective, GraphQLList, GraphQLNonNull, GraphQLString, } from 'graphql';
-import { defaultStitchingDirectiveOptions } from './defaultStitchingDirectiveOptions.js';
-import { stitchingDirectivesTransformer } from './stitchingDirectivesTransformer.js';
-import { stitchingDirectivesValidator } from './stitchingDirectivesValidator.js';
-export function stitchingDirectives(options = {}) {
-    const finalOptions = {
-        ...defaultStitchingDirectiveOptions,
-        ...options,
-    };
-    const { keyDirectiveName, computedDirectiveName, mergeDirectiveName, canonicalDirectiveName } = finalOptions;
-    const keyDirectiveTypeDefs = /* GraphQL */ `directive @${keyDirectiveName}(selectionSet: String!) on OBJECT`;
-    const computedDirectiveTypeDefs = /* GraphQL */ `directive @${computedDirectiveName}(selectionSet: String!) on FIELD_DEFINITION`;
-    const mergeDirectiveTypeDefs = /* GraphQL */ `directive @${mergeDirectiveName}(argsExpr: String, keyArg: String, keyField: String, key: [String!], additionalArgs: String) on FIELD_DEFINITION`;
-    const canonicalDirectiveTypeDefs = /* GraphQL */ `directive @${canonicalDirectiveName} on OBJECT | INTERFACE | INPUT_OBJECT | UNION | ENUM | SCALAR | FIELD_DEFINITION | INPUT_FIELD_DEFINITION`;
-    const keyDirective = new GraphQLDirective({
-        name: keyDirectiveName,
-        locations: ['OBJECT'],
-        args: {
-            selectionSet: { type: new GraphQLNonNull(GraphQLString) },
-        },
-    });
-    const computedDirective = new GraphQLDirective({
-        name: computedDirectiveName,
-        locations: ['FIELD_DEFINITION'],
-        args: {
-            selectionSet: { type: new GraphQLNonNull(GraphQLString) },
-        },
-    });
-    const mergeDirective = new GraphQLDirective({
-        name: mergeDirectiveName,
-        locations: ['FIELD_DEFINITION'],
-        args: {
-            argsExpr: { type: GraphQLString },
-            keyArg: { type: GraphQLString },
-            keyField: { type: GraphQLString },
-            key: { type: new GraphQLList(new GraphQLNonNull(GraphQLString)) },
-            additionalArgs: { type: GraphQLString },
-        },
-    });
-    const canonicalDirective = new GraphQLDirective({
-        name: canonicalDirectiveName,
-        locations: [
-            'OBJECT',
-            'INTERFACE',
-            'INPUT_OBJECT',
-            'UNION',
-            'ENUM',
-            'SCALAR',
-            'FIELD_DEFINITION',
-            'INPUT_FIELD_DEFINITION',
-        ],
-    });
-    const allStitchingDirectivesTypeDefs = [
-        keyDirectiveTypeDefs,
-        computedDirectiveTypeDefs,
-        mergeDirectiveTypeDefs,
-        canonicalDirectiveTypeDefs,
-    ].join('\n');
-    return {
-        keyDirectiveTypeDefs,
-        computedDirectiveTypeDefs,
-        mergeDirectiveTypeDefs,
-        canonicalDirectiveTypeDefs,
-        stitchingDirectivesTypeDefs: allStitchingDirectivesTypeDefs, // for backwards compatibility
-        allStitchingDirectivesTypeDefs,
-        keyDirective,
-        computedDirective,
-        mergeDirective,
-        canonicalDirective,
-        allStitchingDirectives: [keyDirective, computedDirective, mergeDirective, canonicalDirective],
-        stitchingDirectivesValidator: stitchingDirectivesValidator(finalOptions),
-        stitchingDirectivesTransformer: stitchingDirectivesTransformer(finalOptions),
-    };
-}