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

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

@@ -0,0 +1,85 @@
+import { GraphQLError } from 'graphql';
+export function FieldsOfTheSameTypeRule(context) {
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            const typeToGraphs = new Map();
+            fieldState.byGraph.forEach((field, graphName) => {
+                const isNullable = !field.type.endsWith('!');
+                const isNullableInSupergraph = !fieldState.type.endsWith('!');
+                const isMatchingNonNullablePart = fieldState.type.replace(/!$/, '') === field.type.replace(/!$/, '');
+                let normalizedOutputType;
+                if (isMatchingNonNullablePart) {
+                    normalizedOutputType = isNullableInSupergraph
+                        ? isNullable
+                            ? field.type
+                            : field.type.replace(/!$/, '')
+                        : field.type;
+                }
+                else {
+                    normalizedOutputType = field.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 field "${objectTypeState.name}.${fieldState.name}" is incompatible across subgraphs: it has ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+                    extensions: {
+                        code: 'FIELD_TYPE_MISMATCH',
+                    },
+                }));
+            }
+        },
+        InputObjectTypeField(inputObjectTypeState, fieldState) {
+            const typeToGraphs = new Map();
+            fieldState.byGraph.forEach((field, graphName) => {
+                const isNonNullable = field.type.endsWith('!');
+                const isNonNullableInSupergraph = fieldState.type.endsWith('!');
+                const isMatchingNonNullablePart = fieldState.type.replace(/!$/, '') === field.type.replace(/!$/, '');
+                let normalizedOutputType;
+                if (isMatchingNonNullablePart) {
+                    normalizedOutputType = isNonNullableInSupergraph
+                        ? isNonNullable
+                            ? field.type
+                            : field.type + '!'
+                        : field.type;
+                }
+                else {
+                    normalizedOutputType = field.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 field "${inputObjectTypeState.name}.${fieldState.name}" is incompatible across subgraphs: it has ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+                    extensions: {
+                        code: 'FIELD_TYPE_MISMATCH',
+                    },
+                }));
+            }
+        },
+    };
+}

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

