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

package/README.md

@@ -3,5 +3,3 @@ https://www.graphql-tools.com/docs/api/modules/stitching_directives_src
 
 You can also learn more about Schema Stitching Directives in this chapter;
 https://www.graphql-tools.com/docs/stitch-directives-sdl
-
-

package/cjs/defaultStitchingDirectiveOptions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStitchingDirectiveOptions = void 0;
+exports.defaultStitchingDirectiveOptions = {
+    keyDirectiveName: 'key',
+    computedDirectiveName: 'computed',
+    canonicalDirectiveName: 'canonical',
+    mergeDirectiveName: 'merge',
+    pathToDirectivesInExtensions: ['directives'],
+};

package/cjs/extractVariables.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVariables = void 0;
+const graphql_1 = require("graphql");
+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: graphql_1.Kind.NULL,
+            };
+        },
+    };
+    const newInputValue = (0, graphql_1.visit)(inputValue, {
+        [graphql_1.Kind.OBJECT]: keyPathVisitor,
+        [graphql_1.Kind.LIST]: keyPathVisitor,
+        [graphql_1.Kind.OBJECT_FIELD]: fieldPathVisitor,
+        [graphql_1.Kind.VARIABLE]: variableVisitor,
+    });
+    return {
+        inputValue: newInputValue,
+        variablePaths,
+    };
+}
+exports.extractVariables = extractVariables;

package/cjs/federationToStitchingSDL.js

