[Fusion] Used @fusion__inaccessible in the execution schema (#8005)

glen-84 · web-flow · commit fbfa821fb6f3 · 2025-02-10T10:36:46.000+02:00
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Definitions/FusionInaccessibleDirectiveDefinition.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Definitions/FusionInaccessibleDirectiveDefinition.cs
@@ -4,9 +4,9 @@
 
 namespace HotChocolate.Fusion.Definitions;
 
-internal sealed class InaccessibleDirectiveDefinition : DirectiveDefinition
+internal sealed class FusionInaccessibleDirectiveDefinition : DirectiveDefinition
 {
-    public InaccessibleDirectiveDefinition() : base(Inaccessible)
+    public FusionInaccessibleDirectiveDefinition() : base(FusionInaccessible)
     {
         Locations =
             DirectiveLocation.ArgumentDefinition
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Extensions/DirectivesProviderExtensions.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Extensions/DirectivesProviderExtensions.cs
@@ -37,6 +37,11 @@ public static bool HasExternalDirective(this IDirectivesProvider type)
         return type.Directives.ContainsName(DirectiveNames.External);
     }
 
+    public static bool HasFusionInaccessibleDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(DirectiveNames.FusionInaccessible);
+    }
+
     public static bool HasInaccessibleDirective(this IDirectivesProvider type)
     {
         return type.Directives.ContainsName(DirectiveNames.Inaccessible);
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedEnumTypeRule.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedEnumTypeRule.cs
@@ -17,12 +17,12 @@ public void Handle(EnumTypeEvent @event, CompositionContext context)
     {
         var (enumType, schema) = @event;
 
-        if (enumType.HasInaccessibleDirective())
+        if (enumType.HasFusionInaccessibleDirective())
         {
             return;
         }
 
-        var accessibleValues = enumType.Values.Where(v => !v.HasInaccessibleDirective());
+        var accessibleValues = enumType.Values.Where(v => !v.HasFusionInaccessibleDirective());
 
         if (!accessibleValues.Any())
         {
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedInputObjectTypeRule.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedInputObjectTypeRule.cs
@@ -21,12 +21,12 @@ public void Handle(InputTypeEvent @event, CompositionContext context)
     {
         var (inputType, schema) = @event;
 
-        if (inputType.HasInaccessibleDirective())
+        if (inputType.HasFusionInaccessibleDirective())
         {
             return;
         }
 
-        var accessibleFields = inputType.Fields.Where(f => !f.HasInaccessibleDirective());
+        var accessibleFields = inputType.Fields.Where(f => !f.HasFusionInaccessibleDirective());
 
         if (!accessibleFields.Any())
         {
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedInterfaceTypeRule.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedInterfaceTypeRule.cs
@@ -17,12 +17,12 @@ public void Handle(InterfaceTypeEvent @event, CompositionContext context)
     {
         var (interfaceType, schema) = @event;
 
-        if (interfaceType.HasInaccessibleDirective())
+        if (interfaceType.HasFusionInaccessibleDirective())
         {
             return;
         }
 
-        var accessibleFields = interfaceType.Fields.Where(f => !f.HasInaccessibleDirective());
+        var accessibleFields = interfaceType.Fields.Where(f => !f.HasFusionInaccessibleDirective());
 
         if (!accessibleFields.Any())
         {
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedObjectTypeRule.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedObjectTypeRule.cs
@@ -21,12 +21,12 @@ public void Handle(ObjectTypeEvent @event, CompositionContext context)
     {
         var (objectType, schema) = @event;
 
-        if (schema.IsRootOperationType(objectType) || objectType.HasInaccessibleDirective())
+        if (schema.IsRootOperationType(objectType) || objectType.HasFusionInaccessibleDirective())
         {
             return;
         }
 
-        var accessibleFields = objectType.Fields.Where(f => !f.HasInaccessibleDirective());
+        var accessibleFields = objectType.Fields.Where(f => !f.HasFusionInaccessibleDirective());
 
         if (!accessibleFields.Any())
         {
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedUnionTypeRule.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedUnionTypeRule.cs
@@ -17,12 +17,12 @@ public void Handle(UnionTypeEvent @event, CompositionContext context)
     {
         var (unionType, schema) = @event;
 
-        if (unionType.HasInaccessibleDirective())
+        if (unionType.HasFusionInaccessibleDirective())
         {
             return;
         }
 
-        var accessibleTypes = unionType.Types.Where(t => !t.HasInaccessibleDirective());
+        var accessibleTypes = unionType.Types.Where(t => !t.HasFusionInaccessibleDirective());
 
         if (!accessibleTypes.Any())
         {
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/NoQueriesRule.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/NoQueriesRule.cs
@@ -30,7 +30,7 @@ public void Handle(ObjectTypeEvent @event, CompositionContext context)
             return;
         }
 
-        var accessibleFields = objectType.Fields.Where(f => !f.HasInaccessibleDirective());
+        var accessibleFields = objectType.Fields.Where(f => !f.HasFusionInaccessibleDirective());
 
         if (!accessibleFields.Any())
         {
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/SourceSchemaMerger.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/SourceSchemaMerger.cs
@@ -162,13 +162,14 @@ private static InputFieldDefinition MergeArguments(
         mergedArgument.Type = mergedArgument.Type.ReplaceNameType(
             _ => GetOrCreateType(mergedSchema, mergedArgument.Type));
 
+        AddFusionInputFieldDirectives(mergedArgument, argumentGroup);
+
         if (argumentGroup.Any(i => i.Argument.HasInaccessibleDirective()))
         {
-            mergedArgument.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            mergedArgument.Directives.Add(
+                new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionInputFieldDirectives(mergedArgument, argumentGroup);
-
         return mergedArgument;
     }
 
@@ -195,13 +196,13 @@ private EnumTypeDefinition MergeEnumTypes(
 
         enumType.Description = description;
 
+        AddFusionTypeDirectives(enumType, typeGroup);
+
         if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
         {
-            enumType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            enumType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionTypeDirectives(enumType, typeGroup);
-
         // [EnumValueName: [{EnumValue, EnumType, Schema}, ...], ...].
         var enumValueGroupByName = typeGroup
             .SelectMany(
@@ -235,13 +236,13 @@ private EnumValue MergeEnumValues(ImmutableArray<EnumValueInfo> enumValueGroup)
 
         var enumValue = new EnumValue(valueName) { Description = description };
 
+        AddFusionEnumValueDirectives(enumValue, enumValueGroup);
+
         if (enumValueGroup.Any(i => i.EnumValue.HasInaccessibleDirective()))
         {
-            enumValue.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            enumValue.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionEnumValueDirectives(enumValue, enumValueGroup);
-
         return enumValue;
     }
 
@@ -269,13 +270,14 @@ private InputObjectTypeDefinition MergeInputTypes(
 
         inputObjectType.Description = description;
 
+        AddFusionTypeDirectives(inputObjectType, typeGroup);
+
         if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
         {
-            inputObjectType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            inputObjectType.Directives.Add(
+                new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionTypeDirectives(inputObjectType, typeGroup);
-
         // [FieldName: [{Field, Type, Schema}, ...], ...].
         var fieldGroupByName = typeGroup
             .SelectMany(
@@ -326,13 +328,13 @@ private InputFieldDefinition MergeInputFields(
             Type = fieldType.ReplaceNameType(_ => GetOrCreateType(mergedSchema, fieldType))
         };
 
+        AddFusionInputFieldDirectives(inputField, inputFieldGroup);
+
         if (inputFieldGroup.Any(i => i.Field.HasInaccessibleDirective()))
         {
-            inputField.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            inputField.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionInputFieldDirectives(inputField, inputFieldGroup);
-
         return inputField;
     }
 
@@ -374,14 +376,15 @@ private InterfaceTypeDefinition MergeInterfaceTypes(
                 GetOrCreateType<InterfaceTypeDefinition>(mergedSchema, interfaceName));
         }
 
+        AddFusionTypeDirectives(interfaceType, typeGroup);
+        AddFusionImplementsDirectives(interfaceType, [.. interfaceGroupByName.SelectMany(g => g)]);
+
         if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
         {
-            interfaceType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            interfaceType.Directives.Add(
+                new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionTypeDirectives(interfaceType, typeGroup);
-        AddFusionImplementsDirectives(interfaceType, [.. interfaceGroupByName.SelectMany(g => g)]);
-
         // [FieldName: [{Field, Type, Schema}, ...], ...].
         var fieldGroupByName = typeGroup
             .SelectMany(
@@ -449,14 +452,14 @@ private InterfaceTypeDefinition MergeInterfaceTypes(
                 GetOrCreateType<InterfaceTypeDefinition>(mergedSchema, interfaceName));
         }
 
+        AddFusionTypeDirectives(objectType, typeGroup);
+        AddFusionImplementsDirectives(objectType, [.. interfaceGroupByName.SelectMany(g => g)]);
+
         if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
         {
-            objectType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            objectType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionTypeDirectives(objectType, typeGroup);
-        AddFusionImplementsDirectives(objectType, [.. interfaceGroupByName.SelectMany(g => g)]);
-
         // [FieldName: [{Field, Type, Schema}, ...], ...].
         var fieldGroupByName = typeGroup
             .SelectMany(
@@ -536,14 +539,14 @@ private InterfaceTypeDefinition MergeInterfaceTypes(
             }
         }
 
+        AddFusionFieldDirectives(outputField, fieldGroup);
+        AddFusionRequiresDirectives(outputField, fieldGroup);
+
         if (fieldGroup.Any(i => i.Field.HasInaccessibleDirective()))
         {
-            outputField.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            outputField.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionFieldDirectives(outputField, fieldGroup);
-        AddFusionRequiresDirectives(outputField, fieldGroup);
-
         return outputField;
     }
 
@@ -571,13 +574,13 @@ private ScalarTypeDefinition MergeScalarTypes(
 
         scalarType.Description = description;
 
+        AddFusionTypeDirectives(scalarType, typeGroup);
+
         if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
         {
-            scalarType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
+            scalarType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
         }
 
-        AddFusionTypeDirectives(scalarType, typeGroup);
-
         return scalarType;
     }
 
@@ -604,11 +607,6 @@ private UnionTypeDefinition MergeUnionTypes(
 
         unionType.Description = description;
 
-        if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
-        {
-            unionType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));
-        }
-
         AddFusionTypeDirectives(unionType, typeGroup);
 
         // [UnionMemberName: [{MemberType, UnionType, Schema}, ...], ...].
@@ -628,6 +626,11 @@ private UnionTypeDefinition MergeUnionTypes(
             unionType.Types.Add(GetOrCreateType<ObjectTypeDefinition>(mergedSchema, memberName));
         }
 
+        if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))
+        {
+            unionType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));
+        }
+
         return unionType;
     }
 
diff --git a/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/WellKnownDirectiveNames.cs b/src/HotChocolate/Fusion-vnext/src/Fusion.Composition/WellKnownDirectiveNames.cs
@@ -6,6 +6,7 @@ internal static class WellKnownDirectiveNames
     public const string FusionEnumValue = "fusion__enumValue";
     public const string FusionField = "fusion__field";
     public const string FusionImplements = "fusion__implements";
+    public const string FusionInaccessible = "fusion__inaccessible";
     public const string FusionInputField = "fusion__inputField";
     public const string FusionLookup = "fusion__lookup";
     public const string FusionRequires = "fusion__requires";
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Argument.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Argument.Tests.cs
@@ -105,9 +105,9 @@ type Query
                     @fusion__type(schema: A)
                     @fusion__type(schema: B) {
                     field(limit: Int
-                        @inaccessible
                         @fusion__inputField(schema: A)
-                        @fusion__inputField(schema: B)): Int
+                        @fusion__inputField(schema: B)
+                        @fusion__inaccessible): Int
                         @fusion__field(schema: A)
                         @fusion__field(schema: B)
                 }
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Enum.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Enum.Tests.cs
@@ -83,14 +83,14 @@ enum Status
                     @fusion__type(schema: A)
                     @fusion__type(schema: B) {
                     ACTIVE
-                        @inaccessible
                         @fusion__enumValue(schema: A)
+                        @fusion__inaccessible
                     INACTIVE
                         @fusion__enumValue(schema: A)
                         @fusion__enumValue(schema: B)
                     PENDING
-                        @inaccessible
                         @fusion__enumValue(schema: B)
+                        @fusion__inaccessible
                 }
                 """
             },
@@ -113,9 +113,9 @@ enum Status @inaccessible {
                 ],
                 """
                 enum Status
-                    @inaccessible
                     @fusion__type(schema: A)
-                    @fusion__type(schema: B) {
+                    @fusion__type(schema: B)
+                    @fusion__inaccessible {
                     ACTIVE
                         @fusion__enumValue(schema: A)
                     INACTIVE
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.EnumValue.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.EnumValue.Tests.cs
@@ -50,8 +50,8 @@ enum Status
                     ACTIVE
                         @fusion__enumValue(schema: A)
                     INACTIVE
-                        @inaccessible
                         @fusion__enumValue(schema: B)
+                        @fusion__inaccessible
                 }
                 """
             },
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.InputField.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.InputField.Tests.cs
@@ -81,9 +81,9 @@ input OrderFilter
                     @fusion__type(schema: A)
                     @fusion__type(schema: B) {
                     minTotal: Int
-                        @inaccessible
                         @fusion__inputField(schema: A)
                         @fusion__inputField(schema: B)
+                        @fusion__inaccessible
                 }
                 """
             },
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.InputObject.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.InputObject.Tests.cs
@@ -111,9 +111,9 @@ input OrderInput @inaccessible {
                 ],
                 """
                 input OrderInput
-                    @inaccessible
                     @fusion__type(schema: A)
-                    @fusion__type(schema: B) {
+                    @fusion__type(schema: B)
+                    @fusion__inaccessible {
                     id: ID!
                         @fusion__inputField(schema: A)
                         @fusion__inputField(schema: B)
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Interface.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Interface.Tests.cs
@@ -114,9 +114,9 @@ interface Product @inaccessible {
                 ],
                 """
                 interface Product
-                    @inaccessible
                     @fusion__type(schema: A)
-                    @fusion__type(schema: B) {
+                    @fusion__type(schema: B)
+                    @fusion__inaccessible {
                     id: ID!
                         @fusion__field(schema: A)
                         @fusion__field(schema: B)
@@ -168,9 +168,9 @@ interface I1
                 }
 
                 interface I2
-                    @inaccessible
                     @fusion__type(schema: A)
-                    @fusion__type(schema: B) {
+                    @fusion__type(schema: B)
+                    @fusion__inaccessible {
                     id: ID!
                         @fusion__field(schema: A)
                         @fusion__field(schema: B)
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Object.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Object.Tests.cs
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.OutputField.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.OutputField.Tests.cs
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Scalar.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Scalar.Tests.cs
diff --git a/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Union.Tests.cs b/src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaMerger.Union.Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,9 @@`
`4`	`4`
`5`	`5`	`namespace HotChocolate.Fusion.Definitions;`
`6`	`6`
`7`		`-internal sealed class InaccessibleDirectiveDefinition : DirectiveDefinition`
	`7`	`+internal sealed class FusionInaccessibleDirectiveDefinition : DirectiveDefinition`
`8`	`8`	`{`
`9`		`- public InaccessibleDirectiveDefinition() : base(Inaccessible)`
	`9`	`+ public FusionInaccessibleDirectiveDefinition() : base(FusionInaccessible)`
`10`	`10`	`{`
`11`	`11`	`Locations =`
`12`	`12`	`DirectiveLocation.ArgumentDefinition`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,11 @@ public static bool HasExternalDirective(this IDirectivesProvider type)`
`37`	`37`	`return type.Directives.ContainsName(DirectiveNames.External);`
`38`	`38`	`}`
`39`	`39`
	`40`	`+ public static bool HasFusionInaccessibleDirective(this IDirectivesProvider type)`
	`41`	`+ {`
	`42`	`+ return type.Directives.ContainsName(DirectiveNames.FusionInaccessible);`
	`43`	`+ }`
	`44`	`+`
`40`	`45`	`public static bool HasInaccessibleDirective(this IDirectivesProvider type)`
`41`	`46`	`{`
`42`	`47`	`return type.Directives.ContainsName(DirectiveNames.Inaccessible);`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,12 @@ public void Handle(EnumTypeEvent @event, CompositionContext context)`
`17`	`17`	`{`
`18`	`18`	`var (enumType, schema) = @event;`
`19`	`19`
`20`		`- if (enumType.HasInaccessibleDirective())`
	`20`	`+ if (enumType.HasFusionInaccessibleDirective())`
`21`	`21`	`{`
`22`	`22`	`return;`
`23`	`23`	`}`
`24`	`24`
`25`		`- var accessibleValues = enumType.Values.Where(v => !v.HasInaccessibleDirective());`
	`25`	`+ var accessibleValues = enumType.Values.Where(v => !v.HasFusionInaccessibleDirective());`
`26`	`26`
`27`	`27`	`if (!accessibleValues.Any())`
`28`	`28`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,12 @@ public void Handle(InputTypeEvent @event, CompositionContext context)`
`21`	`21`	`{`
`22`	`22`	`var (inputType, schema) = @event;`
`23`	`23`
`24`		`- if (inputType.HasInaccessibleDirective())`
	`24`	`+ if (inputType.HasFusionInaccessibleDirective())`
`25`	`25`	`{`
`26`	`26`	`return;`
`27`	`27`	`}`
`28`	`28`
`29`		`- var accessibleFields = inputType.Fields.Where(f => !f.HasInaccessibleDirective());`
	`29`	`+ var accessibleFields = inputType.Fields.Where(f => !f.HasFusionInaccessibleDirective());`
`30`	`30`
`31`	`31`	`if (!accessibleFields.Any())`
`32`	`32`	`{`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public void Handle(ObjectTypeEvent @event, CompositionContext context)`
`30`	`30`	`return;`
`31`	`31`	`}`
`32`	`32`
`33`		`- var accessibleFields = objectType.Fields.Where(f => !f.HasInaccessibleDirective());`
	`33`	`+ var accessibleFields = objectType.Fields.Where(f => !f.HasFusionInaccessibleDirective());`
`34`	`34`
`35`	`35`	`if (!accessibleFields.Any())`
`36`	`36`	`{`
Original file line number	Diff line number	Diff line change
`@@ -162,13 +162,14 @@ private static InputFieldDefinition MergeArguments(`
`162`	`162`	`mergedArgument.Type = mergedArgument.Type.ReplaceNameType(`
`163`	`163`	`_ => GetOrCreateType(mergedSchema, mergedArgument.Type));`
`164`	`164`
	`165`	`+ AddFusionInputFieldDirectives(mergedArgument, argumentGroup);`
	`166`	`+`
`165`	`167`	`if (argumentGroup.Any(i => i.Argument.HasInaccessibleDirective()))`
`166`	`168`	`{`
`167`		`- mergedArgument.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`169`	`+ mergedArgument.Directives.Add(`
	`170`	`+ new Directive(new FusionInaccessibleDirectiveDefinition()));`
`168`	`171`	`}`
`169`	`172`
`170`		`- AddFusionInputFieldDirectives(mergedArgument, argumentGroup);`
`171`		`-`
`172`	`173`	`return mergedArgument;`
`173`	`174`	`}`
`174`	`175`
`@@ -195,13 +196,13 @@ private EnumTypeDefinition MergeEnumTypes(`
`195`	`196`
`196`	`197`	`enumType.Description = description;`
`197`	`198`
	`199`	`+ AddFusionTypeDirectives(enumType, typeGroup);`
	`200`	`+`
`198`	`201`	`if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
`199`	`202`	`{`
`200`		`- enumType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`203`	`+ enumType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
`201`	`204`	`}`
`202`	`205`
`203`		`- AddFusionTypeDirectives(enumType, typeGroup);`
`204`		`-`
`205`	`206`	`// [EnumValueName: [{EnumValue, EnumType, Schema}, ...], ...].`
`206`	`207`	`var enumValueGroupByName = typeGroup`
`207`	`208`	`.SelectMany(`
`@@ -235,13 +236,13 @@ private EnumValue MergeEnumValues(ImmutableArray<EnumValueInfo> enumValueGroup)`
`235`	`236`
`236`	`237`	`var enumValue = new EnumValue(valueName) { Description = description };`
`237`	`238`
	`239`	`+ AddFusionEnumValueDirectives(enumValue, enumValueGroup);`
	`240`	`+`
`238`	`241`	`if (enumValueGroup.Any(i => i.EnumValue.HasInaccessibleDirective()))`
`239`	`242`	`{`
`240`		`- enumValue.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`243`	`+ enumValue.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
`241`	`244`	`}`
`242`	`245`
`243`		`- AddFusionEnumValueDirectives(enumValue, enumValueGroup);`
`244`		`-`
`245`	`246`	`return enumValue;`
`246`	`247`	`}`
`247`	`248`
`@@ -269,13 +270,14 @@ private InputObjectTypeDefinition MergeInputTypes(`
`269`	`270`
`270`	`271`	`inputObjectType.Description = description;`
`271`	`272`
	`273`	`+ AddFusionTypeDirectives(inputObjectType, typeGroup);`
	`274`	`+`
`272`	`275`	`if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
`273`	`276`	`{`
`274`		`- inputObjectType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`277`	`+ inputObjectType.Directives.Add(`
	`278`	`+ new Directive(new FusionInaccessibleDirectiveDefinition()));`
`275`	`279`	`}`
`276`	`280`
`277`		`- AddFusionTypeDirectives(inputObjectType, typeGroup);`
`278`		`-`
`279`	`281`	`// [FieldName: [{Field, Type, Schema}, ...], ...].`
`280`	`282`	`var fieldGroupByName = typeGroup`
`281`	`283`	`.SelectMany(`
`@@ -326,13 +328,13 @@ private InputFieldDefinition MergeInputFields(`
`326`	`328`	`Type = fieldType.ReplaceNameType(_ => GetOrCreateType(mergedSchema, fieldType))`
`327`	`329`	`};`
`328`	`330`
	`331`	`+ AddFusionInputFieldDirectives(inputField, inputFieldGroup);`
	`332`	`+`
`329`	`333`	`if (inputFieldGroup.Any(i => i.Field.HasInaccessibleDirective()))`
`330`	`334`	`{`
`331`		`- inputField.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`335`	`+ inputField.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
`332`	`336`	`}`
`333`	`337`
`334`		`- AddFusionInputFieldDirectives(inputField, inputFieldGroup);`
`335`		`-`
`336`	`338`	`return inputField;`
`337`	`339`	`}`
`338`	`340`
`@@ -374,14 +376,15 @@ private InterfaceTypeDefinition MergeInterfaceTypes(`
`374`	`376`	`GetOrCreateType<InterfaceTypeDefinition>(mergedSchema, interfaceName));`
`375`	`377`	`}`
`376`	`378`
	`379`	`+ AddFusionTypeDirectives(interfaceType, typeGroup);`
	`380`	`+ AddFusionImplementsDirectives(interfaceType, [.. interfaceGroupByName.SelectMany(g => g)]);`
	`381`	`+`
`377`	`382`	`if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
`378`	`383`	`{`
`379`		`- interfaceType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`384`	`+ interfaceType.Directives.Add(`
	`385`	`+ new Directive(new FusionInaccessibleDirectiveDefinition()));`
`380`	`386`	`}`
`381`	`387`
`382`		`- AddFusionTypeDirectives(interfaceType, typeGroup);`
`383`		`- AddFusionImplementsDirectives(interfaceType, [.. interfaceGroupByName.SelectMany(g => g)]);`
`384`		`-`
`385`	`388`	`// [FieldName: [{Field, Type, Schema}, ...], ...].`
`386`	`389`	`var fieldGroupByName = typeGroup`
`387`	`390`	`.SelectMany(`
`@@ -449,14 +452,14 @@ private InterfaceTypeDefinition MergeInterfaceTypes(`
`449`	`452`	`GetOrCreateType<InterfaceTypeDefinition>(mergedSchema, interfaceName));`
`450`	`453`	`}`
`451`	`454`
	`455`	`+ AddFusionTypeDirectives(objectType, typeGroup);`
	`456`	`+ AddFusionImplementsDirectives(objectType, [.. interfaceGroupByName.SelectMany(g => g)]);`
	`457`	`+`
`452`	`458`	`if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
`453`	`459`	`{`
`454`		`- objectType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`460`	`+ objectType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
`455`	`461`	`}`
`456`	`462`
`457`		`- AddFusionTypeDirectives(objectType, typeGroup);`
`458`		`- AddFusionImplementsDirectives(objectType, [.. interfaceGroupByName.SelectMany(g => g)]);`
`459`		`-`
`460`	`463`	`// [FieldName: [{Field, Type, Schema}, ...], ...].`
`461`	`464`	`var fieldGroupByName = typeGroup`
`462`	`465`	`.SelectMany(`
`@@ -536,14 +539,14 @@ private InterfaceTypeDefinition MergeInterfaceTypes(`
`536`	`539`	`}`
`537`	`540`	`}`
`538`	`541`
	`542`	`+ AddFusionFieldDirectives(outputField, fieldGroup);`
	`543`	`+ AddFusionRequiresDirectives(outputField, fieldGroup);`
	`544`	`+`
`539`	`545`	`if (fieldGroup.Any(i => i.Field.HasInaccessibleDirective()))`
`540`	`546`	`{`
`541`		`- outputField.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`547`	`+ outputField.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
`542`	`548`	`}`
`543`	`549`
`544`		`- AddFusionFieldDirectives(outputField, fieldGroup);`
`545`		`- AddFusionRequiresDirectives(outputField, fieldGroup);`
`546`		`-`
`547`	`550`	`return outputField;`
`548`	`551`	`}`
`549`	`552`
`@@ -571,13 +574,13 @@ private ScalarTypeDefinition MergeScalarTypes(`
`571`	`574`
`572`	`575`	`scalarType.Description = description;`
`573`	`576`
	`577`	`+ AddFusionTypeDirectives(scalarType, typeGroup);`
	`578`	`+`
`574`	`579`	`if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
`575`	`580`	`{`
`576`		`- scalarType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
	`581`	`+ scalarType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
`577`	`582`	`}`
`578`	`583`
`579`		`- AddFusionTypeDirectives(scalarType, typeGroup);`
`580`		`-`
`581`	`584`	`return scalarType;`
`582`	`585`	`}`
`583`	`586`
`@@ -604,11 +607,6 @@ private UnionTypeDefinition MergeUnionTypes(`
`604`	`607`
`605`	`608`	`unionType.Description = description;`
`606`	`609`
`607`		`- if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
`608`		`- {`
`609`		`- unionType.Directives.Add(new Directive(new InaccessibleDirectiveDefinition()));`
`610`		`- }`
`611`		`-`
`612`	`610`	`AddFusionTypeDirectives(unionType, typeGroup);`
`613`	`611`
`614`	`612`	`// [UnionMemberName: [{MemberType, UnionType, Schema}, ...], ...].`
`@@ -628,6 +626,11 @@ private UnionTypeDefinition MergeUnionTypes(`
`628`	`626`	`unionType.Types.Add(GetOrCreateType<ObjectTypeDefinition>(mergedSchema, memberName));`
`629`	`627`	`}`
`630`	`628`
	`629`	`+ if (typeGroup.Any(i => i.Type.HasInaccessibleDirective()))`
	`630`	`+ {`
	`631`	`+ unionType.Directives.Add(new Directive(new FusionInaccessibleDirectiveDefinition()));`
	`632`	`+ }`
	`633`	`+`
`631`	`634`	`return unionType;`
`632`	`635`	`}`
`633`	`636`