@@ -0,0 +1,36 @@
+import { GraphQLError } from 'graphql';
+export function InputFieldDefaultMismatchRule(context) {
+    return {
+        InputObjectTypeField(inputObjectState, fieldState) {
+            if (typeof fieldState.defaultValue !== 'string') {
+                return;
+            }
+            const defaultValueToGraphs = new Map();
+            fieldState.byGraph.forEach((field, graphName) => {
+                if (typeof field.defaultValue === 'string') {
+                    const existing = defaultValueToGraphs.get(field.defaultValue);
+                    if (existing) {
+                        existing.push(graphName);
+                    }
+                    else {
+                        defaultValueToGraphs.set(field.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(`Input field "${inputObjectState.name}.${fieldState.name}" has incompatible default values across subgraphs: it has ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+                    extensions: {
+                        code: 'INPUT_FIELD_DEFAULT_MISMATCH',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/input-object-values-rule.js

@@ -0,0 +1,21 @@
+import { GraphQLError } from 'graphql';
+export function InputObjectValuesRule(context) {
+    return {
+        InputObjectType(inputObjectTypeState) {
+            const fieldsInCommon = [];
+            const total = inputObjectTypeState.byGraph.size;
+            for (const [fieldName, fieldState] of inputObjectTypeState.fields) {
+                if (fieldState.byGraph.size === total) {
+                    fieldsInCommon.push(fieldName);
+                }
+            }
+            if (fieldsInCommon.length === 0) {
+                context.reportError(new GraphQLError(`None of the fields of input object type "${inputObjectTypeState.name}" are consistently defined in all the subgraphs defining that type. As only fields common to all subgraphs are merged, this would result in an empty type.`, {
+                    extensions: {
+                        code: 'EMPTY_MERGED_INPUT_TYPE',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/interface-key-missing-implementation-type.js

@@ -0,0 +1,42 @@
+import { GraphQLError } from 'graphql';
+export function InterfaceKeyMissingImplementationTypeRule(context) {
+    return {
+        InterfaceType(interfaceState) {
+            let someSubgraphsAreMissingImplementation = false;
+            for (const interfaceStateInGraph of interfaceState.byGraph.values()) {
+                if (interfaceStateInGraph.keys.length === 0) {
+                    continue;
+                }
+                if (interfaceStateInGraph.implementedBy.size === 0) {
+                    someSubgraphsAreMissingImplementation = true;
+                    break;
+                }
+            }
+            if (!someSubgraphsAreMissingImplementation) {
+                return;
+            }
+            for (const [graph, interfaceStateInGraph] of interfaceState.byGraph) {
+                if (interfaceStateInGraph.keys.length === 0) {
+                    continue;
+                }
+                const firstKeyFields = interfaceStateInGraph.keys[0].fields;
+                const graphName = context.graphIdToName(graph);
+                const typesToDefine = Array.from(interfaceState.implementedBy)
+                    .filter(objectTypeName => !interfaceStateInGraph.implementedBy.has(objectTypeName))
+                    .sort();
+                context.reportError(new GraphQLError(`[${graphName}] Interface type "${interfaceState.name}" has a resolvable key (@key(fields: "${firstKeyFields}")) in subgraph "${graphName}" but that subgraph is missing some of the supergraph implementation types of "${interfaceState.name}". Subgraph "${graphName}" should define ${typesToDefine.length > 1 ? 'types' : 'type'} ${joinWithAnd(typesToDefine)} (and have ${typesToDefine.length > 1 ? 'them' : 'it'} implement "${interfaceState.name}").`, {
+                    extensions: {
+                        code: 'INTERFACE_KEY_MISSING_IMPLEMENTATION_TYPE',
+                    },
+                }));
+            }
+        },
+    };
+}
+function joinWithAnd(list) {
+    if (list.length <= 2) {
+        return `"${list.join('" and "')}"`;
+    }
+    const last = list.pop();
+    return `"${list.join('", "')}" and "${last}"`;
+}

package/esm/supergraph/validation/rules/invalid-field-sharing-rule.js

@@ -0,0 +1,41 @@
+import { GraphQLError } from 'graphql';
+import { andList } from '../../../utils/format.js';
+export function InvalidFieldSharingRule(context) {
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            if (fieldState.usedAsKey &&
+                Array.from(fieldState.byGraph.values()).every(field => field.usedAsKey)) {
+                return;
+            }
+            const nonSharableIn = [];
+            const resolvableIn = [];
+            for (const [graphId, field] of fieldState.byGraph) {
+                const objectTypeIsShareable = objectTypeState.byGraph.get(graphId).shareable;
+                const fieldIsShareable = field.shareable;
+                const fieldIsExternal = field.external;
+                const fieldHasOverride = field.override;
+                const fieldIsUsedAsKey = field.usedAsKey;
+                if (fieldIsExternal || fieldHasOverride) {
+                    continue;
+                }
+                if (objectTypeIsShareable || fieldIsShareable || fieldIsUsedAsKey) {
+                    resolvableIn.push(graphId);
+                    continue;
+                }
+                nonSharableIn.push(graphId);
+                resolvableIn.push(graphId);
+            }
+            if (nonSharableIn.length >= 1 && resolvableIn.length > 1) {
+                const isNonSharableInAll = resolvableIn.every(graphId => nonSharableIn.includes(graphId));
+                const message = `Non-shareable field "${objectTypeState.name}.${fieldState.name}" is resolved from multiple subgraphs: it is resolved from subgraphs ${andList(resolvableIn.map(context.graphIdToName), false, '"')} and defined as non-shareable in ${isNonSharableInAll
+                    ? 'all of them'
+                    : `subgraph${nonSharableIn.length > 1 ? 's' : ''} ${andList(nonSharableIn.map(context.graphIdToName), true, '"')}`}`;
+                context.reportError(new GraphQLError(message, {
+                    extensions: {
+                        code: 'INVALID_FIELD_SHARING',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/only-inaccessible-children-rule.js

@@ -0,0 +1,36 @@
+import { GraphQLError } from 'graphql';
+export function OnlyInaccessibleChildrenRule(context) {
+    return {
+        EnumType(enumState) {
+            if (enumState.inaccessible === false && areAllInaccessible(enumState.values)) {
+                context.reportError(new GraphQLError(`Type "${enumState.name}" is in the API schema but all of its values are @inaccessible.`, {
+                    extensions: {
+                        code: 'ONLY_INACCESSIBLE_CHILDREN',
+                    },
+                }));
+            }
+        },
+        ObjectType(objectState) {
+            if (objectState.inaccessible === false && areAllInaccessible(objectState.fields)) {
+                context.reportError(new GraphQLError(`Type "${objectState.name}" is in the API schema but all of its fields are @inaccessible.`, {
+                    extensions: {
+                        code: 'ONLY_INACCESSIBLE_CHILDREN',
+                    },
+                }));
+            }
+        },
+        InputObjectType(inputObjectTypeState) {
+            if (inputObjectTypeState.inaccessible === false &&
+                areAllInaccessible(inputObjectTypeState.fields)) {
+                context.reportError(new GraphQLError(`Type "${inputObjectTypeState.name}" is in the API schema but all of its fields are @inaccessible.`, {
+                    extensions: {
+                        code: 'ONLY_INACCESSIBLE_CHILDREN',
+                    },
+                }));
+            }
+        },
+    };
+}
+function areAllInaccessible(childrenMap) {
+    return Array.from(childrenMap.values()).every(f => f.inaccessible === true);
+}

package/esm/supergraph/validation/rules/override-source-has-override.js

@@ -0,0 +1,32 @@
+import { GraphQLError } from 'graphql';
+export function OverrideSourceHasOverrideRule(context) {
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            if (fieldState.override === null) {
+                return;
+            }
+            const graphsWithOverride = Array.from(fieldState.byGraph).filter(onlyWithOverride);
+            if (graphsWithOverride.length === 1) {
+                return;
+            }
+            for (let i = 0; i < graphsWithOverride.length; i++) {
+                const [graph, fieldStateInGraph] = graphsWithOverride[i];
+                const overrideValue = fieldStateInGraph.override.toUpperCase();
+                const graphFromOverride = fieldState.byGraph.get(overrideValue);
+                const anotherGraphId = graphFromOverride && graphFromOverride.override !== null
+                    ? overrideValue
+                    : graphsWithOverride[i + 1]
+                        ? graphsWithOverride[i + 1][0]
+                        : graphsWithOverride[0][0];
+                context.reportError(new GraphQLError(`Field "${objectTypeState.name}.${fieldState.name}" on subgraph "${context.graphIdToName(graph)}" is also marked with directive @override in subgraph "${context.graphIdToName(anotherGraphId)}". Only one @override directive is allowed per field.`, {
+                    extensions: {
+                        code: 'OVERRIDE_SOURCE_HAS_OVERRIDE',
+                    },
+                }));
+            }
+        },
+    };
+}
+function onlyWithOverride(entry) {
+    return entry[1].override !== null;
+}

package/esm/supergraph/validation/rules/referenced-inaccessible-rule.js

@@ -0,0 +1,40 @@
+import { GraphQLError } from 'graphql';
+export function ReferencedInaccessibleRule(context, supergraph) {
+    return {
+        ObjectTypeField(objectState, fieldState) {
+            const outputTypeName = fieldState.type.replace(/[\[\]\!]+/g, '');
+            const referencesInaccessible = findOutputType(supergraph, outputTypeName)?.inaccessible === true;
+            const isInaccessible = fieldState.inaccessible === true || objectState.inaccessible === true;
+            if (referencesInaccessible && !isInaccessible) {
+                context.reportError(new GraphQLError(`Type "${outputTypeName}" is @inaccessible but is referenced by "${objectState.name}.${fieldState.name}", which is in the API schema.`, {
+                    extensions: {
+                        code: 'REFERENCED_INACCESSIBLE',
+                    },
+                }));
+            }
+        },
+        ObjectTypeFieldArg(objectState, fieldState, argState) {
+            const outputTypeName = argState.type.replace(/[\[\]\!]+/g, '');
+            const referencesInaccessible = findInputType(supergraph, outputTypeName)?.inaccessible === true;
+            const isInaccessible = argState.inaccessible === true ||
+                fieldState.inaccessible === true ||
+                objectState.inaccessible === true;
+            if (referencesInaccessible && !isInaccessible) {
+                context.reportError(new GraphQLError(`Type "${outputTypeName}" is @inaccessible but is referenced by "${objectState.name}.${fieldState.name}(${argState.name}:)", which is in the API schema.`, {
+                    extensions: {
+                        code: 'REFERENCED_INACCESSIBLE',
+                    },
+                }));
+            }
+        },
+    };
+}
+function findOutputType(supergraph, typeName) {
+    return (supergraph.enumTypes.get(typeName) ||
+        supergraph.objectTypes.get(typeName) ||
+        supergraph.interfaceTypes.get(typeName) ||
+        supergraph.unionTypes.get(typeName));
+}
+function findInputType(supergraph, typeName) {
+    return supergraph.enumTypes.get(typeName) || supergraph.inputObjectTypes.get(typeName);
+}

package/esm/supergraph/validation/rules/required-argument-missing-in-some-subgraph-rule.js

@@ -0,0 +1,28 @@
+import { GraphQLError } from 'graphql';
+export function RequiredArgumentMissingInSomeSubgraph(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(([_, arg]) => arg.type.endsWith('!'))
+                    .map(([graph]) => graph);
+                const graphsWithoutArg = Array.from(fieldState.byGraph.keys()).filter(graph => !argState.byGraph.has(graph));
+                const requiredIn = `subgraph${graphsWithRequiredArg.length > 1 ? 's' : ''} "${graphsWithRequiredArg.map(context.graphIdToName).join('", "')}"`;
+                const missingIn = `subgraph${graphsWithoutArg.length > 1 ? 's' : ''} "${graphsWithoutArg
+                    .map(context.graphIdToName)
+                    .join('", "')}"`;
+                context.reportError(new GraphQLError(`Argument "${objectState.name}.${fieldState.name}(${argState.name}:)" is required in some subgraphs but does not appear in all subgraphs: it is required in ${requiredIn} but does not appear in ${missingIn}`, {
+                    extensions: {
+                        code: 'REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/required-input-field-missing-in-some-subgraph-rule.js

@@ -0,0 +1,28 @@
+import { GraphQLError } from 'graphql';
+export function RequiredInputFieldMissingInSomeSubgraphRule(context) {
+    return {
+        InputObjectTypeField(inputObjectState, fieldState) {
+            if (fieldState.type.endsWith('!')) {
+                if (inputObjectState.byGraph.size === 1) {
+                    return;
+                }
+                if (inputObjectState.byGraph.size === fieldState.byGraph.size) {
+                    return;
+                }
+                const graphsWithRequiredField = Array.from(fieldState.byGraph)
+                    .filter(([_, field]) => field.type.endsWith('!'))
+                    .map(([graph]) => graph);
+                const graphsWithoutField = Array.from(inputObjectState.byGraph.keys()).filter(graph => !fieldState.byGraph.has(graph));
+                const requiredIn = `subgraph${graphsWithRequiredField.length > 1 ? 's' : ''} "${graphsWithRequiredField.map(context.graphIdToName).join('", "')}"`;
+                const missingIn = `subgraph${graphsWithoutField.length > 1 ? 's' : ''} "${graphsWithoutField
+                    .map(context.graphIdToName)
+                    .join('", "')}"`;
+                context.reportError(new GraphQLError(`Input object field "${inputObjectState.name}.${fieldState.name}" is required in some subgraphs but does not appear in all subgraphs: it is required in ${requiredIn} but does not appear in ${missingIn}`, {
+                    extensions: {
+                        code: 'REQUIRED_INPUT_FIELD_MISSING_IN_SOME_SUBGRAPH',
+                    },
+                }));
+            }
+        },
+    };
+}

package/esm/supergraph/validation/rules/required-query-rule.js

@@ -0,0 +1,10 @@
+import { GraphQLError } from 'graphql';
+export function RequiredQueryRule(context) {
+    if (Array.from(context.subgraphStates.values()).every(subgraph => typeof subgraph.schema.queryType === 'undefined')) {
+        context.reportError(new GraphQLError(`No queries found in any subgraph: a supergraph must have a query root type.`, {
+            extensions: {
+                code: 'NO_QUERIES',
+            },
+        }));
+    }
+}