@wundergraph/composition 0.58.2 → 0.59.0

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.58.2';
+exports.COMPOSITION_VERSION = '0.59.0';
 //# sourceMappingURL=composition-version.js.map

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

@@ -1,5 +1,6 @@
 import { type ConstDirectiveNode, type ConstObjectValueNode, type DefinitionNode, type DirectiveDefinitionNode, type NamedTypeNode, type StringValueNode } from 'graphql';
 import { type MutableDefinitionNode, type MutableInputValueNode, type MutableTypeNode } from '../../schema-building/ast';
+import { type ExecutionMultiResult } from '../../types/results';
 import { type ChildTagData, type InterfaceImplementationData, type InterfaceObjectForInternalGraphOptions, type ParentTagData, type SubscriptionFilterData } from './utils';
 import { type FieldConfiguration, type SubscriptionCondition, type SubscriptionFieldCondition } from '../../router-configuration/types';
 import { type AuthorizationData, type ChildData, type CompositeOutputData, type EntityData, type EntityInterfaceFederationData, type EnumValueData, type FederatedDirectivesData, type FieldData, type InputObjectDefinitionData, type InputValueData, type InterfaceDefinitionData, type NodeData, type ObjectDefinitionData, type ParentDefinitionData, type UnionDefinitionData } from '../../schema-building/types/types';
@@ -10,9 +11,10 @@ import { type GraphNode } from '../../resolvability-graph/graph-nodes';
 import { type InternalSubgraph } from '../../subgraph/types';
 import { type Warning } from '../../warnings/types';
 import { type ContractTagOptions, type FederationResult, type FederationResultWithContracts, type MutualParentDefinitionData } from '../../federation/types/types';
+import { type SubscriptionFilterTargetResult } from '../../federation/types/results';
 import type { GraphFieldData } from '../../utils/types';
 import { type DirectiveName, type FieldCoords, type InterfaceTypeName, type SubgraphName, type TypeName } from '../../types/types';
