@wundergraph/composition 0.55.0 → 0.56.0

package/dist/v1/normalization/normalization-factory.d.ts

@@ -1,4 +1,4 @@
-import { type ConstDirectiveNode, type ConstValueNode, type DirectiveDefinitionNode, type DocumentNode, type EnumValueDefinitionNode, type FieldDefinitionNode, type InputValueDefinitionNode, type InterfaceTypeDefinitionNode, type InterfaceTypeExtensionNode, Kind, type NamedTypeNode, type ObjectTypeDefinitionNode, type ObjectTypeExtensionNode, OperationTypeNode, type SchemaDefinitionNode, type SchemaExtensionNode, type TypeDefinitionNode, type TypeExtensionNode, type TypeNode } from 'graphql';
+import { type ConstDirectiveNode, type ConstValueNode, type DirectiveDefinitionNode, type DocumentNode, type EnumValueDefinitionNode, type FieldDefinitionNode, type InputValueDefinitionNode, type InterfaceTypeDefinitionNode, Kind, type NamedTypeNode, OperationTypeNode, type SchemaDefinitionNode, type SchemaExtensionNode, type TypeDefinitionNode, type TypeExtensionNode, type TypeNode } from 'graphql';
 import { type EnumTypeNode, type InputObjectTypeNode, type InterfaceTypeNode, type ObjectTypeNode, type ScalarTypeNode, type SchemaNode, type UnionTypeNode } from '../../ast/utils';
 import { type ConfigurationData, type Costs, type EventConfiguration, type NatsEventType, type RequiredFieldConfiguration } from '../../router-configuration/types';
 import { type AuthorizationData, type CompositeOutputData, type ConditionalFieldData, type EntityData, type EntityInterfaceSubgraphData, type EnumDefinitionData, ExtensionType, type FieldData, type InputObjectDefinitionData, type InputValueData, type NodeData, type ObjectDefinitionData, type ParentDefinitionData, type PersistedDirectiveDefinitionData, type ScalarDefinitionData, type SchemaData, type UnionDefinitionData } from '../../schema-building/types';
@@ -8,8 +8,8 @@ import { Graph } from '../../resolvability-graph/graph';
 import { type Warning } from '../../warnings/types';
 import { type BatchNormalizationResult, type NormalizationResult } from '../../normalization/types';
 import { type AddInputValueDataByNodeParams, type ConditionalFieldSetValidationResult, type ExtractArgumentDataResult, type FieldSetData, type FieldSetParentResult, type HandleCostDirectiveParams, type HandleListSizeDirectiveParams, type HandleOverrideDirectiveParams, type HandleRequiresScopesDirectiveParams, type HandleSemanticNonNullDirectiveParams, type KeyFieldSetData, type UpsertInputObjectResult, type ValidateDirectiveParams } from './types';
-import { type SubgraphName } from '../../types/types';
-import { type BatchNormalizeParams, type HandleFieldInheritableDirectivesParams, type NormalizationFactoryParams, type NormalizeSubgraphFromStringParams, type NormalizeSubgraphParams, type ValidateOneOfDirectiveParams } from './params';
+import { type AbstractTypeName, type SubgraphName, type TypeName } from '../../types/types';
+import { type BatchNormalizeParams, type HandleFieldInheritableDirectivesParams, type NormalizationFactoryParams, type NormalizeSubgraphFromStringParams, type NormalizeSubgraphParams, type SanitizeDefaultValueParams, type ValidateOneOfDirectiveParams } from './params';
 import type { CompositionOptions } from '../../types/params';
 export declare function normalizeSubgraphFromString({ noLocation, options, sdlString, }: NormalizeSubgraphFromStringParams): NormalizationResult;
 export declare function normalizeSubgraph({ document, internalGraph, options, subgraphName, }: NormalizeSubgraphParams): NormalizationResult;
