@wundergraph/composition 0.29.0 → 0.29.2

package/dist/federation/federation-factory.js

@@ -26,13 +26,13 @@ class FederationFactory {
     concreteTypeNamesByAbstractTypeName;
     clientDefinitions = [constants_1.DEPRECATED_DEFINITION];
     currentSubgraphName = '';
+    subgraphNamesByNamedTypeNameByFieldCoordinates = new Map();
     entityDataByTypeName;
     entityInterfaceFederationDataByTypeName;
     errors = [];
     fieldConfigurationByFieldPath = new Map();
-    graphEdges = new Set();
-    graphPaths = new Map();
     inaccessiblePaths = new Set();
+    isMaxDepth = false;
     internalGraph;
     internalSubgraphBySubgraphName;
     invalidOrScopesHostPaths = new Set();
@@ -54,7 +54,6 @@ class FederationFactory {
     routerDefinitions = [constants_1.DEPRECATED_DEFINITION, constants_1.TAG_DEFINITION];
     shareableErrorTypeNames = new Map();
     subscriptionFilterDataByFieldPath = new Map();
-    isMaxDepth = false;
     tagNamesByPath = new Map();
     warnings;
     constructor(options) {
@@ -390,6 +389,83 @@ class FederationFactory {
             });
         }
     }
