@wundergraph/composition 0.63.0 → 0.63.1

package/dist/types/results.d.ts

@@ -10,5 +10,6 @@ export interface ExecutionSingleFailure extends ExecutionFailure {
 export interface ExecutionSuccess {
     success: true;
 }
+export type ExecutionResult = ExecutionFailure | ExecutionSuccess;
 export type ExecutionMultiResult = ExecutionMultiFailure | ExecutionSuccess;
 export type ExecutionSingleFailureResult = ExecutionSingleFailure | ExecutionSuccess;

package/dist/utils/composition-version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMPOSITION_VERSION = void 0;
-exports.COMPOSITION_VERSION = '0.63.0';
+exports.COMPOSITION_VERSION = '0.63.1';
 //# sourceMappingURL=composition-version.js.map

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

@@ -9,7 +9,7 @@ import { type Warning } from '../../warnings/types';
 import { type NormalizationResult } from '../../normalization/types';
 import { type AddInputValueDataByNodeParams, type ComposeDirectiveNode, type ConditionalFieldSetValidationResult, type ExtractDirectiveArgumentDataResult, type FieldSetData, type HandleCostDirectiveParams, type HandleListSizeDirectiveParams, type HandleOverrideDirectiveParams, type HandleRequiresScopesDirectiveParams, type HandleSemanticNonNullDirectiveParams, type KeyFieldSetData, type LinkImportData, type RecordDirectiveWeightOnFieldParams, type UpsertInputObjectResult, type ValidateDirectiveParams } from './types/types';
 import { type AbstractTypeName, type ArgumentName, type DirectiveName, type FieldName, type SubgraphName, type TypeName } from '../../types/types';
-import { type GetFieldSetParentParams, type HandleFieldInheritableDirectivesParams, type NormalizationFactoryParams, type NormalizeSubgraphFromStringParams, type NormalizeSubgraphParams, type ValidateOneOfDirectiveParams } from './types/params';
+import { type GetFieldSetParentParams, type HandleFieldInheritableDirectivesParams, type IsAnyImplementationFieldExternalParams, type NormalizationFactoryParams, type NormalizeSubgraphFromStringParams, type NormalizeSubgraphParams, type ValidateOneOfDirectiveParams } from './types/params';
 import type { CompositionOptions } from '../../types/params';
 import { type FieldSetParentResult, type SchemaNodeResult } from './types/results';
 import { type AddDirectiveArgumentDataByNodeParams, type ExtractDirectiveArgumentDataParams } from '../../directive-definition-data/types/params';
@@ -102,6 +102,7 @@ export declare class NormalizationFactory {
     upsertUnionByNode(node: UnionTypeNode, isRealExtension?: boolean): void;
     extractKeyFieldSets(node: CompositeOutputNode, keyFieldSetDataByFieldSet: Map<string, KeyFieldSetData>): void;
     getFieldSetParent({ isProvides, parentData, fieldName, fieldSet, parentTypeName, }: GetFieldSetParentParams): FieldSetParentResult;
+    handleConditionalImplementationField({ fieldCoordsPath, fieldName, fieldPath, interfaceTypeName, isProvides, }: IsAnyImplementationFieldExternalParams): boolean;
     validateConditionalFieldSet(selectionSetParentData: CompositeOutputData | UnionDefinitionData, fieldSet: string, directiveFieldName: string, isProvides: boolean, directiveParentTypeName: string): ConditionalFieldSetValidationResult;
     validateProvidesOrRequires(parentData: CompositeOutputData, fieldSetByFieldName: Map<string, string>, isProvides: boolean): RequiredFieldConfiguration[] | undefined;
     validateInterfaceImplementations(data: CompositeOutputData): void;

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

@@ -1185,7 +1185,7 @@ class NormalizationFactory {
         if ((0, utils_1.isValidProvidesParentData)(namedTypeData)) {
             if ((0, utils_3.isUnionDefinitionData)(namedTypeData)) {
                 this.warnings.push((0, warnings_1.providesOnUnionWarning)({
-                    fieldCoords,
+                    directiveCoords: fieldCoords,
                     fieldSet,
                     namedTypeName: fieldNamedTypeName,
                     subgraphName: this.subgraphName,
@@ -1205,7 +1205,18 @@ class NormalizationFactory {
             success: false,
         };
     }
-    #handleNonExternalConditionalField({ currentFieldCoords, directiveCoords, directiveName, fieldSet, }) {
+    #handleNonExternalConditionalField({ currentFieldCoords, directiveCoords, directiveName, fieldSet, parentData, selection, }) {
+        if ((0, utils_4.isInterfaceDefinitionData)(parentData)) {
+            this.errors.push((0, errors_1.directlyProvidedInterfaceFieldError)({
+                directiveCoords,
+                directiveName,
+                fieldSet,
+                selection,
+                subgraphName: this.subgraphName,
+                targetCoords: currentFieldCoords,
+            }));
+            return;
+        }
         if (this.isSubgraphVersionTwo) {
             this.errors.push((0, errors_1.nonExternalConditionalFieldError)({
                 directiveCoords,
@@ -1221,6 +1232,37 @@ class NormalizationFactory {
          * */
         this.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, this.subgraphName, currentFieldCoords, fieldSet, directiveName));
     }
+    // Returns true if at least one implementation field is @external
+    handleConditionalImplementationField({ fieldCoordsPath, fieldName, fieldPath, interfaceTypeName, isProvides, }) {
+        const implementationTypeNames = this.concreteTypeNamesByAbstractTypeName.get(interfaceTypeName);
+        if (!implementationTypeNames) {
+            return false;
+        }
+        let hasExternalField = false;
+        for (const typeName of implementationTypeNames) {
+            const data = this.parentDefinitionDataByTypeName.get(typeName);
+            if (!(0, utils_3.isObjectDefinitionData)(data)) {
+                continue;
+            }
+            const fieldData = data.fieldDataByName.get(fieldName);
+            if (!fieldData?.directivesByName.has(string_constants_1.EXTERNAL)) {
+                continue;
+            }
+            const externalData = fieldData.externalFieldDataBySubgraphName.get(this.subgraphName);
+            if (!externalData || externalData.isUnconditionallyProvided) {
+                continue;
+            }
+            if (!isProvides) {
+                return true;
+            }
+            (0, utils_5.getValueOrDefault)(this.conditionalFieldDataByCoords, `${typeName}.${fieldName}`, utils_4.newConditionalFieldData).providedBy.push((0, utils_6.newFieldSetConditionData)({
+                fieldCoordinatesPath: [...fieldCoordsPath],
+                fieldPath: [...fieldPath],
+            }));
+            hasExternalField = true;
+        }
+        return hasExternalField;
+    }
     validateConditionalFieldSet(selectionSetParentData, fieldSet, directiveFieldName, isProvides, directiveParentTypeName) {
         // Create a new selection set so that the value can be parsed as a new DocumentNode
         const { error, documentNode } = (0, utils_1.safeParse)('{' + fieldSet + '}');
@@ -1265,17 +1307,29 @@ class NormalizationFactory {
                     fieldCoordsPath.push(currentFieldCoords);
                     fieldPath.push(fieldName);
                     lastFieldName = fieldName;
+                    const isInterfaceParent = (0, utils_4.isInterfaceDefinitionData)(parentData);
                     if (fieldName === string_constants_1.TYPENAME) {
                         if (isProvides) {
                             errorMessages.push((0, errors_1.typeNameAlreadyProvidedErrorMessage)(currentFieldCoords, nf.subgraphName));
                             return graphql_1.BREAK;
                         }
                         if (externalAncestors.size < 1) {
+                            if (isProvides && isInterfaceParent) {
+                                nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                                    directiveCoords,
+                                    fieldCoords: currentFieldCoords,
+                                    fieldSet,
+                                    selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                                    subgraphName: nf.subgraphName,
+                                }));
+                            }
                             nf.#handleNonExternalConditionalField({
                                 currentFieldCoords,
                                 directiveCoords,
                                 directiveName,
                                 fieldSet,
+                                parentData,
+                                selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
                             });
                         }
                         return;
@@ -1304,14 +1358,43 @@ class NormalizationFactory {
                         namedTypeData?.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
                         namedTypeData?.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
                         if (externalAncestors.size < 1 && !isDefinedExternal) {
+                            if (isProvides && isInterfaceParent) {
+                                nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                                    directiveCoords,
+                                    fieldCoords: currentFieldCoords,
+                                    fieldSet,
+                                    selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                                    subgraphName: nf.subgraphName,
+                                }));
+                            }
                             nf.#handleNonExternalConditionalField({
                                 currentFieldCoords,
                                 directiveCoords,
                                 directiveName,
                                 fieldSet,
+                                parentData,
+                                selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
                             });
                             return;
                         }
+                        if (isInterfaceParent) {
+                            if (isProvides) {
+                                nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                                    directiveCoords,
+                                    fieldCoords: currentFieldCoords,
+                                    fieldSet,
+                                    selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                                    subgraphName: nf.subgraphName,
+                                }));
+                            }
+                            nf.handleConditionalImplementationField({
+                                fieldCoordsPath,
+                                fieldName,
+                                fieldPath,
+                                interfaceTypeName: parentData.name,
+                                isProvides,
+                            });
+                        }
                         if (externalAncestors.size < 1 && isUnconditionallyProvided) {
                             // V2 subgraphs return an error when an external key field on an entity extension is provided.
                             if (nf.isSubgraphVersionTwo) {
@@ -1352,13 +1435,35 @@ class NormalizationFactory {
                         }
                         externalAncestors.add(currentFieldCoords);
                     }
-                    if (namedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
-                        namedTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
-                        namedTypeData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION) {
-                        shouldDefineSelectionSet = true;
-                        parentDatas.push(namedTypeData);
+                    if (!(0, utils_1.isValidProvidesParentData)(namedTypeData)) {
+                        return;
+                    }
+                    shouldDefineSelectionSet = true;
+                    parentDatas.push(namedTypeData);
+                    if (!isInterfaceParent) {
+                        return;
+                    }
+                    if (isProvides) {
+                        nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                            directiveCoords,
+                            fieldCoords: currentFieldCoords,
+                            fieldSet,
+                            selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                            subgraphName: nf.subgraphName,
+                        }));
+                    }
+                    if (!nf.handleConditionalImplementationField({
+                        fieldCoordsPath,
+                        fieldName,
+                        fieldPath,
+                        interfaceTypeName: parentData.name,
+                        isProvides,
+                    }) ||
+                        externalAncestors.size > 0) {
                         return;
                     }
+                    hasConditionalField = true;
+                    externalAncestors.add(currentFieldCoords);
                 },
                 leave() {
                     externalAncestors.delete(fieldCoordsPath.pop() || '');