@wundergraph/composition 0.23.0 → 0.23.2

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

@@ -1,11 +1,11 @@
 import { MultiGraph } from 'graphology';
 import { DirectiveDefinitionNode, Kind, NamedTypeNode } from 'graphql';
 import { MutableTypeDefinitionNode } from '../schema-building/ast';
-import { FederationResultContainer, FederationResultContainerWithContracts, InterfaceImplementationData, ParentTagData, RootTypeFieldData } from './utils';
+import { ChildTagData, FederationResultContainer, FederationResultContainerWithContracts, InterfaceImplementationData, ParentTagData, RootTypeFieldData } from './utils';
 import { InternalSubgraph, Subgraph } from '../subgraph/subgraph';
 import { AuthorizationData, EntityData, EntityDataByTypeName, EntityInterfaceFederationData } from '../utils/utils';
 import { FieldConfiguration } from '../router-configuration/router-configuration';
-import { DefinitionWithFieldsData, EnumValueData, FieldData, InputObjectDefinitionData, InputValueData, InterfaceDefinitionData, ObjectDefinitionData, ParentDefinitionData, PersistedDirectiveDefinitionData, UnionDefinitionData } from '../schema-building/type-definition-data';
+import { ChildData, DefinitionWithFieldsData, EnumValueData, FieldData, InputObjectDefinitionData, InputValueData, InterfaceDefinitionData, NodeData, ObjectDefinitionData, ParentDefinitionData, PersistedDirectiveDefinitionData, UnionDefinitionData } from '../schema-building/type-definition-data';
 import { MergeMethod } from '../schema-building/utils';
 import { ObjectExtensionData } from '../schema-building/type-extension-data';
 export declare class FederationFactory {
@@ -49,11 +49,12 @@ export declare class FederationFactory {
     getEnumValueMergeMethod(enumTypeName: string): MergeMethod;
     generateTagData(): void;
     evaluateRootNodeFieldsResolvability(): void;
-    upsertEnumValueData(enumValueDataByValueName: Map<string, EnumValueData>, incomingData: EnumValueData): void;
-    upsertInputValueData(inputValueDataByValueName: Map<string, InputValueData>, incomingData: InputValueData): void;
+    upsertEnumValueData(enumValueDataByValueName: Map<string, EnumValueData>, incomingData: EnumValueData, isParentInaccessible: boolean): void;
+    upsertInputValueData(inputValueDataByValueName: Map<string, InputValueData>, incomingData: InputValueData, path?: string): void;
     handleArgumentInaccessibility(isParentInaccessible: boolean, inputValueData: InputValueData, argumentPath: string, fieldPath: string): void;
     upsertFieldData(fieldDataByFieldName: Map<string, FieldData>, incomingData: FieldData, isParentInaccessible: boolean): void;
     getClientSchemaUnionMembers(unionData: UnionDefinitionData): NamedTypeNode[];
+    recordTagNamesByPath(data: NodeData | ObjectExtensionData, nodePath?: string): void;
     upsertParentDefinitionData(incomingData: ParentDefinitionData, subgraphName: string): void;
     upsertObjectExtensionData(incomingData: ObjectExtensionData): void;
     propagateInaccessibilityToExistingChildren(data: InputObjectDefinitionData | InterfaceDefinitionData | ObjectDefinitionData | ObjectExtensionData): void;
@@ -68,7 +69,13 @@ export declare class FederationFactory {
     validateReferencesOfInaccessibleType(data: ParentDefinitionData): void;
     validateQueryRootType(): void;
     buildFederationResult(): FederationResultContainer;
-    buildFederationContractResult(tagExclusions: Set<string>): FederationResultContainer;
+    getClientSchemaObjectBoolean(): {
+        shouldIncludeClientSchema?: undefined;
+    } | {
+        shouldIncludeClientSchema: boolean;
+    };
+    handleChildRemovalByTag(parentDefinitionData: ParentDefinitionData, children: Map<string, ChildData>, childTagDataByChildName: Map<string, ChildTagData>, tagsToExclude: Set<string>): void;
+    buildFederationContractResult(tagsToExclude: Set<string>): FederationResultContainer;
     federateSubgraphsInternal(): FederationResultContainer;
 }
 export declare function federateSubgraphs(subgraphs: Subgraph[]): FederationResultContainer;

package/dist/federation/federation-factory.js

@@ -167,7 +167,7 @@ class FederationFactory {
                 return true;
             }
             if (entityAncestorName === parentTypeName) {
-                const hasOverlap = (0, utils_3.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entityDataByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
+                const hasOverlap = (0, utils_3.doSetsIntersect)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entityDataByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
                 this.graphPaths.set(path, hasOverlap);
                 return hasOverlap;
             }
@@ -244,7 +244,7 @@ class FederationFactory {
             }
             this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, objectData.subgraphNames, entityAncestors, parentTypeName);
             evaluatedObjectLikes.add(parentTypeName);
-            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldData.subgraphNames) ||
+            const isFieldResolvable = (0, utils_3.doSetsIntersect)(rootTypeFieldData.subgraphs, fieldData.subgraphNames) ||
                 this.isFieldResolvableByEntityAncestor(entityAncestors, fieldData.subgraphNames, parentTypeName);
             const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
             const entity = this.entityDataByTypeName.get(namedFieldTypeName);
@@ -314,7 +314,7 @@ class FederationFactory {
                 throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_3.kindToTypeString)(concreteTypeData.kind));
             }
             // If the concrete type is unreachable through an inline fragment, it is not an error
