graphql 2.3.18 → 2.3.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e0bed192e241186842ca39b44c83c48f671afc972369ae621e99a35207c8a28
-  data.tar.gz: ae7547ce51cda8dbb8ae800248dd33baa85807fe08bfdeff2ca438ee3e00634a
+  metadata.gz: 271275308827280721c8a7d93c7a06cdb086c21a3d3ddb1443c27e20567ceba1
+  data.tar.gz: 4a6e8749d13c45572b86cee56eb8078afc6e70a62caff64d3abcf57d42b0fbfe
 SHA512:
-  metadata.gz: dc98ab1793f2331d09f2f768e39fe25de559de7c541d7c6eb1231d2bd81191b5aae965136a496abaeeeaa0306d734fff39a18f802aca9ee1acdfa7a2f48078b9
-  data.tar.gz: f27d94dc58836926fed62c5102f264fd4c473ded461888c22f3717da535a33751cfcfbd4a6d060fd3093799368fa88833fbf694b55c396d53a580797dc80800f
+  metadata.gz: e438382adc6974ff9cc323a076d94675422d8ec5ad5ca0d869421e5b278c9ffa55eb86f07074fa9479552ea17c50c4fc7fac27d630ad99f72977caad5b3adf39
+  data.tar.gz: d035be86b6070cee2aa2559a2567660a4b0847c93f1ab714691deec6f0a8d0eb468ebe1e89eefe33bb64d86ed2ad9fe769ef5b9e7d5fb1f2c9120f1047769fbe

data/lib/graphql/dataloader/async_dataloader.rb

@@ -12,6 +12,7 @@ module GraphQL
       end
 
       def run
+        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
         job_fibers = []
         next_job_fibers = []
         source_tasks = []
@@ -23,7 +24,7 @@ module GraphQL
             first_pass = false
             fiber_vars = get_fiber_variables
 
-            while (f = (job_fibers.shift || spawn_job_fiber))
+            while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber)))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -37,7 +38,7 @@ module GraphQL
             Sync do |root_task|
               set_fiber_variables(fiber_vars)
               while source_tasks.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-                while (task = source_tasks.shift || spawn_source_task(root_task, sources_condition))
+                while (task = (source_tasks.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size + next_source_tasks.size) < total_fiber_limit) && spawn_source_task(root_task, sources_condition))))
                   if task.alive?
                     root_task.yield # give the source task a chance to run
                     next_source_tasks << task

data/lib/graphql/dataloader/source.rb

@@ -98,7 +98,7 @@ module GraphQL
         while pending_result_keys.any? { |key| !@results.key?(key) }
           iterations += 1
           if iterations > MAX_ITERATIONS
-            raise "#{self.class}#sync tried #{MAX_ITERATIONS} times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency."
+            raise "#{self.class}#sync tried #{MAX_ITERATIONS} times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency#{@dataloader.fiber_limit ? " or `fiber_limit: #{@dataloader.fiber_limit}` is set too low" : ""}."
           end
           @dataloader.yield
         end

data/lib/graphql/dataloader.rb

@@ -24,18 +24,23 @@ module GraphQL
   #
   class Dataloader
     class << self
-      attr_accessor :default_nonblocking
+      attr_accessor :default_nonblocking, :default_fiber_limit
     end
 
-    NonblockingDataloader = Class.new(self) { self.default_nonblocking = true }
-
-    def self.use(schema, nonblocking: nil)
-      schema.dataloader_class = if nonblocking
+    def self.use(schema, nonblocking: nil, fiber_limit: nil)
+      dataloader_class = if nonblocking
         warn("`nonblocking: true` is deprecated from `GraphQL::Dataloader`, please use `GraphQL::Dataloader::AsyncDataloader` instead. Docs: https://graphql-ruby.org/dataloader/async_dataloader.")
-        NonblockingDataloader
+        Class.new(self) { self.default_nonblocking = true }
       else
         self
       end
+
+      if fiber_limit
+        dataloader_class = Class.new(dataloader_class)
+        dataloader_class.default_fiber_limit = fiber_limit
+      end
+
+      schema.dataloader_class = dataloader_class
     end
 
     # Call the block with a Dataloader instance,
@@ -50,14 +55,18 @@ module GraphQL
       result
     end
 
