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

package/esm/supergraph/state.js

@@ -0,0 +1,245 @@
+import { Kind, stripIgnoredCharacters, } from 'graphql';
+import { print } from '../graphql/printer.js';
+import { mergeLinks } from '../specifications/link.js';
+import { parseFields } from '../subgraph/helpers.js';
+import { createJoinGraphEnumTypeNode } from './composition/ast.js';
+import { directiveBuilder } from './composition/directive.js';
+import { enumTypeBuilder } from './composition/enum-type.js';
+import { inputObjectTypeBuilder } from './composition/input-object-type.js';
+import { interfaceTypeBuilder } from './composition/interface-type.js';
+import { objectTypeBuilder } from './composition/object-type.js';
+import { scalarTypeBuilder } from './composition/scalar-type.js';
+import { unionTypeBuilder } from './composition/union-type.js';
+export function createSupergraphStateBuilder() {
+    const state = {
+        graphs: new Map(),
+        scalarTypes: new Map(),
+        objectTypes: new Map(),
+        interfaceTypes: new Map(),
+        unionTypes: new Map(),
+        enumTypes: new Map(),
+        inputObjectTypes: new Map(),
+        directives: new Map(),
+        links: [],
+        specs: {
+            tag: false,
+            inaccessible: false,
+        },
+    };
+    const directive = directiveBuilder();
+    const scalarType = scalarTypeBuilder();
+    const enumType = enumTypeBuilder();
+    const inputObjectType = inputObjectTypeBuilder();
+    const interfaceType = interfaceTypeBuilder();
+    const objectType = objectTypeBuilder();
+    const unionType = unionTypeBuilder();
+    return {
+        addGraph(graph) {
+            if (state.graphs.has(graph.id)) {
+                throw new Error(`Graph with ID "${graph.id}" already exists`);
+            }
+            state.graphs.set(graph.id, {
+                id: graph.id,
+                name: graph.name,
+                url: graph.url,
+                version: graph.version,
+            });
+        },
+        getGraph(id) {
+            return state.graphs.get(id);
+        },
+        visitSubgraphState(subgraphState) {
+            for (const link of subgraphState.links) {
+                state.links.push(linkWithGraph(link, subgraphState.graph.id));
+            }
+            if (subgraphState.specs.tag) {
+                state.specs.tag = true;
+            }
+            if (subgraphState.specs.inaccessible) {
+                state.specs.inaccessible = true;
+            }
+            for (const [typeName, type] of subgraphState.types) {
+                switch (type.kind) {
+                    case 'OBJECT': {
+                        objectType.visitSubgraphState(subgraphState.graph, state.objectTypes, typeName, type);
+                        break;
+                    }
+                    case 'INTERFACE': {
+                        interfaceType.visitSubgraphState(subgraphState.graph, state.interfaceTypes, typeName, type);
+                        break;
+                    }
+                    case 'UNION': {
+                        unionType.visitSubgraphState(subgraphState.graph, state.unionTypes, typeName, type);
+                        break;
+                    }
+                    case 'ENUM': {
+                        enumType.visitSubgraphState(subgraphState.graph, state.enumTypes, typeName, type);
+                        break;
+                    }
+                    case 'INPUT_OBJECT': {
+                        inputObjectType.visitSubgraphState(subgraphState.graph, state.inputObjectTypes, typeName, type);
+                        break;
+                    }
+                    case 'DIRECTIVE': {
+                        directive.visitSubgraphState(subgraphState.graph, state.directives, typeName, type);
+                        break;
+                    }
+                    case 'SCALAR': {
+                        scalarType.visitSubgraphState(subgraphState.graph, state.scalarTypes, typeName, type);
+                        break;
+                    }
+                }
+            }
+        },
+        getSupergraphState() {
+            return state;
+        },
+        links() {
+            return mergeLinks(state.links);
+        },
+        build() {
+            const transformFields = createFieldsTransformer(state);
+            const numberOfExpectedNodes = state.directives.size +
+                state.scalarTypes.size +
+                state.objectTypes.size +
+                state.interfaceTypes.size +
+                state.unionTypes.size +
+                state.enumTypes.size +
+                state.inputObjectTypes.size +
+                1;
+            const nodes = new Array(numberOfExpectedNodes);
+            let i = 0;
+            nodes[i++] = createJoinGraphEnumTypeNode(Array.from(state.graphs.values()).map(graph => ({
+                name: graph.name,
+                enumValue: graph.id,
+                url: graph.url ?? '',
+            })));
+            for (const directiveState of state.directives.values()) {
+                nodes[i++] = directive.composeSupergraphNode(directiveState, state.graphs);
+            }
+            for (const scalarTypeState of state.scalarTypes.values()) {
+                nodes[i++] = scalarType.composeSupergraphNode(scalarTypeState, state.graphs);
+            }
+            for (const objectTypeState of state.objectTypes.values()) {
+                nodes[i++] = objectType.composeSupergraphNode(transformFields(objectTypeState), state.graphs);
+            }
+            for (const interfaceTypeState of state.interfaceTypes.values()) {
+                nodes[i++] = interfaceType.composeSupergraphNode(interfaceTypeState, state.graphs);
+            }
+            for (const unionTypeState of state.unionTypes.values()) {
+                nodes[i++] = unionType.composeSupergraphNode(unionTypeState, state.graphs);
+            }
+            for (const enumTypeState of state.enumTypes.values()) {
+                nodes[i++] = enumType.composeSupergraphNode(enumTypeState, state.graphs);
+            }
+            for (const inputObjectTypeState of state.inputObjectTypes.values()) {
+                nodes[i++] = inputObjectType.composeSupergraphNode(inputObjectTypeState, state.graphs);
+            }
+            return nodes;
+        },
+    };
+}
+function linkWithGraph(link, graph) {
+    link.graph = graph;
+    return link;
+}
+function visitSelectionSetNode(selectionSet, locations, currentPath) {
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === Kind.FIELD) {
+            if (selection.selectionSet) {
+                visitSelectionSetNode(selection.selectionSet, locations, currentPath.concat(selection.name.value));
+            }
+            else {
+                locations.add(currentPath.concat(selection.name.value).join('.'));
+            }
+        }
+    }
+}
+function createFieldsSet(selectionSet) {
+    const locations = new Set();
+    visitSelectionSetNode(selectionSet, locations, []);
+    return locations;
+}
+function filterSelectionSetNode(selectionSet, removableFields, currentPath) {
+    const fieldsToDelete = [];
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === Kind.FIELD) {
+            if (selection.selectionSet) {
+                filterSelectionSetNode(selection.selectionSet, removableFields, currentPath + '.' + selection.name.value);
+                if (selectionSet.selections.length === 0) {
+                    fieldsToDelete.push(selection.name.value);
+                }
+            }
+            else {
+                const lookingFor = currentPath === '' ? selection.name.value : currentPath + '.' + selection.name.value;
+                if (removableFields.has(lookingFor)) {
+                    fieldsToDelete.push(selection.name.value);
+                }
+            }
+        }
+    }
+    for (const fieldName of fieldsToDelete) {
+        selectionSet.selections = selectionSet.selections.filter(selection => selection.kind === Kind.FIELD && selection.name.value === fieldName ? false : true);
+    }
+}
+function createFieldsTransformer(state) {
+    function transformFields(removableFields, fields) {
+        const parsedFields = parseFields(fields);
+        if (!parsedFields) {
+            return fields;
+        }
+        filterSelectionSetNode(parsedFields, removableFields, '');
+        const printed = stripIgnoredCharacters(print(parsedFields));
+        return printed.replace(/^\{/, '').replace(/\}$/, '');
+    }
+    function mergeKeyFieldsCollection(fieldsCollection) {
+        const fieldsSets = [];
+        for (const fields of fieldsCollection) {
+            const parsedFields = parseFields(fields);
+            if (!parsedFields) {
+                continue;
+            }
+            fieldsSets.push(createFieldsSet(parsedFields));
+        }
+        let commonFields;
+        for (const fieldsSet of fieldsSets) {
+            if (!commonFields) {
+                commonFields = fieldsSet;
+                continue;
+            }
+            for (const field of commonFields) {
+                if (!fieldsSet.has(field)) {
+                    commonFields.delete(field);
+                }
+            }
+        }
+        return commonFields ?? new Set();
+    }
+    return function visitTypeState(typeState) {
+        for (const [_, fieldState] of typeState.fields) {
+            for (const [graphId, fieldStateInGraph] of fieldState.byGraph) {
+                if (fieldStateInGraph.requires) {
+                    const keyFields = mergeKeyFieldsCollection(typeState.byGraph.get(graphId).keys.map(key => key.fields));
+                    const newRequires = transformFields(keyFields, fieldStateInGraph.requires);
+                    fieldStateInGraph.requires = newRequires.trim().length === 0 ? null : newRequires;
+                }
+                if (fieldStateInGraph.provides) {
+                    const referencedTypeName = fieldState.type.replace(/[!\[\]]+/g, '');
+                    const referencedType = state.objectTypes.get(referencedTypeName) ??
+                        state.interfaceTypes.get(referencedTypeName);
+                    if (!referencedType) {
+                        throw new Error('Referenced type not found: ' + referencedTypeName);
+                    }
+                    const referencedTypeInGraph = referencedType.byGraph.get(graphId);
+                    const keyFields = referencedTypeInGraph.extension === true
+                        ?
+                            mergeKeyFieldsCollection(referencedTypeInGraph.keys.map(key => key.fields))
+                        :
+                            new Set();
+                    fieldStateInGraph.provides = transformFields(keyFields, fieldStateInGraph.provides);
+                }
+            }
+        }
+        return typeState;
+    };
+}

