graphql 1.10.0.pre2 → 1.10.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b0dea1cf870243e0c1ca99c9aa276b3ab6dca48c94048d99033c7e868d6edb7
-  data.tar.gz: a9067feb798b969d50e6cd3b436432adba4216ad8b66d58cd8cde2d76f9d5589
+  metadata.gz: 78e01c4a75da2ab94a931c38e49c2e697de00b28837045807d1c7c9f02a9d831
+  data.tar.gz: eb281e483efaafef9824d8e41f0dc0558fe2c2351a4d675d2b875cc2de630a8f
 SHA512:
-  metadata.gz: d2effe2d2074b17026c7c6e3ddc71db82b1bd17ce8624dbdd9a88345ff39b2177ae48981deabdda227fb4bcf965469a5e874faeb76c0830d598fdb5501673c98
-  data.tar.gz: 810111555e1713e4d0d6afabba7102a03f458349d135d92f573236feedd116d81481ba7119c364d9533d39f1d98aa940ce32dc7d452008f6c00827796e5794ef
+  metadata.gz: 893b327d435f43a7ab1e97940662a9d786b27446b07280df6fe171e1271cc07048ed1098e7bf6cf7bd643d9c77765be4b1abd175f771faefdcc4cc6e49e0724a
+  data.tar.gz: 7ca9736e3fd003b784f2a5c3dfa62a02b44675623c0cddfb4064d26924e77694b6f1f05a9f6ab795d2e6f6ced93f8e57542e4b63123485a7f4599c6d92c36db7

data/lib/graphql/execution/errors.rb

@@ -2,7 +2,7 @@
 
 module GraphQL
   module Execution
-    # A tracer that wraps query execution with error handling.
+    # A plugin that wraps query execution with error handling.
     # Supports class-based schemas and the new {Interpreter} runtime only.
     #
     # @example Handling ActiveRecord::NotFound
@@ -18,31 +18,35 @@ module GraphQL
     #
     class Errors
       def self.use(schema)
-        schema.tracer(self.new)
+        schema.error_handler = self.new(schema)
       end
 
-      def trace(event, data)
-        case event
-        when "execute_field", "execute_field_lazy"
-          with_error_handling(data) { yield }
-        else
+      def initialize(schema)
+        @schema = schema
+      end
+
+      class NullErrorHandler
+        def self.with_error_handling(_ctx)
           yield
         end
       end
 
-      private
-
-      def with_error_handling(trace_data)
+      # Call the given block with the schema's configured error handlers.
+      #
+      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
+      #
+      # @param ctx [GraphQL::Query::Context]
+      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
+      def with_error_handling(ctx)
         yield
       rescue StandardError => err
-        ctx = trace_data[:query].context
-        schema = ctx.schema
-        rescues = schema.rescues
+        rescues = ctx.schema.rescues
         _err_class, handler = rescues.find { |err_class, handler| err.is_a?(err_class) }
         if handler
