@theguild/federation-composition 0.6.2 → 0.7.0-alpha-20240104152841-c814a1f

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectTypeBuilder = exports.isRealExtension = void 0;
+const helpers_js_1 = require("../../utils/helpers.js");
 const ast_js_1 = require("./ast.js");
 const common_js_1 = require("./common.js");
 function isRealExtension(meta, version) {
@@ -50,6 +51,9 @@ function objectTypeBuilder() {
                 });
             }
             type.interfaces.forEach(interfaceName => objectTypeState.interfaces.add(interfaceName));
+            if (type.keys.length) {
+                objectTypeState.isEntity = true;
+            }
             objectTypeState.byGraph.set(graph.id, {
                 hasDefinition: isDefinition,
                 extension: type.extension,
@@ -74,8 +78,7 @@ function objectTypeBuilder() {
                 const shouldForceType = !usedAsKey && !isExternal && !fieldState.internal.seenNonExternal;
                 const shouldChangeType = shouldForceType ||
                     (!isExternal &&
-                        !field.type.endsWith('!') &&
-                        fieldState.type.endsWith('!'));
+                        fieldState.type.lastIndexOf('!') > field.type.lastIndexOf('!'));
                 if (shouldChangeType) {
                     fieldState.type = field.type;
                 }
@@ -94,12 +97,12 @@ function objectTypeBuilder() {
                 if (field.scopes) {
                     fieldState.scopes.push(...field.scopes);
                 }
-                if (field.override) {
-                    fieldState.override = field.override;
-                }
                 if (field.description && !fieldState.description) {
                     fieldState.description = field.description;
                 }
+                if (field.override) {
+                    fieldState.override = field.override;
+                }
                 if (field.deprecated && !fieldState.deprecated) {
                     fieldState.deprecated = field.deprecated;
                 }
@@ -110,6 +113,7 @@ function objectTypeBuilder() {
                     type: field.type,
                     external: field.external,
                     inaccessible: field.inaccessible,
+                    description: field.description ?? null,
                     override: field.override,
                     provides: field.provides,
                     requires: field.requires,
@@ -148,7 +152,7 @@ function objectTypeBuilder() {
                 }
             }
         },
-        composeSupergraphNode(objectType, graphs, { graphNameToId }) {
+        composeSupergraphNode(objectType, graphs, { graphNameToId, supergraphState }) {
             const isQuery = objectType.name === 'Query';
             const joinTypes = isQuery
                 ?
@@ -173,17 +177,91 @@ function objectTypeBuilder() {
                         ];
                     })
                         .flat(1);
+            const fieldNamesOfImplementedInterfaces = {};
+            for (const interfaceName of objectType.interfaces) {
+                const interfaceState = supergraphState.interfaceTypes.get(interfaceName);
+                if (!interfaceState) {
+                    throw new Error(`Interface "${interfaceName}" not found in Supergraph state`);
+                }
+                for (const [interfaceFieldName, interfaceField] of interfaceState.fields) {
+                    const found = fieldNamesOfImplementedInterfaces[interfaceFieldName];
+                    if (found) {
+                        for (const graphId of interfaceField.byGraph.keys()) {
+                            found.add(graphId);
+                        }
+                    }
+                    else {
+                        fieldNamesOfImplementedInterfaces[interfaceFieldName] = new Set(Array.from(interfaceField.byGraph.keys()));
+                    }
+                }
+            }
+            if (objectType.isEntity) {
+                for (const [_, field] of objectType.fields) {
+                    if (field.description) {
+                        if (field.override) {
+                            for (const [_, fieldInGraph] of field.byGraph) {
+                                if (fieldInGraph.override && !fieldInGraph.shareable) {
+                                    field.description = fieldInGraph.description ?? undefined;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            function shouldSetExternalOnJoinField(fieldStateInGraph, graphId, fieldState) {
+                if (!fieldStateInGraph.external) {
+                    return false;
+                }
+                if (fieldStateInGraph.provided) {
+                    return true;
+                }
+                if (fieldState.usedAsKey && objectType.byGraph.get(graphId).extension === true) {
+                    return false;
+                }
+                return true;
+            }
+            function createJoinFields(fieldInGraphs, field, { hasDifferentOutputType, overridesMap, }) {
+                return fieldInGraphs
+                    .map(([graphId, meta]) => {
+                    const type = hasDifferentOutputType ? meta.type : undefined;
+                    const override = meta.override ?? undefined;
+                    const usedOverridden = provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId);
+                    const external = shouldSetExternalOnJoinField(meta, graphId, field);
+                    const provides = meta.provides ?? undefined;
+                    const requires = meta.requires ?? undefined;
+                    const definesSomething = !!type || !!override || !!provides || !!requires || !!usedOverridden;
+                    const isRequiredOrProvided = meta.provided || meta.required;
+                    if (external &&
+                        objectType.byGraph.get(graphId).extension === true &&
+                        !definesSomething &&
+                        !isRequiredOrProvided) {
+                        return null;
+                    }
+                    return {
+                        graph: graphId,
+                        type,
+                        override,
+                        usedOverridden,
+                        external,
+                        provides,
+                        requires,
+                    };
+                })
+                    .filter(helpers_js_1.isDefined);
+            }
             return (0, ast_js_1.createObjectTypeNode)({
                 name: objectType.name,
                 ast: {
                     directives: (0, common_js_1.convertToConst)(objectType.ast.directives),
                 },
                 description: objectType.description,
-                fields: Array.from(objectType.fields.values()).map(field => {
+                fields: Array.from(objectType.fields.values())
+                    .map(field => {
                     const fieldInGraphs = Array.from(field.byGraph.entries());
                     const hasDifferentOutputType = fieldInGraphs.some(([_, meta]) => meta.type !== field.type);
                     const isDefinedEverywhere = field.byGraph.size === (isQuery ? graphs.size : objectType.byGraph.size);
                     let joinFields = [];
+                    const overridesMap = {};
                     const differencesBetweenGraphs = {
                         override: false,
                         type: false,
@@ -199,6 +277,10 @@ function objectTypeBuilder() {
                         }
                         if (meta.override !== null) {
                             differencesBetweenGraphs.override = true;
+                            const originalGraphId = graphNameToId(meta.override);
+                            if (originalGraphId) {
+                                overridesMap[originalGraphId] = graphId;
+                            }
                         }
                         if (meta.provides !== null) {
                             differencesBetweenGraphs.provides = true;
@@ -210,12 +292,30 @@ function objectTypeBuilder() {
                             differencesBetweenGraphs.type = true;
                         }
                     }
+                    if (!isQuery && field.byGraph.size === 1) {
+                        const graphId = field.byGraph.keys().next().value;
+                        const fieldInGraph = field.byGraph.get(graphId);
+                        if (fieldInGraph.external &&
+                            !fieldInGraph.usedAsKey &&
+                            !fieldInGraph.required &&
+                            !fieldInGraph.provided &&
+                            !provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId) &&
+                            graphs.get(graphId).version === 'v1.0') {
+                            return null;
+                        }
+                    }
                     if (isQuery) {
                         if (differencesBetweenGraphs.override) {
-                            const graphsWithOverride = fieldInGraphs.filter(([_, meta]) => meta.override !== null);
+                            const graphsWithOverride = fieldInGraphs.filter(([_, meta]) => meta.override !== null &&
+                                (objectType.byGraph.size > 1
+                                    ?
+                                        true
+                                    :
+                                        typeof graphNameToId(meta.override) === 'string'));
                             joinFields = graphsWithOverride.map(([graphId, meta]) => ({
                                 graph: graphId,
                                 override: meta.override ?? undefined,
+                                usedOverridden: provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId),
                                 type: differencesBetweenGraphs.type ? meta.type : undefined,
                                 external: meta.external ?? undefined,
                                 provides: meta.provides ?? undefined,
@@ -237,16 +337,23 @@ function objectTypeBuilder() {
                     else if (isDefinedEverywhere) {
                         const hasDifferencesBetweenGraphs = Object.values(differencesBetweenGraphs).some(value => value === true);
                         if (differencesBetweenGraphs.override) {
-                            const mutedGraphs = fieldInGraphs
+                            const overriddenGraphs = fieldInGraphs
                                 .map(([_, meta]) => (meta.override ? graphNameToId(meta.override) : null))
                                 .filter((graphId) => typeof graphId === 'string');
-                            const graphsToEmit = fieldInGraphs.filter(([graphId, f]) => f.external || !mutedGraphs.includes(graphId));
+                            const graphsToEmit = fieldInGraphs.filter(([graphId, f]) => {
+                                const isExternal = f.external === true;
+                                const isOverridden = overriddenGraphs.includes(graphId);
+                                const needsToPrintUsedOverridden = provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId);
+                                const isRequired = f.required === true;
+                                return (isExternal && isRequired) || needsToPrintUsedOverridden || !isOverridden;
+                            });
                             if (!(graphsToEmit.length === 1 &&
                                 joinTypes.length === 1 &&
                                 joinTypes[0].graph === graphsToEmit[0][0])) {
                                 joinFields = graphsToEmit.map(([graphId, meta]) => ({
                                     graph: graphId,
                                     override: meta.override ?? undefined,
+                                    usedOverridden: provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId),
                                     type: differencesBetweenGraphs.type ? meta.type : undefined,
                                     external: meta.external ?? undefined,
                                     provides: meta.provides ?? undefined,
@@ -255,27 +362,25 @@ function objectTypeBuilder() {
                             }
                         }
                         else if (hasDifferencesBetweenGraphs) {
-                            joinFields = fieldInGraphs.map(([graphId, meta]) => ({
-                                graph: graphId,
-                                type: differencesBetweenGraphs.type ? meta.type : undefined,
-                                override: meta.override ?? undefined,
-                                external: meta.external
-                                    ?
-                                        field.usedAsKey && objectType.byGraph.get(graphId).extension === true
-                                            ? false
-                                            : true
-                                    : undefined,
-                                provides: meta.provides ?? undefined,
-                                requires: meta.requires ?? undefined,
-                            }));
+                            joinFields = createJoinFields(fieldInGraphs, field, {
+                                hasDifferentOutputType,
+                                overridesMap,
+                            });
                         }
                     }
                     else {
                         if (differencesBetweenGraphs.override) {
-                            const graphsWithOverride = fieldInGraphs.filter(([_, meta]) => meta.override !== null);
-                            joinFields = graphsWithOverride.map(([graphId, meta]) => ({
+                            const overriddenGraphs = fieldInGraphs
+                                .map(([_, meta]) => (meta.override ? graphNameToId(meta.override) : null))
+                                .filter((graphId) => typeof graphId === 'string');
+                            const graphsToPrintJoinField = fieldInGraphs.filter(([graphId, meta]) => meta.override !== null ||
+                                meta.external === true ||
+                                (meta.shareable && !overriddenGraphs.includes(graphId)) ||
+                                provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId));
+                            joinFields = graphsToPrintJoinField.map(([graphId, meta]) => ({
                                 graph: graphId,
                                 override: meta.override ?? undefined,
+                                usedOverridden: provideUsedOverriddenValue(field.name, overridesMap, fieldNamesOfImplementedInterfaces, graphId),
                                 type: differencesBetweenGraphs.type ? meta.type : undefined,
                                 external: meta.external ?? undefined,
                                 provides: meta.provides ?? undefined,
@@ -283,14 +388,10 @@ function objectTypeBuilder() {
                             }));
                         }
                         else {
-                            joinFields = fieldInGraphs.map(([graphId, meta]) => ({
-                                graph: graphId,
-                                type: hasDifferentOutputType ? meta.type : undefined,
-                                override: meta.override ?? undefined,
-                                external: meta.external ?? undefined,
-                                provides: meta.provides ?? undefined,
-                                requires: meta.requires ?? undefined,
-                            }));
+                            joinFields = createJoinFields(fieldInGraphs, field, {
+                                hasDifferentOutputType,
+                                overridesMap,
+                            });
                         }
                     }
                     return {
@@ -313,6 +414,7 @@ function objectTypeBuilder() {
                                 !joinFields[0].override &&
                                 !joinFields[0].provides &&
                                 !joinFields[0].requires &&
+                                !joinFields[0].usedOverridden &&
                                 !joinFields[0].type
                                 ? []
                                 : joinFields,
@@ -339,7 +441,8 @@ function objectTypeBuilder() {
                             };
                         }),
                     };
-                }),
+                })
+                    .filter(helpers_js_1.isDefined),
                 interfaces: Array.from(objectType.interfaces),
                 tags: Array.from(objectType.tags),
                 inaccessible: objectType.inaccessible,
@@ -367,6 +470,18 @@ function objectTypeBuilder() {
     };
 }
 exports.objectTypeBuilder = objectTypeBuilder;
+function provideUsedOverriddenValue(fieldName, overridesMap, fieldNamesOfImplementedInterfaces, graphId) {
+    const inGraphs = fieldNamesOfImplementedInterfaces[fieldName];
+    const hasMatchingInterfaceFieldInGraph = inGraphs && inGraphs.has(graphId);
+    if (!hasMatchingInterfaceFieldInGraph) {
+        return false;
+    }
+    const hasOverride = typeof overridesMap[graphId] === 'string';
+    if (!hasOverride) {
+        return false;
+    }
+    return true;
+}
 function getOrCreateObjectType(state, typeName) {
     const existing = state.get(typeName);
     if (existing) {
@@ -376,6 +491,7 @@ function getOrCreateObjectType(state, typeName) {
         name: typeName,
         tags: new Set(),
         hasDefinition: false,
+        isEntity: false,
         inaccessible: false,
         authenticated: false,
         policies: [],

package/cjs/supergraph/state.js

@@ -122,6 +122,7 @@ function createSupergraphStateBuilder() {
                 graphNameToId(graphName) {
                     return graphNameToIdMap[graphName] ?? null;
                 },
+                supergraphState: state,
             };
             const numberOfExpectedNodes = state.directives.size +
                 state.scalarTypes.size +

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

@@ -10,7 +10,9 @@ function EnumValuesRule(context) {
                 const total = enumTypeState.byGraph.size;
                 for (const [valueName, valueState] of enumTypeState.values) {
                     if (valueState.byGraph.size !== total) {
-                        missingValues.push(valueName);
+                        if (!valueState.inaccessible) {
+                            missingValues.push(valueName);
+                        }
                     }
                 }
                 if (missingValues.length === 0) {

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

@@ -2,31 +2,54 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldsOfTheSameTypeRule = void 0;
 const graphql_1 = require("graphql");
+function stripNonNull(type) {
+    return type.replace(/!$/, '');
+}
+function stripList(type) {
+    const startsAt = type.indexOf('[');
+    const endsAt = type.lastIndexOf(']');
+    return type.slice(startsAt + 1, endsAt);
+}
+function normalizeOutputTypeStrings({ superType, localType, }) {
+    let superTypeNormalized = superType;
+    let localTypeNormalized = localType;
+    if (!superTypeNormalized.endsWith('!')) {
+        localTypeNormalized = stripNonNull(localTypeNormalized);
+    }
+    if (superTypeNormalized.startsWith('[') && localTypeNormalized.startsWith('[')) {
+        const innerSuper = stripList(superTypeNormalized);
+        let innerLocal = stripList(localTypeNormalized);
+        if (!innerSuper.endsWith('!')) {
+            innerLocal = stripNonNull(innerLocal);
+        }
+        const superSign = superTypeNormalized.endsWith('!') ? '!' : '';
+        const localSign = localTypeNormalized.endsWith('!') ? '!' : '';
+        superTypeNormalized = `[${innerSuper}]${superSign}`;
+        localTypeNormalized = `[${innerLocal}]${localSign}`;
+    }
+    return {
+        superType: superTypeNormalized,
+        localType: localTypeNormalized,
+    };
+}
 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);
+                const normalizedOutputTypes = normalizeOutputTypeStrings({
+                    superType: fieldState.type,
+                    localType: field.type,
+                });
+                const fieldOutputType = normalizedOutputTypes.superType === normalizedOutputTypes.localType
+                    ? normalizedOutputTypes.localType
+                    : field.type;
+                const existing = typeToGraphs.get(fieldOutputType);
                 if (existing) {
                     existing.push(graphName);
                 }
                 else {
-                    typeToGraphs.set(normalizedOutputType, [graphName]);
+                    typeToGraphs.set(fieldOutputType, [graphName]);
                 }
             });
             if (typeToGraphs.size > 1) {