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

package/esm/federationToStitchingSDL.js

@@ -0,0 +1,110 @@
+// Taken from https://github.com/gmac/federation-to-stitching-sdl/blob/main/index.js
+import { print, Kind, parse, } 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) {
+    var _a;
+    const schemaDef = definitions.find(def => def.kind === 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 === 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 => {
+        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 = 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 === 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

@@ -0,0 +1,21 @@
+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

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

package/esm/parseMergeArgsExpr.js

@@ -0,0 +1,65 @@
+import { parseValue, valueFromASTUntyped } from 'graphql';
+import { extractVariables } from './extractVariables.js';
+import { EXPANSION_PREFIX, KEY_DELIMITER, preparseMergeArgsExpr } from './preparseMergeArgsExpr.js';
+import { propertyTreeFromPaths } from './properties.js';
+import { getSourcePaths } from './getSourcePaths.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

@@ -0,0 +1,27 @@
+import { Kind } from 'graphql';
+export 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;
+}
+function pathsFromSelection(selection, path) {
+    var _a, _b;
+    if (selection.kind === 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 === Kind.INLINE_FRAGMENT) {
+        return pathsFromSelectionSet(selection.selectionSet, path);
+    }
+}

package/esm/preparseMergeArgsExpr.js

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,74 @@
+import { GraphQLDirective, GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql';
+import { defaultStitchingDirectiveOptions } from './defaultStitchingDirectiveOptions.js';
+import { stitchingDirectivesValidator } from './stitchingDirectivesValidator.js';
+import { stitchingDirectivesTransformer } from './stitchingDirectivesTransformer.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,
+        allStitchingDirectivesTypeDefs,
+        keyDirective,
+        computedDirective,
+        mergeDirective,
+        canonicalDirective,
+        allStitchingDirectives: [keyDirective, computedDirective, mergeDirective, canonicalDirective],
+        stitchingDirectivesValidator: stitchingDirectivesValidator(finalOptions),
+        stitchingDirectivesTransformer: stitchingDirectivesTransformer(finalOptions),
+    };
+}