-          obj = trace_data[:object]
-          args = trace_data[:arguments]
-          field = trace_data[:field]
+          runtime_info = ctx.namespace(:interpreter) || {}
+          obj = runtime_info[:current_object]
+          args = runtime_info[:current_arguments]
+          field = runtime_info[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end

data/lib/graphql/execution/interpreter/runtime.rb

@@ -11,7 +11,7 @@ module GraphQL
         # @return [GraphQL::Query]
         attr_reader :query
 
-        # @return [Class]
+        # @return [Class<GraphQL::Schema>]
         attr_reader :schema
 
         # @return [GraphQL::Query::Context]
@@ -43,18 +43,21 @@ module GraphQL
         # might be stored up in lazies.
         # @return [void]
         def run_eager
+
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
+          path = []
+          @interpreter_context[:current_object] = query.root_value
+          @interpreter_context[:current_path] = path
           object_proxy = root_type.authorized_new(query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
             # Root .authorized? returned false.
-            write_in_response([], nil)
+            write_in_response(path, nil)
             nil
           else
-            path = []
-            evaluate_selections(path, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
+            evaluate_selections(path, context.scoped_context, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
             nil
           end
         end
@@ -100,7 +103,8 @@ module GraphQL
             when GraphQL::Language::Nodes::FragmentSpread
               fragment_def = query.fragments[node.name]
               type_defn = schema.get_type(fragment_def.type.name)
-              query.warden.possible_types(type_defn).each do |t|
+              possible_types = query.warden.possible_types(type_defn)
+              possible_types.each do |t|
                 if t == owner_type
                   gather_selections(owner_object, owner_type, fragment_def.selections, selections_by_name)
                   break
@@ -112,7 +116,9 @@ module GraphQL
           end
         end
 
-        def evaluate_selections(path, owner_object, owner_type, selections, root_operation_type: nil)
+        def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
+          @interpreter_context[:current_object] = owner_object
+          @interpreter_context[:current_path] = path
           selections_by_name = {}
           gather_selections(owner_object, owner_type, selections, selections_by_name)
           selections_by_name.each do |result_name, field_ast_nodes_or_ast_node|
@@ -155,6 +161,7 @@ module GraphQL
             @interpreter_context[:current_path] = next_path
             @interpreter_context[:current_field] = field_defn
 
+            context.scoped_context = scoped_context
             object = owner_object
 
             if is_introspection
@@ -192,6 +199,8 @@ module GraphQL
               end
             end
 
+            @interpreter_context[:current_arguments] = kwarg_arguments
+
             # Optimize for the case that field is selected only once
             if field_ast_nodes.nil? || field_ast_nodes.size == 1
               next_selections = ast_node.selections
@@ -203,13 +212,15 @@ module GraphQL
             field_result = resolve_with_directives(object, ast_node) do
               # Actually call the field resolver and capture the result
               app_result = begin
-                query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, query: query, object: object, arguments: kwarg_arguments}) do
-                  field_defn.resolve(object, kwarg_arguments, context)
+                query.with_error_handling do
+                  query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, query: query, object: object, arguments: kwarg_arguments}) do
+                    field_defn.resolve(object, kwarg_arguments, context)
+                  end
                 end
               rescue GraphQL::ExecutionError => err
                 err
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, owner_object: object, arguments: kwarg_arguments) do |inner_result|
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
@@ -283,7 +294,7 @@ module GraphQL
             r
           when "UNION", "INTERFACE"
             resolved_type_or_lazy = query.resolve_type(type, value)
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
+            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
@@ -302,12 +313,12 @@ module GraphQL
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: type, path: path, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
+            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
               continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
                 write_in_response(path, response_hash)
-                evaluate_selections(path, continue_value, type, next_selections)
+                evaluate_selections(path, context.scoped_context, continue_value, type, next_selections)
                 response_hash
               end
             end
@@ -316,6 +327,7 @@ module GraphQL
             write_in_response(path, response_list)
             inner_type = type.of_type
             idx = 0
+            scoped_context = context.scoped_context
             value.each do |inner_value|
               next_path = path.dup
               next_path << idx
@@ -323,7 +335,7 @@ module GraphQL
               idx += 1
               set_type_at_path(next_path, inner_type)
               # This will update `response_list` with the lazy
-              after_lazy(inner_value, owner: inner_type, path: next_path, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
+              after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
                 # reset `is_non_null` here and below, because the inner type will have its own nullability constraint
                 continue_value = continue_value(next_path, inner_inner_value, field, false, ast_node)
                 if HALT != continue_value
@@ -379,23 +391,30 @@ module GraphQL
         # @param field [GraphQL::Schema::Field]
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(lazy_obj, owner:, field:, path:, owner_object:, arguments:, eager: false)
+        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false)
+          @interpreter_context[:current_object] = owner_object
+          @interpreter_context[:current_arguments] = arguments
           @interpreter_context[:current_path] = path
           @interpreter_context[:current_field] = field
           if schema.lazy?(lazy_obj)
             lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
               @interpreter_context[:current_path] = path
               @interpreter_context[:current_field] = field