-    def initialize(nonblocking: self.class.default_nonblocking)
+    def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.class.default_fiber_limit)
       @source_cache = Hash.new { |h, k| h[k] = {} }
       @pending_jobs = []
       if !nonblocking.nil?
         @nonblocking = nonblocking
       end
+      @fiber_limit = fiber_limit
     end
 
+    # @return [Integer, nil]
+    attr_reader :fiber_limit
+
     def nonblocking?
       @nonblocking
     end
@@ -178,6 +187,7 @@ module GraphQL
     end
 
     def run
+      jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
       next_job_fibers = []
       source_fibers = []
@@ -187,7 +197,7 @@ module GraphQL
         while first_pass || job_fibers.any?
           first_pass = false
 
-          while (f = (job_fibers.shift || spawn_job_fiber))
+          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber)))
             if f.alive?
               finished = run_fiber(f)
               if !finished
@@ -197,8 +207,8 @@ module GraphQL
           end
           join_queues(job_fibers, next_job_fibers)
 
-          while source_fibers.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-            while (f = source_fibers.shift || spawn_source_fiber)
+          while (source_fibers.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
+            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -242,6 +252,17 @@ module GraphQL
 
     private
 
+    def calculate_fiber_limit
+      total_fiber_limit = @fiber_limit || Float::INFINITY
+      if total_fiber_limit < 4
+        raise ArgumentError, "Dataloader fiber limit is too low (#{total_fiber_limit}), it must be at least 4"
+      end
+      total_fiber_limit -= 1 # deduct one fiber for `manager`
+      # Deduct at least one fiber for sources
+      jobs_fiber_limit = total_fiber_limit - 2
+      return jobs_fiber_limit, total_fiber_limit
+    end
+
     def join_queues(prev_queue, new_queue)
       @nonblocking && Fiber.scheduler.run
       prev_queue.concat(new_queue)

data/lib/graphql/query/null_context.rb

@@ -28,7 +28,7 @@ module GraphQL
       end
 
       def types
-        @types ||= GraphQL::Schema::Warden::SchemaSubset.new(@warden)
+        @types ||= Schema::Warden::VisibilityProfile.new(@warden)
       end
     end
   end

data/lib/graphql/query.rb

@@ -95,21 +95,24 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_schema_subset: nil)
+    # @param visibility_profile [Symbol]
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, visibility_profile: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_visibility_profile: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
       @context = schema.context_class.new(query: self, values: context)
 
-      if use_schema_subset.nil?
-        use_schema_subset = warden ? false : schema.use_schema_visibility?
+      if use_visibility_profile.nil?
+        use_visibility_profile = warden ? false : schema.use_visibility_profile?
       end
 
-      if use_schema_subset
-        @schema_subset = @schema.subset_class.new(context: @context, schema: @schema)
+      @visibility_profile = visibility_profile
+
+      if use_visibility_profile
+        @visibility_profile = @schema.visibility.profile_for(@context, visibility_profile)
         @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
       else
-        @schema_subset = nil
+        @visibility_profile = nil
         @warden = warden
       end
 
@@ -187,6 +190,9 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
+    # @return [Symbol, nil]
+    attr_reader :visibility_profile
+
     attr_accessor :multiplex
 
     # @return [GraphQL::Tracing::Trace]
@@ -203,15 +209,19 @@ module GraphQL
     def lookahead
       @lookahead ||= begin
         ast_node = selected_operation
-        root_type = case ast_node.operation_type
-        when nil, "query"
-          types.query_root # rubocop:disable Development/ContextIsPassedCop
-        when "mutation"
-          types.mutation_root # rubocop:disable Development/ContextIsPassedCop
-        when "subscription"
-          types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+        if ast_node.nil?
+          GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+        else
+          root_type = case ast_node.operation_type
+          when nil, "query"
+            types.query_root # rubocop:disable Development/ContextIsPassedCop
+          when "mutation"
+            types.mutation_root # rubocop:disable Development/ContextIsPassedCop
+          when "subscription"
+            types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+          end
+          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
         end
-        GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
 
@@ -343,10 +353,33 @@ module GraphQL
       with_prepared_ast { @warden }
     end
 
