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

package/esm/subgraph/validation/validate-subgraph.js

@@ -0,0 +1,323 @@
+import { concatAST, GraphQLError, Kind, parse, visit, visitInParallel, } from 'graphql';
+import { TypeNodeInfo, visitWithTypeNodeInfo } from '../../graphql/type-node-info.js';
+import { createSpecSchema } from '../../specifications/federation.js';
+import { parseLinkDirective } from '../../specifications/link.js';
+import { ComposeDirectiveRules } from './rules/elements/compose-directive.js';
+import { ExtendsRules } from './rules/elements/extends.js';
+import { ExternalRules } from './rules/elements/external.js';
+import { FieldSetRules } from './rules/elements/field-set.js';
+import { InaccessibleRules } from './rules/elements/inaccessible.js';
+import { KeyRules } from './rules/elements/key.js';
+import { OverrideRules } from './rules/elements/override.js';
+import { ProvidesRules } from './rules/elements/provides.js';
+import { RequiresRules } from './rules/elements/requires.js';
+import { ShareableRules } from './rules/elements/shareable.js';
+import { TagRules } from './rules/elements/tag.js';
+import { KnownArgumentNamesOnDirectivesRule } from './rules/known-argument-names-on-directives-rule.js';
+import { KnownDirectivesRule } from './rules/known-directives-rule.js';
+import { KnownFederationDirectivesRule } from './rules/known-federation-directive-rule.js';
+import { KnownRootTypeRule } from './rules/known-root-type-rule.js';
+import { KnownTypeNamesRule } from './rules/known-type-names-rule.js';
+import { LoneSchemaDefinitionRule } from './rules/lone-schema-definition-rule.js';
+import { ProvidedArgumentsOnDirectivesRule } from './rules/provided-arguments-on-directives-rule.js';
+import { ProvidedRequiredArgumentsOnDirectivesRule } from './rules/provided-required-arguments-on-directives-rule.js';
+import { QueryRootTypeInaccessibleRule } from './rules/query-root-type-inaccessible-rule.js';
+import { ReservedSubgraphNameRule } from './rules/reserved-subgraph-name-rule.js';
+import { RootTypeUsedRule } from './rules/root-type-used-rule.js';
+import { UniqueArgumentDefinitionNamesRule } from './rules/unique-argument-definition-names-rule.js';
+import { UniqueArgumentNamesRule } from './rules/unique-argument-names-rule.js';
+import { UniqueDirectiveNamesRule } from './rules/unique-directive-names-rule.js';
+import { UniqueDirectivesPerLocationRule } from './rules/unique-directives-per-location-rule.js';
+import { UniqueEnumValueNamesRule } from './rules/unique-enum-value-names-rule.js';
+import { UniqueFieldDefinitionNamesRule } from './rules/unique-field-definition-names-rule.js';
+import { UniqueInputFieldNamesRule } from './rules/unique-input-field-names-rule.js';
+import { UniqueOperationTypesRule } from './rules/unique-operation-types-rule.js';
+import { UniqueTypeNamesRule } from './rules/unique-type-names-rule.js';
+import { validateSubgraphState } from './validate-state.js';
+import { createSimpleValidationContext, createSubgraphValidationContext, } from './validation-context.js';
+export function assertUniqueSubgraphNames(subgraphs) {
+    const names = new Set();
+    for (const subgraph of subgraphs) {
+        if (names.has(subgraph.name)) {
+            throw new Error(`A subgraph named ${subgraph.name} already exists`);
+        }
+        names.add(subgraph.name);
+    }
+}
+export function validateSubgraphCore(subgraph) {
+    const extractedLinks = extractLinks(subgraph);
+    if (extractedLinks.errors) {
+        extractedLinks.errors.forEach(error => enrichErrorWithSubgraphName(error, subgraph.name));
+    }
+    return extractedLinks;
+}
+export function validateSubgraph(subgraph, stateBuilder, federation, __internal) {
+    subgraph.typeDefs = cleanSubgraphTypeDefsFromSubgraphSpec(subgraph.typeDefs);
+    const rulesToSkip = __internal?.disableValidationRules ?? [];
+    const typeNodeInfo = new TypeNodeInfo();
+    const validationContext = createSubgraphValidationContext(subgraph, federation, typeNodeInfo, stateBuilder);
+    const federationRules = [
+        ReservedSubgraphNameRule,
+        KnownFederationDirectivesRule,
+        FieldSetRules,
+        InaccessibleRules,
+        OverrideRules,
+        ExtendsRules,
+        QueryRootTypeInaccessibleRule,
+        KnownTypeNamesRule,
+        KnownRootTypeRule,
+        RootTypeUsedRule,
+        ShareableRules,
+        KeyRules,
+        ProvidesRules,
+        RequiresRules,
+        ExternalRules,
+        TagRules,
+        ComposeDirectiveRules,
+    ];
+    const graphqlRules = [
+        LoneSchemaDefinitionRule,
+        UniqueOperationTypesRule,
+        UniqueTypeNamesRule,
+        UniqueEnumValueNamesRule,
+        UniqueFieldDefinitionNamesRule,
+        UniqueArgumentDefinitionNamesRule,
+        KnownDirectivesRule,
+        UniqueDirectivesPerLocationRule,
+        KnownArgumentNamesOnDirectivesRule,
+        UniqueArgumentNamesRule,
+        UniqueInputFieldNamesRule,
+        UniqueDirectiveNamesRule,
+        ProvidedRequiredArgumentsOnDirectivesRule,
+        ProvidedArgumentsOnDirectivesRule,
+    ];
+    visit(subgraph.typeDefs, visitWithTypeNodeInfo(typeNodeInfo, visitInParallel([stateBuilder.visitor(typeNodeInfo)].concat(federationRules.map(rule => {
+        if (rulesToSkip.includes(rule.name)) {
+            return {};
+        }
+        return rule(validationContext);
+    })))));
+    const federationDefinitionReplacements = validationContext.collectFederationDefinitionReplacements();
+    const fullTypeDefs = concatAST([
+        {
+            kind: Kind.DOCUMENT,
+            definitions: validationContext
+                .getAvailableFederationTypeAndDirectiveDefinitions()
+                .filter(def => !federationDefinitionReplacements.has(def.name.value)),
+        },
+        validationContext.satisfiesVersionRange('> v1.0') && !stateBuilder.state.specs.link
+            ?
+                parse(`
+            scalar Import
+            enum Purpose {
+              EXECUTION
+              SECURITY
+            }
+
+            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
+            }
+          `)
+            : null,
+        subgraph.typeDefs,
+    ].filter(onlyDocumentNode));
+    const subgraphStateErrors = validateSubgraphState(stateBuilder.state);
+    const simpleValidationContext = createSimpleValidationContext(fullTypeDefs, typeNodeInfo);
+    visit(fullTypeDefs, visitInParallel(graphqlRules.map(rule => {
+        if (rulesToSkip.includes(rule.name)) {
+            return {};
+        }
+        return rule(simpleValidationContext);
+    })));
+    return validationContext
+        .collectReportedErrors()
+        .concat(validationContext.collectUnusedExternal().map(coordinate => enrichErrorWithSubgraphName(new GraphQLError(`Field "${coordinate}" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).`, {
+        extensions: {
+            code: 'EXTERNAL_UNUSED',
+        },
+    }), subgraph.name)))
+        .concat(simpleValidationContext.collectReportedErrors())
+        .concat(subgraphStateErrors)
+        .map(error => enrichErrorWithSubgraphName(error, subgraph.name));
+}
+function enrichErrorWithSubgraphName(error, subgraphName) {
+    if (error.extensions.subgraphName) {
+        return error;
+    }
+    error.message = `[${subgraphName}] ${error.message}`;
+    error.extensions.subgraphName = subgraphName;
+    return error;
+}
+const availableFeatures = {
+    link: ['v1.0'],
+    tag: ['v0.1', 'v0.2'],
+    kotlin_labs: ['v0.1', 'v0.2'],
+    join: ['v0.1', 'v0.2', 'v0.3'],
+    inaccessible: ['v0.1', 'v0.2'],
+    core: ['v0.1', 'v0.2'],
+};
+function extractLinks(subgraph) {
+    const schemaNodes = subgraph.typeDefs.definitions.filter(isSchemaDefinitionOrExtensionNode);
+    if (schemaNodes.length === 0) {
+        return {
+            links: [],
+        };
+    }
+    const linkDirectives = [];
+    for (const schemaNode of schemaNodes) {
+        if (schemaNode.directives?.length) {
+            for (const directiveNode of schemaNode.directives) {
+                if (directiveNode.name.value === 'link') {
+                    linkDirectives.push(directiveNode);
+                }
+            }
+        }
+    }
+    if (!linkDirectives) {
+        return {
+            links: [],
+        };
+    }
+    const errors = [];
+    const links = [];
+    const identities = new Set();
+    const reportedAsDuplicate = new Set();
+    for (let i = 0; i < linkDirectives.length; i++) {
+        const linkDirective = linkDirectives[i];
+        try {
+            const link = parseLinkDirective(linkDirective);
+            if (!link) {
+                continue;
+            }
+            if (identities.has(link.identity) && !reportedAsDuplicate.has(link.identity)) {
+                errors.push(new GraphQLError(`Duplicate inclusion of feature ${link.identity}`, {
+                    extensions: {
+                        code: 'INVALID_LINK_DIRECTIVE_USAGE',
+                    },
+                }));
+                reportedAsDuplicate.add(link.identity);
+            }
+            identities.add(link.identity);
+            if (link.version && !/^v\d+\.\d+/.test(link.version)) {
+                errors.push(new GraphQLError(`Expected a version string (of the form v1.2), got ${link.version}`, {
+                    extensions: {
+                        code: 'INVALID_LINK_IDENTIFIER',
+                    },
+                }));
+                continue;
+            }
+            if (!link.name) {
+                errors.push(new GraphQLError(`Missing path in feature url '${link.identity}'`, {
+                    extensions: {
+                        code: 'INVALID_LINK_IDENTIFIER',
+                    },
+                }));
+                continue;
+            }
+            if (link.identity.startsWith('https://specs.apollo.dev/')) {
+                if (link.name === 'federation') {
+                    if (!link.version) {
+                        errors.push(new GraphQLError(`Missing version in feature url '${link.identity}'`, {
+                            extensions: {
+                                code: 'TODO',
+                            },
+                        }));
+                        continue;
+                    }
+                    const spec = createSpecSchema(link.version);
+                    const availableElements = new Set(spec.directives.map(d => d.name.value).concat(spec.types.map(t => t.name.value)));
+                    let pushedError = false;
+                    for (const im of link.imports) {
+                        if (!availableElements.has(im.name.replace(/^@/, ''))) {
+                            pushedError = true;
+                            errors.push(new GraphQLError(`Cannot import unknown element "${im.name}".`, {
+                                extensions: {
+                                    code: 'INVALID_LINK_DIRECTIVE_USAGE',
+                                },
+                            }));
+                        }
+                    }
+                    if (pushedError) {
+                        continue;
+                    }
+                }
+                else if (link.version && availableFeatures[link.name]) {
+                    if (!availableFeatures[link.name].includes(link.version)) {
+                        errors.push(new GraphQLError(`Schema uses unknown version ${link.version} of the ${link.name} spec`, {
+                            extensions: {
+                                code: 'UNKNOWN_LINK_VERSION',
+                            },
+                        }));
+                        continue;
+                    }
+                }
+            }
+            links.push(link);
+        }
+        catch (error) {
+            errors.push(error instanceof GraphQLError ? error : new GraphQLError(String(error)));
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            errors,
+        };
+    }
+    return {
+        links,
+    };
+}
+function isSchemaDefinitionOrExtensionNode(node) {
+    return (node.kind === Kind.SCHEMA_DEFINITION || node.kind === Kind.SCHEMA_EXTENSION);
+}
+function onlyDocumentNode(item) {
+    return item != null;
+}
+function cleanSubgraphTypeDefsFromSubgraphSpec(typeDefs) {
+    let queryTypes = [];
+    typeDefs.definitions = typeDefs.definitions.filter(def => {
+        if (def.kind === Kind.SCALAR_TYPE_DEFINITION && def.name.value === '_Any') {
+            return false;
+        }
+        if (def.kind === Kind.UNION_TYPE_DEFINITION && def.name.value === '_Entity') {
+            return false;
+        }
+        if (def.kind === Kind.OBJECT_TYPE_DEFINITION && def.name.value === '_Service') {
+            return false;
+        }
+        if ((def.kind === Kind.OBJECT_TYPE_DEFINITION || def.kind === Kind.OBJECT_TYPE_EXTENSION) &&
+            def.name.value === 'Query') {
+            queryTypes.push(def);
+        }
+        return true;
+    });
+    if (queryTypes.length > 0) {
+        for (const queryType of queryTypes) {
+            queryType.fields =
+                queryType.fields?.filter(field => {
+                    if (field.name.value === '_service' || field.name.value === '_entities') {
+                        return false;
+                    }
+                    return true;
+                }) ?? [];
+        }
+    }
+    return typeDefs;
+}