package/esm/supergraph/validation/rules/default-value-uses-inaccessible-rule.js

@@ -0,0 +1,31 @@
+import { GraphQLError } from 'graphql';
+export function DefaultValueUsesInaccessibleRule(context, supergraph) {
+    return {
+        InputObjectTypeField(inputObjectState, fieldState) {
+            if (typeof fieldState.defaultValue !== 'string') {
+                return;
+            }
+            detectInaccessibleDefaultValue(context, () => `${inputObjectState.name}.${fieldState.name}`, fieldState.type, fieldState.defaultValue, supergraph.enumTypes);
+        },
+        ObjectTypeFieldArg(objectState, fieldState, argState) {
+            if (typeof argState.defaultValue !== 'string') {
+                return;
+            }
+            detectInaccessibleDefaultValue(context, () => `${objectState.name}.${fieldState.name}(${argState.name}:)`, argState.type, argState.defaultValue, supergraph.enumTypes);
+        },
+    };
+}
+function detectInaccessibleDefaultValue(context, schemaCoordinate, outputType, defaultValue, enumTypes) {
+    const outputTypeName = outputType.replace(/[\[\]\!]+/g, '');
+    const enumType = enumTypes.get(outputTypeName);
+    if (!enumType) {
+        return;
+    }
+    if (enumType.inaccessible === true || enumType.values.get(defaultValue)?.inaccessible === true) {
+        context.reportError(new GraphQLError(`Enum value "${outputTypeName}.${defaultValue}" is @inaccessible but is used in the default value of "${schemaCoordinate()}", which is in the API schema.`, {
+            extensions: {
+                code: 'DEFAULT_VALUE_USES_INACCESSIBLE',
+            },
+        }));
+    }
+}