-import { type ExtractFederatedDirectivesParams, type FederateSubgraphsContractV1Params, type FederateSubgraphsWithContractsV1Params, type FederationFactoryParams, type FederationParams, type UpsertDirectiveArgumentDataParams, type ValidateOneOfDirectiveParams } from './types/params';
+import { type ExtractFederatedDirectivesParams, type FederateSubgraphsContractV1Params, type FederateSubgraphsWithContractsV1Params, type FederationFactoryParams, type FederationParams, type MergeSubscriptionFilterTargetResultParams, type UpsertDirectiveArgumentDataParams, type ValidateSubscriptionFilterAndGenerateConfigurationParams, type ValidateOneOfDirectiveParams } from './types/params';
 import type { CompositionOptions } from '../../types/params';
 import { type DirectiveArgumentData, type DirectiveDefinitionData } from '../../directive-definition-data/types/types';
 export declare class FederationFactory {
@@ -101,10 +103,13 @@ export declare class FederationFactory {
     validateReferencesOfInaccessibleType(data: ParentDefinitionData): void;
     validateQueryRootType(): void;
     validateSubscriptionFieldConditionFieldPath(conditionFieldPath: string, objectData: ObjectDefinitionData, inputFieldPath: string, directiveSubgraphName: string, fieldErrorMessages: Array<string>): string[];
-    validateSubscriptionFieldCondition(objectValueNode: ConstObjectValueNode, condition: SubscriptionFieldCondition, objectData: ObjectDefinitionData, depth: number, inputPath: string, directiveSubgraphName: string, errorMessages: string[]): boolean;
-    validateSubscriptionFilterCondition(objectValueNode: ConstObjectValueNode, configuration: SubscriptionCondition, objectData: ObjectDefinitionData, depth: number, inputPath: string, directiveSubgraphName: string, errorMessages: string[]): boolean;
-    validateSubscriptionFilterAndGenerateConfiguration(directiveNode: ConstDirectiveNode, objectData: ObjectDefinitionData, fieldPath: string, fieldName: string, parentTypeName: string, directiveSubgraphName: string): void;
+    validateSubscriptionFieldCondition(objectValueNode: ConstObjectValueNode, condition: SubscriptionFieldCondition, objectData: ObjectDefinitionData, depth: number, inputPath: string, directiveSubgraphName: string): ExecutionMultiResult;
+    validateSubscriptionFilterCondition(objectValueNode: ConstObjectValueNode, configuration: SubscriptionCondition, objectData: ObjectDefinitionData, depth: number, inputPath: string, directiveSubgraphName: string): ExecutionMultiResult;
+    validateSubscriptionFilterForTarget(directiveNode: ConstDirectiveNode, target: ObjectDefinitionData, directiveSubgraphName: string): SubscriptionFilterTargetResult;
+    validateSubscriptionFilterAndGenerateConfiguration({ directiveNode, objectData, fieldPath, fieldName, parentTypeName, directiveSubgraphName, }: ValidateSubscriptionFilterAndGenerateConfigurationParams): void;
+    collectSubscriptionFilterConcreteTargets(abstractTypeName: string): Array<ObjectDefinitionData>;
     validateSubscriptionFiltersAndGenerateConfiguration(): void;
+    mergeSubscriptionFilterTargetResults({ directiveNode, abstractTypeData, targets, directiveSubgraphName, }: MergeSubscriptionFilterTargetResultParams): SubscriptionFilterTargetResult;
     buildFederationResult(): FederationResult;
     getClientSchemaObjectBoolean(): {
         shouldIncludeClientSchema?: undefined;

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

@@ -2039,11 +2039,10 @@ class FederationFactory {
         }
         return paths;
     }
-    validateSubscriptionFieldCondition(objectValueNode, condition, objectData, depth, inputPath, directiveSubgraphName, errorMessages) {
+    validateSubscriptionFieldCondition(objectValueNode, condition, objectData, depth, inputPath, directiveSubgraphName) {
         if (depth > integer_constants_1.MAX_SUBSCRIPTION_FILTER_DEPTH || this.isMaxDepth) {
-            errorMessages.push((0, errors_1.subscriptionFilterConditionDepthExceededErrorMessage)(inputPath));
             this.isMaxDepth = true;
-            return false;
+            return { success: false, errors: [(0, errors_1.subscriptionFilterConditionDepthExceededError)(inputPath)] };
         }
         let hasErrors = false;
         const validFieldNames = new Set([string_constants_1.FIELD_PATH, string_constants_1.VALUES]);
@@ -2127,27 +2126,34 @@ class FederationFactory {
             }
         }
         if (!hasErrors) {
-            return true;
+            return { success: true };
         }
-        errorMessages.push((0, errors_1.subscriptionFieldConditionInvalidInputFieldErrorMessage)(inputPath, [...validFieldNames], [...duplicatedFieldNames], [...invalidFieldNames], fieldErrorMessages));
-        return false;
+        return {
+            success: false,
+            errors: [
+                (0, errors_1.subscriptionFieldConditionInvalidInputFieldError)(inputPath, [...validFieldNames], [...duplicatedFieldNames], [...invalidFieldNames], fieldErrorMessages),
+            ],
+        };
     }
-    validateSubscriptionFilterCondition(objectValueNode, configuration, objectData, depth, inputPath, directiveSubgraphName, errorMessages) {
+    validateSubscriptionFilterCondition(objectValueNode, configuration, objectData, depth, inputPath, directiveSubgraphName) {
         if (depth > integer_constants_1.MAX_SUBSCRIPTION_FILTER_DEPTH || this.isMaxDepth) {
-            errorMessages.push((0, errors_1.subscriptionFilterConditionDepthExceededErrorMessage)(inputPath));
             this.isMaxDepth = true;
-            return false;
+            return { success: false, errors: [(0, errors_1.subscriptionFilterConditionDepthExceededError)(inputPath)] };
         }
         depth += 1;
         if (objectValueNode.fields.length !== 1) {
-            errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldNumberErrorMessage)(inputPath, objectValueNode.fields.length));
-            return false;
+            return {
+                success: false,
+                errors: [(0, errors_1.subscriptionFilterConditionInvalidInputFieldNumberError)(inputPath, objectValueNode.fields.length)],
+            };
         }
         const objectFieldNode = objectValueNode.fields[0];
         const fieldName = objectFieldNode.name.value;
         if (!strings_1.SUBSCRIPTION_FILTER_INPUT_NAMES.has(fieldName)) {
-            errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldErrorMessage)(inputPath, fieldName));
-            return false;
+            return {
+                success: false,
+                errors: [(0, errors_1.subscriptionFilterConditionInvalidInputFieldError)(inputPath, fieldName)],
+            };
         }
         const inputFieldPath = inputPath + `.${fieldName}`;
         switch (objectFieldNode.value.kind) {
@@ -2155,16 +2161,18 @@ class FederationFactory {
                 switch (fieldName) {
                     case string_constants_1.IN_UPPER: {
                         configuration.in = { fieldPath: [], values: [] };
-                        return this.validateSubscriptionFieldCondition(objectFieldNode.value, configuration.in, objectData, depth, inputPath + `.IN`, directiveSubgraphName, errorMessages);
+                        return this.validateSubscriptionFieldCondition(objectFieldNode.value, configuration.in, objectData, depth, inputPath + `.IN`, directiveSubgraphName);
                     }
                     case string_constants_1.NOT_UPPER: {
                         configuration.not = {};
-                        return this.validateSubscriptionFilterCondition(objectFieldNode.value, configuration.not, objectData, depth, inputPath + `.NOT`, directiveSubgraphName, errorMessages);
+                        return this.validateSubscriptionFilterCondition(objectFieldNode.value, configuration.not, objectData, depth, inputPath + `.NOT`, directiveSubgraphName);
                     }
                     default:
                         // The field is guaranteed to be an AND or an OR
-                        errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(inputFieldPath, string_constants_1.LIST, string_constants_1.OBJECT));
-                        return false;
+                        return {
+                            success: false,
+                            errors: [(0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeError)(inputFieldPath, string_constants_1.LIST, string_constants_1.OBJECT)],
+                        };
                 }
             }
             case graphql_1.Kind.LIST: {
@@ -2180,15 +2188,20 @@ class FederationFactory {
                     }
                     default:
                         // The field is guaranteed to be an IN or a NOT
-                        errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(inputFieldPath, string_constants_1.OBJECT, string_constants_1.LIST));
-                        return false;
+                        return {
+                            success: false,
+                            errors: [(0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeError)(inputFieldPath, string_constants_1.OBJECT, string_constants_1.LIST)],
+                        };
                 }
                 const listLength = objectFieldNode.value.values.length;
                 if (listLength < 1 || listLength > 5) {
-                    errorMessages.push((0, errors_1.subscriptionFilterArrayConditionInvalidLengthErrorMessage)(inputFieldPath, listLength));
-                    return false;
+                    return {
+                        success: false,
+                        errors: [(0, errors_1.subscriptionFilterArrayConditionInvalidLengthError)(inputFieldPath, listLength)],
+                    };
                 }
                 let isValid = true;