+              @interpreter_context[:current_object] = owner_object
+              @interpreter_context[:current_arguments] = arguments
+              context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
-                query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments}) do
-                  schema.sync_lazy(lazy_obj)
+                query.with_error_handling do
+                  query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments}) do
+                    schema.sync_lazy(lazy_obj)
+                  end
                 end
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
                   yield(err)
               end
-              after_lazy(inner_obj, owner: owner, field: field, path: path, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
+              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
                 yield(really_inner_obj)
               end
             end
@@ -494,15 +513,21 @@ module GraphQL
               if ast_value.nil?
                 return false, nil
               else
-                return true, arg_type.new(ruby_kwargs: ast_value, context: context, defaults_used: nil)
+                args = ast_value
               end
             else
               # For these, `prepare` is applied during `#initialize`.
               # Pass `nil` so it will be skipped in `#arguments`.
               # What a mess.
               args = arguments(nil, arg_type, ast_value)
-              return true, arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
             end
+
+            input_obj = query.with_error_handling do
+              # We're not tracking defaults_used, but for our purposes
+              # we compare the value to the default value.
+              arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
+            end
+            return true, input_obj
           else
             flat_value = if already_arguments
               # It was coerced by variable handling

data/lib/graphql/introspection/entry_points.rb

@@ -15,6 +15,7 @@ module GraphQL
       end
 
       def __type(name:)
+        return unless context.warden.reachable_type?(name)
         type = context.warden.get_type(name)
 
         if type && context.interpreter? && !type.is_a?(Module)

data/lib/graphql/introspection/schema_type.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Introspection
     class SchemaType < Introspection::BaseObject
@@ -14,7 +15,7 @@ module GraphQL
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
       def types
-        @context.warden.types.values
+        @context.warden.reachable_types.sort_by(&:graphql_name)
       end
 
       def query_type

data/lib/graphql/query.rb

@@ -306,6 +306,13 @@ module GraphQL
       with_prepared_ast { @subscription }
     end
 
+    # @api private
+    def with_error_handling
+      schema.error_handler.with_error_handling(context) do
+        yield
+      end
+    end
+
     private
 
     def find_operation(operations, operation_name)

data/lib/graphql/query/context.rb

@@ -155,6 +155,7 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods
+        @scoped_context = {}
       end
 
       # @api private
@@ -163,15 +164,30 @@ module GraphQL
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
-      def_delegators :@query, :trace, :interpreter?
+      # @api private
+      attr_accessor :scoped_context
 
-      # @!method [](key)
-      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def_delegators :@provided_values, :[]=
+      def_delegators :to_h, :fetch, :dig
+      def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
+      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def [](key)
+        return @scoped_context[key] if @scoped_context.key?(key)
+        @provided_values[key]
+      end
+
+      def to_h
+        @provided_values.merge(@scoped_context)
+      end
+      alias :to_hash :to_h
+
+      def key?(key)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
 
       # @return [GraphQL::Schema::Warden]
       def warden
@@ -195,6 +211,15 @@ module GraphQL
         @value = nil
       end
 
+      def scoped_merge!(hash)
+        @scoped_context = @scoped_context.merge(hash)
+      end
+
+      def scoped_set!(key, value)
+        scoped_merge!(key => value)
+        nil
+      end
+
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable

data/lib/graphql/query/null_context.rb

@@ -21,9 +21,13 @@ module GraphQL
         )
       end
 
+      def [](key); end
+
       class << self
         extend Forwardable
 
+        def [](key); end
+
         def instance
           @instance = self.new
         end

data/lib/graphql/query/variables.rb

@@ -38,7 +38,9 @@ module GraphQL
                   memo[variable_name] = if provided_value.nil?
                     nil
                   else
-                    variable_type.coerce_input(provided_value, ctx)
+                    schema.error_handler.with_error_handling(context) do
+                      variable_type.coerce_input(provided_value, ctx)
+                    end
                   end
                 elsif default_value != nil
                   # Add the variable if it wasn't provided but it has a default value (including `null`)

data/lib/graphql/schema.rb

