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

package/esm/specifications/link.js

@@ -0,0 +1,210 @@
+import { Kind } from 'graphql';
+import JSON5 from 'json5';
+import { print } from '../graphql/printer.js';
+export function printLink(link) {
+    return print({
+        kind: Kind.DIRECTIVE,
+        name: {
+            kind: Kind.NAME,
+            value: 'link',
+        },
+        arguments: [
+            {
+                kind: Kind.ARGUMENT,
+                name: {
+                    kind: Kind.NAME,
+                    value: 'url',
+                },
+                value: {
+                    kind: Kind.STRING,
+                    value: [link.identity, link.version].filter(Boolean).join('/'),
+                },
+            },
+            {
+                kind: Kind.ARGUMENT,
+                name: {
+                    kind: Kind.NAME,
+                    value: 'import',
+                },
+                value: {
+                    kind: Kind.LIST,
+                    values: link.imports.map(im => ({
+                        kind: Kind.STRING,
+                        value: im.name,
+                    })),
+                },
+            },
+        ],
+    });
+}
+export 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('/'),
+    };
+}
+export function parseLinkImport(importString) {
+    try {
+        const bindings = JSON5.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)}`);
+    }
+}
+export 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,
+    }));
+}
+export function parseLink(urlString, importString) {
+    const spec = parseLinkUrl(urlString);
+    return {
+        name: spec.name,
+        version: spec.version,
+        identity: spec.identity,
+        imports: parseLinkImport(importString),
+    };
+}
+export 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 ? print(importArg.value) : '[]'),
+    };
+}
+function isUrlArgument(arg) {
+    return arg.name.value === 'url' && arg.value.kind === Kind.STRING;
+}
+function isImportArgument(arg) {
+    return arg.name.value === 'import' && arg.value.kind === Kind.LIST;
+}
+export const 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/esm/specifications/tag.js

@@ -0,0 +1,9 @@
+import { parse } from 'graphql';
+import { isDirectiveDefinition } from '../graphql/helpers.js';
+export const sdl = `
+  directive @tag(
+    name: String!
+  ) repeatable on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION | SCHEMA
+`;
+export const typeDefs = parse(sdl);
+export const directive = typeDefs.definitions.filter(isDirectiveDefinition)[0];

package/esm/subgraph/helpers.js

@@ -0,0 +1,245 @@
+import { GraphQLError, Kind, parse, } from 'graphql';
+import { print } from '../graphql/printer.js';
+export function validateDirectiveAgainstOriginal(providedDirectiveNode, directiveName, context) {
+    if (!context.isAvailableFederationDirective(directiveName, providedDirectiveNode)) {
+        return;
+    }
+    const isFederationV2 = context.satisfiesVersionRange('>= v2.0');
+    const federationDirective = context
+        .getKnownFederationDirectives()
+        .find(d => context.isAvailableFederationDirective(directiveName, d));
+    if (!federationDirective) {
+        throw new Error(`Federation directive @${directiveName} not found`);
+    }
+    const errors = [];
+    const original = {
+        args: new Map(federationDirective.arguments?.map(arg => [arg.name.value, arg])),
+        locations: federationDirective.locations.map(loc => loc.value),
+    };
+    const provided = {
+        args: new Map(providedDirectiveNode.arguments?.map(arg => [arg.name.value, arg])),
+        locations: providedDirectiveNode.locations.map(loc => loc.value),
+    };
+    for (const [argName, argDef] of original.args.entries()) {
+        const providedArgNode = provided.args.get(argName);
+        if (isNonNullTypeNode(argDef.type) && !providedArgNode) {
+            errors.push(new GraphQLError(`Invalid definition for directive "@${directiveName}": missing required argument "${argName}"`, {
+                nodes: providedDirectiveNode,
+                extensions: { code: 'DIRECTIVE_DEFINITION_INVALID' },
+            }));
+        }
+        if (providedArgNode) {
+            const expectedType = print(argDef.type);
+            const providedType = print(providedArgNode.type);
+            if (expectedType !== providedType) {
+                const isNonNullableString = providedType === 'String!';
+                const allowedFieldSetTypes = isFederationV2
+                    ? ['FieldSet!', 'federation__FieldSet!', '_FieldSet!']
+                    : ['_FieldSet!', 'String'];
+                const fieldSetTypesInSpec = isFederationV2
+                    ? ['FieldSet!', 'federation__FieldSet!', '_FieldSet!']
+                    : ['_FieldSet!', 'FieldSet!', 'String'];
+                const expectsFieldSet = fieldSetTypesInSpec.includes(expectedType);
+                if (!isNonNullableString && expectsFieldSet) {
+                    const isOneOfExpected = allowedFieldSetTypes.includes(providedType);
+                    if (!isOneOfExpected) {
+                        errors.push(new GraphQLError(`Invalid definition for directive "@${directiveName}": argument "${argName}" should have type "${expectedType}" but found type "${providedType}"`, {
+                            nodes: providedDirectiveNode,
+                            extensions: { code: 'DIRECTIVE_DEFINITION_INVALID' },
+                        }));
+                    }
+                }
+            }
+            if (expectedType === 'Boolean' && argDef.defaultValue?.kind === Kind.BOOLEAN) {
+                let providedValue = null;
+                if (providedArgNode.defaultValue) {
+                    if (providedArgNode.defaultValue.kind !== Kind.BOOLEAN) {
+                        throw new Error('Expected a Boolean');
+                    }
+                    providedValue = providedArgNode.defaultValue.value;
+                }
+                if (argDef.defaultValue?.value !== providedValue) {
+                    errors.push(new GraphQLError(`Invalid definition for directive "@${directiveName}": argument "${argName}" should have default value ${argDef.defaultValue ? 'true' : 'false'} but found default value ${providedValue ?? 'null'}`, {
+                        nodes: providedDirectiveNode,
+                        extensions: { code: 'DIRECTIVE_DEFINITION_INVALID' },
+                    }));
+                }
+            }
+        }
+    }
+    const locationIntersection = provided.locations.filter(loc => original.locations.includes(loc));
+    if (!locationIntersection.length) {
+        errors.push(new GraphQLError(`Invalid definition for directive "@${directiveName}": "@${directiveName}" should have locations ${Array.from(original.locations).join(', ')}, but found (non-subset) ${Array.from(provided.locations).join(', ')}`, {
+            nodes: providedDirectiveNode,
+            extensions: { code: 'DIRECTIVE_DEFINITION_INVALID' },
+        }));
+    }
+    if (errors.length) {
+        for (const error of errors) {
+            context.reportError(error);
+        }
+    }
+    else {
+        context.markAsFederationDefinitionReplacement(providedDirectiveNode.name.value);
+    }
+}
+export function visitFields({ context, selectionSet, typeDefinition, interceptField, interceptArguments, interceptUnknownField, interceptDirective, interceptInterfaceType, interceptExternalField, interceptNonExternalField, }) {
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === Kind.FRAGMENT_SPREAD) {
+            continue;
+        }
+        if (selection.kind === Kind.INLINE_FRAGMENT) {
+            if (!selection.typeCondition) {
+                continue;
+            }
+            const interfaceName = selection.typeCondition.name.value;
+            const interfaceDefinition = context.getSubgraphObjectOrInterfaceTypes().get(interfaceName);
+            if (!interfaceDefinition) {
+                continue;
+            }
+            visitFields({
+                context,
+                selectionSet: selection.selectionSet,
+                typeDefinition: interfaceDefinition,
+                interceptArguments,
+                interceptUnknownField,
+                interceptInterfaceType,
+            });
+            break;
+        }
+        const selectionFieldDef = selection.name.value === '__typename'
+            ? {
+                kind: Kind.FIELD_DEFINITION,
+                name: {
+                    kind: Kind.NAME,
+                    value: '__typename',
+                },
+                type: {
+                    kind: Kind.NAMED_TYPE,
+                    name: {
+                        kind: Kind.NAME,
+                        value: 'String',
+                    },
+                },
+            }
+            : typeDefinition.fields?.find(field => field.name.value === selection.name.value);
+        if (!selectionFieldDef) {
+            if (interceptUnknownField) {
+                interceptUnknownField({
+                    typeDefinition,
+                    fieldName: selection.name.value,
+                });
+            }
+            break;
+        }
+        if (interceptDirective && selection.directives?.length) {
+            for (const directive of selection.directives) {
+                interceptDirective({
+                    directiveName: directive.name.value,
+                    isKnown: context.getSubgraphDirectiveDefinitions().has(directive.name.value),
+                });
+            }
+        }
+        context.markAsUsed('fields', typeDefinition.kind, typeDefinition.name.value, selectionFieldDef.name.value);
+        if (interceptField) {
+            interceptField({
+                typeDefinition,
+                fieldName: selection.name.value,
+            });
+        }
+        if (selectionFieldDef.arguments?.length && interceptArguments) {
+            interceptArguments({
+                typeDefinition,
+                fieldName: selection.name.value,
+            });
+            continue;
+        }
+        if (interceptNonExternalField || interceptExternalField) {
+            const isExternal = selectionFieldDef.directives?.some(d => context.isAvailableFederationDirective('external', d));
+            const fieldName = selection.name.value;
+            const fieldDef = typeDefinition.fields?.find(field => field.name.value === fieldName);
+            if (!fieldDef) {
+                continue;
+            }
+            const namedType = namedTypeFromTypeNode(fieldDef.type);
+            const isLeaf = context.isLeafType(namedType.name.value);
+            if (isLeaf) {
+                if (isExternal && interceptExternalField) {
+                    interceptExternalField({
+                        typeDefinition,
+                        fieldName,
+                    });
+                }
+                else if (!isExternal && interceptNonExternalField) {
+                    interceptNonExternalField({
+                        typeDefinition,
+                        fieldName,
+                    });
+                }
+            }
+        }
+        const outputType = namedTypeFromTypeNode(selectionFieldDef.type).name.value;
+        const innerTypeDef = context.getSubgraphObjectOrInterfaceTypes().get(outputType);
+        if (!innerTypeDef) {
+            continue;
+        }
+        if (interceptInterfaceType &&
+            (innerTypeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                innerTypeDef.kind === Kind.INTERFACE_TYPE_EXTENSION)) {
+            interceptInterfaceType({
+                typeDefinition,
+                fieldName: selection.name.value,
+            });
+        }
+        const innerSelection = selection.selectionSet;
+        if (!innerSelection) {
+            continue;
+        }
+        visitFields({
+            context,
+            selectionSet: innerSelection,
+            typeDefinition: innerTypeDef,
+            interceptArguments,
+            interceptUnknownField,
+            interceptInterfaceType,
+        });
+    }
+}
+export function getFieldsArgument(directiveNode) {
+    const fieldsArg = directiveNode.arguments?.find(arg => arg.name.value === 'fields');
+    if (!fieldsArg) {
+        return;
+    }
+    return fieldsArg;
+}
+export function parseFields(fields) {
+    const parsed = parse(fields.trim().startsWith(`{`) ? `query ${fields}` : `query { ${fields} }`).definitions.find(d => d.kind === Kind.OPERATION_DEFINITION);
+    return parsed?.selectionSet;
+}
+export function namedTypeFromTypeNode(type) {
+    if (type.kind === Kind.NAMED_TYPE) {
+        return type;
+    }
+    if (type.kind === Kind.LIST_TYPE) {
+        return namedTypeFromTypeNode(type.type);
+    }
+    if (type.kind === Kind.NON_NULL_TYPE) {
+        return namedTypeFromTypeNode(type.type);
+    }
+    throw new Error('Unknown type node: ' + type);
+}
+export function isDirectiveDefinitionNode(node) {
+    return node.kind === Kind.DIRECTIVE_DEFINITION;
+}
+export function printOutputType(type) {
+    if (type.kind === Kind.NAMED_TYPE) {
+        return type.name.value;
+    }
+    if (type.kind === Kind.LIST_TYPE) {
+        return `[${printOutputType(type.type)}]`;
+    }
+    return `${printOutputType(type.type)}!`;
+}
+function isNonNullTypeNode(node) {
+    return node.kind === Kind.NON_NULL_TYPE;
+}