+                const aggregatedErrors = [];
                 const invalidIndices = [];
                 for (let i = 0; i < objectFieldNode.value.values.length; i++) {
                     const arrayIndexPath = inputFieldPath + `[${i}]`;
@@ -2197,49 +2210,89 @@ class FederationFactory {
                         invalidIndices.push(i);
                         continue;
                     }
+                    /* Preserve original short-circuit behaviour (`isValid &&= ...`): once any earlier
+                     * item failed, do not recurse into subsequent items so error output stays focused
+                     * on the first failing branch.
+                     */
+                    if (!isValid) {
+                        continue;
+                    }
                     const listConfiguration = {};
-                    isValid &&= this.validateSubscriptionFilterCondition(listValueNode, listConfiguration, objectData, depth, arrayIndexPath, directiveSubgraphName, errorMessages);
-                    if (isValid) {
-                        listConfigurations.push(listConfiguration);
+                    const itemResult = this.validateSubscriptionFilterCondition(listValueNode, listConfiguration, objectData, depth, arrayIndexPath, directiveSubgraphName);
+                    if (!itemResult.success) {
+                        isValid = false;
+                        aggregatedErrors.push(...itemResult.errors);
+                        continue;
                     }
+                    listConfigurations.push(listConfiguration);
                 }
                 if (invalidIndices.length > 0) {
-                    errorMessages.push((0, errors_1.subscriptionFilterArrayConditionInvalidItemTypeErrorMessage)(inputFieldPath, invalidIndices));
-                    return false;
+                    aggregatedErrors.push((0, errors_1.subscriptionFilterArrayConditionInvalidItemTypeErrorMessage)(inputFieldPath, invalidIndices));
+                    return { success: false, errors: aggregatedErrors };
                 }
-                return isValid;
+                return isValid ? { success: true } : { success: false, errors: aggregatedErrors };
             }
             default: {
                 const expectedTypeString = strings_1.SUBSCRIPTION_FILTER_LIST_INPUT_NAMES.has(fieldName) ? string_constants_1.LIST : string_constants_1.OBJECT;
-                errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(inputFieldPath, expectedTypeString, (0, utils_6.kindToNodeType)(objectFieldNode.value.kind)));
-                return false;
+                return {
+                    success: false,
+                    errors: [
+                        (0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeError)(inputFieldPath, expectedTypeString, (0, utils_6.kindToNodeType)(objectFieldNode.value.kind)),
+                    ],
+                };
             }
         }
     }
