@wundergraph/composition 0.58.3 → 0.62.2

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,73 @@ 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;
+            }
+            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({ abstractTypeData, directiveNode, directiveSubgraphName, targets, }) {
+        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;
             }
-            this.validateSubscriptionFilterAndGenerateConfiguration(data.directive, namedTypeData, fieldPath, data.fieldData.name, data.fieldData.renamedParentTypeName, data.directiveSubgraphName);
+            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);
         }
+        if (firstCondition === null || aggregatedErrors.length > 0) {
+            return { errors: aggregatedErrors, success: false };
+        }
+        return { condition: firstCondition, success: true };
     }
     buildFederationResult() {
         if (this.subscriptionFilterDataByFieldPath.size > 0) {
@@ -2416,13 +2530,21 @@ class FederationFactory {
              ** However, contracts require @inaccessible to exclude applicable tagged types. */
             this.routerDefinitions.push(directive_definitions_1.INACCESSIBLE_DEFINITION);
         }
-        if (contractTagOptions.tagNamesToExclude.size > 0) {
-            for (const [parentTypeName, parentTagData] of this.parentTagDataByTypeName) {
-                const parentDefinitionData = (0, utils_6.getOrThrowError)(this.parentDefinitionDataByTypeName, parentTypeName, string_constants_1.PARENT_DEFINITION_DATA);
+        const tagIntersection = contractTagOptions.tagNamesToExclude.intersection(contractTagOptions.tagNamesToInclude);
+        if (tagIntersection.size > 0) {
+            return {
+                errors: [(0, errors_1.intersectingExcludeAndIncludeContractTagsError)([...tagIntersection])],
+                success: false,
+                warnings: this.warnings,
+            };
+        }
+        if (contractTagOptions.tagNamesToInclude.size > 0) {
+            for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
                 if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                     continue;
                 }
-                if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(parentTagData.tagNames)) {
+                const parentTagData = this.parentTagDataByTypeName.get(parentTypeName);
+                if (!parentTagData) {
                     parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                     ]);
@@ -2430,50 +2552,42 @@ class FederationFactory {
                     // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
+                if (!contractTagOptions.tagNamesToInclude.isDisjointFrom(parentTagData.tagNames)) {
+                    continue;
+                }
                 if (parentTagData.childTagDataByChildName.size < 1) {
+                    parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
+                        (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                    ]);
+                    this.inaccessibleCoords.add(parentTypeName);
+                    // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
                 switch (parentDefinitionData.kind) {
                     case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                     // intentional fallthrough
-                    case graphql_1.Kind.UNION_TYPE_DEFINITION: {
-                        break;
-                    }
-                    case graphql_1.Kind.ENUM_TYPE_DEFINITION: {
-                        this.handleChildTagExclusions(parentDefinitionData, parentDefinitionData.enumValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToExclude);
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                        continue;
+                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                        this.handleChildTagInclusions(parentDefinitionData, parentDefinitionData.enumValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToInclude);
                         break;
-                    }
-                    case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
-                        this.handleChildTagExclusions(parentDefinitionData, parentDefinitionData.inputValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToExclude);
+                    case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                        this.handleChildTagInclusions(parentDefinitionData, parentDefinitionData.inputValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToInclude);
                         break;
-                    }
-                    default: {
+                    default:
                         let accessibleFields = parentDefinitionData.fieldDataByName.size;
-                        for (const [fieldName, childTagData] of parentTagData.childTagDataByChildName) {
-                            const fieldData = (0, utils_6.getOrThrowError)(parentDefinitionData.fieldDataByName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
+                        for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByName) {
                             if ((0, utils_5.isNodeDataInaccessible)(fieldData)) {
                                 accessibleFields -= 1;
                                 continue;
                             }
-                            if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(childTagData.tagNames)) {
+                            const childTagData = parentTagData.childTagDataByChildName.get(fieldName);
+                            if (!childTagData || contractTagOptions.tagNamesToInclude.isDisjointFrom(childTagData.tagNames)) {
                                 (0, utils_6.getValueOrDefault)(fieldData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                                     (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                                 ]);
                                 this.inaccessibleCoords.add(fieldData.federatedCoords);
                                 accessibleFields -= 1;
-                                continue;
-                            }
-                            for (const [argumentName, argTagNames] of childTagData.tagNamesByArgumentName) {
-                                const inputValueData = (0, utils_6.getOrThrowError)(fieldData.argumentDataByName, argumentName, `${fieldName}.argumentDataByArgumentName`);
-                                if ((0, utils_5.isNodeDataInaccessible)(inputValueData)) {
-                                    continue;
-                                }
-                                if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(argTagNames)) {
-                                    (0, utils_6.getValueOrDefault)(inputValueData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
-                                        (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
-                                    ]);
-                                    this.inaccessibleCoords.add(inputValueData.federatedCoords);
-                                }
                             }
                         }
                         if (accessibleFields < 1) {
@@ -2482,17 +2596,16 @@ class FederationFactory {
                             ]);
                             this.inaccessibleCoords.add(parentTypeName);
                         }
-                    }
                 }
             }
         }