-    def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
+    def get_type(type_name)
+      types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def get_field(owner, field_name)
+      types.field(owner, field_name) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def possible_types(type)
+      types.possible_types(type) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def root_type_for_operation(op_type)
+      case op_type
+      when "query"
+        types.query_root # rubocop:disable Development/ContextIsPassedCop
+      when "mutation"
+        types.mutation_root # rubocop:disable Development/ContextIsPassedCop
+      when "subscription"
+        types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+      else
+        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected 'query', 'mutation', or 'subscription'"
+      end
+    end
 
     def types
-      @schema_subset || warden.schema_subset
+      @visibility_profile || warden.visibility_profile
     end
 
     # @param abstract_type [GraphQL::UnionType, GraphQL::InterfaceType]

data/lib/graphql/schema/always_visible.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 module GraphQL
   class Schema
-    class AlwaysVisible
+    module AlwaysVisible
       def self.use(schema, **opts)
-        schema.warden_class = GraphQL::Schema::Warden::NullWarden
-        schema.subset_class = GraphQL::Schema::Warden::NullWarden::NullSubset
+        schema.extend(self)
+      end
+
+      def visible?(_member, _context)
+        true
       end
     end
   end

data/lib/graphql/schema/argument.rb

@@ -364,6 +364,7 @@ module GraphQL
 
       # @api private
       def validate_default_value
+        return unless default_value?
         coerced_default_value = begin
           # This is weird, but we should accept single-item default values for list-type arguments.
           # If we used `coerce_isolated_input` below, it would do this for us, but it's not really

data/lib/graphql/schema/build_from_definition.rb

@@ -188,6 +188,7 @@ module GraphQL
 
             def self.inherited(child_class)
               child_class.definition_default_resolve = self.definition_default_resolve
+              super
             end
           end
 

data/lib/graphql/schema/enum.rb

@@ -153,6 +153,8 @@ module GraphQL
           else
             nil
           end
+        # rescue MissingValuesError
+        #   nil
         end
 
         # Called by the runtime when a field returns a value to give back to the client.

data/lib/graphql/schema/input_object.rb

@@ -133,12 +133,14 @@ module GraphQL
           end
           # Add a method access
           method_name = argument_defn.keyword
-          class_eval <<-RUBY, __FILE__, __LINE__
-            def #{method_name}
-              self[#{method_name.inspect}]
-            end
-            alias_method :#{method_name}, :#{method_name}
-          RUBY
+          suppress_redefinition_warning do
+            class_eval <<-RUBY, __FILE__, __LINE__
+              def #{method_name}
+                self[#{method_name.inspect}]
+              end
+              alias_method :#{method_name}, :#{method_name}
+            RUBY
+          end
           argument_defn
         end
 
@@ -163,7 +165,7 @@ module GraphQL
 
           # Inject missing required arguments
           missing_required_inputs = ctx.types.arguments(self).reduce({}) do |m, (argument)|
-            if !input.key?(argument.graphql_name) && argument.type.non_null? && types.argument(self, argument.graphql_name)
+            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value? && types.argument(self, argument.graphql_name)
               m[argument.graphql_name] = nil
             end
 
@@ -243,6 +245,17 @@ module GraphQL
 
           result
         end
+
+        private
+
+        # Suppress redefinition warning for objectId arguments
+        def suppress_redefinition_warning
+          verbose = $VERBOSE
+          $VERBOSE = nil
+          yield
+        ensure
+          $VERBOSE = verbose
+        end
       end
 
       private

data/lib/graphql/schema/member/has_arguments.rb

@@ -135,7 +135,7 @@ module GraphQL
 
             def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
               warden = Warden.from_context(context)
-              skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Subset)
+              skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
               for ancestor in ancestors
                 if ancestor.respond_to?(:own_arguments) &&
                   (a = ancestor.own_arguments[argument_name]) &&
@@ -210,7 +210,7 @@ module GraphQL
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
         def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
-          if (arg_config = own_arguments[argument_name]) && ((context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Subset)) || (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden)))
+          if (arg_config = own_arguments[argument_name]) && ((context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)) || (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden)))
             visible_arg || arg_config
           elsif defined?(@resolver_class) && @resolver_class
             @resolver_class.get_field_argument(argument_name, context)

data/lib/graphql/schema/member/has_fields.rb

@@ -99,7 +99,7 @@ module GraphQL
         module InterfaceMethods
           def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