-    validateSubscriptionFilterAndGenerateConfiguration(directiveNode, objectData, fieldPath, fieldName, parentTypeName, directiveSubgraphName) {
-        // directive validation occurs elsewhere
+    validateSubscriptionFilterForTarget(directiveNode, target, directiveSubgraphName) {
+        // directive validation occurs elsewhere; an empty errors array signals "skip silently".
         if (!directiveNode.arguments || directiveNode.arguments.length !== 1) {
-            return;
+            return { success: false, errors: [] };
         }
         const argumentNode = directiveNode.arguments[0];
         if (argumentNode.value.kind !== graphql_1.Kind.OBJECT) {
-            this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, [
-                (0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(string_constants_1.CONDITION, string_constants_1.OBJECT, (0, utils_6.kindToNodeType)(argumentNode.value.kind)),
-            ]));
-            return;
+            return {
+                success: false,
+                errors: [
+                    (0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeError)(string_constants_1.CONDITION, string_constants_1.OBJECT, (0, utils_6.kindToNodeType)(argumentNode.value.kind)),
+                ],
+            };
         }
         const condition = {};
-        const errorMessages = [];
-        if (!this.validateSubscriptionFilterCondition(argumentNode.value, condition, objectData, 0, string_constants_1.CONDITION, directiveSubgraphName, errorMessages)) {
-            this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, errorMessages));
-            this.isMaxDepth = false;
+        // Reset depth state so each target validation starts fresh.
+        this.isMaxDepth = false;
+        const result = this.validateSubscriptionFilterCondition(argumentNode.value, condition, target, 0, string_constants_1.CONDITION, directiveSubgraphName);
+        if (!result.success) {
+            return result;
+        }
+        return { success: true, condition };
+    }
+    validateSubscriptionFilterAndGenerateConfiguration({ directiveNode, objectData, fieldPath, fieldName, parentTypeName, directiveSubgraphName, }) {
+        const result = this.validateSubscriptionFilterForTarget(directiveNode, objectData, directiveSubgraphName);
+        if (!result.success) {
+            if (result.errors.length > 0) {
+                this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, result.errors));
+            }
             return;
         }
         (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldCoords, fieldPath, () => ({
             argumentNames: [],
             fieldName,
             typeName: parentTypeName,
-        })).subscriptionFilterCondition = condition;
+        })).subscriptionFilterCondition = result.condition;
+    }
+    collectSubscriptionFilterConcreteTargets(abstractTypeName) {
+        const concreteNames = this.concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
+        if (!concreteNames) {
+            return [];
+        }
+        const out = [];
+        for (const concreteName of concreteNames) {
+            const data = this.parentDefinitionDataByTypeName.get(concreteName);
+            if (data && data.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION && !(0, utils_5.isNodeDataInaccessible)(data)) {
+                out.push(data);
+            }
+        }
+        return out;
     }
     validateSubscriptionFiltersAndGenerateConfiguration() {
         for (const [fieldPath, data] of this.subscriptionFilterDataByFieldPath) {
@@ -2252,7 +2305,7 @@ class FederationFactory {
              */
             if (!namedTypeData) {
                 this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, [
-                    (0, errors_1.subscriptionFilterNamedTypeErrorMessage)(data.fieldData.namedTypeName),
+                    (0, errors_1.subscriptionFilterNamedTypeError)(data.fieldData.namedTypeName),
                 ]));
                 continue;
             }
@@ -2260,12 +2313,74 @@ class FederationFactory {
                 // @inaccessible error are caught elsewhere
                 continue;
             }
-            // TODO handle Unions and Interfaces
-            if (namedTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            if (namedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                this.validateSubscriptionFilterAndGenerateConfiguration({
+                    directiveNode: data.directive,
+                    objectData: namedTypeData,
+                    fieldPath,
+                    fieldName: data.fieldData.name,
+                    parentTypeName: data.fieldData.renamedParentTypeName,
+                    directiveSubgraphName: data.directiveSubgraphName,
+                });
                 continue;
             }
-            this.validateSubscriptionFilterAndGenerateConfiguration(data.directive, namedTypeData, fieldPath, data.fieldData.name, data.fieldData.renamedParentTypeName, data.directiveSubgraphName);
+            if (!(0, utils_1.isKindAbstract)(namedTypeData.kind)) {
+                /* Other kinds (Enum/Input/Scalar) should be caught at normalization time.
+                 * Emit an explicit composition error so the directive cannot be silently dropped here again.
+                 */
+                this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, [
+                    (0, errors_1.subscriptionFilterUnsupportedNamedTypeKindError)(namedTypeData.name, namedTypeData.kind),
+                ]));
+                continue;
+            }
+            const targets = this.collectSubscriptionFilterConcreteTargets(namedTypeData.name);
+            if (targets.length === 0) {
+                const kindLabel = (0, utils_6.kindToNodeType)(namedTypeData.kind);
+                this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, [
+                    (0, errors_1.subscriptionFilterNoAccessibleConcreteTypesError)(namedTypeData.name, kindLabel),
+                ]));
+                continue;
+            }
+            const result = this.mergeSubscriptionFilterTargetResults({
+                directiveNode: data.directive,
+                abstractTypeData: namedTypeData,
+                targets,
+                directiveSubgraphName: data.directiveSubgraphName,
+            });
+            if (!result.success) {
+                this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, result.errors));
+                continue;
+            }
+            (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldCoords, fieldPath, () => ({
+                argumentNames: [],
+                fieldName: data.fieldData.name,
+                typeName: data.fieldData.renamedParentTypeName,
+            })).subscriptionFilterCondition = result.condition;
+        }
+    }
+    mergeSubscriptionFilterTargetResults({ directiveNode, abstractTypeData, targets, directiveSubgraphName, }) {
+        const aggregatedErrors = [];
+        let firstCondition = null;
+        for (const target of targets) {
+            const result = this.validateSubscriptionFilterForTarget(directiveNode, target, directiveSubgraphName);
+            if (result.success) {
+                firstCondition ??= result.condition;
+                continue;
+            }
+            if (result.errors.length === 0) {
+                // The directive is malformed — that error is reported elsewhere; skip silently.
+                continue;
+            }
+            const wrapped = abstractTypeData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION
+                ? (0, errors_1.subscriptionFilterUnionMemberInvalidError)(abstractTypeData.name, target.name, result.errors.map((error) => error.message).join(string_constants_1.LITERAL_NEW_LINE))
+                : (0, errors_1.subscriptionFilterInterfaceImplementationInvalidError)(abstractTypeData.name, target.name, result.errors.map((error) => error.message).join(string_constants_1.LITERAL_NEW_LINE));
+            aggregatedErrors.push(wrapped);
+            continue;
+        }
+        if (firstCondition === null || aggregatedErrors.length > 0) {
+            return { errors: aggregatedErrors, success: false };
         }
+        return { condition: firstCondition, success: true };
     }
     buildFederationResult() {
         if (this.subscriptionFilterDataByFieldPath.size > 0) {