-            if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteTypeData.subgraphNames, rootTypeFieldData.subgraphs)) {
+            if (!(0, utils_3.doSetsIntersect)(concreteTypeData.subgraphNames, rootTypeFieldData.subgraphs)) {
                 continue;
             }
             const entity = this.entityDataByTypeName.get(concreteTypeName);
@@ -560,9 +560,16 @@ class FederationFactory {
             }
         }
     }
-    upsertEnumValueData(enumValueDataByValueName, incomingData) {
+    upsertEnumValueData(enumValueDataByValueName, incomingData, isParentInaccessible) {
         const existingData = enumValueDataByValueName.get(incomingData.name);
-        (0, utils_5.extractPersistedDirectives)(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const baseData = existingData || incomingData;
+        const enumValuePath = `${incomingData.parentTypeName}.${incomingData.name}`;
+        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
+        if (isParentInaccessible || isFieldInaccessible) {
+            this.inaccessiblePaths.add(enumValuePath);
+        }
+        this.recordTagNamesByPath(baseData, enumValuePath);
         if (!existingData) {
             incomingData.node = {
                 directives: [],
@@ -575,9 +582,12 @@ class FederationFactory {
         existingData.appearances += 1;
         (0, utils_5.setLongestDescription)(existingData, incomingData);
     }
-    upsertInputValueData(inputValueDataByValueName, incomingData) {
+    // To facilitate the splitting of tag paths, field arguments do not use the renamedPath property for tagNamesByPath
+    upsertInputValueData(inputValueDataByValueName, incomingData, path) {
         const existingData = inputValueDataByValueName.get(incomingData.name);
-        (0, utils_5.extractPersistedDirectives)(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const baseData = existingData || incomingData;
+        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        this.recordTagNamesByPath(baseData, path || baseData.renamedPath);
         if (!existingData) {
             incomingData.node = {
                 directives: [],
@@ -629,17 +639,13 @@ class FederationFactory {
         (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(fieldPath);
         this.namedOutputTypeNames.add(incomingData.namedTypeName);
         const existingData = fieldDataByFieldName.get(incomingData.name);
-        (0, utils_5.extractPersistedDirectives)(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const baseData = existingData || incomingData;
+        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
         const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
         if (isParentInaccessible || isFieldInaccessible) {
             this.inaccessiblePaths.add(fieldPath);
         }
-        if (incomingData.persistedDirectivesData.tags.size > 0) {
-            const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, fieldPath, () => new Set());
-            for (const tagName of incomingData.persistedDirectivesData.tags.keys()) {
-                tagNames.add(tagName);
-            }
-        }
+        this.recordTagNamesByPath(baseData, fieldPath);
         if (!existingData) {
             fieldDataByFieldName.set(incomingData.name, incomingData);
             incomingData.node = {
@@ -656,22 +662,15 @@ class FederationFactory {
                     name: (0, utils_1.stringToNameNode)(inputValueData.name),
                     type: inputValueData.type,
                 };
-                const argumentPath = `${fieldPath}(${argumentName}: ... )`;
                 const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+                (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
                 this.namedInputValueTypeNames.add(namedArgumentTypeName);
                 (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
                 /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
                  ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
                  ** error. */
-                this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
-                if (inputValueData.persistedDirectivesData.tags.size > 0) {
-                    const tagArgumentPath = `${fieldPath}.${argumentName}`;
-                    const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, tagArgumentPath, () => new Set());
-                    for (const tagName of inputValueData.persistedDirectivesData.tags.keys()) {
-                        tagNames.add(tagName);
-                    }
-                }
+                this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
+                this.recordTagNamesByPath(inputValueData, `${fieldPath}.${argumentName}`);
             }
             return;
         }
@@ -686,22 +685,14 @@ class FederationFactory {
             this.errors.push((0, errors_1.incompatibleChildTypesError)(fieldPath, typeErrors[0], typeErrors[1]));
         }
         for (const [argumentName, inputValueData] of incomingData.argumentDataByArgumentName) {
-            const argumentPath = `${fieldPath}(${argumentName}: ... )`;
             const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-            (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+            (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
             this.namedInputValueTypeNames.add(namedArgumentTypeName);
             /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
              ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
              ** error. */
-            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
-            if (inputValueData.persistedDirectivesData.tags.size > 0) {
-                const tagArgumentPath = `${fieldPath}.${argumentName}`;
-                const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, tagArgumentPath, () => new Set());
-                for (const tagName of inputValueData.persistedDirectivesData.tags.keys()) {
-                    tagNames.add(tagName);
-                }
-            }
-            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData);
+            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
+            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData, `${fieldPath}.${argumentName}`);
         }
         (0, utils_5.setLongestDescription)(existingData, incomingData);
         existingData.isInaccessible ||= incomingData.isInaccessible;
@@ -718,21 +709,25 @@ class FederationFactory {
         }
         return members;
     }
+    recordTagNamesByPath(data, nodePath) {
+        const path = nodePath || data.name;
+        if (data.persistedDirectivesData.tags.size > 0) {
+            const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, path, () => new Set());
+            for (const tagName of data.persistedDirectivesData.tags.keys()) {
+                tagNames.add(tagName);
+            }
+        }
+    }
     upsertParentDefinitionData(incomingData, subgraphName) {
         const entityInterfaceData = this.entityInterfaceFederationDataByTypeName.get(incomingData.name);
         const existingData = this.parentDefinitionDataByTypeName.get(incomingData.name);
         const baseData = existingData || incomingData;
         (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        this.recordTagNamesByPath(baseData);
         const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(baseData);
         if (isParentInaccessible) {
             this.inaccessiblePaths.add(incomingData.name);
         }
-        if (incomingData.persistedDirectivesData.tags.size > 0) {
-            const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, incomingData.name, () => new Set());
-            for (const tagName of incomingData.persistedDirectivesData.tags.keys()) {
-                tagNames.add(tagName);
-            }
-        }
         if (!existingData) {
             if (entityInterfaceData && entityInterfaceData.interfaceObjectSubgraphs.has(subgraphName)) {
                 incomingData.kind = graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
@@ -745,14 +740,16 @@ class FederationFactory {
             switch (incomingData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     for (const [enumValueName, enumValueData] of incomingData.enumValueDataByValueName) {
+                        const enumValuePath = `${incomingData.name}.${enumValueName}`;
                         enumValueData.node = {
                             directives: [],
                             kind: enumValueData.node.kind,
                             name: (0, utils_1.stringToNameNode)(enumValueData.name),
                         };
                         (0, utils_5.extractPersistedDirectives)(enumValueData.persistedDirectivesData, enumValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                        this.recordTagNamesByPath(enumValueData, enumValuePath);
                         if ((0, utils_5.isNodeDataInaccessible)(enumValueData)) {
-                            this.inaccessiblePaths.add(`${incomingData.name}.${enumValueName}`);
+                            this.inaccessiblePaths.add(enumValuePath);
                         }
                     }
                     return;
@@ -765,12 +762,12 @@ class FederationFactory {
                             type: inputValueData.type,
                         };
                         const namedInputFieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                        const inputFieldPath = `${incomingData.name}.${inputFieldName}`;
-                        (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputFieldPath);
+                        (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputValueData.renamedPath);
                         this.namedInputValueTypeNames.add(namedInputFieldTypeName);
                         (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                        this.recordTagNamesByPath(inputValueData, `${incomingData.name}.${inputFieldName}`);
                         if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(inputValueData)) {
-                            this.inaccessiblePaths.add(inputFieldPath);
+                            this.inaccessiblePaths.add(inputValueData.renamedPath);
                         }
                     }
                     return;
@@ -789,6 +786,7 @@ class FederationFactory {
                         (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, fieldData.namedTypeName, () => new Set()).add(fieldPath);
                         this.namedOutputTypeNames.add(fieldData.namedTypeName);
                         (0, utils_5.extractPersistedDirectives)(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                        this.recordTagNamesByPath(fieldData, fieldPath);
                         const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(fieldData);
                         if (isParentInaccessible || isFieldInaccessible) {
                             this.inaccessiblePaths.add(fieldPath);
@@ -801,14 +799,14 @@ class FederationFactory {
                                 type: inputValueData.type,
                             };
                             const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                            const argumentPath = `${fieldPath}(${argumentName}: ... )`;
-                            (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+                            (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
                             this.namedInputValueTypeNames.add(namedArgumentTypeName);
                             (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                            this.recordTagNamesByPath(inputValueData, `${fieldPath}.${argumentName}`);
                             /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
                              ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
                              ** error. */
-                            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
+                            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
                         }
                     }
                     return;
@@ -831,7 +829,7 @@ class FederationFactory {
             case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                 existingData.appearances += 1;
                 for (const data of incomingData.enumValueDataByValueName.values()) {
-                    this.upsertEnumValueData(existingData.enumValueDataByValueName, data);
+                    this.upsertEnumValueData(existingData.enumValueDataByValueName, data, isParentInaccessible);
                 }
                 return;
             case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
@@ -846,6 +844,7 @@ class FederationFactory {
                     (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputFieldPath);
                     this.namedInputValueTypeNames.add(namedInputFieldTypeName);
                     this.upsertInputValueData(existingData.inputValueDataByValueName, inputValueData);
+                    this.recordTagNamesByPath(inputValueData, inputFieldPath);
                     if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(inputValueData)) {
                         this.inaccessiblePaths.add(inputFieldPath);
                     }
@@ -857,16 +856,10 @@ class FederationFactory {
                 if (isParentInaccessible && !existingData.isInaccessible) {
                     this.propagateInaccessibilityToExistingChildren(existingData);
                 }
-                const objectData = incomingData;
-                if (objectData.persistedDirectivesData.tags.size > 0) {
-                    const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, incomingData.name, () => new Set());
-                    for (const tagName of objectData.persistedDirectivesData.tags.keys()) {
-                        tagNames.add(tagName);
-                    }
-                }
-                (0, utils_3.addIterableValuesToSet)(objectData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
-                (0, utils_3.addIterableValuesToSet)(objectData.subgraphNames, existingData.subgraphNames);
-                for (const fieldData of objectData.fieldDataByFieldName.values()) {
+                const definitionWithFieldsData = incomingData;
+                (0, utils_3.addIterableValuesToSet)(definitionWithFieldsData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+                (0, utils_3.addIterableValuesToSet)(definitionWithFieldsData.subgraphNames, existingData.subgraphNames);
+                for (const fieldData of definitionWithFieldsData.fieldDataByFieldName.values()) {
                     this.upsertFieldData(existingData.fieldDataByFieldName, fieldData, isParentInaccessible || existingData.isInaccessible);
                 }
                 return;
@@ -882,6 +875,7 @@ class FederationFactory {
         const existingData = this.objectExtensionDataByTypeName.get(incomingData.name);
         const baseData = existingData || incomingData;
         (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        this.recordTagNamesByPath(baseData);
         const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(baseData);
         if (isParentInaccessible) {
             this.inaccessiblePaths.add(incomingData.name);
@@ -903,6 +897,7 @@ class FederationFactory {
                 (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, fieldData.namedTypeName, () => new Set()).add(fieldPath);
                 this.namedOutputTypeNames.add(fieldData.namedTypeName);
                 (0, utils_5.extractPersistedDirectives)(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                this.recordTagNamesByPath(fieldData, fieldPath);
                 const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(fieldData);
                 if (isParentInaccessible || isFieldInaccessible) {
                     this.inaccessiblePaths.add(fieldPath);
@@ -915,11 +910,11 @@ class FederationFactory {
                         type: inputValueData.type,
                     };
                     const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                    const argumentPath = `${fieldPath}(${argumentName}: ... )`;
-                    (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+                    (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
                     this.namedInputValueTypeNames.add(namedArgumentTypeName);
                     (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-                    this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
+                    this.recordTagNamesByPath(inputValueData, `${incomingData.name}.${argumentName}`);
+                    this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
                 }
             }
             this.objectExtensionDataByTypeName.set(incomingData.name, incomingData);
@@ -947,8 +942,7 @@ class FederationFactory {
                     const fieldPath = `${fieldData.renamedParentTypeName}.${fieldName}`;
                     this.inaccessiblePaths.add(fieldPath);
                     for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
-                        const argumentPath = `${fieldPath}(${argumentName}: ... )`;
-                        this.inaccessiblePaths.add(argumentPath);
+                        this.inaccessiblePaths.add(inputValueData.renamedPath);
                     }
                 }
         }
@@ -1258,7 +1252,7 @@ class FederationFactory {
                             invalidFieldNames.add(fieldName);
                         }
                         fieldNodes.push((0, utils_5.getNodeWithPersistedDirectivesByFieldData)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, argumentNodes, this.errors));
-                        if (fieldData.isInaccessible) {
+                        if ((0, utils_5.isNodeDataInaccessible)(fieldData)) {
                             continue;
                         }
                         clientSchemaFieldNodes.push((0, utils_5.getClientSchemaFieldNodeByFieldData)(fieldData));
@@ -1436,10 +1430,10 @@ class FederationFactory {
             kind: graphql_1.Kind.DOCUMENT,
             definitions: this.routerDefinitions,
         };
-        const newClientAST = {
+        const newClientSchema = (0, graphql_1.buildASTSchema)({
             kind: graphql_1.Kind.DOCUMENT,
             definitions: this.clientDefinitions,
-        };
+        });
         const subgraphConfigBySubgraphName = new Map();
         for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
             subgraphConfigBySubgraphName.set(subgraph.name, {
@@ -1456,24 +1450,61 @@ class FederationFactory {
                 subgraphConfigBySubgraphName,
                 federatedGraphAST: newRouterAST,
                 federatedGraphSchema: (0, graphql_1.buildASTSchema)(newRouterAST),
-                federatedGraphClientSchema: (0, graphql_1.buildASTSchema)(newClientAST),
+                federatedGraphClientSchema: newClientSchema,
+                ...this.getClientSchemaObjectBoolean(),
             },
             ...warnings,
         };
     }
-    buildFederationContractResult(tagExclusions) {
+    getClientSchemaObjectBoolean() {
+        // If the schema does not implement @tag nor @inaccessible, an empty object will be spread
+        if (this.inaccessiblePaths.size < 1 && this.tagNamesByPath.size < 1) {
+            return {};
+        }
+        // otherwise, the object is spread in as true
+        return { shouldIncludeClientSchema: true };
+    }
+    handleChildRemovalByTag(parentDefinitionData, children, childTagDataByChildName, tagsToExclude) {
+        let accessibleChildren = children.size;
+        for (const [childName, childTagData] of childTagDataByChildName) {
+            const childData = (0, utils_3.getOrThrowError)(children, childName, `${parentDefinitionData.name}.childDataByChildName`);
+            if ((0, utils_5.isNodeDataInaccessible)(childData)) {
+                accessibleChildren -= 1;
+                continue;
+            }
+            if ((0, utils_3.doSetsIntersect)(tagsToExclude, childTagData.tagNames)) {
+                (0, utils_3.getValueOrDefault)(childData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
+                    (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                ]);
+                this.inaccessiblePaths.add(`${parentDefinitionData.name}.${childName}`);
+                accessibleChildren -= 1;
+            }
+        }
+        if (accessibleChildren < 1) {
+            parentDefinitionData.persistedDirectivesData.directives.set(string_constants_1.INACCESSIBLE, [
+                (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+            ]);
+            this.inaccessiblePaths.add(parentDefinitionData.name);
+        }
+    }
+    buildFederationContractResult(tagsToExclude) {
         if (!this.isVersionTwo) {
             /* If all the subgraphs are version one, the @inaccessible directive won't be present.
              ** However, contracts require @inaccessible to exclude applicable tagged types. */
             this.routerDefinitions.push(constants_1.INACCESSIBLE_DEFINITION);
         }
-        for (const [typeName, parentTagData] of this.parentTagDataByTypeName) {
-            // TODO assess children
-            const parentDefinitionData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, typeName, string_constants_1.PARENT_DEFINITION_DATA);
-            if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, parentTagData.tagNames)) {
-                (0, utils_3.getValueOrDefault)(parentDefinitionData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
+        for (const [parentTypeName, parentTagData] of this.parentTagDataByTypeName) {
+            const parentDefinitionData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, parentTypeName, string_constants_1.PARENT_DEFINITION_DATA);
+            if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
+                continue;
+            }
+            if ((0, utils_3.doSetsIntersect)(tagsToExclude, parentTagData.tagNames)) {
+                parentDefinitionData.persistedDirectivesData.directives.set(string_constants_1.INACCESSIBLE, [
                     (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                 ]);
+                this.inaccessiblePaths.add(parentTypeName);
+                // If the parent is inaccessible, there is no need to assess further
+                continue;
             }
             if (parentTagData.childTagDataByChildName.size < 1) {
                 continue;
@@ -1481,37 +1512,49 @@ class FederationFactory {
             switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                 // intentional fallthrough
-                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                // intentional fallthrough
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
                     continue;
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    this.handleChildRemovalByTag(parentDefinitionData, parentDefinitionData.enumValueDataByValueName, parentTagData.childTagDataByChildName, tagsToExclude);
+                    break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    for (const [inputFieldName, childTagData] of parentTagData.childTagDataByChildName) {
-                        const inputValueData = (0, utils_3.getOrThrowError)(parentDefinitionData.inputValueDataByValueName, inputFieldName, 'parentDefinitionData.inputValueDataByValueName');
-                        if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, childTagData.tagNames)) {
-                            (0, utils_3.getValueOrDefault)(inputValueData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
-                                (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
-                            ]);
-                        }
-                    }
+                    this.handleChildRemovalByTag(parentDefinitionData, parentDefinitionData.inputValueDataByValueName, parentTagData.childTagDataByChildName, tagsToExclude);
                     break;
                 default:
+                    let accessibleFields = parentDefinitionData.fieldDataByFieldName.size;
                     for (const [fieldName, childTagData] of parentTagData.childTagDataByChildName) {
-                        const fieldData = (0, utils_3.getOrThrowError)(parentDefinitionData.fieldDataByFieldName, fieldName, 'parentDefinitionData.fieldDataByFieldName');
-                        if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, childTagData.tagNames)) {
+                        const fieldData = (0, utils_3.getOrThrowError)(parentDefinitionData.fieldDataByFieldName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
+                        if ((0, utils_5.isNodeDataInaccessible)(fieldData)) {
+                            accessibleFields -= 1;
+                            continue;
+                        }
+                        if ((0, utils_3.doSetsIntersect)(tagsToExclude, childTagData.tagNames)) {
                             (0, utils_3.getValueOrDefault)(fieldData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
                                 (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                             ]);
+                            this.inaccessiblePaths.add(`${parentTypeName}.${fieldName}`);
+                            accessibleFields -= 1;
+                            continue;
                         }
                         for (const [argumentName, tagNames] of childTagData.tagNamesByArgumentName) {
-                            const inputValueData = (0, utils_3.getOrThrowError)(fieldData.argumentDataByArgumentName, argumentName, 'fieldData.argumentDataByArgumentName');
-                            if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, tagNames)) {
+                            const inputValueData = (0, utils_3.getOrThrowError)(fieldData.argumentDataByArgumentName, argumentName, `${fieldName}.argumentDataByArgumentName`);
+                            if ((0, utils_5.isNodeDataInaccessible)(inputValueData)) {
+                                continue;
+                            }
+                            if ((0, utils_3.doSetsIntersect)(tagsToExclude, tagNames)) {
                                 (0, utils_3.getValueOrDefault)(inputValueData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
                                     (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
                                 ]);
+                                this.inaccessiblePaths.add(inputValueData.renamedPath);
                             }
                         }
                     }
+                    if (accessibleFields < 1) {
+                        parentDefinitionData.persistedDirectivesData.directives.set(string_constants_1.INACCESSIBLE, [
+                            (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                        ]);
+                        this.inaccessiblePaths.add(parentTypeName);
+                    }
             }
         }
         for (const data of this.potentialPersistedDirectiveDefinitionDataByDirectiveName.values()) {
@@ -1529,10 +1572,10 @@ class FederationFactory {
             kind: graphql_1.Kind.DOCUMENT,
             definitions: this.routerDefinitions,
         };
-        const newClientAST = {
+        const newClientSchema = (0, graphql_1.buildASTSchema)({
             kind: graphql_1.Kind.DOCUMENT,
             definitions: this.clientDefinitions,
-        };
+        });
         const subgraphConfigBySubgraphName = new Map();
         for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
             subgraphConfigBySubgraphName.set(subgraph.name, {
@@ -1549,7 +1592,8 @@ class FederationFactory {
                 subgraphConfigBySubgraphName,
                 federatedGraphAST: newRouterAST,
                 federatedGraphSchema: (0, graphql_1.buildASTSchema)(newRouterAST),
-                federatedGraphClientSchema: (0, graphql_1.buildASTSchema)(newClientAST),
+                federatedGraphClientSchema: newClientSchema,
+                ...this.getClientSchemaObjectBoolean(),
             },
             warnings,
         };