@@ -41,6 +41,7 @@ require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/transform"
+require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
@@ -466,10 +467,11 @@ module GraphQL
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
+    # @param context [GraphQL::Query::Context] The context for the current query
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
-    def possible_types(type_defn)
+    def possible_types(type_defn, context = GraphQL::Query::NullContext)
       @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
-      @possible_types.possible_types(type_defn)
+      @possible_types.possible_types(type_defn, context)
     end
 
     # @see [GraphQL::Schema::Warden] Resticted access to root types
@@ -615,6 +617,7 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
+    def_delegators :_schema_class, :error_handler
 
 
     # Given this schema member, find the class-based definition object
@@ -987,11 +990,20 @@ module GraphQL
       # @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.
-      def possible_types(type = nil)
+      def possible_types(type = nil, context = GraphQL::Query::NullContext)
         if type
-          own_possible_types[type.graphql_name] ||
-            find_inherited_value(:possible_types, EMPTY_HASH)[type.graphql_name] ||
-            EMPTY_ARRAY
+          # TODO duck-typing `.possible_types` would probably be nicer here
+          if type.kind.union?
+            type.possible_types(context: context)
+          else
+            own_possible_types[type.graphql_name] ||
+              introspection_system.possible_types[type.graphql_name] ||
+              (
+                superclass.respond_to?(:possible_types) ?
+                  superclass.possible_types(type, context) :
+                  EMPTY_ARRAY
+              )
+          end
         else
           find_inherited_value(:possible_types, EMPTY_HASH)
             .merge(own_possible_types)
@@ -1347,6 +1359,12 @@ module GraphQL
       def parse_error(parse_err, ctx)
         ctx.errors.push(parse_err)
       end
+      attr_writer :error_handler
+
+      # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
+      def error_handler
+        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
+      end
 
       def lazy_resolve(lazy_class, value_method)
         lazy_methods.set(lazy_class, value_method)
@@ -1641,18 +1659,16 @@ module GraphQL
           if owner.kind.union?
             # It's a union with possible_types
             # Replace the item by class name
