handle case where all fields are removed via Field visibility transformer

andimarek · andimarek · commit 84070430c597 · 2026-01-08T07:40:12.000+10:00
diff --git a/src/main/java/graphql/schema/transform/FieldVisibilitySchemaTransformation.java b/src/main/java/graphql/schema/transform/FieldVisibilitySchemaTransformation.java
@@ -4,6 +4,7 @@
 import graphql.PublicApi;
 import graphql.schema.GraphQLEnumType;
 import graphql.schema.GraphQLFieldDefinition;
+import graphql.schema.GraphQLFieldsContainer;
 import graphql.schema.GraphQLImplementingType;
 import graphql.schema.GraphQLInputObjectField;
 import graphql.schema.GraphQLInputObjectType;
@@ -24,6 +25,7 @@
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -45,7 +47,9 @@ public class FieldVisibilitySchemaTransformation {
     private final Runnable afterTransformationHook;
 
     public FieldVisibilitySchemaTransformation(VisibleFieldPredicate visibleFieldPredicate) {
-        this(visibleFieldPredicate, () -> {}, () -> {});
+        this(visibleFieldPredicate, () -> {
+        }, () -> {
+        });
     }
 
     public FieldVisibilitySchemaTransformation(VisibleFieldPredicate visibleFieldPredicate,
@@ -155,16 +159,53 @@ private static class FieldRemovalVisitor extends GraphQLTypeVisitorStub {
         private final VisibleFieldPredicate visibilityPredicate;
         private final Set<GraphQLType> removedTypes;
 
+        private final Set<GraphQLFieldDefinition> fieldDefinitionsToActuallyRemove = new LinkedHashSet<>();
+
         private FieldRemovalVisitor(VisibleFieldPredicate visibilityPredicate,
                                     Set<GraphQLType> removedTypes) {
             this.visibilityPredicate = visibilityPredicate;
             this.removedTypes = removedTypes;
         }
 
+        @Override
+        public TraversalControl visitGraphQLObjectType(GraphQLObjectType objectType, TraverserContext<GraphQLSchemaElement> context) {
+            return visitFieldsContainer(objectType, context);
+        }
+
+        @Override
+        public TraversalControl visitGraphQLInterfaceType(GraphQLInterfaceType objectType, TraverserContext<GraphQLSchemaElement> context) {
+            return visitFieldsContainer(objectType, context);
+        }
+
+        private TraversalControl visitFieldsContainer(GraphQLFieldsContainer fieldsContainer, TraverserContext<GraphQLSchemaElement> context) {
+            boolean allFieldsDeleted = true;
+            for (GraphQLFieldDefinition fieldDefinition : fieldsContainer.getFieldDefinitions()) {
+                VisibleFieldPredicateEnvironment environment = new VisibleFieldPredicateEnvironmentImpl(
+                        fieldDefinition, fieldsContainer);
+                if (!visibilityPredicate.isVisible(environment)) {
+                    fieldDefinitionsToActuallyRemove.add(fieldDefinition);
+                    removedTypes.add(fieldDefinition.getType());
+                } else {
+                    allFieldsDeleted = false;
+                }
+            }
+            if (allFieldsDeleted) {
+                // we are deleting the whole interface type because all fields are supposed to be deleted
+                return deleteNode(context);
+            } else {
+                return TraversalControl.CONTINUE;
+            }
+        }
+
+
         @Override
         public TraversalControl visitGraphQLFieldDefinition(GraphQLFieldDefinition definition,
                                                             TraverserContext<GraphQLSchemaElement> context) {
-            return visitField(definition, context);
+            if (fieldDefinitionsToActuallyRemove.contains(definition)) {
+                return deleteNode(context);
+            } else {
+                return TraversalControl.CONTINUE;
+            }
         }
 
         @Override
@@ -216,12 +257,12 @@ public TraversalControl visitGraphQLInterfaceType(GraphQLInterfaceType node,
         public TraversalControl visitGraphQLType(GraphQLSchemaElement node,
                                                  TraverserContext<GraphQLSchemaElement> context) {
             if (observedBeforeTransform.contains(node) &&
-                    !observedAfterTransform.contains(node) &&
-                    (node instanceof GraphQLObjectType ||
-                            node instanceof GraphQLEnumType ||
-                            node instanceof GraphQLInputObjectType ||
-                            node instanceof GraphQLInterfaceType ||
-                            node instanceof GraphQLUnionType)) {
+                !observedAfterTransform.contains(node) &&
+                (node instanceof GraphQLObjectType ||
+                 node instanceof GraphQLEnumType ||
+                 node instanceof GraphQLInputObjectType ||
+                 node instanceof GraphQLInterfaceType ||
+                 node instanceof GraphQLUnionType)) {
 
                 return deleteNode(context);
             }
diff --git a/src/test/groovy/graphql/schema/transform/FieldVisibilitySchemaTransformationTest.groovy b/src/test/groovy/graphql/schema/transform/FieldVisibilitySchemaTransformationTest.groovy
@@ -1073,7 +1073,7 @@ class FieldVisibilitySchemaTransformationTest extends Specification {
         def visibilitySchemaTransformation = new FieldVisibilitySchemaTransformation({ environment ->
             def directives = (environment.schemaElement as GraphQLDirectiveContainer).appliedDirectives
             return directives.find({ directive -> directive.name == "private" }) == null
-        }, { -> callbacks << "before" }, { -> callbacks << "after"} )
+        }, { -> callbacks << "before" }, { -> callbacks << "after" })
 
         GraphQLSchema schema = TestUtil.schema("""
 
@@ -1245,5 +1245,38 @@ class FieldVisibilitySchemaTransformationTest extends Specification {
         then:
         (restrictedSchema.getType("Account") as GraphQLObjectType).getFieldDefinition("billingStatus") == null
         restrictedSchema.getType("BillingStatus") == null
+
+    }
+
+    def "remove all fields from a type which is referenced via additional types"() {
+        given:
+        GraphQLSchema schema = TestUtil.schema("""
+        directive @private on FIELD_DEFINITION
+        type Query {
+         foo: Foo
+        }
+        type Foo {
+         foo: String
+         toDelete: ToDelete @private
+        } 
+        type ToDelete {
+         toDelete:String @private
+        }
+        """)
+
+        when:
+        schema.typeMap
+        def patchedSchema = schema.transform { builder ->
+            schema.typeMap.each { entry ->
+                def type = entry.value
+                if (type != schema.queryType && type != schema.mutationType && type != schema.subscriptionType) {
+                    builder.additionalType(type)
+                }
+            }
+        }
+        GraphQLSchema restrictedSchema = visibilitySchemaTransformation.apply(patchedSchema)
+        then:
+        (restrictedSchema.getType("Foo") as GraphQLObjectType).getFieldDefinition("toDelete") == null
     }
+
 }
