@theguild/federation-composition 0.10.1 → 0.11.0-alpha-20240315131906-9fcd4e6

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

@@ -5,6 +5,7 @@ const graphql_1 = require("graphql");
 const federation_js_1 = require("../../specifications/federation.js");
 const link_js_1 = require("../../specifications/link.js");
 const state_js_1 = require("../../utils/state.js");
+const version_js_1 = require("../../utils/version.js");
 const state_js_2 = require("../state.js");
 const linkSpec = (0, graphql_1.parse)(link_js_1.sdl);
 const linkSpecDirectives = linkSpec.definitions.filter((def) => def.kind === graphql_1.Kind.DIRECTIVE_DEFINITION);
@@ -180,16 +181,7 @@ function createSubgraphValidationContext(subgraph, federation, typeNodeInfo, sta
             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;
+            return (0, version_js_1.satisfiesVersionRange)(version, range);
         },
         getKnownFederationDirectives() {
             return knownSpec.directives;
@@ -268,8 +260,12 @@ function createSubgraphValidationContext(subgraph, federation, typeNodeInfo, sta
             return unused.filter(coordinate => {
                 const [typeName, fieldName] = coordinate.split('.');
                 const typeDef = stateBuilder.state.types.get(typeName);
-                if (typeDef && typeDef.kind === state_js_2.TypeKind.OBJECT) {
+                if (!typeDef) {
+                    return true;
+                }
+                if (typeDef.kind === state_js_2.TypeKind.OBJECT && !stateBuilder.isInterfaceObject(typeName)) {
                     const fieldDef = typeDef.fields.get(fieldName);
+                    debugger;
                     if (fieldDef) {
                         const outputTypeName = (0, state_js_1.stripTypeModifiers)(fieldDef.type);
                         const outputType = stateBuilder.state.types.get(outputTypeName);
@@ -277,6 +273,17 @@ function createSubgraphValidationContext(subgraph, federation, typeNodeInfo, sta
                             return false;
                         }
                     }
+                    for (const interfaceName of typeDef.interfaces) {
+                        const iDef = stateBuilder.state.types.get(interfaceName);
+                        if (!iDef) {
+                            continue;
+                        }
+                        if (iDef.kind === state_js_2.TypeKind.INTERFACE && iDef.fields.has(fieldName)) {
+                            if (iDef.fields.has(fieldName)) {
+                                return false;
+                            }
+                        }
+                    }
                 }
                 return true;
             });

package/cjs/supergraph/composition/interface-type.js

@@ -23,6 +23,9 @@ function interfaceTypeBuilder() {
             if (type.isDefinition) {
                 interfaceTypeState.hasDefinition = true;
             }
+            if (type.isInterfaceObject) {
+                interfaceTypeState.hasInterfaceObject = true;
+            }
             if (type.description && !interfaceTypeState.description) {
                 interfaceTypeState.description = type.description;
             }
@@ -31,11 +34,15 @@ function interfaceTypeBuilder() {
             });
             type.interfaces.forEach(interfaceName => interfaceTypeState.interfaces.add(interfaceName));
             type.implementedBy.forEach(objectTypeName => interfaceTypeState.implementedBy.add(objectTypeName));
+            if (type.keys.length) {
+                interfaceTypeState.isEntity = true;
+            }
             interfaceTypeState.byGraph.set(graph.id, {
                 extension: type.extension,
                 keys: type.keys,
                 interfaces: type.interfaces,
                 implementedBy: type.implementedBy,
+                isInterfaceObject: type.isInterfaceObject,
                 version: graph.version,
             });
             for (const field of type.fields.values()) {
@@ -44,6 +51,9 @@ function interfaceTypeBuilder() {
                 if (!field.type.endsWith('!') && fieldState.type.endsWith('!')) {
                     fieldState.type = field.type;
                 }
+                if (field.isLeaf) {
+                    fieldState.isLeaf = true;
+                }
                 if (field.inaccessible) {
                     fieldState.inaccessible = true;
                 }
@@ -65,12 +75,19 @@ function interfaceTypeBuilder() {
                 field.ast.directives.forEach(directive => {
                     fieldState.ast.directives.push(directive);
                 });
+                const usedAsKey = type.fieldsUsedAsKeys.has(field.name);
+                if (usedAsKey) {
+                    fieldState.usedAsKey = true;
+                }
                 fieldState.byGraph.set(graph.id, {
                     type: field.type,
                     override: field.override,
                     provides: field.provides,
                     requires: field.requires,
                     version: graph.version,
+                    external: field.external,
+                    shareable: field.shareable,
+                    usedAsKey,
                 });
                 for (const arg of field.args.values()) {
                     const argState = getOrCreateArg(fieldState, arg.name, arg.type);
@@ -102,6 +119,27 @@ function interfaceTypeBuilder() {
             return (0, ast_js_1.createInterfaceTypeNode)({
                 name: interfaceType.name,
                 fields: Array.from(interfaceType.fields.values()).map(field => {
+                    let nonEmptyJoinField = false;
+                    const joinFields = [];
+                    if (field.byGraph.size !== interfaceType.byGraph.size) {
+                        for (const [graphId, meta] of field.byGraph.entries()) {
+                            if (meta.type !== field.type ||
+                                meta.override ||
+                                meta.provides ||
+                                meta.requires ||
+                                meta.external) {
+                                nonEmptyJoinField = true;
+                            }
+                            joinFields.push({
+                                graph: graphId,
+                                type: meta.type === field.type ? undefined : meta.type,
+                                override: meta.override ?? undefined,
+                                provides: meta.provides ?? undefined,
+                                requires: meta.requires ?? undefined,
+                                external: meta.external,
+                            });
+                        }
+                    }
                     return {
                         name: field.name,
                         type: field.type,
@@ -136,15 +174,7 @@ function interfaceTypeBuilder() {
                             };
                         }),
                         join: {
-                            field: field.byGraph.size === interfaceType.byGraph.size
-                                ? []
-                                : Array.from(field.byGraph.entries()).map(([graphName, meta]) => ({
-                                    graph: graphName.toUpperCase(),
-                                    type: meta.type === field.type ? undefined : meta.type,
-                                    override: meta.override ?? undefined,
-                                    provides: meta.provides ?? undefined,
-                                    requires: meta.requires ?? undefined,
-                                })),
+                            field: joinFields,
                         },
                     };
                 }),
@@ -166,6 +196,8 @@ function interfaceTypeBuilder() {
                                 graph: graphId,
                                 key: key.fields,
                                 extension: meta.extension,
+                                isInterfaceObject: meta.isInterfaceObject,
+                                resolvable: key.resolvable,
                             }));
                         }
                         return [
@@ -208,6 +240,8 @@ function getOrCreateInterfaceType(state, typeName) {
         policies: [],
         scopes: [],
         hasDefinition: false,
+        hasInterfaceObject: false,
+        isEntity: false,
         byGraph: new Map(),
         fields: new Map(),
         interfaces: new Set(),
@@ -227,6 +261,8 @@ function getOrCreateInterfaceField(interfaceTypeState, fieldName, fieldType) {
     const def = {
         name: fieldName,
         type: fieldType,
+        isLeaf: false,
+        usedAsKey: false,
         tags: new Set(),
         inaccessible: false,
         authenticated: false,

package/cjs/supergraph/composition/object-type.js

@@ -83,6 +83,9 @@ function objectTypeBuilder() {
                 if (shouldChangeType) {
                     fieldState.type = field.type;
                 }
+                if (field.isLeaf) {
+                    fieldState.isLeaf = true;
+                }
                 if (!fieldState.internal.seenNonExternal && !isExternal) {
                     fieldState.internal.seenNonExternal = true;
                 }
@@ -182,6 +185,7 @@ function objectTypeBuilder() {
                     })
                         .flat(1);
             const fieldNamesOfImplementedInterfaces = {};
+            const resolvableFieldsFromInterfaceObjects = [];
             for (const interfaceName of objectType.interfaces) {
                 const interfaceState = supergraphState.interfaceTypes.get(interfaceName);
                 if (!interfaceState) {
@@ -197,6 +201,12 @@ function objectTypeBuilder() {
                     else {
                         fieldNamesOfImplementedInterfaces[interfaceFieldName] = new Set(Array.from(interfaceField.byGraph.keys()));
                     }
+                    if (!interfaceState.hasInterfaceObject) {
+                        continue;
+                    }
+                    if (!resolvableFieldsFromInterfaceObjects.some(f => f.name === interfaceFieldName)) {
+                        resolvableFieldsFromInterfaceObjects.push(interfaceField);
+                    }
                 }
             }
             if (objectType.isEntity) {
@@ -439,7 +449,49 @@ function objectTypeBuilder() {
                         }),
                     };
                 })
-                    .filter(helpers_js_1.isDefined),
+                    .filter(helpers_js_1.isDefined)
+                    .concat(resolvableFieldsFromInterfaceObjects
+                    .filter(f => !objectType.fields.has(f.name))
+                    .map(field => {
+                    return {
+                        name: field.name,
+                        type: field.type,
+                        inaccessible: field.inaccessible,
+                        authenticated: field.authenticated,
+                        policies: field.policies,
+                        scopes: field.scopes,
+                        tags: Array.from(field.tags),
+                        description: field.description,
+                        deprecated: field.deprecated,
+                        ast: {
+                            directives: (0, common_js_1.convertToConst)(field.ast.directives),
+                        },
+                        join: {
+                            field: [{}],
+                        },
+                        arguments: Array.from(field.args.values())
+                            .filter(arg => {
+                            if (arg.byGraph.size !== field.byGraph.size) {
+                                return false;
+                            }
+                            return true;
+                        })
+                            .map(arg => {
+                            return {
+                                name: arg.name,
+                                type: arg.type,
+                                inaccessible: false,
+                                tags: Array.from(arg.tags),
+                                defaultValue: arg.defaultValue,
+                                description: arg.description,
+                                deprecated: arg.deprecated,
+                                ast: {
+                                    directives: (0, common_js_1.convertToConst)(arg.ast.directives),
+                                },
+                            };
+                        }),
+                    };
+                })),
                 interfaces: Array.from(objectType.interfaces),
                 tags: Array.from(objectType.tags),
                 inaccessible: objectType.inaccessible,
@@ -510,6 +562,7 @@ function getOrCreateField(objectTypeState, fieldName, fieldType) {
     const def = {
         name: fieldName,
         type: fieldType,
+        isLeaf: false,
         tags: new Set(),
         inaccessible: false,
         authenticated: false,

package/cjs/supergraph/composition/visitor.js

@@ -50,6 +50,13 @@ function visitSupergraphState(supergraphState, visitors) {
                 visitor.InterfaceType(interfaceTypeState);
             }
         }
+        for (const fieldState of interfaceTypeState.fields.values()) {
+            for (const visitor of visitors) {
+                if (visitor.InterfaceTypeField) {
+                    visitor.InterfaceTypeField(interfaceTypeState, fieldState);
+                }
+            }
+        }
     });
     supergraphState.directives.forEach(directiveState => {
         for (const visitor of visitors) {

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

@@ -2,15 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InterfaceKeyMissingImplementationTypeRule = void 0;
 const graphql_1 = require("graphql");
+const version_js_1 = require("../../../utils/version.js");
 function InterfaceKeyMissingImplementationTypeRule(context) {
     return {
         InterfaceType(interfaceState) {
+            if (!interfaceState.isEntity || interfaceState.hasInterfaceObject) {
+                return;
+            }
             let someSubgraphsAreMissingImplementation = false;
             for (const interfaceStateInGraph of interfaceState.byGraph.values()) {
+                if ((0, version_js_1.satisfiesVersionRange)(interfaceStateInGraph.version, '< v2.3')) {
+                    continue;
+                }
                 if (interfaceStateInGraph.keys.length === 0) {
                     continue;
                 }
-                if (interfaceStateInGraph.implementedBy.size === 0) {
+                if (interfaceStateInGraph.implementedBy.size === 0 &&
+                    !interfaceStateInGraph.isInterfaceObject) {
                     someSubgraphsAreMissingImplementation = true;
                     break;
                 }

package/cjs/supergraph/validation/rules/interface-object-usage-error.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceObjectUsageErrorRule = void 0;
+const graphql_1 = require("graphql");
+function InterfaceObjectUsageErrorRule(context) {
+    return {
+        InterfaceType(interfaceState) {
+            if (!interfaceState.hasInterfaceObject) {
+                return;
+            }
+            for (const [_, interfaceStateInGraph] of interfaceState.byGraph) {
+                if (!interfaceStateInGraph.isInterfaceObject) {
+                    return;
+                }
+            }
+            context.reportError(new graphql_1.GraphQLError(`Type "${interfaceState.name}" is declared with @interfaceObject in all the subgraphs in which is is defined`, {
+                extensions: {
+                    code: 'INTERFACE_OBJECT_USAGE_ERROR',
+                },
+            }));
+        },
+    };
+}
+exports.InterfaceObjectUsageErrorRule = InterfaceObjectUsageErrorRule;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidFieldSharingRule = void 0;
 const graphql_1 = require("graphql");
 const format_js_1 = require("../../../utils/format.js");
-function InvalidFieldSharingRule(context) {
+function InvalidFieldSharingRule(context, supergraphState) {
     return {
         ObjectTypeField(objectTypeState, fieldState) {
             if (Array.from(objectTypeState.byGraph.keys()).some(graph => context.subgraphStates.get(graph)?.schema.subscriptionType === objectTypeState.name)) {
@@ -46,9 +46,100 @@ function InvalidFieldSharingRule(context) {
                 nonSharableIn.push(graphId);
                 resolvableIn.push(graphId);
             }
+            const interfaceObjectFieldIn = [];
+            if (nonSharableIn.length > 0) {
+                for (const interfaceName of objectTypeState.interfaces) {
+                    const interfaceState = supergraphState.interfaceTypes.get(interfaceName);
+                    if (!interfaceState || !interfaceState.hasInterfaceObject) {
+                        continue;
+                    }
+                    const interfaceObjectFieldState = interfaceState.fields.get(fieldState.name);
+                    if (!interfaceObjectFieldState || interfaceObjectFieldState.usedAsKey) {
+                        continue;
+                    }
+                    for (const [graphId, field] of interfaceObjectFieldState.byGraph) {
+                        const isInterfaceObject = interfaceState.byGraph.get(graphId)?.isInterfaceObject === true;
+                        if (!isInterfaceObject) {
+                            continue;
+                        }
+                        const fieldIsShareable = field.shareable;
+                        const fieldIsExternal = field.external;
+                        const fieldHasOverride = field.override;
+                        const fieldIsUsedAsKey = field.usedAsKey;
+                        if (fieldIsExternal) {
+                            continue;
+                        }
+                        if (fieldHasOverride) {
+                            const overrideGraphId = context.graphNameToId(fieldHasOverride);
+                            if (overrideGraphId && fieldState.byGraph.has(overrideGraphId)) {
+                                continue;
+                            }
+                        }
+                        interfaceObjectFieldIn.push([graphId, interfaceName]);
+                        if (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 ${(0, format_js_1.andList)(resolvableIn.map(graphId => {
+                    const name = context.graphIdToName(graphId);
+                    const interfaceObjectField = interfaceObjectFieldIn.find(([g, _]) => g === graphId);
+                    if (!interfaceObjectField) {
+                        return `"${name}"`;
+                    }
+                    return `"${name}" (through @interfaceObject field "${interfaceObjectField[1]}.${fieldState.name}")`;
+                }), false)} and defined as non-shareable in ${isNonSharableInAll
+                    ? 'all of them'
+                    : `subgraph${nonSharableIn.length > 1 ? 's' : ''} ${(0, format_js_1.andList)(nonSharableIn.map(context.graphIdToName), true, '"')}`}`;
+                context.reportError(new graphql_1.GraphQLError(message, {
+                    extensions: {
+                        code: 'INVALID_FIELD_SHARING',
+                    },
+                }));
+            }
+        },
+        InterfaceTypeField(interfaceTypeState, fieldState) {
+            if (!interfaceTypeState.hasInterfaceObject) {
+                return;
+            }
+            const nonSharableIn = [];
+            const resolvableIn = [];
+            const interfaceObjectFieldIn = [];
+            for (const [graphId, field] of fieldState.byGraph) {
+                const isInterfaceObject = interfaceTypeState.byGraph.get(graphId)?.isInterfaceObject === true;
+                if (!isInterfaceObject) {
+                    continue;
+                }
+                const fieldIsShareable = field.shareable;
+                const fieldIsExternal = field.external;
+                const fieldHasOverride = field.override;
+                const fieldIsUsedAsKey = field.usedAsKey;
+                if (fieldIsExternal) {
+                    continue;
+                }
+                if (fieldHasOverride) {
+                    const overrideGraphId = context.graphNameToId(fieldHasOverride);
+                    if (overrideGraphId && fieldState.byGraph.has(overrideGraphId)) {
+                        continue;
+                    }
+                }
+                if (fieldIsShareable || fieldIsUsedAsKey) {
+                    resolvableIn.push(graphId);
+                    continue;
+                }
+                nonSharableIn.push(graphId);
+                resolvableIn.push(graphId);
+                interfaceObjectFieldIn.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 ${(0, format_js_1.andList)(resolvableIn.map(context.graphIdToName), false, '"')} and defined as non-shareable in ${isNonSharableInAll
+                const message = `Non-shareable field "${interfaceTypeState.name}.${fieldState.name}" is resolved from multiple subgraphs: it is resolved from subgraphs ${(0, format_js_1.andList)(resolvableIn.map(context.graphIdToName), false, '"')} and defined as non-shareable in ${isNonSharableInAll
                     ? 'all of them'
                     : `subgraph${nonSharableIn.length > 1 ? 's' : ''} ${(0, format_js_1.andList)(nonSharableIn.map(context.graphIdToName), true, '"')}`}`;
                 context.reportError(new graphql_1.GraphQLError(message, {

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

@@ -22,6 +22,15 @@ function OnlyInaccessibleChildrenRule(context) {
                 }));
             }
         },
+        InterfaceType(interfaceState) {
+            if (interfaceState.inaccessible === false && areAllInaccessible(interfaceState.fields)) {
+                context.reportError(new graphql_1.GraphQLError(`Type "${interfaceState.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)) {

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

@@ -21,6 +21,9 @@ class SatisfiabilityError extends Error {
     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}".`);
     }
+    static forNoImplementation(sourceGraphName, typeName) {
+        return new SatisfiabilityError('NO_IMPLEMENTATION', sourceGraphName, typeName, null, `no subgraph can be reached to resolve the implementation type of @interfaceObject type "${typeName}".`);
+    }
     constructor(kind, sourceGraphName, typeName, fieldName, message) {
         super(message);
         this.kind = kind;