@@ -32,6 +32,7 @@ export declare class NormalizationFactory {
     entityInterfaceDataByTypeName: Map<string, EntityInterfaceSubgraphData>;
     eventsConfigurations: Map<string, EventConfiguration[]>;
     fieldSetDataByTypeName: Map<string, FieldSetData>;
+    interfaceImplementationTypeNamesByInterfaceTypeName: Map<string, Set<string>>;
     internalGraph: Graph;
     invalidConfigureDescriptionNodeDatas: Array<NodeData>;
     invalidORScopesCoords: Set<string>;
@@ -62,6 +63,7 @@ export declare class NormalizationFactory {
     usesEdfsNatsStreamConfiguration: boolean;
     warnings: Array<Warning>;
     constructor({ internalGraph, options, subgraphName }: NormalizationFactoryParams);
+    sanitizeDefaultValue({ data, namedTypeData, node }: SanitizeDefaultValueParams): void;
     validateArguments(fieldData: FieldData, parentKind: Kind): void;
     isTypeNameRootType(typeName: string): boolean;
     isArgumentValueValid(typeNode: TypeNode, argumentValue: ConstValueNode): boolean;
@@ -73,9 +75,9 @@ export declare class NormalizationFactory {
     setParentDataExtensionType(parentData: ParentDefinitionData, incomingExtensionType: ExtensionType): void;
     extractConfigureDescriptionData(data: NodeData, directiveNode: ConstDirectiveNode): void;
     extractConfigureDescriptionsData(data: NodeData): void;
-    extractImplementedInterfaceTypeNames(node: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode | ObjectTypeDefinitionNode | ObjectTypeExtensionNode, implementedInterfaceTypeNames: Set<string>): Set<string>;
+    extractImplementedInterfaceTypeNames(node: InterfaceTypeNode | ObjectTypeNode, implementedInterfaceTypeNames: Set<AbstractTypeName>): Set<AbstractTypeName>;
     updateCompositeOutputDataByNode(node: CompositeOutputNode, data: CompositeOutputData, extensionType: ExtensionType): void;
-    addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames: Set<string>, concreteTypeName: string): void;
+    addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames: Set<AbstractTypeName>, concreteTypeName: TypeName): void;
     extractArguments(argumentDataByName: Map<string, InputValueData>, node: FieldDefinitionNode): Map<string, InputValueData>;
     addPersistedDirectiveDefinitionDataByNode(persistedDirectiveDefinitionDataByDirectiveName: Map<string, PersistedDirectiveDefinitionData>, node: DirectiveDefinitionNode, executableLocations: Set<string>): void;
     extractDirectiveLocations(node: DirectiveDefinitionNode, errorMessages: Array<string>): Set<string>;

package/dist/v1/normalization/normalization-factory.js

@@ -65,6 +65,7 @@ class NormalizationFactory {
     entityInterfaceDataByTypeName = new Map();
     eventsConfigurations = new Map();
     fieldSetDataByTypeName = new Map();
+    interfaceImplementationTypeNamesByInterfaceTypeName = new Map();
     internalGraph;
     invalidConfigureDescriptionNodeDatas = [];
     invalidORScopesCoords = new Set();
@@ -106,6 +107,27 @@ class NormalizationFactory {
             operationTypes: new Map(),
         };
     }
+    sanitizeDefaultValue({ data, namedTypeData, node }) {
+        if (!data.defaultValue) {
+            return;
+        }
+        if (!(0, utils_4.isEnumData)(namedTypeData)) {
+            return;
+        }
+        data.defaultValue = (0, graphql_1.visit)(data.defaultValue, {
+            StringValue: {
+                enter(node) {
+                    return {
+                        kind: graphql_1.Kind.ENUM,
+                        value: node.value,
+                    };
+                },
+            },
+        });
+        if (node) {
+            node.defaultValue = data.defaultValue;
+        }
+    }
     validateArguments(fieldData, parentKind) {
         for (const argumentData of fieldData.argumentDataByName.values()) {
             const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(argumentData.type);
@@ -120,6 +142,7 @@ class NormalizationFactory {
             }
             if ((0, utils_4.isInputNodeKind)(namedTypeData.kind)) {
                 argumentData.namedTypeKind = namedTypeData.kind;
+                this.sanitizeDefaultValue({ data: argumentData, namedTypeData, node: argumentData.node });
                 continue;
             }
             this.errors.push((0, errors_1.invalidNamedTypeError)({
@@ -193,7 +216,7 @@ class NormalizationFactory {
                             return true;
                         }
                         if (parentData.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
-                            if (argumentValue.kind !== graphql_1.Kind.ENUM) {
+                            if (argumentValue.kind !== graphql_1.Kind.ENUM && argumentValue.kind !== graphql_1.Kind.STRING) {
                                 return false;
                             }
                             const enumValue = parentData.enumValueDataByName.get(argumentValue.value);
@@ -405,6 +428,21 @@ class NormalizationFactory {
                 }
             }
             const requiredArgumentNames = [...definitionData.requiredArgumentNames];
+            for (const argumentNode of definitionData.node.arguments ?? []) {
+                if (!argumentNode.defaultValue) {
+                    continue;
+                }
+                const argumentData = definitionData.argumentTypeNodeByName.get(argumentNode.name.value);
+                if (!argumentData) {
+                    continue;
+                }
+                const namedTypeData = this.parentDefinitionDataByTypeName.get((0, ast_1.getTypeNodeNamedTypeName)(argumentData.typeNode));
+                // Undefined types are handled elsewhere
+                if (!namedTypeData) {
+                    continue;
+                }
+                this.sanitizeDefaultValue({ data: argumentData, namedTypeData, node: argumentNode });
+            }
             for (let i = 0; i < directiveNodes.length; i++) {
                 const errorMessages = this.validateDirective({
                     data,
@@ -543,6 +581,7 @@ class NormalizationFactory {
         if (!node.interfaces) {
             return implementedInterfaceTypeNames;
         }
+        const isInterface = (0, utils_4.isInterfaceNode)(node);
         const parentTypeName = node.name.value;
         for (const implementedInterface of node.interfaces) {
             const interfaceTypeName = implementedInterface.name.value;
@@ -550,6 +589,9 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.duplicateImplementedInterfaceError)((0, utils_3.kindToConvertedTypeString)(node.kind), parentTypeName, interfaceTypeName));
                 continue;
             }
+            if (isInterface) {
+                (0, utils_5.getValueOrDefault)(this.interfaceImplementationTypeNamesByInterfaceTypeName, interfaceTypeName, () => new Set()).add(parentTypeName);
+            }
             implementedInterfaceTypeNames.add(interfaceTypeName);
         }
         return implementedInterfaceTypeNames;
@@ -1550,7 +1592,12 @@ class NormalizationFactory {
                     unimplementedArguments: new Set(),
                 };
                 // The implemented field type must be equally or more restrictive than the original interface field type
-                if (!(0, utils_4.isTypeValidImplementation)(interfaceField.node.type, fieldData.node.type, this.concreteTypeNamesByAbstractTypeName)) {
+                if (!(0, utils_4.isTypeValidImplementation)({
+                    concreteTypeNamesByAbstractTypeName: this.concreteTypeNamesByAbstractTypeName,
+                    implementationType: fieldData.node.type,
+                    interfaceImplementationTypeNamesByInterfaceTypeName: this.interfaceImplementationTypeNamesByInterfaceTypeName,
+                    originalType: interfaceField.node.type,
+                })) {
                     hasErrors = true;
                     hasNestedErrors = true;
                     invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(fieldData.node.type);
@@ -2933,9 +2980,10 @@ class NormalizationFactory {
                         }
                         const namedTypeData = this.parentDefinitionDataByTypeName.get(valueData.namedTypeName);
                         if (!namedTypeData) {
-                            // undefined types are handled elsewhere
+                            // Undefined types are handled elsewhere
                             continue;
                         }
+                        this.sanitizeDefaultValue({ data: valueData, namedTypeData, node: valueData.node });
                         if (!(0, utils_4.isInputNodeKind)(namedTypeData.kind)) {
                             this.errors.push((0, errors_1.invalidNamedTypeError)({
                                 data: valueData,
@@ -3152,6 +3200,7 @@ class NormalizationFactory {
             entityDataByTypeName: this.entityDataByTypeName,
             entityInterfaces: this.entityInterfaceDataByTypeName,
             fieldCoordsByNamedTypeName: this.fieldCoordsByNamedTypeName,
+            interfaceImplementationTypeNamesByInterfaceTypeName: this.interfaceImplementationTypeNamesByInterfaceTypeName,
             isEventDrivenGraph: this.isSubgraphEventDrivenGraph,
             isVersionTwo: this.isSubgraphVersionTwo,
             keyFieldNamesByParentTypeName: this.keyFieldNamesByParentTypeName,
@@ -3175,6 +3224,7 @@ function batchNormalize({ options, subgraphs }) {
     const authorizationDataByParentTypeName = new Map();
     const concreteTypeNamesByAbstractTypeName = new Map();
     const entityDataByTypeName = new Map();
+    const interfaceImplementationTypeNamesByInterfaceTypeName = new Map();
     const internalSubgraphBySubgraphName = new Map();
     const allOverridesByTargetSubgraphName = new Map();
     const overrideSourceSubgraphNamesByFieldPath = new Map();
@@ -3238,6 +3288,17 @@ function batchNormalize({ options, subgraphs }) {
                 target: existingConcreteTypeNames,
             });
         }
+        for (const [interfaceTypeName, incomingInterfaceTypeNames,] of normalizationResult.interfaceImplementationTypeNamesByInterfaceTypeName) {
+            const existingInterfaceTypeNames = interfaceImplementationTypeNamesByInterfaceTypeName.get(interfaceTypeName);
+            if (!existingInterfaceTypeNames) {
+                interfaceImplementationTypeNamesByInterfaceTypeName.set(interfaceTypeName, new Set(incomingInterfaceTypeNames));
+                continue;
+            }
+            (0, utils_5.addIterableToSet)({
+                source: incomingInterfaceTypeNames,
+                target: existingInterfaceTypeNames,
+            });
+        }
         for (const [typeName, entityData] of normalizationResult.entityDataByTypeName) {
             const keyFieldSetDataByFieldSet = entityData.keyFieldSetDatasBySubgraphName.get(subgraphName);
             if (!keyFieldSetDataByFieldSet) {
@@ -3345,6 +3406,7 @@ function batchNormalize({ options, subgraphs }) {
         concreteTypeNamesByAbstractTypeName,
         entityDataByTypeName,
         fieldCoordsByNamedTypeName,
+        interfaceImplementationTypeNamesByInterfaceTypeName,
         internalSubgraphBySubgraphName: internalSubgraphBySubgraphName,
         internalGraph,
         success: true,