@theguild/federation-composition 0.9.0 → 0.10.0

package/esm/supergraph/composition/scalar-type.js

@@ -28,6 +28,7 @@ export function scalarTypeBuilder() {
             });
             scalarTypeState.byGraph.set(graph.id, {
                 inaccessible: type.inaccessible,
+                version: graph.version,
             });
         },
         composeSupergraphNode(scalarType) {
@@ -58,6 +59,7 @@ function getOrCreateScalarType(state, typeName) {
         return existing;
     }
     const def = {
+        kind: 'scalar',
         name: typeName,
         tags: new Set(),
         inaccessible: false,

package/esm/supergraph/composition/union-type.js

@@ -15,6 +15,7 @@ export function unionTypeBuilder() {
             }
             unionTypeState.byGraph.set(graph.id, {
                 members: type.members,
+                version: graph.version,
             });
             for (const member of type.members) {
                 unionTypeState.members.add(member);
@@ -48,6 +49,7 @@ function getOrCreateUnionType(state, typeName) {
         return existing;
     }
     const def = {
+        kind: 'union',
         name: typeName,
         members: new Set(),
         tags: new Set(),

package/esm/supergraph/state.js

@@ -12,7 +12,7 @@ import { scalarTypeBuilder } from './composition/scalar-type.js';
 import { unionTypeBuilder } from './composition/union-type.js';
 export function createSupergraphStateBuilder() {
     const state = {
-        graphs: new Map(),
+        subgraphs: new Map(),
         scalarTypes: new Map(),
         objectTypes: new Map(),
         interfaceTypes: new Map(),
@@ -36,22 +36,21 @@ export function createSupergraphStateBuilder() {
     const interfaceType = interfaceTypeBuilder();
     const objectType = objectTypeBuilder();
     const unionType = unionTypeBuilder();
+    const subgraphStates = new Map();
+    const graphNameToIdMap = {};
     return {
-        addGraph(graph) {
-            if (state.graphs.has(graph.id)) {
-                throw new Error(`Graph with ID "${graph.id}" already exists`);
+        addSubgraph(subgraph) {
+            if (state.subgraphs.has(subgraph.graph.id)) {
+                throw new Error(`Graph with ID "${subgraph.graph.id}" already exists`);
             }
-            state.graphs.set(graph.id, {
-                id: graph.id,
-                name: graph.name,
-                url: graph.url,
-                version: graph.version,
-            });
+            state.subgraphs.set(subgraph.graph.id, subgraph);
+            graphNameToIdMap[subgraph.graph.name] = subgraph.graph.id;
         },
         getGraph(id) {
-            return state.graphs.get(id);
+            return state.subgraphs.get(id);
         },
         visitSubgraphState(subgraphState) {
+            subgraphStates.set(subgraphState.graph.id, subgraphState);
             for (const link of subgraphState.links) {
                 state.links.push(linkWithGraph(link, subgraphState.graph.id));
             }
@@ -106,15 +105,14 @@ export function createSupergraphStateBuilder() {
         getSupergraphState() {
             return state;
         },
+        getSubgraphState(graphId) {
+            return subgraphStates.get(graphId);
+        },
         links() {
             return mergeLinks(state.links);
         },
         build() {
             const transformFields = createFieldsTransformer(state);
-            const graphNameToIdMap = {};
-            for (const [id, graph] of state.graphs) {
-                graphNameToIdMap[graph.name] = id;
-            }
             const helpers = {
                 graphNameToId(graphName) {
                     return graphNameToIdMap[graphName] ?? null;
@@ -131,31 +129,31 @@ export function createSupergraphStateBuilder() {
                 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 ?? '',
+            nodes[i++] = createJoinGraphEnumTypeNode(Array.from(state.subgraphs.values()).map(subgraph => ({
+                name: subgraph.graph.name,
+                enumValue: subgraph.graph.id,
+                url: subgraph.graph.url ?? '',
             })));
             for (const directiveState of state.directives.values()) {
-                nodes[i++] = directive.composeSupergraphNode(directiveState, state.graphs, helpers);
+                nodes[i++] = directive.composeSupergraphNode(directiveState, state.subgraphs, helpers);
             }
             for (const scalarTypeState of state.scalarTypes.values()) {
-                nodes[i++] = scalarType.composeSupergraphNode(scalarTypeState, state.graphs, helpers);
+                nodes[i++] = scalarType.composeSupergraphNode(scalarTypeState, state.subgraphs, helpers);
             }
             for (const objectTypeState of state.objectTypes.values()) {
-                nodes[i++] = objectType.composeSupergraphNode(transformFields(objectTypeState), state.graphs, helpers);
+                nodes[i++] = objectType.composeSupergraphNode(transformFields(objectTypeState), state.subgraphs, helpers);
             }
             for (const interfaceTypeState of state.interfaceTypes.values()) {
-                nodes[i++] = interfaceType.composeSupergraphNode(interfaceTypeState, state.graphs, helpers);
+                nodes[i++] = interfaceType.composeSupergraphNode(interfaceTypeState, state.subgraphs, helpers);
             }
             for (const unionTypeState of state.unionTypes.values()) {
-                nodes[i++] = unionType.composeSupergraphNode(unionTypeState, state.graphs, helpers);
+                nodes[i++] = unionType.composeSupergraphNode(unionTypeState, state.subgraphs, helpers);
             }
             for (const enumTypeState of state.enumTypes.values()) {
-                nodes[i++] = enumType.composeSupergraphNode(enumTypeState, state.graphs, helpers);
+                nodes[i++] = enumType.composeSupergraphNode(enumTypeState, state.subgraphs, helpers);
             }
             for (const inputObjectTypeState of state.inputObjectTypes.values()) {
-                nodes[i++] = inputObjectType.composeSupergraphNode(inputObjectTypeState, state.graphs, helpers);
+                nodes[i++] = inputObjectType.composeSupergraphNode(inputObjectTypeState, state.subgraphs, helpers);
             }
             return nodes;
         },

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

@@ -1,4 +1,5 @@
 import { GraphQLError } from 'graphql';
+import { TypeKind } from '../../../subgraph/state.js';
 function stripNonNull(type) {
     return type.replace(/!$/, '');
 }
@@ -33,7 +34,28 @@ export function FieldsOfTheSameTypeRule(context) {
     return {
         ObjectTypeField(objectTypeState, fieldState) {
             const typeToGraphs = new Map();
+            const typeNameToPossibleTypeNames = new Map();
             fieldState.byGraph.forEach((field, graphName) => {
+                const typeName = field.type.replaceAll('!', '').replaceAll('[', '').replaceAll(']', '');
+                const typeState = context.subgraphStates.get(graphName)?.types.get(typeName);
+                if (typeState?.kind === TypeKind.UNION) {
+                    if (!typeNameToPossibleTypeNames.has(typeName)) {
+                        typeNameToPossibleTypeNames.set(typeName, new Set());
+                    }
+                    const list = typeNameToPossibleTypeNames.get(typeName);
+                    typeState.members.forEach(member => {
+                        list.add(member);
+                    });
+                }
+                else if (typeState?.kind === TypeKind.INTERFACE) {
+                    if (!typeNameToPossibleTypeNames.has(typeName)) {
+                        typeNameToPossibleTypeNames.set(typeName, new Set());
+                    }
+                    const list = typeNameToPossibleTypeNames.get(typeName);
+                    typeState.implementedBy.forEach(member => {
+                        list.add(member);
+                    });
+                }
                 const normalizedOutputTypes = normalizeOutputTypeStrings({
                     superType: fieldState.type,
                     localType: field.type,
@@ -50,6 +72,19 @@ export function FieldsOfTheSameTypeRule(context) {
                 }
             });
             if (typeToGraphs.size > 1) {
+                if (typeNameToPossibleTypeNames.size === 1) {
+                    const possibleTypeNames = [];
+                    typeNameToPossibleTypeNames.forEach((list, unionOrInterfaceName) => {
+                        possibleTypeNames.push(unionOrInterfaceName);
+                        for (const typeName of list) {
+                            possibleTypeNames.push(typeName);
+                        }
+                    });
+                    const outputTypeNames = Array.from(typeToGraphs.keys()).map(t => t.replaceAll('!', '').replaceAll('[', '').replaceAll(']', ''));
+                    if (outputTypeNames.every(t => possibleTypeNames.includes(t))) {
+                        return;
+                    }
+                }
                 const groups = Array.from(typeToGraphs.entries()).map(([outputType, graphs]) => {
                     const plural = graphs.length > 1 ? 's' : '';
                     return `type "${outputType}" in subgraph${plural} "${graphs

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

@@ -33,7 +33,10 @@ export function InvalidFieldSharingRule(context) {
                         continue;
                     }
                 }
-                if (fieldIsShareable || fieldIsUsedAsKey) {
+                const fedV1FieldInExtension = field.version === 'v1.0' && field.extension;
+                if (fieldIsShareable ||
+                    fieldIsUsedAsKey ||
+                    (objectTypeState.isEntity && fedV1FieldInExtension)) {
                     resolvableIn.push(graphId);
                     continue;
                 }

package/esm/supergraph/validation/rules/satisfiablity/constants.js

@@ -0,0 +1 @@
+export const SUPERGRAPH_ID = Symbol('__supergraph__');

package/esm/supergraph/validation/rules/satisfiablity/edge.js

@@ -0,0 +1,54 @@
+import { lazy } from './helpers';
+import { AbstractMove, EntityMove, FieldMove } from './moves';
+export function isEntityEdge(edge) {
+    return edge.move instanceof EntityMove;
+}
+export function assertEntityEdge(edge) {
+    if (!isEntityEdge(edge)) {
+        throw new Error(`Expected edge to be Edge<EntityMove>, but got ${edge}`);
+    }
+}
+export function isAbstractEdge(edge) {
+    return edge.move instanceof AbstractMove;
+}
+export function assertAbstractEdge(edge) {
+    if (!isAbstractEdge(edge)) {
+        throw new Error(`Expected edge to be Edge<AbstractMove>, but got ${edge}`);
+    }
+}
+export function isFieldEdge(edge) {
+    return edge.move instanceof FieldMove;
+}
+export function assertFieldEdge(edge) {
+    if (!isFieldEdge(edge)) {
+        throw new Error(`Expected edge to be Edge<FieldMove>, but got ${edge}`);
+    }
+}
+export class Edge {
+    head;
+    move;
+    tail;
+    resolvable = [];
+    _toString = lazy(() => `${this.head} -(${this.move})-> ${this.tail}`);
+    constructor(head, move, tail) {
+        this.head = head;
+        this.move = move;
+        this.tail = tail;
+    }
+    isCrossGraphEdge() {
+        return this.head.graphId !== this.tail.graphId;
+    }
+    toString() {
+        return this._toString.get();
+    }
+    getResolvability(graphNames) {
+        return this.resolvable.find(([checkedGraphNames]) => {
+            return checkedGraphNames.every(name => graphNames.includes(name));
+        })?.[1];
+    }
+    setResolvable(success, graphNames, error) {
+        const result = success ? { success, error: undefined } : { success, error: error };
+        this.resolvable.push([graphNames, result]);
+        return result;
+    }
+}

package/esm/supergraph/validation/rules/satisfiablity/errors.js

@@ -0,0 +1,40 @@
+export class SatisfiabilityError extends Error {
+    kind;
+    sourceGraphName;
+    typeName;
+    fieldName;
+    static forKey(sourceGraphName, targetGraphName, typeName, keyFields) {
+        return new SatisfiabilityError('KEY', sourceGraphName, typeName, null, `cannot move to subgraph "${targetGraphName}" using @key(fields: "${keyFields}") of "${typeName}", the key field(s) cannot be resolved from subgraph "${sourceGraphName}".`);
+    }
+    static forRequire(sourceGraphName, typeName, fieldName) {
+        return new SatisfiabilityError('REQUIRE', sourceGraphName, typeName, fieldName, `cannot satisfy @require conditions on field "${typeName}.${fieldName}".`);
+    }
+    static forExternal(sourceGraphName, typeName, fieldName) {
+        return new SatisfiabilityError('EXTERNAL', sourceGraphName, typeName, fieldName, `field "${typeName}.${fieldName}" is not resolvable because marked @external.`);
+    }
+    static forMissingField(sourceGraphName, typeName, fieldName) {
+        return new SatisfiabilityError('MISSING_FIELD', sourceGraphName, typeName, fieldName, `cannot find field "${typeName}.${fieldName}".`);
+    }
+    static forNoKey(sourceGraphName, targetGraphName, typeName, fieldName) {
+        return new SatisfiabilityError('NO_KEY', sourceGraphName, typeName, fieldName, `cannot move to subgraph "${targetGraphName}", which has field "${typeName}.${fieldName}", because type "${typeName}" has no @key defined in subgraph "${targetGraphName}".`);
+    }
+    constructor(kind, sourceGraphName, typeName, fieldName, message) {
+        super(message);
+        this.kind = kind;
+        this.sourceGraphName = sourceGraphName;
+        this.typeName = typeName;
+        this.fieldName = fieldName;
+    }
+    isMatchingField(typeName, fieldName) {
+        if (this.typeName !== typeName) {
+            return false;
+        }
+        if (this.fieldName) {
+            return this.fieldName === fieldName;
+        }
+        return true;
+    }
+    toString() {
+        return this.message;
+    }
+}

package/esm/supergraph/validation/rules/satisfiablity/fields.js

@@ -0,0 +1,142 @@
+import { Kind } from 'graphql';
+import { parseFields } from '../../../../subgraph/helpers';
+import { stripTypeModifiers } from '../../../../utils/state';
+export class Fields {
+    typeName;
+    source;
+    fields;
+    constructor(typeName, source, fields) {
+        this.typeName = typeName;
+        this.source = source;
+        this.fields = fields;
+    }
+    contains(typeName, fieldName) {
+        return this._contains(typeName, fieldName, this.fields);
+    }
+    equals(other) {
+        if (this.typeName !== other.typeName) {
+            return false;
+        }
+        if (this.source === other.source) {
+            return true;
+        }
+        return this._fieldsEqual(this.fields, other.fields);
+    }
+    _fieldsEqual(fields, otherFields) {
+        if (fields.length !== otherFields.length) {
+            return false;
+        }
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            const otherField = otherFields[i];
+            if (field.typeName !== otherField.typeName || field.fieldName !== otherField.fieldName) {
+                return false;
+            }
+            const areEqual = Array.isArray(field.selectionSet) && Array.isArray(otherField.selectionSet)
+                ? this._fieldsEqual(field.selectionSet, otherField.selectionSet)
+                : field.selectionSet === otherField.selectionSet;
+            if (!areEqual) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _contains(typeName, fieldName, fields) {
+        return fields.some(f => (f.typeName === typeName && f.fieldName === fieldName) ||
+            (f.selectionSet ? this._contains(typeName, fieldName, f.selectionSet) : false));
+    }
+    toString() {
+        return this.source;
+    }
+}
+export class FieldsResolver {
+    supergraphState;
+    cache = new Map();
+    constructor(supergraphState) {
+        this.supergraphState = supergraphState;
+    }
+    resolve(typeName, keyFields) {
+        const key = this.keyFactory(typeName, keyFields);
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const typeState = this.supergraphState.objectTypes.get(typeName);
+        if (!typeState) {
+            throw new Error(`Expected an object type when resolving keyFields of ${typeName}`);
+        }
+        const selectionSetNode = parseFields(keyFields);
+        if (!selectionSetNode) {
+            throw new Error(`Expected a selection set when resolving keyFields of ${typeName}`);
+        }
+        const fields = new Fields(typeName, keyFields, this.resolveSelectionSetNode(typeName, selectionSetNode));
+        this.cache.set(key, fields);
+        return fields;
+    }
+    keyFactory(typeName, keyFields) {
+        return `${typeName}/${keyFields}`;
+    }
+    resolveFieldNode(typeName, fieldNode, fields) {
+        const typeState = this.supergraphState.objectTypes.get(typeName) ??
+            this.supergraphState.interfaceTypes.get(typeName);
+        if (!typeState) {
+            throw new Error(`Type "${typeName}" is not defined.`);
+        }
+        if (fieldNode.name.value === '__typename') {
+            return;
+        }
+        if (!typeState.fields.has(fieldNode.name.value)) {
+            throw new Error(`Type "${typeName.toString()}" does not have field "${fieldNode.name.value}".`);
+        }
+        if (fieldNode.selectionSet) {
+            const outputType = stripTypeModifiers(typeState.fields.get(fieldNode.name.value).type);
+            fields.push({
+                fieldName: fieldNode.name.value,
+                typeName,
+                selectionSet: this.resolveSelectionSetNode(outputType, fieldNode.selectionSet),
+            });
+        }
+        else {
+            fields.push({
+                typeName,
+                fieldName: fieldNode.name.value,
+                selectionSet: null,
+            });
+        }
+    }
+    resolveInlineFragmentNode(fragmentNode, fields) {
+        if (!fragmentNode.typeCondition?.name.value) {
+            throw new Error(`Inline fragment without type condition is not supported.`);
+        }
+        const typeName = fragmentNode.typeCondition.name.value;
+        const typeState = this.supergraphState.objectTypes.get(typeName) ??
+            this.supergraphState.interfaceTypes.get(typeName);
+        if (!typeState) {
+            throw new Error(`Type "${typeName}" is not defined.`);
+        }
+        for (const selection of fragmentNode.selectionSet.selections) {
+            if (selection.kind === Kind.FIELD) {
+                this.resolveFieldNode(typeName, selection, fields);
+            }
+            else {
+                throw new Error(`Inline fragment within an inline fragment is not supported.`);
+            }
+        }
+    }
+    resolveSelectionSetNode(typeName, selectionSetNode, fields = []) {
+        for (const selection of selectionSetNode.selections) {
+            if (selection.kind === Kind.FIELD) {
+                this.resolveFieldNode(typeName, selection, fields);
+            }
+            else if (selection.kind === Kind.INLINE_FRAGMENT) {
+                this.resolveInlineFragmentNode(selection, fields);
+            }
+            else {
+                throw new Error(`Fragment spread is not supported.`);
+            }
+        }
+        return this.sortFields(fields);
+    }
+    sortFields(fields) {
+        return fields.sort((a, b) => `${a.typeName}.${a.fieldName}`.localeCompare(`${b.typeName}.${b.fieldName}`));
+    }
+}