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

package/cjs/specifications/federation.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFederationVersion = exports.isFederationLink = exports.createSpecSchema = exports.isFederationVersion = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../graphql/printer.js");
+const inaccessible_js_1 = require("./inaccessible.js");
+const link_js_1 = require("./link.js");
+const tag_js_1 = require("./tag.js");
+function isFederationVersion(version) {
+    return version in federationSpecFactory;
+}
+exports.isFederationVersion = isFederationVersion;
+function createSpecSchema(version, imports) {
+    if (!isFederationVersion(version)) {
+        throw new graphql_1.GraphQLError(`Invalid version ${version} for the federation feature in @link direction on schema`, {
+            extensions: {
+                code: 'UNKNOWN_FEDERATION_LINK_VERSION',
+            },
+        });
+    }
+    if (version !== 'v1.0') {
+        const spec = federationSpecFactory[version]('', imports);
+        const namespacedSpec = federationSpecFactory[version]('federation__');
+        return {
+            directives: spec.directives.concat(namespacedSpec.directives),
+            types: spec.types.concat(namespacedSpec.types),
+        };
+    }
+    const spec = federationSpecFactory[version]('');
+    return {
+        directives: spec.directives.concat([tag_js_1.directive, inaccessible_js_1.directive]),
+        types: spec.types,
+    };
+}
+exports.createSpecSchema = createSpecSchema;
+const federationSpecFactory = {
+    'v1.0': (prefix) => createTypeDefinitions(`
+        directive @key(
+          fields: _FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+        directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @extends on OBJECT | INTERFACE
+        # @override is not supported in v1 but somehow it's supported by Apollo Composition
+        directive @override(from: String!) on FIELD_DEFINITION
+        scalar _FieldSet
+      `, prefix),
+    'v2.0': (prefix, imports) => createTypeDefinitions(`
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @shareable on FIELD_DEFINITION | OBJECT
+        directive @extends on OBJECT | INTERFACE
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+    'v2.1': (prefix, imports) => createTypeDefinitions(`
+        directive @composeDirective(name: String!) repeatable on SCHEMA
+        directive @extends on OBJECT | INTERFACE
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @shareable on FIELD_DEFINITION | OBJECT
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+    'v2.2': (prefix, imports) => createTypeDefinitions(`
+        directive @composeDirective(name: String!) repeatable on SCHEMA
+        directive @extends on OBJECT | INTERFACE
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @shareable repeatable on FIELD_DEFINITION | OBJECT
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+    'v2.3': (prefix, imports) => createTypeDefinitions(`
+        directive @composeDirective(name: String!) repeatable on SCHEMA
+        directive @extends on OBJECT | INTERFACE
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @interfaceObject on OBJECT
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @shareable repeatable on FIELD_DEFINITION | OBJECT
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+};
+function createTypeDefinitions(doc, prefix, imports) {
+    const shouldFilter = !!imports;
+    const toInclude = new Set(imports?.map(i => i.name.replace(/^@/, '')));
+    const docAST = (0, graphql_1.parse)(doc, {
+        noLocation: true,
+    });
+    if (!imports?.length ||
+        toInclude.has('key') ||
+        toInclude.has('requires') ||
+        toInclude.has('provides')) {
+        toInclude.add('FieldSet');
+        toInclude.add('federation__FieldSet');
+    }
+    const directives = [];
+    const types = [];
+    for (const node of docAST.definitions) {
+        if (isDirectiveDefinitionNode(node)) {
+            directives.push(applyPrefix(node, prefix));
+        }
+        else {
+            types.push(applyPrefix(node, prefix));
+        }
+    }
+    return {
+        directives: directives.filter(d => !graphql_1.specifiedDirectives.some(sd => sd.name === d.name.value) &&
+            (!shouldFilter || toInclude.has(d.name.value))),
+        types: types.filter(t => toInclude.has(t.name.value)),
+    };
+}
+function isDirectiveDefinitionNode(node) {
+    return node.kind === graphql_1.Kind.DIRECTIVE_DEFINITION;
+}
+function applyPrefix(node, prefix) {
+    if (prefix.length === 0) {
+        return node;
+    }
+    node.name.value = `${prefix}${node.name.value}`;
+    if (isDirectiveDefinitionNode(node)) {
+        node.arguments?.forEach(arg => {
+            const nameNode = resolveNamedType(arg.type);
+            if (!graphql_1.specifiedScalarTypes.some(t => t.name === nameNode.value)) {
+                nameNode.value = `${prefix}${nameNode.value}`;
+            }
+        });
+    }
+    return node;
+}
+function resolveNamedType(node) {
+    if (node.kind === graphql_1.Kind.LIST_TYPE) {
+        return resolveNamedType(node.type);
+    }
+    if (node.kind === graphql_1.Kind.NON_NULL_TYPE) {
+        return resolveNamedType(node.type);
+    }
+    return node.name;
+}
+function isFederationLink(link) {
+    return link.identity === 'https://specs.apollo.dev/federation';
+}
+exports.isFederationLink = isFederationLink;
+function detectFederationVersion(typeDefs) {
+    for (const definition of typeDefs.definitions) {
+        if (definition.kind === graphql_1.Kind.SCHEMA_EXTENSION || definition.kind === graphql_1.Kind.SCHEMA_DEFINITION) {
+            const links = definition.directives?.filter(directive => directive.name.value === 'link');
+            if (links?.length) {
+                const parsedLinks = links.map(l => {
+                    const url = l.arguments?.find(a => a.name.value === 'url');
+                    const importArg = l.arguments?.find(a => a.name.value === 'import');
+                    if (!url) {
+                        throw new Error('Invalid @link directive');
+                    }
+                    return (0, link_js_1.parseLink)(url.value.value, importArg ? (0, printer_js_1.print)(importArg.value) : '[]');
+                });
+                const fedLink = parsedLinks.find(l => l.identity === 'https://specs.apollo.dev/federation');
+                if (fedLink?.version) {
+                    if (!isFederationVersion(fedLink.version)) {
+                        throw new Error(`Unsupported federation version: ${fedLink.version}`);
+                    }
+                    return {
+                        version: fedLink.version,
+                        imports: fedLink.imports,
+                    };
+                }
+            }
+        }
+    }
+    return { version: 'v1.0', imports: [] };
+}
+exports.detectFederationVersion = detectFederationVersion;

package/cjs/specifications/inaccessible.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directive = exports.typeDefs = exports.sdl = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../graphql/helpers.js");
+exports.sdl = `
+  directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+`;
+exports.typeDefs = (0, graphql_1.parse)(exports.sdl);
+exports.directive = exports.typeDefs.definitions.filter(helpers_js_1.isDirectiveDefinition)[0];

package/cjs/specifications/join.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdl = void 0;
+exports.sdl = `
+  directive @join__enumValue(graph: join__Graph!) repeatable on ENUM_VALUE
+
+  directive @join__field(
+    graph: join__Graph
+    requires: join__FieldSet
+    provides: join__FieldSet
+    type: String
+    external: Boolean
+    override: String
+    usedOverridden: Boolean
+  ) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
+
+  directive @join__graph(name: String!, url: String!) on ENUM_VALUE
+
+  directive @join__implements(
+    graph: join__Graph!
+    interface: String!
+  ) repeatable on OBJECT | INTERFACE
+
+  directive @join__type(
+    graph: join__Graph!
+    key: join__FieldSet
+    extension: Boolean! = false
+    resolvable: Boolean! = true
+    isInterfaceObject: Boolean! = false
+  ) repeatable on OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT | SCALAR
+
+  directive @join__unionMember(graph: join__Graph!, member: String!) repeatable on UNION
+
+  scalar join__FieldSet
+`;

package/cjs/specifications/link.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdl = exports.parseLinkDirective = exports.parseLink = exports.mergeLinks = exports.parseLinkImport = exports.parseLinkUrl = exports.printLink = void 0;
+const graphql_1 = require("graphql");
+const json5_1 = __importDefault(require("json5"));
+const printer_js_1 = require("../graphql/printer.js");
+function printLink(link) {
+    return (0, printer_js_1.print)({
+        kind: graphql_1.Kind.DIRECTIVE,
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: 'link',
+        },
+        arguments: [
+            {
+                kind: graphql_1.Kind.ARGUMENT,
+                name: {
+                    kind: graphql_1.Kind.NAME,
+                    value: 'url',
+                },
+                value: {
+                    kind: graphql_1.Kind.STRING,
+                    value: [link.identity, link.version].filter(Boolean).join('/'),
+                },
+            },
+            {
+                kind: graphql_1.Kind.ARGUMENT,
+                name: {
+                    kind: graphql_1.Kind.NAME,
+                    value: 'import',
+                },
+                value: {
+                    kind: graphql_1.Kind.LIST,
+                    values: link.imports.map(im => ({
+                        kind: graphql_1.Kind.STRING,
+                        value: im.name,
+                    })),
+                },
+            },
+        ],
+    });
+}
+exports.printLink = printLink;
+function parseLinkUrl(urlString) {
+    const url = new URL(urlString);
+    const parts = url.pathname.split('/').filter(Boolean);
+    const len = parts.length;
+    if (!len) {
+        return { name: null, version: null, identity: url.origin };
+    }
+    const last = parts[len - 1];
+    const secondLast = parts[len - 2];
+    const potentiallyNameAndVersion = typeof secondLast === 'string';
+    if (potentiallyNameAndVersion) {
+        return {
+            name: secondLast,
+            version: last,
+            identity: url.origin +
+                '/' +
+                parts
+                    .slice(0, len - 2)
+                    .concat(secondLast)
+                    .join('/'),
+        };
+    }
+    if (/^v\d+/i.test(last)) {
+        return {
+            name: null,
+            version: last,
+            identity: url.origin,
+        };
+    }
+    return {
+        name: last,
+        version: null,
+        identity: url.origin +
+            '/' +
+            parts
+                .slice(0, len - 2)
+                .concat(last)
+                .join('/'),
+    };
+}
+exports.parseLinkUrl = parseLinkUrl;
+function parseLinkImport(importString) {
+    try {
+        const bindings = json5_1.default.parse(importString);
+        if (!Array.isArray(bindings)) {
+            throw new Error(`Expected an array`);
+        }
+        return bindings.map(binding => {
+            if (typeof binding === 'string') {
+                return {
+                    kind: binding.startsWith('@') ? 'directive' : 'type',
+                    name: binding,
+                };
+            }
+            if (typeof binding === 'object' && binding.name) {
+                const nameKind = binding.name.startsWith('@') ? 'directive' : 'type';
+                if (!binding.as) {
+                    return {
+                        kind: nameKind,
+                        name: binding.name,
+                    };
+                }
+                const aliasKind = binding.as.startsWith('@') ? 'directive' : 'type';
+                if (nameKind !== aliasKind) {
+                    throw new Error(`${binding.name} and ${binding.as} must be of the same kind`);
+                }
+                return {
+                    kind: nameKind,
+                    name: binding.name,
+                    alias: binding.as,
+                };
+            }
+            throw new Error(`Syntax`);
+        });
+    }
+    catch (error) {
+        throw new Error(`Invalid import binding: ${importString}: ${String(error)}`);
+    }
+}
+exports.parseLinkImport = parseLinkImport;
+function mergeLinks(links) {
+    const groupByIdentity = new Map();
+    for (const link of links) {
+        const existing = groupByIdentity.get(link.identity);
+        if (!existing) {
+            const importedDirectives = link.imports.filter(im => im.kind === 'directive');
+            if (importedDirectives.length === 0) {
+                continue;
+            }
+            groupByIdentity.set(link.identity, {
+                name: link.name,
+                highestVersion: link.version ?? '',
+                imports: link.imports.filter(im => im.kind === 'directive'),
+            });
+        }
+        else {
+            if (link.version &&
+                parseFloat(link.version.replace('v', '')) >
+                    parseFloat(existing.highestVersion.replace('v', ''))) {
+                existing.highestVersion = link.version;
+            }
+            for (const im of link.imports) {
+                if (im.kind === 'type') {
+                    continue;
+                }
+                const hasImport = existing.imports.some(existingIm => existingIm.kind === im.kind && existingIm.name === im.name);
+                if (!hasImport) {
+                    existing.imports.push(im);
+                }
+            }
+            if (link.name) {
+                existing.name = link.name;
+            }
+        }
+    }
+    return Array.from(groupByIdentity.entries()).map(([identity, link]) => ({
+        identity,
+        version: link.highestVersion,
+        imports: Array.from(link.imports).map(link => ({ kind: link.kind, name: link.name })),
+        name: link.name,
+    }));
+}
+exports.mergeLinks = mergeLinks;
+function parseLink(urlString, importString) {
+    const spec = parseLinkUrl(urlString);
+    return {
+        name: spec.name,
+        version: spec.version,
+        identity: spec.identity,
+        imports: parseLinkImport(importString),
+    };
+}
+exports.parseLink = parseLink;
+function parseLinkDirective(directive) {
+    const urlArg = directive.arguments?.find(isUrlArgument);
+    if (!urlArg) {
+        return null;
+    }
+    const importArg = directive.arguments?.find(isImportArgument);
+    const spec = parseLinkUrl(urlArg?.value.value);
+    return {
+        name: spec.name,
+        version: spec.version,
+        identity: spec.identity,
+        imports: parseLinkImport(importArg ? (0, printer_js_1.print)(importArg.value) : '[]'),
+    };
+}
+exports.parseLinkDirective = parseLinkDirective;
+function isUrlArgument(arg) {
+    return arg.name.value === 'url' && arg.value.kind === graphql_1.Kind.STRING;
+}
+function isImportArgument(arg) {
+    return arg.name.value === 'import' && arg.value.kind === graphql_1.Kind.LIST;
+}
+exports.sdl = `
+  directive @link(
+    url: String
+    as: String
+    for: link__Purpose
+    import: [link__Import]
+  ) repeatable on SCHEMA
+
+  scalar link__Import
+
+  enum link__Purpose {
+    """
+    \`SECURITY\` features provide metadata necessary to securely resolve fields.
+    """
+    SECURITY
+
+    """
+    \`EXECUTION\` features provide metadata necessary for operation execution.
+    """
+    EXECUTION
+  }
+`;

package/cjs/specifications/tag.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directive = exports.typeDefs = exports.sdl = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../graphql/helpers.js");
+exports.sdl = `
+  directive @tag(
+    name: String!
+  ) repeatable on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION | SCHEMA
+`;
+exports.typeDefs = (0, graphql_1.parse)(exports.sdl);
+exports.directive = exports.typeDefs.definitions.filter(helpers_js_1.isDirectiveDefinition)[0];