-            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Subset)
+            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
             for ancestor in ancestors
               if ancestor.respond_to?(:own_fields) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
@@ -135,7 +135,7 @@ module GraphQL
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             ancs = ancestors
-            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Subset)
+            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
             i = 0
             while (ancestor = ancs[i])
               if ancestor.respond_to?(:own_fields) &&

data/lib/graphql/schema/validator/required_validator.rb

@@ -35,9 +35,10 @@ module GraphQL
       #   end
       #
       class RequiredValidator < Validator
-        # @param one_of [Symbol, Array<Symbol>] An argument, or a list of arguments, that represents a valid set of inputs for this field
+        # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
+        # @param argument [Symbol] An argument that is required for this field
         # @param message [String]
-        def initialize(one_of: nil, argument: nil, message: "%{validated} has the wrong arguments", **default_options)
+        def initialize(one_of: nil, argument: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
@@ -49,7 +50,7 @@ module GraphQL
           super(**default_options)
         end
 
-        def validate(_object, _context, value)
+        def validate(_object, context, value)
           matched_conditions = 0
 
           if !value.nil?
@@ -73,9 +74,32 @@ module GraphQL
           if matched_conditions == 1
             nil # OK
           else
-            @message
+            @message || build_message(context)
           end
         end
+
+        def build_message(context)
+          argument_definitions = @validated.arguments(context).values
+          required_names = @one_of.map do |arg_keyword|
+            if arg_keyword.is_a?(Array)
+              names = arg_keyword.map { |arg| arg_keyword_to_grapqhl_name(argument_definitions, arg) }
+              "(" + names.join(" and ") + ")"
+            else
+              arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+            end
+          end
+
+          if required_names.size == 1
+            "%{validated} must include the following argument: #{required_names.first}."
+          else
+            "%{validated} must include exactly one of the following arguments: #{required_names.join(", ")}."
+          end
+        end
+
+        def arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+          argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
+          argument_definition.graphql_name
+        end
       end
     end
   end

data/lib/graphql/schema/visibility/migration.rb

@@ -2,7 +2,7 @@
 module GraphQL
   class Schema
     class Visibility
-      # You can use this to see how {GraphQL::Schema::Warden} and {GraphQL::Schema::Visibility::Subset}
+      # You can use this to see how {GraphQL::Schema::Warden} and {GraphQL::Schema::Visibility::Profile}
       # handle `.visible?` differently in your schema.
       #
       # It runs the same method on both implementations and raises an error when the results diverge.
@@ -15,28 +15,24 @@ module GraphQL
       # This plugin adds two keys to `context` when running:
       #
       # - `visibility_migration_running: true`
-      # - For the {Warden} which it instantiates, it adds `visibility_migration_warden_running: true`.
+      # - For the {Schema::Warden} which it instantiates, it adds `visibility_migration_warden_running: true`.
       #
       # Use those keys to modify your `visible?` behavior as needed.
       #
       # Also, in a pinch, you can set `skip_visibility_migration_error: true` in context to turn off this behavior per-query.
-      # (In that case, it uses {Subset} directly.)
+      # (In that case, it uses {Profile} directly.)
       #
       # @example Adding this plugin
       #
-      #   use GraphQL::Schema::Visibility::Migration
+      #   use GraphQL::Schema::Visibility, migration_errors: true
       #
-      class Migration < GraphQL::Schema::Visibility::Subset
-        def self.use(schema)
-          schema.subset_class = self
-        end
-
+      class Migration < GraphQL::Schema::Visibility::Profile
         class RuntimeTypesMismatchError < GraphQL::Error
-          def initialize(method_called, warden_result, subset_result, method_args)
+          def initialize(method_called, warden_result, profile_result, method_args)
             super(<<~ERR)
               Mismatch in types for `##{method_called}(#{method_args.map(&:inspect).join(", ")})`:
 
-              #{compare_results(warden_result, subset_result)}
+              #{compare_results(warden_result, profile_result)}
 
               Update your `.visible?` implementation to make these implementations return the same value.
 
@@ -45,9 +41,9 @@ module GraphQL
           end
 
           private
-          def compare_results(warden_result, subset_result)
-            if warden_result.is_a?(Array) && subset_result.is_a?(Array)
-              all_results = warden_result | subset_result
+          def compare_results(warden_result, profile_result)
+            if warden_result.is_a?(Array) && profile_result.is_a?(Array)
+              all_results = warden_result | profile_result
               all_results.sort_by!(&:graphql_name)
 
               entries_text = all_results.map { |entry| "#{entry.graphql_name} (#{entry})"}
@@ -55,13 +51,13 @@ module GraphQL
               yes = "    ✔   "
               no =  "        "
               res = "".dup
-              res << "#{"Result".center(width)} Warden  Subset \n"
+              res << "#{"Result".center(width)} Warden  Profile \n"
               all_results.each_with_index do |entry, idx|
-                res << "#{entries_text[idx].ljust(width)}#{warden_result.include?(entry) ? yes : no}#{subset_result.include?(entry) ? yes : no}\n"
+                res << "#{entries_text[idx].ljust(width)}#{warden_result.include?(entry) ? yes : no}#{profile_result.include?(entry) ? yes : no}\n"
               end
               res << "\n"
             else
-              "- Warden returned: #{humanize(warden_result)}\n\n- Subset returned: #{humanize(subset_result)}"
+              "- Warden returned: #{humanize(warden_result)}\n\n- Visibility::Profile returned: #{humanize(profile_result)}"
             end
           end
           def humanize(val)
@@ -80,38 +76,39 @@ module GraphQL
           end
         end
 
-        def initialize(context:, schema:)
-          @skip_error = context[:skip_visibility_migration_error]
-          context[:visibility_migration_running] = true
-          @subset_types = GraphQL::Schema::Visibility::Subset.new(context: context, schema: schema)
+        def initialize(context:, schema:, name: nil)
+          @name = name
+          @skip_error = context[:skip_visibility_migration_error] || context.is_a?(Query::NullContext) || context.is_a?(Hash)
+          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema)
           if !@skip_error