-            new_possible_types = owner.possible_types.map { |t|
-              if t.is_a?(String) && (t == type.name)
+            owner.type_memberships.each { |tm|
+              possible_type = tm.object_type
+              if possible_type.is_a?(String) && (possible_type == type.name)
                 # This is a match of Ruby class names, not graphql names,
                 # since strings are used to refer to constants.
-                type
-              elsif t.is_a?(LateBoundType) && t.graphql_name == type.graphql_name
-                type
-              else
-                t
+                tm.object_type = type
+              elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == type.graphql_name
+                tm.object_type = type
               end
             }
-            owner.possible_types(*new_possible_types)
             own_possible_types[owner.graphql_name] = owner.possible_types
           elsif type.kind.interface? && owner.kind.object?
             new_interfaces = owner.interfaces.map do |t|

data/lib/graphql/schema/argument.rb

@@ -2,6 +2,10 @@
 module GraphQL
   class Schema
     class Argument
+      if !String.method_defined?(:-@)
+        using GraphQL::StringDedupBackport
+      end
+
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
@@ -43,8 +47,7 @@ module GraphQL
       # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, &definition_block)
         arg_name ||= name
-        name_str = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
-        @name = name_str.freeze
+        @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
         @null = !required

data/lib/graphql/schema/base_64_bp.rb

@@ -10,8 +10,9 @@ module Base64Bp
   module_function
 
   def urlsafe_encode64(bin, padding:)
-    str = strict_encode64(bin).tr("+/", "-_")
-    str = str.delete("=") unless padding
+    str = strict_encode64(bin)
+    str.tr!("+/", "-_")
+    str.delete!("=") unless padding
     str
   end
 

data/lib/graphql/schema/field.rb

@@ -16,6 +16,7 @@ module GraphQL
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
       extend GraphQL::Schema::FindInheritedValue
+      include GraphQL::Schema::FindInheritedValue::EmptyObjects
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -186,7 +187,7 @@ module GraphQL
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: {}, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -202,8 +203,9 @@ module GraphQL
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
         @original_name = name
-        @underscored_name = -Member::BuildType.underscore(name.to_s)
-        @name = -(camelize ? Member::BuildType.camelize(name.to_s) : name.to_s)
+        name_s = -name.to_s
+        @underscored_name = -Member::BuildType.underscore(name_s)
+        @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
           raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
@@ -250,13 +252,11 @@ module GraphQL
         @ast_node = ast_node
         @method_conflict_warning = method_conflict_warning
 
-        # Override the default from HasArguments
-        @own_arguments = {}
         arguments.each do |name, arg|
           if arg.is_a?(Hash)
             argument(name: name, **arg)
           else
-            @own_arguments[name] = arg
+            own_arguments[name] = arg
           end
         end
 
@@ -689,7 +689,7 @@ module GraphQL
       # Written iteratively to avoid big stack traces.
       # @return [Object] Whatever the
       def with_extensions(obj, args, ctx)
-        if @extensions.empty?
+        if @extensions.nil?
           yield(obj, args)
         else
           # Save these so that the originals can be re-given to `after_resolve` handlers.

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'irb/ruby-token'
 
 module GraphQL
   class Schema
@@ -43,9 +42,7 @@ module GraphQL
         # A list of Ruby keywords.
         #
         # @api private
-        RUBY_KEYWORDS = RubyToken::TokenDefinitions.select { |definition| definition[1] == RubyToken::TkId }
-                                                   .map { |definition| definition[2] }
-                                                   .compact
+        RUBY_KEYWORDS = [:class, :module, :def, :undef, :begin, :rescue, :ensure, :end, :if, :unless, :then, :elsif, :else, :case, :when, :while, :until, :for, :break, :next, :redo, :retry, :in, :do, :return, :yield, :super, :self, :nil, :true, :false, :and, :or, :not, :alias, :defined?, :BEGIN, :END, :__LINE__, :__FILE__]
 
         # A list of GraphQL-Ruby keywords.
         #

data/lib/graphql/schema/object.rb

@@ -35,10 +35,12 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = begin
-            authorized?(object, context)
-          rescue GraphQL::UnauthorizedError => err
-            context.schema.unauthorized_object(err)
+          auth_val = context.query.with_error_handling do
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            end
           end
 
           context.schema.after_lazy(auth_val) do |is_authorized|

data/lib/graphql/schema/possible_types.rb

@@ -20,12 +20,12 @@ module GraphQL
         end
       end
 
-      def possible_types(type_defn)
+      def possible_types(type_defn, ctx)
         case type_defn
         when Module
-          possible_types(type_defn.graphql_definition)
+          possible_types(type_defn.graphql_definition, ctx)
         when GraphQL::UnionType
-          type_defn.possible_types
+          type_defn.possible_types(ctx)
         when GraphQL::InterfaceType
           @interface_implementers[type_defn]
         when GraphQL::BaseType

data/lib/graphql/schema/type_membership.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This class joins an object type to an abstract type (interface or union) of which
+    # it is a member.
+    #
+    # TODO: Not yet implemented for interfaces.
+    class TypeMembership
+      # @return [Class<GraphQL::Schema::Object>]
+      attr_accessor :object_type
+
+      # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      attr_reader :abstract_type
+
+      # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
+      # or {Schema::Object.implements} (for interfaces).
+      #
+      # @param abstract_type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param object_type [Class<GraphQL::Schema::Object>]
+      # @param options [Hash] Any options passed to `.possible_types` or `.implements`
+      def initialize(abstract_type, object_type, options)
+        @abstract_type = abstract_type
+        @object_type = object_type
+        @options = options
+      end
+
+      # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
+      def visible?(_ctx)
+        true
+      end
+    end
+  end
+end

data/lib/graphql/schema/union.rb

@@ -5,13 +5,19 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
-        def possible_types(*types)
+        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
-            @possible_types = types
+            types.each do |t|
+              type_memberships << type_membership_class.new(self, t, options)
+            end
           else
-            all_possible_types = @possible_types || []
-            all_possible_types += super if defined?(super)
-            all_possible_types.uniq
+            visible_types = []
+            type_memberships.each do |type_membership|
+              if type_membership.visible?(context)
+                visible_types << type_membership.object_type
+              end
+            end
+            visible_types
           end
         end
 
@@ -19,8 +25,8 @@ module GraphQL
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name
           type_defn.description = description
-          type_defn.possible_types = possible_types
           type_defn.ast_node = ast_node
+          type_defn.type_memberships = type_memberships
           if respond_to?(:resolve_type)
             type_defn.resolve_type = method(:resolve_type)
           end
@@ -28,9 +34,21 @@ module GraphQL
           type_defn
         end
 
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::UNION
         end
+
+        def type_memberships
+          @type_memberships ||= []
+        end
       end
     end
   end

data/lib/graphql/schema/warden.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'set'
+
 module GraphQL
   class Schema
     # Restrict access to a {GraphQL::Schema} with a user-defined filter.
@@ -44,6 +47,7 @@ module GraphQL
         @query = @schema.query
         @mutation = @schema.mutation
         @subscription = @schema.subscription
+        @context = context
         @visibility_cache = read_through { |m| filter.call(m, context) }
       end
 
@@ -74,6 +78,17 @@ module GraphQL
         @visible_types[type_name]
       end
 
+      # @return [Array<GraphQL::BaseType>] Visible and reachable types in the schema
+      def reachable_types
+        @reachable_types ||= reachable_type_set.to_a
+      end
+
+      # @return Boolean True if the type is visible and reachable in the schema
+      def reachable_type?(type_name)
+        type = get_type(type_name)
+        type && reachable_type_set.include?(type)
+      end
+
       # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
       def get_field(parent_type, field_name)
 
@@ -93,15 +108,9 @@ module GraphQL
 
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
-        @visible_possible_types ||= if @schema.is_a?(Class)
-          all_possible_types = @schema.possible_types
-          read_through { |type_defn|
-            pt = all_possible_types[type_defn.graphql_name] || []
-            pt.select { |t| visible_type?(t) }
-          }
-        else
-          read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible_type?(t) } }
-        end
+        @visible_possible_types ||= read_through { |type_defn|
+          @schema.possible_types(type_defn, @context).select { |t| visible_type?(t) }
+        }
         @visible_possible_types[type_defn]
       end
 
