Make Schema.warden_class pluggable

Author: rmosolgo

lib/graphql/language/document_from_schema_definition.rb

@@ -30,7 +30,7 @@ def initialize(
         end
 
         schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
-        @warden = GraphQL::Schema::Warden.new(
+        @warden = @schema.warden_class.new(
           filter,
           schema: @schema,
           context: schema_context,

lib/graphql/query.rb

@@ -375,7 +375,7 @@ def find_operation(operations, operation_name)
 
     def prepare_ast
       @prepared_ast = true
-      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
+      @warden ||= @schema.warden_class.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string

lib/graphql/query/null_context.rb

@@ -3,14 +3,6 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext
-      class NullWarden < GraphQL::Schema::Warden
-        def visible_field?(field, ctx); true; end
-        def visible_argument?(arg, ctx); true; end
-        def visible_type?(type, ctx); true; end
-        def visible_enum_value?(ev, ctx); true; end
-        def visible_type_membership?(tm, ctx); true; end
-      end
-
       class NullQuery
       end
 
@@ -23,11 +15,7 @@ def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
-        @warden = NullWarden.new(
-          GraphQL::Filter.new(silence_deprecation_warning: true),
-          context: self,
-          schema: @schema,
-        )
+        @warden = Schema::Warden::NullWarden.new(nil, context: self, schema: @schema)
       end
 
       def [](key); end

lib/graphql/schema.rb

@@ -418,6 +418,18 @@ def root_types
         @root_types
       end
 
+      def warden_class
+        if defined?(@warden_class)
+          @warden_class
+        elsif superclass.respond_to?(:warden_class)
+          superclass.warden_class
+        else
+          GraphQL::Schema::Warden
+        end
+      end
+
+      attr_writer :warden_class
+
       # @param type [Module] The type definition whose possible types you want to see
       # @return [Hash<String, Module>] All possible types, if no `type` is given.
       # @return [Array<Module>] Possible types for `type`, if it's given.

lib/graphql/schema/warden.rb

@@ -87,6 +87,33 @@ def arguments(owner, ctx); owner.arguments(ctx); end
         end
       end
 
+      class NullWarden
+        def initialize(_filter, context:, schema:)
+          @schema = schema
+          # TODO consider per-query caches even though there's no filtering
+        end
+
+        def visible_field?(field_defn, _ctx = nil, owner = nil); true; end
+        def visible_argument?(arg_defn, _ctx = nil); true; end
+        def visible_type?(type_defn, _ctx = nil); true; end
+        def visible_enum_value?(enum_value, _ctx = nil); true; end
+        def visible_type_membership?(type_membership, _ctx = nil); true; end
+        def interface_type_memberships(obj_type, _ctx = nil); obj_type.interface_type_memberships; end
+        def get_type(type_name); @schema.get_type(type_name); end
+        def arguments(argument_owner, ctx = nil); argument_owner.arguments(ctx).values; end
+        def enum_values(enum_defn); enum_defn.enum_values; end
+        def get_argument(parent_type, argument_name); parent_type.get_argument(argument_name); end
+        def types; @schema.types; end
+        def root_type_for_operation(op_name); @schema.root_type_for_operation(op_name); end
+        def directives; @schema.directives.values; end
+        def fields(type_defn); type_defn.fields; end
+        def get_field(parent_type, field_name); @schema.get_field(parent_type, field_name); end
+        def reachable_type?(type_name); true; end
+        def reachable_types; @schema.types.values; end
+        def possible_types(type_defn); @schema.possible_types(type_defn); end
+        def interfaces(obj_type); obj_type.interfaces; end
+      end
+
       # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]

spec/graphql/execution/interpreter_spec.rb

@@ -261,6 +261,8 @@ class Schema < GraphQL::Schema
       mutation(Mutation)
       lazy_resolve(Box, :value)
 
+      self.warden_class = GraphQL::Schema::Warden::NullWarden
+
       def self.object_from_id(id, ctx)
         OpenStruct.new(id: id)
       end

spec/graphql/schema/warden_spec.rb

@@ -948,4 +948,15 @@ class Query < GraphQL::Schema::Object
       end
     end
   end
+
+  describe "NullWarden" do
+    it "implements all Warden methods" do
+      warden_methods = GraphQL::Schema::Warden.instance_methods - Object.methods
+      warden_methods.each do |method_name|
+        warden_params =  GraphQL::Schema::Warden.instance_method(method_name).parameters
+        assert GraphQL::Schema::Warden::NullWarden.method_defined?(method_name), "Null warden also responds to #{method_name} (#{warden_params})"
+        assert_equal warden_params, GraphQL::Schema::Warden::NullWarden.instance_method(method_name).parameters,"#{method_name} has the same parameters"
+      end
+    end
+  end
 end

spec/spec_helper.rb

@@ -60,7 +60,9 @@ def prepare_ast
   def setup_finalizer
     if !@finalizer_defined
       @finalizer_defined = true
-      ObjectSpace.define_finalizer(self, CheckShape.new(warden))
+      if warden.is_a?(GraphQL::Schema::Warden)
+        ObjectSpace.define_finalizer(self, CheckShape.new(warden))
+      end
     end
   end
 end