+    federateOutputType({ current, other, hostPath, mostRestrictive }) {
+        other = (0, ast_1.getMutableTypeNode)(other, hostPath, this.errors); // current is already a deep copy
+        // The first type of the pair to diverge in restriction takes precedence in all future differences.
+        // If the other type of the pair also diverges, it's a src error.
+        // To keep the output link intact, it is not possible to spread assign "lastTypeNode".
+        const federatedTypeNode = { kind: current.kind };
+        let divergentType = type_merging_1.DivergentType.NONE;
+        let lastTypeNode = federatedTypeNode;
+        for (let i = 0; i < integer_constants_1.MAXIMUM_TYPE_NESTING; i++) {
+            if (current.kind === other.kind) {
+                switch (current.kind) {
+                    case graphql_1.Kind.NAMED_TYPE:
+                        lastTypeNode.kind = current.kind;
+                        lastTypeNode.name = current.name;
+                        return { success: true, typeNode: federatedTypeNode };
+                    case graphql_1.Kind.LIST_TYPE:
+                        lastTypeNode.kind = current.kind;
+                        lastTypeNode.type = { kind: current.type.kind };
+                        lastTypeNode = lastTypeNode.type;
+                        current = current.type;
+                        other = other.type;
+                        continue;
+                    case graphql_1.Kind.NON_NULL_TYPE:
+                        lastTypeNode.kind = current.kind;
+                        lastTypeNode.type = { kind: current.type.kind };
+                        lastTypeNode = lastTypeNode.type;
+                        current = current.type;
+                        other = other.type;
+                        continue;
+                }
+            }
+            if (current.kind === graphql_1.Kind.NON_NULL_TYPE) {
+                if (divergentType === type_merging_1.DivergentType.OTHER) {
+                    this.errors.push((0, errors_1.incompatibleChildTypesError)(hostPath, current.kind, other.kind));
+                    return { success: false };
+                }
+                else {
+                    divergentType = type_merging_1.DivergentType.CURRENT;
+                }
+                if (mostRestrictive) {
+                    lastTypeNode.kind = current.kind;
+                    lastTypeNode.type = { kind: current.type.kind };
+                    lastTypeNode = lastTypeNode.type;
+                }
+                current = current.type;
+                continue;
+            }
+            if (other.kind === graphql_1.Kind.NON_NULL_TYPE) {
+                if (divergentType === type_merging_1.DivergentType.CURRENT) {
+                    this.errors.push((0, errors_1.incompatibleChildTypesError)(hostPath, current.kind, other.kind));
+                    return { success: false };
+                }
+                else {
+                    divergentType = type_merging_1.DivergentType.OTHER;
+                }
+                if (mostRestrictive) {
+                    lastTypeNode.kind = other.kind;
+                    lastTypeNode.type = { kind: other.type.kind };
+                    lastTypeNode = lastTypeNode.type;
+                }
+                other = other.type;
+                continue;
+            }
+            // At least one of the types must be a non-null wrapper, or the types are inconsistent
+            this.errors.push((0, errors_1.incompatibleChildTypesError)(hostPath, current.kind, other.kind));
+            return { success: false };
+        }
+        this.errors.push((0, errors_1.maximumTypeNestingExceededError)(hostPath));
+        return { success: false };
+    }
+    addSubgraphNameToExistingFieldNamedTypeDisparity(incomingData) {
+        const subgraphNamesByNamedTypeName = this.subgraphNamesByNamedTypeNameByFieldCoordinates.get(`${incomingData.renamedParentTypeName}.${incomingData.name}`);
+        if (!subgraphNamesByNamedTypeName) {
+            return;
+        }
+        (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, (0, utils_3.getValueOrDefault)(subgraphNamesByNamedTypeName, incomingData.namedTypeName, () => new Set()));
+    }
     upsertFieldData(fieldDataByFieldName, incomingData, isParentInaccessible) {
         const fieldPath = `${incomingData.renamedParentTypeName}.${incomingData.name}`;
         (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(fieldPath);
@@ -431,15 +507,36 @@ class FederationFactory {
             }
             return;
         }
-        const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingData.type, incomingData.type, fieldPath, this.errors);
-        if (typeNode) {
-            existingData.type = typeNode;
-        }
-        else {
-            if (!typeErrors || typeErrors.length < 2) {
-                throw (0, errors_1.fieldTypeMergeFatalError)(existingData.name);
+        const result = this.federateOutputType({
+            current: existingData.type,
+            other: incomingData.type,
+            hostPath: fieldPath,
+            mostRestrictive: false,
+        });
+        if (result.success) {
+            existingData.type = result.typeNode;
+            if (existingData.namedTypeName !== incomingData.namedTypeName) {
+                const subgraphNamesByNamedTypeName = (0, utils_3.getValueOrDefault)(this.subgraphNamesByNamedTypeNameByFieldCoordinates, `${existingData.renamedParentTypeName}.${existingData.name}`, () => new Map());
+                /* Only propagate the subgraph names of the existing data if it has never been propagated before.
+                 * This is to prevent the propagation of subgraph names where that named type is not returned.
+                 */
+                const existingSubgraphNames = (0, utils_3.getValueOrDefault)(subgraphNamesByNamedTypeName, existingData.namedTypeName, () => new Set());
+                if (existingSubgraphNames.size < 1) {
+                    // Add all subgraph names that are not the subgraph name in the incoming data
+                    for (const subgraphName of existingData.subgraphNames) {
+                        if (!incomingData.subgraphNames.has(subgraphName)) {
+                            existingSubgraphNames.add(subgraphName);
+                        }
+                    }
+                }
+                (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, (0, utils_3.getValueOrDefault)(subgraphNamesByNamedTypeName, incomingData.namedTypeName, () => new Set()));
+            }
+            else {
+                /* If the named types match but there has already been a disparity in the named type names returned by the
+                 * field, add the incoming subgraph name to the existing subgraph name set for that named type name.
+                 */
+                this.addSubgraphNameToExistingFieldNamedTypeDisparity(incomingData);
             }
-            this.errors.push((0, errors_1.incompatibleChildTypesError)(fieldPath, typeErrors[0], typeErrors[1]));
         }
         for (const [argumentName, inputValueData] of incomingData.argumentDataByArgumentName) {
             const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
@@ -693,9 +790,151 @@ class FederationFactory {
         existingData.repeatable &&= incomingData.repeatable;
         (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
     }
+    shouldUpdateFederatedFieldAbstractNamedType(abstractTypeName, objectTypeNames) {
+        if (!abstractTypeName) {
+            return false;
+        }
+        const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
+        if (!concreteTypeNames || concreteTypeNames.size < 1) {
+            return false;
+        }
+        for (const objectTypeName of objectTypeNames) {
+            if (!concreteTypeNames.has(objectTypeName)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    updateTypeNodeNamedType(typeNode, namedTypeName) {
+        let lastTypeNode = typeNode;
+        for (let i = 0; i < integer_constants_1.MAXIMUM_TYPE_NESTING; i++) {
+            if (lastTypeNode.kind === graphql_1.Kind.NAMED_TYPE) {
+                lastTypeNode.name = (0, utils_1.stringToNameNode)(namedTypeName);
+                return;
+            }
+            lastTypeNode = lastTypeNode.type;
+        }
+    }
+    handleDisparateFieldNamedTypes() {
+        for (const [fieldCoordinates, subgraphNamesByNamedTypeName] of this
+            .subgraphNamesByNamedTypeNameByFieldCoordinates) {
+            const coordinates = fieldCoordinates.split(string_constants_1.PERIOD);
+            if (coordinates.length !== 2) {
+                continue;
+            }
+            const compositeOutputData = this.parentDefinitionDataByTypeName.get(coordinates[0]);
+            if (!compositeOutputData) {
+                this.errors.push((0, errors_1.undefinedTypeError)(coordinates[0]));
+                continue;
+            }
+            // This error should never happen
+            if (compositeOutputData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
+                compositeOutputData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.unexpectedNonCompositeOutputTypeError)(coordinates[0], (0, utils_3.kindToTypeString)(compositeOutputData.kind)));
+                continue;
+            }
+            const fieldData = compositeOutputData.fieldDataByFieldName.get(coordinates[1]);
+            // This error should never happen
+            if (!fieldData) {
+                this.errors.push((0, errors_1.unknownFieldDataError)(fieldCoordinates));
+                continue;
+            }
+            const interfaceDataByTypeName = new Map();
+            const objectTypeNames = new Set();
+            let unionTypeName = '';
+            for (const namedTypeName of subgraphNamesByNamedTypeName.keys()) {
+                if (constants_1.BASE_SCALARS.has(namedTypeName)) {
+                    this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                    break;
+                }
+                const namedTypeData = this.parentDefinitionDataByTypeName.get(namedTypeName);
+                // This error should never happen
+                if (!namedTypeData) {
+                    this.errors.push((0, errors_1.unknownNamedTypeError)(fieldCoordinates, namedTypeName));
+                    break;
+                }
+                switch (namedTypeData.kind) {
+                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION: {
+                        interfaceDataByTypeName.set(namedTypeData.name, namedTypeData);
+                        break;
+                    }
+                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION: {
+                        objectTypeNames.add(namedTypeData.name);
+                        /* Multiple shared Field instances can explicitly return the same Object named type across subgraphs.
+                         * However, the Field is invalid if *any* of the other shared Field instances return a different Object named
+                         * type, even if each of those Objects named types could be coerced into the same mutual abstract type.
+                         * This is because it would be impossible to return identical data from each subgraph if one shared Field
+                         * instance explicitly returns a different Object named type to another shared Field instance.
+                         */
+                        if (objectTypeNames.size > 1) {
+                            this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                            continue;
+                        }
+                        break;
+                    }
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION: {
+                        if (unionTypeName) {
+                            this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                            continue;
+                        }
+                        unionTypeName = namedTypeName;
+                        break;
+                    }
+                    default: {
+                        this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                        break;
+                    }
+                }
+            }
+            if (interfaceDataByTypeName.size < 0 && !unionTypeName) {
+                this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                continue;
+            }
+            /* Default to the Union type name.
+             * If more than one type of abstract type is returned, an error will be propagated.
+             */
+            let abstractTypeName = unionTypeName;
+            if (interfaceDataByTypeName.size > 0) {
+                if (unionTypeName) {
+                    this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                    continue;
+                }
+                /* If there is more than one Interface, there must be an origin Interface.
+                 * This is the "mutual Interface" that all the other Interfaces implement.
+                 */
+                for (const interfaceTypeName of interfaceDataByTypeName.keys()) {
+                    abstractTypeName = interfaceTypeName;
+                    for (const [comparisonTypeName, comparisonData] of interfaceDataByTypeName) {
+                        if (interfaceTypeName === comparisonTypeName) {
+                            continue;
+                        }
+                        if (!comparisonData.implementedInterfaceTypeNames.has(interfaceTypeName)) {
+                            abstractTypeName = '';
+                            break;
+                        }
+                    }
+                    if (abstractTypeName) {
+                        break;
+                    }
+                }
+            }
+            /* If the abstract type is:
+             * 1. An Interface: each returned Object types must implement that origin Interface.
+             * 2. A Union: all returned Object types must be Member of that Union.
+             * 3. Invalid (empty string): return an error
+             */
+            if (!this.shouldUpdateFederatedFieldAbstractNamedType(abstractTypeName, objectTypeNames)) {
+                this.errors.push((0, errors_1.incompatibleFederatedFieldNamedTypeError)(fieldCoordinates, subgraphNamesByNamedTypeName));
+                continue;
+            }
+            fieldData.namedTypeName = abstractTypeName;
+            this.updateTypeNodeNamedType(fieldData.type, abstractTypeName);
+        }
+    }
     /* federateInternalSubgraphData is responsible for merging each subgraph TypeScript representation of a GraphQL type
-     ** into a single representation.
-     ** This method is always necessary, regardless of whether federating a source graph or contract graph. */
+     * into a single representation.
+     * This method is always necessary, regardless of whether federating a source graph or contract graph.
+     * */
     federateInternalSubgraphData() {
         let subgraphNumber = 0;
         let shouldSkipPersistedExecutableDirectives = false;
@@ -725,6 +964,7 @@ class FederationFactory {
                 shouldSkipPersistedExecutableDirectives = true;
             }
         }
+        this.handleDisparateFieldNamedTypes();
     }
     handleInterfaceObjectForInternalGraph({ entityData, internalSubgraph, interfaceObjectData, interfaceObjectNode, resolvableKeyFieldSets, subgraphName, }) {
         const entityGraphNode = this.internalGraph.addOrUpdateNode(entityData.typeName);
@@ -1080,6 +1320,20 @@ class FederationFactory {
             constants_1.SCOPE_SCALAR_DEFINITION,
         ];
     }
+    validatePathSegmentInaccessibility(path) {
+        const segments = path.split(string_constants_1.PERIOD);
+        if (segments.length < 1) {
+            return false;
+        }
+        let segment = segments[0];
+        for (let i = 1; i < segments.length; i++) {
+            if (this.inaccessiblePaths.has(segment)) {
+                return true;
+            }
+            segment += `.${segments[i]}`;
+        }
+        return false;
+    }
     validateReferencesOfInaccessibleType(data) {
         const paths = this.pathsByNamedTypeName.get(data.name);
         if (!paths || paths.size < 1) {
@@ -1087,7 +1341,10 @@ class FederationFactory {
         }
         const invalidPaths = [];
         for (const path of paths) {
-            if (!this.inaccessiblePaths.has(path)) {
+            if (this.inaccessiblePaths.has(path)) {
+                continue;
+            }
+            if (!this.validatePathSegmentInaccessibility(path)) {
                 invalidPaths.push(path);
             }
         }