@@ -209,6 +218,67 @@ module GraphQL
       def read_through
         Hash.new { |h, k| h[k] = yield(k) }
       end
+
+      def reachable_type_set
+        return @reachable_type_set if defined?(@reachable_type_set)
+
+        @reachable_type_set = Set.new
+
+        unvisited_types = []
+        ['query', 'mutation', 'subscription'].each do |op_name|
+          root_type = root_type_for_operation(op_name)
+          unvisited_types << root_type if root_type
+        end
+        unvisited_types.concat(@schema.introspection_system.types.values)
+        @schema.orphan_types.each do |orphan_type|
+          if get_type(orphan_type.graphql_name)
+            unvisited_types << orphan_type
+          end
+        end
+
+        until unvisited_types.empty?
+          type = unvisited_types.pop
+          if @reachable_type_set.add?(type)
+            if type.kind.input_object?
+              # recurse into visible arguments
+              arguments(type).each do |argument|
+                argument_type = argument.type.unwrap
+                unvisited_types << argument_type
+              end
+            elsif type.kind.union?
+              # recurse into visible possible types
+              possible_types(type).each do |possible_type|
+                unvisited_types << possible_type
+              end
+            elsif type.kind.fields?
+              if type.kind.interface?
+                # recurse into visible possible types
+                possible_types(type).each do |possible_type|
+                  unvisited_types << possible_type
+                end
+              elsif type.kind.object?
+                # recurse into visible implemented interfaces
+                interfaces(type).each do |interface|
+                  unvisited_types << interface
+                end
+              end
+
+              # recurse into visible fields
+              fields(type).each do |field|
+                field_type = field.type.unwrap
+                unvisited_types << field_type
+                # recurse into visible arguments
+                arguments(field).each do |argument|
+                  argument_type = argument.type.unwrap
+                  unvisited_types << argument_type
+                end
+              end
+            end
+          end
+        end
+
+        @reachable_type_set
+      end
     end
   end
 end

