@theguild/federation-composition/esm/graphql/transform-supergraph-to-public-schema.js

Open Source Composition library for Apollo Federation

import { Kind, specifiedDirectives as specifiedDirectivesArray, visit, } from 'graphql';
import { extractLinkImplementations } from '../utils/link/index.js';
import { extraFederationDirectiveNames, extraFederationTypeNames, getSupergraphSpecNodes, } from './supergraph-spec.js';
const specifiedDirectives = new Set(specifiedDirectivesArray.map(d => d.name));
function getAdditionalDirectivesToStrip(documentNode) {
    const schemaDefinitionNode = documentNode.definitions.find((node) => node.kind === Kind.SCHEMA_DEFINITION);
    if (!schemaDefinitionNode?.directives?.length) {
        return null;
    }
    const additionalDirectivesToStrip = new Set();
    for (const directive of schemaDefinitionNode.directives) {
        if (directive.name.value !== 'link') {
            continue;
        }
        const asArg = directive.arguments?.find(arg => arg.name.value === 'as');
        if (asArg?.value.kind === Kind.STRING) {
            additionalDirectivesToStrip.add(asArg.value.value);
        }
    }
    return additionalDirectivesToStrip;
}
const federationInaccessibleDirectiveUrlPrefix = 'https://specs.apollo.dev/inaccessible';
function getInaccessibleDirectiveName(documentNode) {
    const schemaDefinitionNode = documentNode.definitions.find((node) => node.kind === Kind.SCHEMA_DEFINITION);
    if (schemaDefinitionNode?.directives?.length) {
        for (const directive of schemaDefinitionNode.directives) {
            if (directive.name.value !== 'link') {
                continue;
            }
            const urlArg = directive.arguments?.find(arg => arg.name.value === 'url');
            const asArg = directive.arguments?.find(arg => arg.name.value === 'as');
            if (urlArg?.value.kind === Kind.STRING &&
                urlArg.value.value.startsWith(federationInaccessibleDirectiveUrlPrefix)) {
                if (asArg?.value.kind === Kind.STRING) {
                    return asArg.value.value;
                }
                break;
            }
        }
    }
    return 'inaccessible';
}
export function transformSupergraphToPublicSchema(documentNode) {
    const additionalFederationDirectives = getAdditionalDirectivesToStrip(documentNode);
    const inaccessibleDirectiveName = getInaccessibleDirectiveName(documentNode);
    const specLinks = extractLinkImplementations(documentNode).links.filter(link => link.identity.includes('//specs.apollo.dev/'));
    const specPrefixes = specLinks.map(l => l.identity.substring(l.identity.lastIndexOf('/') + 1) + '__');
    const supergraphSpecNodeNames = getSupergraphSpecNodes();
    const supergraphDirectives = new Set();
    const supergraphEnums = new Set();
    const supergraphInputObjects = new Set();
    const supergraphScalars = new Set();
    for (const { kind, name } of supergraphSpecNodeNames) {
        if (kind === Kind.ENUM_TYPE_DEFINITION) {
            supergraphEnums.add(name);
        }
        else if (kind === Kind.INPUT_OBJECT_TYPE_DEFINITION) {
            supergraphInputObjects.add(name);
        }
        else if (kind === Kind.SCALAR_TYPE_DEFINITION) {
            supergraphScalars.add(name);
        }
        else if (kind === Kind.DIRECTIVE_DEFINITION) {
            supergraphDirectives.add(name);
        }
    }
    const importedPieces = specLinks.map(l => l.imports.map(i => i.as ?? i.name)).flat();
    const definitionsToRemove = new Set(importedPieces.map(name => name.replace('@', '')));
    const directivesToRemove = new Set(importedPieces.filter(name => name.startsWith('@')).map(name => name.substring(1)));
    function removeFederationOrSpecifiedDirectives(node) {
        if (belongsToLinkedSpec(node) ||
            supergraphDirectives.has(node.name.value) ||
            extraFederationDirectiveNames.has(node.name.value) ||
            additionalFederationDirectives?.has(node.name.value) ||
            directivesToRemove.has(node.name.value) ||
            (node.kind === Kind.DIRECTIVE_DEFINITION && specifiedDirectives.has(node.name.value))) {
            return null;
        }
    }
    function belongsToLinkedSpec(node) {
        return specPrefixes.some(prefix => node.name.value.startsWith(prefix));
    }
    function hasInaccessibleDirective(node) {
        return node.directives?.some(d => d.name.value === inaccessibleDirectiveName);
    }
    function removeInaccessibleNode(node) {
        if (hasInaccessibleDirective(node) || belongsToLinkedSpec(node)) {
            return null;
        }
    }
    return visit(documentNode, {
        [Kind.DIRECTIVE_DEFINITION]: removeFederationOrSpecifiedDirectives,
        [Kind.DIRECTIVE]: removeFederationOrSpecifiedDirectives,
        [Kind.SCHEMA_EXTENSION]: () => null,
        [Kind.SCHEMA_DEFINITION]: () => null,
        [Kind.SCALAR_TYPE_DEFINITION](node) {
            if (belongsToLinkedSpec(node) ||
                supergraphScalars.has(node.name.value) ||
                extraFederationTypeNames.has(node.name.value) ||
                definitionsToRemove.has(node.name.value) ||
                hasInaccessibleDirective(node)) {
                return null;
            }
        },
        [Kind.ENUM_TYPE_DEFINITION](node) {
            if (belongsToLinkedSpec(node) ||
                supergraphEnums.has(node.name.value) ||
                extraFederationTypeNames.has(node.name.value) ||
                definitionsToRemove.has(node.name.value) ||
                hasInaccessibleDirective(node)) {
                return null;
            }
        },
        [Kind.ENUM_VALUE_DEFINITION]: removeInaccessibleNode,
        [Kind.OBJECT_TYPE_DEFINITION]: removeInaccessibleNode,
        [Kind.FIELD_DEFINITION]: removeInaccessibleNode,
        [Kind.INTERFACE_TYPE_DEFINITION]: removeInaccessibleNode,
        [Kind.UNION_TYPE_DEFINITION]: removeInaccessibleNode,
        [Kind.INPUT_OBJECT_TYPE_DEFINITION](node) {
            if (belongsToLinkedSpec(node) ||
                supergraphInputObjects.has(node.name.value) ||
                definitionsToRemove.has(node.name.value) ||
                hasInaccessibleDirective(node)) {
                return null;
            }
        },
        [Kind.INPUT_VALUE_DEFINITION]: removeInaccessibleNode,
    });
}