@@ -0,0 +1,114 @@
+"use strict";
+// Taken from https://github.com/gmac/federation-to-stitching-sdl/blob/main/index.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.federationToStitchingSDL = void 0;
+const graphql_1 = require("graphql");
+const stitchingDirectives_js_1 = require("./stitchingDirectives.js");
+const extensionKind = /Extension$/;
+const entityKinds = [
+    graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+    graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+    graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+    graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
+];
+function isEntityKind(def) {
+    return entityKinds.includes(def.kind);
+}
+function getQueryTypeDef(definitions) {
+    var _a;
+    const schemaDef = definitions.find(def => def.kind === graphql_1.Kind.SCHEMA_DEFINITION);
+    const typeName = schemaDef
+        ? (_a = schemaDef.operationTypes.find(({ operation }) => operation === 'query')) === null || _a === void 0 ? void 0 : _a.type.name.value
+        : 'Query';
+    return definitions.find(def => def.kind === graphql_1.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
+function federationToStitchingSDL(federationSDL, stitchingConfig = (0, stitchingDirectives_js_1.stitchingDirectives)()) {
+    const doc = (0, graphql_1.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 => {
+        var _a, _b, _c;
+        // 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 = [];
+        (_a = typeDef.directives) === null || _a === void 0 ? void 0 : _a.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 = (0, graphql_1.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 = (_b = typeDef.fields) === null || _b === void 0 ? void 0 : _b.filter(fieldDef => {
+            var _a;
+            return (keyFields.includes(fieldDef.name.value) || !((_a = fieldDef.directives) === null || _a === void 0 ? void 0 : _a.find(dir => dir.name.value === 'external')));
+        });
+        // Discard remaining "@external" directives and any "@provides" directives
+        (_c = typeDef.fields) === null || _c === void 0 ? void 0 : _c.forEach((fieldDef) => {
+            fieldDef.directives = fieldDef.directives.filter((dir) => !/^(external|provides)$/.test(dir.name.value));
+            fieldDef.directives.forEach((dir) => {
+                if (dir.name.value === 'requires') {
+                    dir.name.value = stitchingConfig.computedDirective.name;
+                    dir.arguments[0].name.value = 'selectionSet';
+                    dir.arguments[0].value.value = `{ ${dir.arguments[0].value.value} }`;
+                }
+            });
+        });
+        if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || typeDef.kind === graphql_1.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 = (0, graphql_1.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, (0, graphql_1.print)(doc)].join('\n');
+}
+exports.federationToStitchingSDL = federationToStitchingSDL;

package/cjs/getSourcePaths.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourcePaths = void 0;
+const graphql_1 = require("graphql");
+const pathsFromSelectionSet_js_1 = require("./pathsFromSelectionSet.js");
+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 = (0, pathsFromSelectionSet_js_1.pathsFromSelectionSet)(selectionSet);
+        for (const path of paths) {
+            sourcePaths.push(path);
+        }
+        sourcePaths.push([graphql_1.TypeNameMetaFieldDef.name]);
+    }
+    return sourcePaths;
+}
+exports.getSourcePaths = getSourcePaths;

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./stitchingDirectives.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./federationToStitchingSDL.js"), exports);

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/parseMergeArgsExpr.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMergeArgsExpr = void 0;
+const graphql_1 = require("graphql");
+const extractVariables_js_1 = require("./extractVariables.js");
+const preparseMergeArgsExpr_js_1 = require("./preparseMergeArgsExpr.js");
+const properties_js_1 = require("./properties.js");
+const getSourcePaths_js_1 = require("./getSourcePaths.js");
+function parseMergeArgsExpr(mergeArgsExpr, selectionSet) {
+    const { mergeArgsExpr: newMergeArgsExpr, expansionExpressions } = (0, preparseMergeArgsExpr_js_1.preparseMergeArgsExpr)(mergeArgsExpr);
+    const inputValue = (0, graphql_1.parseValue)(`{ ${newMergeArgsExpr} }`, { noLocation: true });
+    const { inputValue: newInputValue, variablePaths } = (0, extractVariables_js_1.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 = (0, properties_js_1.propertyTreeFromPaths)((0, getSourcePaths_js_1.getSourcePaths)(mappingInstructions, selectionSet));
+        return { args: (0, graphql_1.valueFromASTUntyped)(newInputValue), usedProperties, mappingInstructions };
+    }
+    const expansionRegEx = new RegExp(`^${preparseMergeArgsExpr_js_1.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 } = (0, extractVariables_js_1.extractVariables)((0, graphql_1.parseValue)(`${str}`, { noLocation: true }));
+        if (!Object.keys(expansionVariablePaths).length) {
+            throw new Error('Merge arguments must declare a key.');
+        }
+        const mappingInstructions = getMappingInstructions(expansionVariablePaths);
+        const value = (0, graphql_1.valueFromASTUntyped)(expansionInputValue);
+        sourcePaths.push(...(0, getSourcePaths_js_1.getSourcePaths)(mappingInstructions, selectionSet));
+        assertNotWithinList(valuePath);
+        expansions.push({
+            valuePath,
+            value,
+            mappingInstructions,
+        });
+    }
+    const usedProperties = (0, properties_js_1.propertyTreeFromPaths)(sourcePaths);
+    return { args: (0, graphql_1.valueFromASTUntyped)(newInputValue), usedProperties, expansions };
+}
+exports.parseMergeArgsExpr = parseMergeArgsExpr;
+function getMappingInstructions(variablePaths) {
+    const mappingInstructions = [];
+    for (const keyPath in variablePaths) {
+        const valuePath = variablePaths[keyPath];
+        const splitKeyPath = keyPath.split(preparseMergeArgsExpr_js_1.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/cjs/pathsFromSelectionSet.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathsFromSelectionSet = void 0;
+const graphql_1 = require("graphql");
+function pathsFromSelectionSet(selectionSet, path = []) {
+    var _a;
+    const paths = [];
+    for (const selection of selectionSet.selections) {
+        const additions = (_a = pathsFromSelection(selection, path)) !== null && _a !== void 0 ? _a : [];
+        for (const addition of additions) {
+            paths.push(addition);
+        }
+    }
+    return paths;
+}
+exports.pathsFromSelectionSet = pathsFromSelectionSet;
+function pathsFromSelection(selection, path) {
+    var _a, _b;
+    if (selection.kind === graphql_1.Kind.FIELD) {
+        const responseKey = (_b = (_a = selection.alias) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : selection.name.value;
+        if (selection.selectionSet) {
+            return pathsFromSelectionSet(selection.selectionSet, path.concat([responseKey]));
+        }
+        else {
+            return [path.concat([responseKey])];
+        }
+    }
+    else if (selection.kind === graphql_1.Kind.INLINE_FRAGMENT) {
+        return pathsFromSelectionSet(selection.selectionSet, path);
+    }
+}

package/cjs/preparseMergeArgsExpr.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparseMergeArgsExpr = exports.EXPANSION_PREFIX = exports.KEY_DELIMITER = void 0;
+exports.KEY_DELIMITER = '__dot__';
+exports.EXPANSION_PREFIX = '__exp';
+function preparseMergeArgsExpr(mergeArgsExpr) {
+    const variableRegex = /\$[_A-Za-z][_A-Za-z0-9.]*/g;
+    const dotRegex = /\./g;
+    mergeArgsExpr = mergeArgsExpr.replace(variableRegex, variable => variable.replace(dotRegex, exports.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 = `${exports.EXPANSION_PREFIX}${(i - 1) / 2 + 1}`;
+        expansionExpressions[variableName] = finalSegments[i];
+        finalMergeArgsExpr += `\$${variableName}${finalSegments[i + 1]}`;
+    }
+    return { mergeArgsExpr: finalMergeArgsExpr, expansionExpressions };
+}
+exports.preparseMergeArgsExpr = preparseMergeArgsExpr;

package/cjs/properties.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyTreeFromPaths = exports.getProperties = exports.getProperty = exports.addProperty = void 0;
+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;
+}
+exports.addProperty = addProperty;
+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);
+}
+exports.getProperty = getProperty;
+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;
+}
+exports.getProperties = getProperties;
+function propertyTreeFromPaths(paths) {
+    const propertyTree = Object.create(null);
+    for (const path of paths) {
+        addProperty(propertyTree, path, null);
+    }
+    return propertyTree;
+}
+exports.propertyTreeFromPaths = propertyTreeFromPaths;
+function deepMap(arrayOrItem, fn) {
+    if (Array.isArray(arrayOrItem)) {
+        return arrayOrItem.map(nestedArrayOrItem => deepMap(nestedArrayOrItem, fn));
+    }
+    return fn(arrayOrItem);
+}

package/cjs/stitchingDirectives.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchingDirectives = void 0;
+const graphql_1 = require("graphql");
+const defaultStitchingDirectiveOptions_js_1 = require("./defaultStitchingDirectiveOptions.js");
+const stitchingDirectivesValidator_js_1 = require("./stitchingDirectivesValidator.js");
+const stitchingDirectivesTransformer_js_1 = require("./stitchingDirectivesTransformer.js");
+function stitchingDirectives(options = {}) {
+    const finalOptions = {
+        ...defaultStitchingDirectiveOptions_js_1.defaultStitchingDirectiveOptions,
+        ...options,
+    };
+    const { keyDirectiveName, computedDirectiveName, mergeDirectiveName, canonicalDirectiveName } = finalOptions;
+    const keyDirectiveTypeDefs = /* GraphQL */ `directive @${keyDirectiveName}(selectionSet: String!) on OBJECT`;
+    const computedDirectiveTypeDefs = /* GraphQL */ `directive @${computedDirectiveName}(selectionSet: String!) on FIELD_DEFINITION`;
+    const mergeDirectiveTypeDefs = /* GraphQL */ `directive @${mergeDirectiveName}(argsExpr: String, keyArg: String, keyField: String, key: [String!], additionalArgs: String) on FIELD_DEFINITION`;
+    const canonicalDirectiveTypeDefs = /* GraphQL */ `directive @${canonicalDirectiveName} on OBJECT | INTERFACE | INPUT_OBJECT | UNION | ENUM | SCALAR | FIELD_DEFINITION | INPUT_FIELD_DEFINITION`;
+    const keyDirective = new graphql_1.GraphQLDirective({
+        name: keyDirectiveName,
+        locations: ['OBJECT'],
+        args: {
+            selectionSet: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+        },
+    });
+    const computedDirective = new graphql_1.GraphQLDirective({
+        name: computedDirectiveName,
+        locations: ['FIELD_DEFINITION'],
+        args: {
+            selectionSet: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+        },
+    });
+    const mergeDirective = new graphql_1.GraphQLDirective({
+        name: mergeDirectiveName,
+        locations: ['FIELD_DEFINITION'],
+        args: {
+            argsExpr: { type: graphql_1.GraphQLString },
+            keyArg: { type: graphql_1.GraphQLString },
+            keyField: { type: graphql_1.GraphQLString },
+            key: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(graphql_1.GraphQLString)) },
+            additionalArgs: { type: graphql_1.GraphQLString },
+        },
+    });
+    const canonicalDirective = new graphql_1.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,
+        allStitchingDirectivesTypeDefs,
+        keyDirective,
+        computedDirective,
+        mergeDirective,
+        canonicalDirective,
+        allStitchingDirectives: [keyDirective, computedDirective, mergeDirective, canonicalDirective],
+        stitchingDirectivesValidator: (0, stitchingDirectivesValidator_js_1.stitchingDirectivesValidator)(finalOptions),
+        stitchingDirectivesTransformer: (0, stitchingDirectivesTransformer_js_1.stitchingDirectivesTransformer)(finalOptions),
+    };
+}
+exports.stitchingDirectives = stitchingDirectives;