data/lib/graphql/union_type.rb

@@ -24,22 +24,27 @@ module GraphQL
   #  }
   #
   class UnionType < GraphQL::BaseType
-    accepts_definitions :possible_types, :resolve_type
-    ensure_defined :possible_types, :resolve_type, :resolve_type_proc
+    accepts_definitions :resolve_type, :type_membership_class,
+      possible_types: ->(target, possible_types, options = {}) { target.add_possible_types(possible_types, options) }
+    ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
 
     attr_accessor :resolve_type_proc
+    attr_reader :type_memberships
+    attr_accessor :type_membership_class
 
     def initialize
       super
-      @dirty_possible_types = []
-      @clean_possible_types = nil
+      @type_membership_class = GraphQL::Schema::TypeMembership
+      @type_memberships = []
+      @cached_possible_types = nil
       @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
       super
-      @clean_possible_types = nil
-      @dirty_possible_types = other.dirty_possible_types.dup
+      @type_membership_class = other.type_membership_class
+      @type_memberships = other.type_memberships.dup
+      @cached_possible_types = nil
     end
 
     def kind
@@ -47,26 +52,37 @@ module GraphQL
     end
 
     # @return [Boolean] True if `child_type_defn` is a member of this {UnionType}
-    def include?(child_type_defn)
-      possible_types.include?(child_type_defn)
-    end
-
-    def possible_types=(new_possible_types)
-      @clean_possible_types = nil
-      @dirty_possible_types = new_possible_types
+    def include?(child_type_defn, ctx = GraphQL::Query::NullContext)
+      possible_types(ctx).include?(child_type_defn)
     end
 
     # @return [Array<GraphQL::ObjectType>] Types which may be found in this union
-    def possible_types
-      @clean_possible_types ||= begin
-        if @dirty_possible_types.respond_to?(:map)
-          @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
-        else
-          @dirty_possible_types
-        end
+    def possible_types(ctx = GraphQL::Query::NullContext)
+      if ctx == GraphQL::Query::NullContext
+        # Only cache the default case; if we cached for every `ctx`, it would be a memory leak
+        # (The warden should cache calls to this method, so it's called only once per query,
+        # unless user code calls it directly.)
+        @cached_possible_types ||= possible_types_for_context(ctx)
+      else
+        possible_types_for_context(ctx)
       end
     end
 
+    def possible_types=(types)
+      # This is a re-assignment, so clear the previous values
+      @type_memberships = []
+      @cached_possible_types = nil
+      add_possible_types(types, {})
+    end
+
+    def add_possible_types(types, options)
+      @type_memberships ||= []
+      Array(types).each { |t|
+        @type_memberships << self.type_membership_class.new(self, t, options)
+      }
+      nil
+    end
+
     # Get a possible type of this {UnionType} by type name
     # @param type_name [String]
     # @param ctx [GraphQL::Query::Context] The context for the current query
@@ -93,8 +109,20 @@ module GraphQL
       @resolve_type_proc = new_resolve_type_proc
     end
 
-    protected
+    def type_memberships=(type_memberships)
+      @type_memberships = type_memberships
+    end
+
+    private
 
-    attr_reader :dirty_possible_types
+    def possible_types_for_context(ctx)
+      visible_types = []
+      @type_memberships.each do |type_membership|
+        if type_membership.visible?(ctx)
+          visible_types << BaseType.resolve_related_type(type_membership.object_type)
+        end
+      end
+      visible_types
+    end
   end
 end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.10.0.pre2"
+  VERSION = "1.10.0.pre3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.0.pre2
+  version: 1.10.0.pre3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-04 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -599,6 +599,7 @@ files:
 - lib/graphql/schema/timeout_middleware.rb
 - lib/graphql/schema/traversal.rb
 - lib/graphql/schema/type_expression.rb
+- lib/graphql/schema/type_membership.rb
 - lib/graphql/schema/union.rb
 - lib/graphql/schema/unique_within_type.rb
 - lib/graphql/schema/validation.rb