+            context[:visibility_migration_running] = true
             warden_ctx_vals = context.to_h.dup
             warden_ctx_vals[:visibility_migration_warden_running] = true
-            if defined?(schema::WardenCompatSchema)
-              warden_schema = schema::WardenCompatSchema
+            if schema.const_defined?(:WardenCompatSchema, false) # don't use a defn from a superclass
+              warden_schema = schema.const_get(:WardenCompatSchema, false)
             else
               warden_schema = Class.new(schema)
-              warden_schema.use_schema_visibility = false
+              warden_schema.use_visibility_profile = false
               # TODO public API
               warden_schema.send(:add_type_and_traverse, [warden_schema.query, warden_schema.mutation, warden_schema.subscription].compact, root: true)
               warden_schema.send(:add_type_and_traverse, warden_schema.directives.values + warden_schema.orphan_types, root: false)
+              schema.const_set(:WardenCompatSchema, warden_schema)
             end
             warden_ctx = GraphQL::Query::Context.new(query: context.query, values: warden_ctx_vals)
-            example_warden = GraphQL::Schema::Warden.new(schema: warden_schema, context: warden_ctx)
-            @warden_types = example_warden.schema_subset
-            warden_ctx.warden = example_warden
-            warden_ctx.types = @warden_types
+            warden_ctx.warden = GraphQL::Schema::Warden.new(schema: warden_schema, context: warden_ctx)
+            warden_ctx.types = @warden_types = warden_ctx.warden.visibility_profile
           end
         end
 
         def loaded_types
-          @subset_types.loaded_types
+          @profile_types.loaded_types
         end
 
-        PUBLIC_SUBSET_METHODS = [
+        PUBLIC_PROFILE_METHODS = [
           :enum_values,
           :interfaces,
           :all_types,
+          :all_types_h,
           :fields,
           :loadable?,
           :type,
@@ -127,14 +124,14 @@ module GraphQL
           :reachable_type?
         ]
 
-        PUBLIC_SUBSET_METHODS.each do |subset_method|
-          define_method(subset_method) do |*args|
-            call_method_and_compare(subset_method, args)
+        PUBLIC_PROFILE_METHODS.each do |profile_method|
+          define_method(profile_method) do |*args|
+            call_method_and_compare(profile_method, args)
           end
         end
 
         def call_method_and_compare(method, args)
-          res_1 = @subset_types.public_send(method, *args)
+          res_1 = @profile_types.public_send(method, *args)
           if @skip_error
             return res_1
           end