@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2023 The Guild
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/cjs/compose.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositionHasErrors = exports.assertCompositionFailure = exports.assertCompositionSuccess = exports.composeServices = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("./graphql/printer.js");
+const inaccessible_js_1 = require("./specifications/inaccessible.js");
+const join_js_1 = require("./specifications/join.js");
+const link_js_1 = require("./specifications/link.js");
+const tag_js_1 = require("./specifications/tag.js");
+const validate_js_1 = require("./validate.js");
+function composeServices(services, __internal) {
+    const validationResult = (0, validate_js_1.validate)(services, __internal);
+    if (!validationResult.success) {
+        return {
+            errors: validationResult.errors,
+        };
+    }
+    const rootTypes = {
+        query: false,
+        mutation: false,
+        subscription: false,
+    };
+    for (const def of validationResult.supergraph) {
+        if (def.name.value === 'Query') {
+            rootTypes.query = true;
+        }
+        else if (def.name.value === 'Mutation') {
+            rootTypes.mutation = true;
+        }
+        else if (def.name.value === 'Subscription') {
+            rootTypes.subscription = true;
+        }
+        if (rootTypes.query === true &&
+            rootTypes.mutation === true &&
+            rootTypes.subscription === true) {
+            break;
+        }
+    }
+    const usedTagSpec = validationResult.specs.tag;
+    const usedInaccessibleSpec = validationResult.specs.inaccessible;
+    return {
+        supergraphSdl: `
+schema
+  @link(url: "https://specs.apollo.dev/link/v1.0")
+  @link(url: "https://specs.apollo.dev/join/v0.3", for: EXECUTION)
+  ${usedTagSpec ? '@link(url: "https://specs.apollo.dev/tag/v0.3")' : ''}
+  ${usedInaccessibleSpec
+            ? '@link(url: "https://specs.apollo.dev/inaccessible/v0.2", for: SECURITY)'
+            : ''}
+  ${validationResult.links.map(link_js_1.printLink).join('\n  ')}
+{
+  ${rootTypes.query ? 'query: Query' : ''}
+  ${rootTypes.mutation ? 'mutation: Mutation' : ''}
+  ${rootTypes.subscription ? 'subscription: Subscription' : ''}
+}
+
+${join_js_1.sdl}
+${link_js_1.sdl}
+${usedTagSpec ? tag_js_1.sdl : ''}
+${usedInaccessibleSpec ? inaccessible_js_1.sdl : ''}
+
+${(0, printer_js_1.print)({
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: validationResult.supergraph,
+        })}
+    `,
+    };
+}
+exports.composeServices = composeServices;
+function assertCompositionSuccess(compositionResult, message) {
+    if (compositionHasErrors(compositionResult)) {
+        throw new Error(message || 'Unexpected test failure');
+    }
+}
+exports.assertCompositionSuccess = assertCompositionSuccess;
+function assertCompositionFailure(compositionResult, message) {
+    if (!compositionHasErrors(compositionResult)) {
+        throw new Error(message || 'Unexpected test failure');
+    }
+}
+exports.assertCompositionFailure = assertCompositionFailure;
+function compositionHasErrors(compositionResult) {
+    return 'errors' in compositionResult && !!compositionResult.errors;
+}
+exports.compositionHasErrors = compositionHasErrors;

package/cjs/graphql/helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripFederationFromSupergraph = exports.isDirectiveDefinition = void 0;
+const graphql_1 = require("graphql");
+function isDirectiveDefinition(node) {
+    return node.kind === graphql_1.Kind.DIRECTIVE_DEFINITION;
+}
+exports.isDirectiveDefinition = isDirectiveDefinition;
+function stripFederationFromSupergraph(supergraph) {
+    function remove() {
+        return null;
+    }
+    return (0, graphql_1.visit)(supergraph, {
+        DirectiveDefinition: remove,
+        Directive: remove,
+        SchemaDefinition: remove,
+        SchemaExtension: remove,
+        EnumTypeDefinition: node => {
+            if (node.name.value === 'core__Purpose' || node.name.value === 'join__Graph') {
+                return null;
+            }
+            return node;
+        },
+        ScalarTypeDefinition: node => {
+            if (node.name.value === '_FieldSet') {
+                return null;
+            }
+            return node;
+        },
+    });
+}
+exports.stripFederationFromSupergraph = stripFederationFromSupergraph;