package/esm/supergraph/validation/rules/directive-composition-rule.js

@@ -0,0 +1,94 @@
+import { GraphQLError } from 'graphql';
+export function DirectiveCompositionRule(context, supergraph) {
+    const linkIdentityToMajorVersion = new Map();
+    const appliedDirectiveToGraphs = new Map();
+    const appliedDirectiveToLinkIdentities = new Map();
+    for (const link of supergraph.links) {
+        if (link.version) {
+            const major = parseInt(link.version.replace('v', '').split('.')[0]);
+            const existing = linkIdentityToMajorVersion.get(link.identity);
+            if (typeof existing === 'number' && existing !== major) {
+                context.reportError(new GraphQLError(`Core feature "${link.identity}" requested to be merged has major version mismatch across subgraphs`, {
+                    extensions: {
+                        code: 'DIRECTIVE_COMPOSITION_ERROR',
+                        versions: [existing, major],
+                    },
+                }));
+            }
+            else {
+                linkIdentityToMajorVersion.set(link.identity, major);
+            }
+        }
+        for (const im of link.imports) {
+            if (im.kind === 'directive') {
+                const appliedName = im.alias ?? im.name;
+                const originalName = im.name;
+                const appliedDirectiveToGraph = appliedDirectiveToGraphs.get(originalName);
+                if (appliedDirectiveToGraph) {
+                    const graphs = appliedDirectiveToGraph.get(appliedName);
+                    if (graphs) {
+                        graphs.add(link.graph);
+                    }
+                    else {
+                        appliedDirectiveToGraph.set(appliedName, new Set([link.graph]));
+                    }
+                }
+                else {
+                    appliedDirectiveToGraphs.set(originalName, new Map([[appliedName, new Set([link.graph])]]));
+                }
+                const appliedDirectiveToLinkIdentity = appliedDirectiveToLinkIdentities.get(appliedName);
+                if (appliedDirectiveToLinkIdentity) {
+                    appliedDirectiveToLinkIdentity.add(link.identity);
+                }
+                else {
+                    appliedDirectiveToLinkIdentities.set(appliedName, new Set([link.identity]));
+                }
+            }
+        }
+    }
+    for (const [originalDirectiveName, appliedNames] of appliedDirectiveToGraphs) {
+        if (appliedNames.size > 1) {
+            const groups = Array.from(appliedNames.entries()).map(([appliedName, graphs]) => {
+                const plural = graphs.size > 1 ? 's' : '';
+                return `name "${appliedName}" in subgraph${plural} "${Array.from(graphs)
+                    .map(context.graphIdToName)
+                    .join('", "')}"`;
+            });
+            const [first, second, ...rest] = groups;
+            context.reportError(new GraphQLError(`Composed directive "${originalDirectiveName}" has incompatible name across subgraphs: it has ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}. Composed directive must have the same name across all subgraphs.`, {
+                extensions: {
+                    code: 'DIRECTIVE_COMPOSITION_ERROR',
+                },
+            }));
+        }
+    }
+    for (const [directiveName, linkIdentities] of appliedDirectiveToLinkIdentities) {
+        if (linkIdentities.size > 1) {
+            context.reportError(new GraphQLError(`Composed directive "${directiveName}" is not linked by the same core feature in every subgraph`, {
+                extensions: {
+                    code: 'DIRECTIVE_COMPOSITION_ERROR',
+                },
+            }));
+        }
+    }
+    return {
+        Directive(directiveState) {
+            if (directiveState.byGraph.size === 1) {
+                return;
+            }
+            const graphsSize = directiveState.byGraph.size;
+            const hasLocationDefinedInAllGraphs = Array.from(directiveState.locations).some(location => {
+                let count = 0;
+                for (const [_, graphState] of directiveState.byGraph) {
+                    if (graphState.locations.has(location)) {
+                        count++;
+                    }
+                }
+                return count === graphsSize;
+            });
+            if (!hasLocationDefinedInAllGraphs) {
+                context.reportError(new GraphQLError(`Directive "@${directiveState.name}" has no shared locations between subgraphs`));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/enum-values-rule.js

@@ -0,0 +1,55 @@
+import { GraphQLError } from 'graphql';
+export function EnumValuesRule(context) {
+    return {
+        EnumType(enumTypeState) {
+            if (enumTypeState.referencedByInputType && enumTypeState.referencedByOutputType) {
+                const missingValues = [];
+                const total = enumTypeState.byGraph.size;
+                for (const [valueName, valueState] of enumTypeState.values) {
+                    if (valueState.byGraph.size !== total) {
+                        missingValues.push(valueName);
+                    }
+                }
+                if (missingValues.length === 0) {
+                    return;
+                }
+                const exampleInputType = `(for example, as type of "${enumTypeState.inputTypeReferences.values().next().value}")`;
+                const exampleOutputType = `(for example, as type of "${enumTypeState.outputTypeReferences.values().next().value}")`;
+                for (const missingValue of missingValues) {
+                    const valueState = enumTypeState.values.get(missingValue);
+                    const definedIn = Array.from(valueState.byGraph.keys()).map(context.graphIdToName);
+                    const notDefinedIn = Array.from(enumTypeState.byGraph.keys())
+                        .filter(key => !valueState.byGraph.has(key))
+                        .map(context.graphIdToName);
+                    const msg = [
+                        `Enum type "${enumTypeState.name}" is used as both input type ${exampleInputType} and output type ${exampleOutputType},`,
+                        `but value "${missingValue}" is not defined in all the subgraphs defining "${enumTypeState.name}":`,
+                        `"${missingValue}" is defined in subgraph${definedIn.length > 1 ? 's' : ''} "${definedIn.join('", "')}"`,
+                        `but not in subgraph${notDefinedIn.length > 1 ? 's' : ''} "${notDefinedIn.join('", "')}"`,
+                    ].join(' ');
+                    context.reportError(new GraphQLError(msg, {
+                        extensions: {
+                            code: 'ENUM_VALUE_MISMATCH',
+                        },
+                    }));
+                }
+            }
+            else if (enumTypeState.referencedByInputType) {
+                const valuesInCommon = [];
+                const total = enumTypeState.byGraph.size;
+                for (const [valueName, valueState] of enumTypeState.values) {
+                    if (valueState.byGraph.size === total) {
+                        valuesInCommon.push(valueName);
+                    }
+                }
+                if (valuesInCommon.length === 0) {
+                    context.reportError(new GraphQLError(`None of the values of enum type "${enumTypeState.name}" are defined consistently in all the subgraphs defining that type. As only values common to all subgraphs are merged, this would result in an empty type.`, {
+                        extensions: {
+                            code: 'EMPTY_MERGED_ENUM_TYPE',
+                        },
+                    }));
+                }
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/extension-with-base.js

@@ -0,0 +1,27 @@
+import { GraphQLError } from 'graphql';
+export function ExtensionWithBaseRule(context) {
+    return {
+        ObjectType(objectTypeState) {
+            if (objectTypeState.name === 'Query' ||
+                objectTypeState.name === 'Mutation' ||
+                objectTypeState.name === 'Subscription') {
+                return;
+            }
+            if (!objectTypeState.hasDefinition) {
+                if (objectTypeState.byGraph.size > 1 &&
+                    Array.from(objectTypeState.byGraph).every(([graphId, meta]) => context.subgraphStates.get(graphId).version === 'v1.0'
+                        ? meta.extensionType === '@extends'
+                        : false)) {
+                    return;
+                }
+                objectTypeState.byGraph.forEach((_, graph) => {
+                    context.reportError(new GraphQLError(`[${context.graphIdToName(graph)}] Type "${objectTypeState.name}" is an extension type, but there is no type definition for "${objectTypeState.name}" in any subgraph.`, {
+                        extensions: {
+                            code: 'EXTENSION_WITH_NO_BASE',
+                        },
+                    }));
+                });
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/external-argument-missing-rule.js

@@ -0,0 +1,28 @@
+import { GraphQLError } from 'graphql';
+export function ExternalArgumentMissingRule(context) {
+    return {
+        ObjectTypeFieldArg(objectState, fieldState, argState) {
+            if (argState.type.endsWith('!')) {
+                if (argState.byGraph.size === 1 && fieldState.byGraph.size === argState.byGraph.size) {
+                    return;
+                }
+                if (fieldState.byGraph.size === argState.byGraph.size) {
+                    return;
+                }
+                const graphsWithRequiredArg = Array.from(argState.byGraph)
+                    .filter(([graph, arg]) => arg.type.endsWith('!') && fieldState.byGraph.get(graph)?.external !== true)
+                    .map(([graph]) => graph);
+                const externalGraphsWithoutArg = Array.from(fieldState.byGraph.keys()).filter(graph => !argState.byGraph.has(graph) && fieldState.byGraph.get(graph)?.external === true);
+                const requiredIn = `subgraph${graphsWithRequiredArg.length > 1 ? 's' : ''} "${graphsWithRequiredArg.map(context.graphIdToName).join('", "')}"`;
+                const missingIn = `subgraph${externalGraphsWithoutArg.length > 1 ? 's' : ''} "${externalGraphsWithoutArg.map(context.graphIdToName).join('", "')}"`;
+                const fieldCoordinate = `${objectState.name}.${fieldState.name}`;
+                const argCoordinate = `${objectState.name}.${fieldState.name}(${argState.name}:)`;
+                context.reportError(new GraphQLError(`Field "${fieldCoordinate}" is missing argument "${argCoordinate}" in some subgraphs where it is marked @external: argument "${argCoordinate}" is declared in ${requiredIn} but not in ${missingIn} (where "${fieldCoordinate}" is @external)`, {
+                    extensions: {
+                        code: 'EXTERNAL_ARGUMENT_MISSING',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/external-missing-on-base-rule.js

@@ -0,0 +1,44 @@
+import { GraphQLError } from 'graphql';
+import { andList } from '../../../utils/format.js';
+export function ExternalMissingOnBaseRule(context) {
+    return {
+        ObjectType(objectTypeState) {
+            if (Array.from(objectTypeState.byGraph).every(([_, stateInGraph]) => stateInGraph.external === true)) {
+                const subgraphs = objectTypeState.byGraph.size > 1 ? 'subgraphs' : 'subgraph';
+                context.reportError(new GraphQLError(`Type "${objectTypeState.name}" is marked @external on all the subgraphs in which it is listed (${subgraphs} ${(andList(Array.from(objectTypeState.byGraph.keys()).map(graphId => context.graphIdToName(graphId))),
+                    true,
+                    '"')}).`, {
+                    extensions: {
+                        code: 'EXTERNAL_MISSING_ON_BASE',
+                    },
+                }));
+            }
+        },
+        ObjectTypeField(objectState, fieldState) {
+            if (Array.from(fieldState.byGraph).every(([graphId, stateInGraph]) => {
+                const graphVersion = context.subgraphStates.get(graphId).version;
+                if (stateInGraph.usedAsKey) {
+                    if (graphVersion === 'v1.0') {
+                        return stateInGraph.external && !objectState.byGraph.get(graphId).extension;
+                    }
+                    return (stateInGraph.external === true &&
+                        objectState.byGraph.get(graphId).extensionType !== '@extends');
+                }
+                if (graphVersion === 'v1.0') {
+                    if (stateInGraph.external === true && stateInGraph.used) {
+                        return true;
+                    }
+                    return false;
+                }
+                return stateInGraph.external === true;
+            })) {
+                const subgraphs = fieldState.byGraph.size > 1 ? 'subgraphs' : 'subgraph';
+                context.reportError(new GraphQLError(`Field "${objectState.name}.${fieldState.name}" is marked @external on all the subgraphs in which it is listed (${subgraphs} ${andList(Array.from(fieldState.byGraph.keys()).map(context.graphIdToName), true, '"')}).`, {
+                    extensions: {
+                        code: 'EXTERNAL_MISSING_ON_BASE',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/external-type-mismatch-rule.js

@@ -0,0 +1,48 @@
+import { GraphQLError } from 'graphql';
+import { andList } from '../../../utils/format.js';
+import { isRealExtension } from '../../composition/object-type.js';
+export function ExternalTypeMismatchRule(context) {
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            if (fieldState.usedAsKey) {
+                return;
+            }
+            const groupByType = new Map();
+            const graphsWithEqualType = [];
+            for (const [graphId, field] of fieldState.byGraph) {
+                const graphVersion = context.subgraphStates.get(graphId).version;
+                const isExternal = graphVersion === 'v1.0'
+                    ? field.external && isRealExtension(objectTypeState.byGraph.get(graphId), graphVersion)
+                    : field.external;
+                if (!isExternal) {
+                    graphsWithEqualType.push(graphId);
+                    continue;
+                }
+                if (field.type === fieldState.type) {
+                    graphsWithEqualType.push(graphId);
+                    continue;
+                }
+                const existing = groupByType.get(field.type);
+                if (existing) {
+                    existing.push(graphId);
+                }
+                else {
+                    groupByType.set(field.type, [graphId]);
+                }
+            }
+            if (groupByType.size && graphsWithEqualType.length) {
+                const groups = Array.from(groupByType.entries()).map(([type, graphs]) => {
+                    const plural = graphs.length > 1 ? 's' : '';
+                    return `type "${type}" in subgraph${plural} ${andList(graphs.map(context.graphIdToName), true, '"')}`;
+                });
+                const [first, ...rest] = groups;
+                const nonExternal = `type "${fieldState.type}" in subgraph${graphsWithEqualType.length > 1 ? 's' : ''} ${andList(graphsWithEqualType.map(context.graphIdToName), true, '"')}`;
+                context.reportError(new GraphQLError(`Type of field "${objectTypeState.name}.${fieldState.name}" is incompatible across subgraphs (where marked @external): it has ${nonExternal} but ${first}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+                    extensions: {
+                        code: 'EXTERNAL_TYPE_MISMATCH',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/field-argument-default-mismatch-rule.js

@@ -0,0 +1,36 @@
+import { GraphQLError } from 'graphql';
+export function FieldArgumentDefaultMismatchRule(context) {
+    return {
+        ObjectTypeFieldArg(objectState, fieldState, argState) {
+            if (typeof argState.defaultValue !== 'string') {
+                return;
+            }
+            const defaultValueToGraphs = new Map();
+            argState.byGraph.forEach((arg, graphName) => {
+                if (typeof arg.defaultValue === 'string') {
+                    const existing = defaultValueToGraphs.get(arg.defaultValue);
+                    if (existing) {
+                        existing.push(graphName);
+                    }
+                    else {
+                        defaultValueToGraphs.set(arg.defaultValue, [graphName]);
+                    }
+                }
+            });
+            if (defaultValueToGraphs.size > 1) {
+                const groups = Array.from(defaultValueToGraphs.entries()).map(([defaultValue, graphs]) => {
+                    const plural = graphs.length > 1 ? 's' : '';
+                    return `default value ${defaultValue} in subgraph${plural} "${graphs
+                        .map(context.graphIdToName)
+                        .join('", "')}"`;
+                });
+                const [first, second, ...rest] = groups;
+                context.reportError(new GraphQLError(`Argument "${objectState.name}.${fieldState.name}(${argState.name}:)" has incompatible default values across subgraphs: it has ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+                    extensions: {
+                        code: 'FIELD_ARGUMENT_DEFAULT_MISMATCH',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/field-arguments-of-the-same-type-rule.js

@@ -0,0 +1,45 @@
+import { GraphQLError } from 'graphql';
+export function FieldArgumentsOfTheSameTypeRule(context) {
+    return {
+        ObjectTypeFieldArg(objectTypeState, fieldState, argState) {
+            const typeToGraphs = new Map();
+            argState.byGraph.forEach((arg, graphName) => {
+                const isNonNullable = arg.type.endsWith('!');
+                const isNonNullableInSupergraph = argState.type.endsWith('!');
+                const isMatchingNonNullablePart = argState.type.replace(/!$/, '') === arg.type.replace(/!$/, '');
+                let normalizedOutputType;
+                if (isMatchingNonNullablePart) {
+                    normalizedOutputType = isNonNullableInSupergraph
+                        ? isNonNullable
+                            ? arg.type
+                            : arg.type + '!'
+                        : arg.type;
+                }
+                else {
+                    normalizedOutputType = arg.type;
+                }
+                const existing = typeToGraphs.get(normalizedOutputType);
+                if (existing) {
+                    existing.push(graphName);
+                }
+                else {
+                    typeToGraphs.set(normalizedOutputType, [graphName]);
+                }
+            });
+            if (typeToGraphs.size > 1) {
+                const groups = Array.from(typeToGraphs.entries()).map(([outputType, graphs]) => {
+                    const plural = graphs.length > 1 ? 's' : '';
+                    return `type "${outputType}" in subgraph${plural} "${graphs
+                        .map(context.graphIdToName)
+                        .join('", "')}"`;
+                });
+                const [first, second, ...rest] = groups;
+                context.reportError(new GraphQLError(`Type of argument "${objectTypeState.name}.${fieldState.name}(${argState.name}:)" is incompatible across subgraphs: it has ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+                    extensions: {
+                        code: 'FIELD_ARGUMENT_TYPE_MISMATCH',
+                    },
+                }));
+            }
+        },
+    };
+}