package/esm/subgraph/validation/validation-context.js

@@ -0,0 +1,262 @@
+import { Kind, specifiedScalarTypes, } from 'graphql';
+import { createSpecSchema } from '../../specifications/federation.js';
+import { stripTypeModifiers } from '../../utils/state.js';
+import { TypeKind } from '../state.js';
+export function createSimpleValidationContext(typeDefs, typeNodeInfo) {
+    let reportedErrors = [];
+    const directiveDefinitionMap = new Map();
+    const typeDefinitionMap = new Map();
+    for (const definition of typeDefs.definitions) {
+        if (definition.kind === Kind.DIRECTIVE_DEFINITION) {
+            directiveDefinitionMap.set(definition.name.value, definition);
+        }
+        else if ('name' in definition && definition.name && definition.name.kind === Kind.NAME) {
+            typeDefinitionMap.set(definition.name.value, {
+                name: definition.name,
+                kind: definition.kind,
+            });
+        }
+    }
+    return {
+        getDocument() {
+            return typeDefs;
+        },
+        getKnownDirectiveDefinition(name) {
+            return directiveDefinitionMap.get(name);
+        },
+        getKnownTypeDefinition(name) {
+            return typeDefinitionMap.get(name);
+        },
+        getSchemaCoordinate(ancestors) {
+            let coordinate = '';
+            for (let i = 0; i < ancestors.length; i++) {
+                const ancestor = ancestors[i];
+                if ('kind' in ancestor && ancestor.kind !== Kind.DOCUMENT) {
+                    const name = ancestor.kind === Kind.SCHEMA_DEFINITION || ancestor.kind === Kind.SCHEMA_EXTENSION
+                        ? 'schema'
+                        : 'name' in ancestor && ancestor.name
+                            ? ancestor.name.value
+                            : '';
+                    if (coordinate.length > 0) {
+                        coordinate = coordinate + '.' + name;
+                    }
+                    else {
+                        coordinate = name;
+                    }
+                }
+            }
+            return coordinate;
+        },
+        reportError(error) {
+            reportedErrors.push(error);
+        },
+        collectReportedErrors() {
+            const errors = reportedErrors;
+            reportedErrors = [];
+            return errors;
+        },
+    };
+}
+export function createSubgraphValidationContext(subgraph, federation, typeNodeInfo, stateBuilder) {
+    const { version, imports } = federation;
+    const availableSpec = createSpecSchema(version, imports);
+    const knownSpec = createSpecSchema(version);
+    const knownSubgraphEntities = new Map(subgraph.typeDefs.definitions.filter(def => def.kind === Kind.OBJECT_TYPE_DEFINITION ||
+        def.kind === Kind.OBJECT_TYPE_EXTENSION ||
+        def.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+        def.kind === Kind.INTERFACE_TYPE_EXTENSION).map(def => [def.name.value, def]));
+    const knownSubgraphDirectiveDefinitions = new Map(subgraph.typeDefs.definitions.filter(def => def.kind === Kind.DIRECTIVE_DEFINITION).map(def => [def.name.value, def]));
+    const leafTypeNames = new Set(specifiedScalarTypes.map(type => type.name));
+    for (const def of subgraph.typeDefs.definitions) {
+        if (def.kind === Kind.SCALAR_TYPE_DEFINITION ||
+            def.kind === Kind.SCALAR_TYPE_EXTENSION ||
+            def.kind === Kind.ENUM_TYPE_DEFINITION ||
+            def.kind === Kind.ENUM_TYPE_EXTENSION) {
+            leafTypeNames.add(def.name.value);
+        }
+    }
+    let reportedErrors = [];
+    const markedAsExternal = new Set();
+    const markedAsUsed = new Set();
+    const markedAsKeyField = new Set();
+    const overwrittenFederationDefinitionNames = new Set();
+    const directiveAlternativeNamesMap = new Map();
+    for (const specDirective of availableSpec.directives) {
+        const isFederationPrefixed = specDirective.name.value.startsWith('federation__');
+        if (isFederationPrefixed) {
+            const normalizedName = specDirective.name.value.replace('federation__', '');
+            const setOfNames = directiveAlternativeNamesMap.get(normalizedName);
+            if (!setOfNames) {
+                directiveAlternativeNamesMap.set(normalizedName, new Set([specDirective.name.value]));
+            }
+        }
+        else {
+            const { alias } = imports.find(i => i.name.replace(/^@/, '') === specDirective.name.value) ?? {
+                alias: undefined,
+            };
+            let setOfNames = directiveAlternativeNamesMap.get(specDirective.name.value);
+            if (!setOfNames) {
+                directiveAlternativeNamesMap.set(specDirective.name.value, new Set());
+                setOfNames = directiveAlternativeNamesMap.get(specDirective.name.value);
+            }
+            setOfNames.add(alias ? alias.replace(/^@/, '') : specDirective.name.value);
+        }
+    }
+    const typeAlternativeNamesMap = new Map();
+    for (const specType of availableSpec.types) {
+        const isFederationPrefixed = specType.name.value.startsWith('federation__');
+        if (isFederationPrefixed) {
+            const normalizedName = specType.name.value.replace('federation__', '');
+            const setOfNames = typeAlternativeNamesMap.get(normalizedName);
+            if (!setOfNames) {
+                typeAlternativeNamesMap.set(normalizedName, new Set([specType.name.value]));
+            }
+        }
+        else {
+            const { alias } = imports.find(i => i.name === specType.name.value) ?? {
+                alias: undefined,
+            };
+            let setOfNames = typeAlternativeNamesMap.get(specType.name.value);
+            if (!setOfNames) {
+                typeAlternativeNamesMap.set(specType.name.value, new Set());
+                setOfNames = typeAlternativeNamesMap.get(specType.name.value);
+            }
+            setOfNames.add(alias ? alias : specType.name.value);
+        }
+    }
+    const importedTypesSet = new Set(availableSpec.types.map(t => t.name.value));
+    if (importedTypesSet.size) {
+        subgraph.typeDefs.definitions.forEach(def => {
+            if ('name' in def && def.name && importedTypesSet.has(def.name.value)) {
+                overwrittenFederationDefinitionNames.add(def.name.value);
+            }
+        });
+    }
+    return {
+        stateBuilder,
+        isAvailableFederationType(name) {
+            const alternativeNames = typeAlternativeNamesMap.get(name);
+            if (alternativeNames) {
+                return alternativeNames.has(name);
+            }
+            return false;
+        },
+        isAvailableFederationDirective(specDirectiveName, directiveNode) {
+            const alternativeNames = directiveAlternativeNamesMap.get(specDirectiveName);
+            if (alternativeNames) {
+                return alternativeNames.has(typeof directiveNode.name === 'string' ? directiveNode.name : directiveNode.name.value);
+            }
+            return false;
+        },
+        satisfiesVersionRange(range) {
+            const [sign, ver] = range.split(' ');
+            const versionInRange = parseFloat(ver.replace('v', ''));
+            const detectedVersion = parseFloat(version.replace('v', ''));
+            if (sign === '<') {
+                return detectedVersion < versionInRange;
+            }
+            if (sign === '>') {
+                return detectedVersion > versionInRange;
+            }
+            return detectedVersion >= versionInRange;
+        },
+        getKnownFederationDirectives() {
+            return knownSpec.directives;
+        },
+        getAvailableFederationDirectives() {
+            return availableSpec.directives;
+        },
+        isLeafType(typeName) {
+            return leafTypeNames.has(typeName);
+        },
+        getSubgraphObjectOrInterfaceTypes() {
+            return knownSubgraphEntities;
+        },
+        getSubgraphDirectiveDefinitions() {
+            return knownSubgraphDirectiveDefinitions;
+        },
+        getAvailableFederationTypeAndDirectiveDefinitions() {
+            return [].concat(availableSpec.directives.map(d => {
+                const alias = imports.find(i => i.name.replace(/^@/, '') === d.name.value)?.alias;
+                if (alias) {
+                    d.name.value = alias.replace(/^@/, '');
+                }
+                return d;
+            }), availableSpec.types.map(t => {
+                const alias = imports.find(i => i.name === t.name.value)?.alias;
+                if (alias) {
+                    t.name.value = alias;
+                }
+                return t;
+            }));
+        },
+        typeNodeInfo,
+        getDocument() {
+            return subgraph.typeDefs;
+        },
+        getSubgraphName() {
+            return subgraph.name;
+        },
+        getSubgraphId() {
+            return subgraph.id;
+        },
+        markAsExternal(coordinate) {
+            markedAsExternal.add(coordinate);
+        },
+        markAsUsed(reason, kind, typeName, fieldName) {
+            if (!fieldName.startsWith('__') && !typeName.startsWith('__') && reason === 'fields') {
+                switch (kind) {
+                    case Kind.OBJECT_TYPE_DEFINITION:
+                    case Kind.OBJECT_TYPE_EXTENSION: {
+                        stateBuilder.objectType.field.setUsed(typeName, fieldName);
+                        break;
+                    }
+                    case Kind.INTERFACE_TYPE_DEFINITION:
+                    case Kind.INTERFACE_TYPE_EXTENSION: {
+                        stateBuilder.interfaceType.field.setUsed(typeName, fieldName);
+                        break;
+                    }
+                }
+            }
+            markedAsUsed.add(`${typeName}.${fieldName}`);
+        },
+        markAsKeyField(coordinate) {
+            markedAsKeyField.add(coordinate);
+        },
+        markAsFederationDefinitionReplacement(name) {
+            overwrittenFederationDefinitionNames.add(name);
+        },
+        collectFederationDefinitionReplacements() {
+            return overwrittenFederationDefinitionNames;
+        },
+        collectUnusedExternal() {
+            if (version === 'v1.0') {
+                return Array.from(markedAsExternal).filter(c => !markedAsUsed.has(c) && markedAsKeyField.has(c));
+            }
+            const unused = Array.from(markedAsExternal).filter(c => !markedAsUsed.has(c));
+            return unused.filter(coordinate => {
+                const [typeName, fieldName] = coordinate.split('.');
+                const typeDef = stateBuilder.state.types.get(typeName);
+                if (typeDef && typeDef.kind === TypeKind.OBJECT) {
+                    const fieldDef = typeDef.fields.get(fieldName);
+                    if (fieldDef) {
+                        const outputTypeName = stripTypeModifiers(fieldDef.type);
+                        const outputType = stateBuilder.state.types.get(outputTypeName);
+                        if (outputType?.kind === TypeKind.OBJECT && outputType.shareable) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            });
+        },
+        reportError(error) {
+            reportedErrors.push(error);
+        },
+        collectReportedErrors() {
+            const errors = reportedErrors;
+            reportedErrors = [];
+            return errors;
+        },
+    };
+}