package/cjs/graphql/printer.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.print = void 0;
+function printString(string) {
+    return JSON.stringify(string);
+}
+function printBlockString(string) {
+    return '"""\n' + string.replace(/"""/g, '\\"""') + '\n"""';
+}
+const nodes = {
+    Document(node) {
+        return node.definitions?.length > 0 ? node.definitions.map(print).join('\n\n') : '';
+    },
+    OperationDefinition(node) {
+        if (node.operation === 'query' &&
+            !node.name &&
+            !node.variableDefinitions?.length &&
+            !node.directives?.length) {
+            return print(node.selectionSet);
+        }
+        return (join([
+            node.operation,
+            print(node.name) + wrap('(', join(node.variableDefinitions?.map(print), ', '), ')'),
+            join(node.directives?.map(print), ' '),
+        ], ' ') + print(node.selectionSet));
+    },
+    VariableDefinition(node) {
+        return [
+            print(node.variable),
+            ':',
+            print(node.type),
+            wrap(' = ', print(node.defaultValue)),
+            join(node.directives?.map(print), ' '),
+        ].join(' ');
+    },
+    Field(node) {
+        return (join([
+            (node.alias ? node.alias.value + ': ' : '') + node.name.value + printArgs(node.arguments),
+            join(node.directives?.map(print), ' '),
+        ], ' ') + print(node.selectionSet));
+    },
+    StringValue(node) {
+        return node.block ? printBlockString(node.value) : printString(node.value);
+    },
+    BooleanValue(node) {
+        return '' + node.value;
+    },
+    NullValue(_node) {
+        return 'null';
+    },
+    IntValue(node) {
+        return node.value;
+    },
+    FloatValue(node) {
+        return node.value;
+    },
+    EnumValue(node) {
+        return node.value;
+    },
+    Name(node) {
+        return node.value;
+    },
+    Variable(node) {
+        return '$' + node.name.value;
+    },
+    ListValue(node) {
+        return '[' + node.values.map(print).join(', ') + ']';
+    },
+    ObjectValue(node) {
+        return '{' + node.fields.map(print).join(', ') + '}';
+    },
+    ObjectField(node) {
+        return node.name.value + ': ' + print(node.value);
+    },
+    SelectionSet(node) {
+        return block(node.selections.map(print));
+    },
+    Argument(node) {
+        return node.name.value + ': ' + print(node.value);
+    },
+    FragmentSpread(node) {
+        return join(['...', print(node.name), join(node.directives?.map(print), ' ')], ' ');
+    },
+    InlineFragment(node) {
+        return join([
+            '...',
+            node.typeCondition ? 'on ' + node.typeCondition.name.value : '',
+            join(node.directives?.map(print), ' '),
+            print(node.selectionSet),
+        ], ' ');
+    },
+    FragmentDefinition(node) {
+        return join([
+            'fragment',
+            print(node.name),
+            'on',
+            node.typeCondition.name.value,
+            join(node.directives?.map(print), ' '),
+            print(node.selectionSet),
+        ]);
+    },
+    Directive(node) {
+        return '@' + node.name.value + printArgs(node.arguments);
+    },
+    NamedType(node) {
+        return node.name.value;
+    },
+    ListType(node) {
+        return '[' + print(node.type) + ']';
+    },
+    NonNullType(node) {
+        return print(node.type) + '!';
+    },
+    SchemaDefinition(node) {
+        return join(['schema', join(node.directives?.map(print), ' '), block(node.operationTypes?.map(print))], ' ');
+    },
+    OperationTypeDefinition(node) {
+        return node.operation + ': ' + print(node.type);
+    },
+    ScalarTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join(['scalar', print(node.name), join(node.directives?.map(print), ' ')], ' '));
+    },
+    ObjectTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'type',
+                print(node.name),
+                wrap('implements ', join(node.interfaces?.map(print), ' & ')),
+                join(node.directives?.map(print), ' '),
+                block(node.fields?.map(print)),
+            ], ' '));
+    },
+    InterfaceTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'interface',
+                print(node.name),
+                wrap('implements ', join(node.interfaces?.map(print), ' & ')),
+                join(node.directives?.map(print), ' '),
+                block(node.fields?.map(print)),
+            ], ' '));
+    },
+    InputObjectTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'input',
+                print(node.name),
+                join(node.directives?.map(print), ' '),
+                block(node.fields?.map(print)),
+            ], ' '));
+    },
+    UnionTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'union',
+                print(node.name),
+                join(node.directives?.map(print), ' '),
+                wrap('= ', join(node.types?.map(print), ' | ')),
+            ], ' '));
+    },
+    EnumTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'enum',
+                print(node.name),
+                join(node.directives?.map(print), ' '),
+                block(node.values?.map(print)),
+            ], ' '));
+    },
+    EnumValueDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([print(node.name), join(node.directives?.map(print), ' ')], ' '));
+    },
+    FieldDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            print(node.name) +
+            printArgs(node.arguments) +
+            ': ' +
+            print(node.type) +
+            wrap(' ', join(node.directives?.map(print), ' ')));
+    },
+    InputValueDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                print(node.name) + ': ' + print(node.type),
+                wrap('= ', print(node.defaultValue)),
+                join(node.directives?.map(print), ' '),
+            ], ' '));
+    },
+    DirectiveDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            'directive @' +
+            print(node.name) +
+            printArgs(node.arguments) +
+            (node.repeatable ? ' repeatable' : '') +
+            ' on ' +
+            join(node.locations?.map(print), ' | '));
+    },
+    SchemaExtension() {
+        return '';
+    },
+    ScalarTypeExtension() {
+        return '';
+    },
+    ObjectTypeExtension() {
+        return '';
+    },
+    InterfaceTypeExtension() {
+        return '';
+    },
+    UnionTypeExtension() {
+        return '';
+    },
+    EnumTypeExtension() {
+        return '';
+    },
+    InputObjectTypeExtension() {
+        return '';
+    },
+};
+function print(node) {
+    if (!node) {
+        return '';
+    }
+    return nodes[node.kind] ? nodes[node.kind](node) : '';
+}
+exports.print = print;
+function printArgs(nodes) {
+    if (!nodes || nodes.length === 0) {
+        return '';
+    }
+    const args = nodes.map(print);
+    const argsLine = '(' + args.join(', ') + ') ';
+    return argsLine.length > 80 ? '(\n  ' + args.join('\n').replace(/\n/g, '\n  ') + '\n)' : argsLine;
+}
+function block(array) {
+    return wrap('{\n', indent(join(array, '\n')), '\n}');
+}
+function indent(str) {
+    return wrap('  ', str.replaceAll('\n', '\n  '));
+}
+function wrap(start, maybeString, end = '') {
+    return maybeString != null && maybeString !== '' ? start + maybeString + end : '';
+}
+function join(maybeArray, separator = '') {
+    return maybeArray?.filter(x => x).join(separator) ?? '';
+}

package/cjs/graphql/type-node-info.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitWithTypeNodeInfo = exports.TypeNodeInfo = void 0;
+const graphql_1 = require("graphql");
+function getEnterLeaveForKind(visitor, kind) {
+    const kindVisitor = visitor[kind];
+    if (typeof kindVisitor === 'object') {
+        return kindVisitor;
+    }
+    if (typeof kindVisitor === 'function') {
+        return { enter: kindVisitor, leave: undefined };
+    }
+    return { enter: visitor.enter, leave: visitor.leave };
+}
+function isNode(maybeNode) {
+    const maybeKind = maybeNode?.kind;
+    return typeof maybeKind === 'string';
+}
+class TypeNodeInfo {
+    _type;
+    _field;
+    _arg;
+    _value;
+    constructor() {
+        this._type = undefined;
+        this._field = undefined;
+        this._arg = undefined;
+        this._value = undefined;
+    }
+    get [Symbol.toStringTag]() {
+        return 'TypeNodeInfo';
+    }
+    getTypeDef() {
+        return this._type;
+    }
+    getFieldDef() {
+        return this._field;
+    }
+    getArgumentDef() {
+        return this._arg;
+    }
+    getValueDef() {
+        return this._value;
+    }
+    enter(node) {
+        switch (node.kind) {
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+            case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+            case graphql_1.Kind.UNION_TYPE_DEFINITION:
+            case graphql_1.Kind.UNION_TYPE_EXTENSION:
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+            case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+            case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+            case graphql_1.Kind.DIRECTIVE_DEFINITION:
+                this._type = node;
+                break;
+            case graphql_1.Kind.ENUM_VALUE_DEFINITION:
+                this._value = node;
+                break;
+            case graphql_1.Kind.FIELD_DEFINITION:
+                this._field = node;
+                break;
+            case graphql_1.Kind.INPUT_VALUE_DEFINITION:
+                if (this._field) {
+                    this._arg = node;
+                }
+                else {
+                    this._field = node;
+                }
+                break;
+            default:
+        }
+    }
+    leave(node) {
+        switch (node.kind) {
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+            case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+            case graphql_1.Kind.UNION_TYPE_DEFINITION:
+            case graphql_1.Kind.UNION_TYPE_EXTENSION:
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+            case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+            case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+            case graphql_1.Kind.DIRECTIVE_DEFINITION:
+                this._type = undefined;
+                break;
+            case graphql_1.Kind.FIELD_DEFINITION:
+                this._field = undefined;
+                break;
+            case graphql_1.Kind.ENUM_VALUE_DEFINITION:
+                this._value = undefined;
+                break;
+            case graphql_1.Kind.INPUT_VALUE_DEFINITION:
+                if (this._arg) {
+                    this._arg = undefined;
+                }
+                else {
+                    this._field = undefined;
+                }
+                break;
+            default:
+        }
+    }
+}
+exports.TypeNodeInfo = TypeNodeInfo;
+function visitWithTypeNodeInfo(typeInfo, visitor) {
+    return {
+        enter(node, key, parent, path, ancestors) {
+            typeInfo.enter(node);
+            const fn = getEnterLeaveForKind(visitor, node.kind).enter;
+            if (fn) {
+                const result = fn.call(visitor, node, key, parent, path, ancestors);
+                if (result !== undefined) {
+                    typeInfo.leave(node);
+                    if (isNode(result)) {
+                        typeInfo.enter(result);
+                    }
+                }
+                return result;
+            }
+        },
+        leave(node, key, parent, path, ancestors) {
+            const fn = getEnterLeaveForKind(visitor, node.kind).leave;
+            let result;
+            if (fn) {
+                result = fn.call(visitor, node, key, parent, path, ancestors);
+            }
+            typeInfo.leave(node);
+            return result;
+        },
+    };
+}
+exports.visitWithTypeNodeInfo = visitWithTypeNodeInfo;

package/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripFederationFromSupergraph = void 0;
+__exportStar(require("./compose.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./validate.js"), exports);
+var helpers_js_1 = require("./graphql/helpers.js");
+Object.defineProperty(exports, "stripFederationFromSupergraph", { enumerable: true, get: function () { return helpers_js_1.stripFederationFromSupergraph; } });

package/cjs/package.json

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