-        else if (contractTagOptions.tagNamesToInclude.size > 0) {
-            for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
+        if (contractTagOptions.tagNamesToExclude.size > 0) {
+            for (const [parentTypeName, parentTagData] of this.parentTagDataByTypeName) {
+                const parentDefinitionData = (0, utils_6.getOrThrowError)(this.parentDefinitionDataByTypeName, parentTypeName, string_constants_1.PARENT_DEFINITION_DATA);
                 if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                     continue;
                 }
-                const parentTagData = this.parentTagDataByTypeName.get(parentTypeName);
-                if (!parentTagData) {
+                if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(parentTagData.tagNames)) {
                     parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                     ]);
@@ -2500,42 +2613,50 @@ class FederationFactory {
                     // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
-                if (!contractTagOptions.tagNamesToInclude.isDisjointFrom(parentTagData.tagNames)) {
-                    continue;
-                }
                 if (parentTagData.childTagDataByChildName.size < 1) {
-                    parentDefinitionData.federatedDirectivesData.directivesByName.set(string_constants_1.INACCESSIBLE, [
-                        (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
-                    ]);
-                    this.inaccessibleCoords.add(parentTypeName);
-                    // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
                 switch (parentDefinitionData.kind) {
                     case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                     // intentional fallthrough
-                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        continue;
-                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                        this.handleChildTagInclusions(parentDefinitionData, parentDefinitionData.enumValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToInclude);
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION: {
                         break;
-                    case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                        this.handleChildTagInclusions(parentDefinitionData, parentDefinitionData.inputValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToInclude);
+                    }
+                    case graphql_1.Kind.ENUM_TYPE_DEFINITION: {
+                        this.handleChildTagExclusions(parentDefinitionData, parentDefinitionData.enumValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToExclude);
                         break;
-                    default:
+                    }
+                    case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
+                        this.handleChildTagExclusions(parentDefinitionData, parentDefinitionData.inputValueDataByName, parentTagData.childTagDataByChildName, contractTagOptions.tagNamesToExclude);
+                        break;
+                    }
+                    default: {
                         let accessibleFields = parentDefinitionData.fieldDataByName.size;
-                        for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByName) {
+                        for (const [fieldName, childTagData] of parentTagData.childTagDataByChildName) {
+                            const fieldData = (0, utils_6.getOrThrowError)(parentDefinitionData.fieldDataByName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
                             if ((0, utils_5.isNodeDataInaccessible)(fieldData)) {
                                 accessibleFields -= 1;
                                 continue;
                             }
-                            const childTagData = parentTagData.childTagDataByChildName.get(fieldName);
-                            if (!childTagData || contractTagOptions.tagNamesToInclude.isDisjointFrom(childTagData.tagNames)) {
+                            if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(childTagData.tagNames)) {
                                 (0, utils_6.getValueOrDefault)(fieldData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
                                     (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                                 ]);
                                 this.inaccessibleCoords.add(fieldData.federatedCoords);
                                 accessibleFields -= 1;
+                                continue;
+                            }
+                            for (const [argumentName, argTagNames] of childTagData.tagNamesByArgumentName) {
+                                const inputValueData = (0, utils_6.getOrThrowError)(fieldData.argumentDataByName, argumentName, `${fieldName}.argumentDataByArgumentName`);
+                                if ((0, utils_5.isNodeDataInaccessible)(inputValueData)) {
+                                    continue;
+                                }
+                                if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(argTagNames)) {
+                                    (0, utils_6.getValueOrDefault)(inputValueData.federatedDirectivesData.directivesByName, string_constants_1.INACCESSIBLE, () => [
+                                        (0, utils_6.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                                    ]);
+                                    this.inaccessibleCoords.add(inputValueData.federatedCoords);
+                                }
                             }
                         }
                         if (accessibleFields < 1) {
@@ -2544,6 +2665,7 @@ class FederationFactory {
                             ]);
                             this.inaccessibleCoords.add(parentTypeName);
                         }
+                    }
                 }
             }
         }