graphql 2.0.1 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f37881627f4e4ddcdb6f2f83f395982d624396949b7e26c1c7fa395f34b6c37a
-  data.tar.gz: c4840087ffff471824df26453876279b2e44014cdf99f9778b35481c917e18fa
+  metadata.gz: 823ea48d61ed1b30e6ad87a6817f80206b9c5d8865f6350cbd142c9798162e37
+  data.tar.gz: 8e5f383cfe80418109b0f424d06ab7a78c72255d167f21f32b6c8f6bcef10610
 SHA512:
-  metadata.gz: 34999652dad1730d8cf51a46b213dc62d34a00e429b734da857aadbe5d5497c1a70c5d6ebc9d0a316db65a2e8e40075ab56d8bb59eb1cdc45b88c9549149ff92
-  data.tar.gz: 8ff253848a6fcdaaaa831c87377b4b9d4ca494704bba0844336dc3c500b125df5f888f076f77cdf4fae61c03b2d8cb9383e18406bbf8b6ab2d7bd399dd54bf7d
+  metadata.gz: 95e9de185715e1b2a752ecaefdd75e8b4daad8afd4125429d58627972805d759c3a842a58bec29b0b5ee1aba5e1d06a6cb1aed9bd1881653d710f71fe4edfdc7
+  data.tar.gz: 99ff2f59d77ee74ba4c1af7fcf097afb5415b6d18a95c1a2527413d6f782f8fa6238aafa96430d2d7332f1177e64b70e5aa2eac1557d042ede9eb4a33466b8b5

data/lib/graphql/analysis/ast/max_query_complexity.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "./query_complexity"
 module GraphQL
   module Analysis
     module AST

data/lib/graphql/execution/errors.rb

@@ -2,51 +2,15 @@
 
 module GraphQL
   module Execution
-    # A plugin that wraps query execution with error handling. Installed by default.
-    #
-    # @example Handling ActiveRecord::NotFound
-    #
-    #   class MySchema < GraphQL::Schema
-    #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
-    #       ErrorTracker.log("Not Found: #{err.message}")
-    #       nil
-    #     end
-    #   end
-    #
     class Errors
-      NEW_HANDLER_HASH = ->(h, k) {
-        h[k] = {
-          class: k,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-         }
-      }
-
-      def initialize(schema)
-        @schema = schema
-        @handlers = {
-          class: nil,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-        }
-      end
-
-      # @api private
-      def each_rescue
-        handlers = @handlers.values
-        while (handler = handlers.shift) do
-          yield(handler[:class], handler[:handler])
-          handlers.concat(handler[:subclass_handlers].values)
-        end
-      end
-
       # Register this handler, updating the
       # internal handler index to maintain least-to-most specific.
       #
       # @param error_class [Class<Exception>]
+      # @param error_handlers [Hash]
       # @param error_handler [Proc]
       # @return [void]
-      def rescue_from(error_class, error_handler)
+      def self.register_rescue_from(error_class, error_handlers, error_handler)
         subclasses_handlers = {}
         this_level_subclasses = []
         # During this traversal, do two things:
@@ -54,13 +18,12 @@ module GraphQL
         #   and gather them up to be inserted _under_ this class
         # - Find the point in the index where this handler should be inserted
         #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
-        handlers = @handlers[:subclass_handlers]
-        while (handlers) do
+        while (error_handlers) do
           this_level_subclasses.clear
           # First, identify already-loaded handlers that belong
           # _under_ this one. (That is, they're handlers
           # for subclasses of `error_class`.)
-          handlers.each do |err_class, handler|
+          error_handlers.each do |err_class, handler|
             if err_class < error_class
               subclasses_handlers[err_class] = handler
               this_level_subclasses << err_class
@@ -68,13 +31,13 @@ module GraphQL
           end
           # Any handlers that we'll be moving, delete them from this point in the index
           this_level_subclasses.each do |err_class|
-            handlers.delete(err_class)
+            error_handlers.delete(err_class)
           end
 
           # See if any keys in this hash are superclasses of this new class:
-          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          next_index_point = error_handlers.find { |err_class, handler| error_class < err_class }
           if next_index_point
-            handlers = next_index_point[1][:subclass_handlers]
+            error_handlers = next_index_point[1][:subclass_handlers]
           else
             # this new handler doesn't belong to any sub-handlers,
             # so insert it in the current set of `handlers`
@@ -83,40 +46,15 @@ module GraphQL
         end
         # Having found the point at which to insert this handler,
         # register it and merge any subclass handlers back in at this point.
-        this_class_handlers = handlers[error_class]
+        this_class_handlers = error_handlers[error_class]
         this_class_handlers[:handler] = error_handler
         this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
         nil
       end
 
-      # 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
-        handler = find_handler_for(err.class)
-        if handler
-          runtime_info = ctx.namespace(:interpreter) || {}
-          obj = runtime_info[:current_object]
-          args = runtime_info[:current_arguments]
-          args = args && args.keyword_arguments
-          field = runtime_info[:current_field]
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
-          end
-          handler[:handler].call(err, obj, args, ctx, field)
-        else
-          raise err
-        end
-      end
-
       # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
-      def find_handler_for(error_class)
-        handlers = @handlers[:subclass_handlers]
+      def self.find_handler_for(schema, error_class)
+        handlers = schema.error_handlers[:subclass_handlers]
         handler = nil
         while (handlers) do
           _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
@@ -131,8 +69,8 @@ module GraphQL
         end
 
         # check for a handler from a parent class:
-        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
-          parent_handler = parent_errors.find_handler_for(error_class)
+        if schema.superclass.respond_to?(:error_handlers)
+          parent_handler = find_handler_for(schema.superclass, error_class)
         end
 
         # If the inherited handler is more specific than the one defined here,

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

@@ -498,13 +498,17 @@ module GraphQL
             field_result = call_method_on_directives(:resolve, object, directives) do
               # Actually call the field resolver and capture the result
               app_result = begin
-                query.with_error_handling do
-                  query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments}) do
-                    field_defn.resolve(object, kwarg_arguments, context)
-                  end
+                query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments}) do
+                  field_defn.resolve(object, kwarg_arguments, context)
                 end
               rescue GraphQL::ExecutionError => err
                 err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
@@ -871,21 +875,21 @@ module GraphQL
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
-                query.with_error_handling do
-                  begin
-                    if trace
-                      query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
-                        schema.sync_lazy(lazy_obj)
-                      end
-                    else
-                      schema.sync_lazy(lazy_obj)
-                    end
-                  rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
-                    err
+                if trace
+                  query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
+                    schema.sync_lazy(lazy_obj)
                   end
+                else
+                  schema.sync_lazy(lazy_obj)
                 end
-              rescue GraphQL::ExecutionError => ex_err
+              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
                 ex_err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
               yield(inner_obj)
             end

data/lib/graphql/query/null_context.rb

@@ -12,9 +12,6 @@ module GraphQL
       end
 
       class NullQuery
-        def with_error_handling
-          yield
-        end
       end
 
       class NullSchema < GraphQL::Schema

data/lib/graphql/query.rb

@@ -331,10 +331,8 @@ module GraphQL
     end
 
     # @api private
-    def with_error_handling
-      schema.error_handler.with_error_handling(context) do
-        yield
-      end
+    def handle_or_reraise(err)
+      schema.handle_or_reraise(context, err)
     end
 
     private

data/lib/graphql/relay/range_add.rb

@@ -31,25 +31,18 @@ module GraphQL
 
       # @param collection [Object] The list of items to wrap in a connection
       # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
+      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection
       # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
-      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
       # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
-      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
-        if context && context.schema.new_connections?
-          conn_class = context.schema.connections.wrapper_for(collection)
-          # The rest will be added by ConnectionExtension
-          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
-          # Check if this connection supports it, to support old versions of GraphQL-Pro
-          @edge = if @connection.respond_to?(:range_add_edge)
-            @connection.range_add_edge(item)
-          else
-            @connection.edge_class.new(item, @connection)
-          end
+      def initialize(collection:, item:, context:, parent: nil, edge_class: nil)
+        conn_class = context.schema.connections.wrapper_for(collection)
+        # The rest will be added by ConnectionExtension
+        @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+        # Check if this connection supports it, to support old versions of GraphQL-Pro
+        @edge = if @connection.respond_to?(:range_add_edge)
+          @connection.range_add_edge(item)
         else
-          connection_class = BaseConnection.connection_for_nodes(collection)
-          @connection = connection_class.new(collection, {}, parent: parent, context: context)
-          edge_class ||= Relay::Edge
-          @edge = edge_class.new(item, @connection)
+          @connection.edge_class.new(item, @connection)
         end
 
         @parent = parent

data/lib/graphql/schema/addition.rb

@@ -107,6 +107,11 @@ module GraphQL
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
+              int.interfaces.each do |indirect_int|
+                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
+                  update_type_owner(owner, indirect_int_type)
+                end
+              end
             end
           end
         when nil

data/lib/graphql/schema/argument.rb

@@ -75,7 +75,10 @@ module GraphQL
           end
         end
 
-        self.validates(validates)
+        if validates && !validates.empty?
+          self.validates(validates)
+        end
+
         if required == :nullable
           self.owner.validates(required: { argument: arg_name })
         end
@@ -247,24 +250,30 @@ module GraphQL
         end
 
         loaded_value = nil
-        coerced_value = context.schema.error_handler.with_error_handling(context) do
+        coerced_value = begin
           type.coerce_input(value, context)
+        rescue StandardError => err
+          context.schema.handle_or_reraise(context, err)
         end
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
         # If it _is_ lazy, then we write the lazy to the hash, then update it later
         argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
           if loads && !from_resolver?
-            loaded_value = context.query.with_error_handling do
+            loaded_value = begin
               load_and_authorize_value(owner, coerced_value, context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
           end
 
           maybe_loaded_value = loaded_value || resolved_coerced_value
           context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
             owner.validate_directive_argument(self, resolved_loaded_value)
-            prepared_value = context.schema.error_handler.with_error_handling(context) do
+            prepared_value = begin
               prepare_value(parent_object, resolved_loaded_value, context: context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
 
             # TODO code smell to access such a deeply-nested constant in a distant module

data/lib/graphql/schema/field.rb

@@ -145,8 +145,18 @@ module GraphQL
         if !@scope.nil?
           # The default was overridden
           @scope
+        elsif @return_type_expr
+          # Detect a list return type, but don't call `type` since that may eager-load an otherwise lazy-loaded type
+          @return_type_expr.is_a?(Array) ||
+            (@return_type_expr.is_a?(String) && @return_type_expr.include?("[")) ||
+            connection?
+        elsif @resolver_class
+          resolver_type = @resolver_class.type_expr
+          resolver_type.is_a?(Array) ||
+            (resolver_type.is_a?(String) && resolver_type.include?("[")) ||
+            connection?
         else
-          @return_type_expr && (@return_type_expr.is_a?(Array) || (@return_type_expr.is_a?(String) && @return_type_expr.include?("[")) || connection?)
+          false
         end
       end
 
@@ -177,7 +187,7 @@ module GraphQL
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
       # @param type [Class, GraphQL::BaseType, Array] The return type of this field
       # @param owner [Class] The type that this field belongs to
-      # @param null [Boolean] `true` if this field may return `null`, `false` if it is never `null`
+      # @param null [Boolean] (defaults to `true`) `true` if this field may return `null`, `false` if it is never `null`
       # @param description [String] Field description
       # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message
       # @param method [Symbol] The method to call on the underlying object to resolve this field (defaults to `name`)
@@ -201,7 +211,7 @@ module GraphQL
       # @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
       # @param validates [Array<Hash>] Configurations for validating this field
-      def initialize(type: nil, name: nil, owner: nil, null: true, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -214,7 +224,9 @@ module GraphQL
         name_s = -name.to_s
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-        @description = description
+        if description != :not_given
+          @description = description
+        end
         self.deprecation_reason = deprecation_reason
 
         if method && hash_key && dig
@@ -241,7 +253,13 @@ module GraphQL
         @resolver_method = resolver_method
         @complexity = complexity
         @return_type_expr = type
-        @return_type_null = null
+        @return_type_null = if !null.nil?
+          null
+        elsif resolver_class
+          nil
+        else
+          true
+        end
         @connection = connection
         @has_max_page_size = max_page_size != :not_given
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
@@ -303,7 +321,9 @@ module GraphQL
           end
         end
 
-        self.validates(validates)
+        if !validates.empty?
+          self.validates(validates)
+        end
 
         if definition_block
           if definition_block.arity == 1
@@ -335,10 +355,12 @@ module GraphQL
       def description(text = nil)
         if text
           @description = text
+        elsif defined?(@description)
+          @description
         elsif @resolver_class
           @description || @resolver_class.description
         else
-          @description
+          nil
         end
       end
 
@@ -514,19 +536,15 @@ module GraphQL
       attr_writer :type
 
       def type
-        if @resolver_class && (t = @resolver_class.type)
-          t
-        else
-          @type ||= if @return_type_expr.nil?
-            # Not enough info to determine type
-            message = "Can't determine the return type for #{self.path}"
-            if @resolver_class
-              message += " (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
-            end
-            raise MissingReturnTypeError, message
-          else
-            Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+        if @resolver_class
+          return_type = @return_type_expr || @resolver_class.type_expr
+          if return_type.nil?
+            raise MissingReturnTypeError, "Can't determine the return type for #{self.path} (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
           end
+          nullable = @return_type_null.nil? ? @resolver_class.null : @return_type_null
+          Member::BuildType.parse_type(return_type, null: nullable)
+        else
+          @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
         end
       rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err
         # Let this propagate up
@@ -597,31 +615,94 @@ module GraphQL
       # @param object [GraphQL::Schema::Object] An instance of some type class, wrapping an application object
       # @param args [Hash] A symbol-keyed hash of Ruby keyword arguments. (Empty if no args)
       # @param ctx [GraphQL::Query::Context]
-      def resolve(object, args, ctx)
-        if @resolve_proc
-          raise "Can't run resolve proc for #{path} when using GraphQL::Execution::Interpreter"
-        end
-        begin
-          # Unwrap the GraphQL object to get the application object.
-          application_object = object.object
+      def resolve(object, args, query_ctx)
+        # Unwrap the GraphQL object to get the application object.
+        application_object = object.object
+        method_receiver = nil
+        method_to_call = nil
+        method_args = nil
+
+        Schema::Validator.validate!(validators, application_object, query_ctx, args)
+
+        query_ctx.schema.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
+          if is_authorized
+            with_extensions(object, args, query_ctx) do |obj, ruby_kwargs|
+              method_args = ruby_kwargs
+              if @resolver_class
+                if obj.is_a?(GraphQL::Schema::Object)
+                  obj = obj.object
+                end
+                obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
+              end
 
-          Schema::Validator.validate!(validators, application_object, ctx, args)
+              # Find a way to resolve this field, checking:
+              #
+              # - A method on the type instance;
+              # - Hash keys, if the wrapped object is a hash;
+              # - A method on the wrapped object;
+              # - Or, raise not implemented.
+              #
+              if obj.respond_to?(resolver_method)
+                method_to_call = resolver_method
+                method_receiver = obj
+                # Call the method with kwargs, if there are any
+                if ruby_kwargs.any?
+                  obj.public_send(resolver_method, **ruby_kwargs)
+                else
+                  obj.public_send(resolver_method)
+                end
+              elsif obj.object.is_a?(Hash)
+                inner_object = obj.object
+                if @dig_keys
+                  inner_object.dig(*@dig_keys)
+                elsif inner_object.key?(@method_sym)
+                  inner_object[@method_sym]
+                else
+                  inner_object[@method_str]
+                end
+              elsif obj.object.respond_to?(@method_sym)
+                method_to_call = @method_sym
+                method_receiver = obj.object
+                if ruby_kwargs.any?
+                  obj.object.public_send(@method_sym, **ruby_kwargs)
+                else
+                  obj.object.public_send(@method_sym)
+                end
+              else
+                raise <<-ERR
+              Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
-          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
-            if is_authorized
-              public_send_field(object, args, ctx)
-            else
-              raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              - `#{obj.class}##{resolver_method}`, which did not exist
+              - `#{obj.object.class}##{@method_sym}`, which did not exist
+              - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+
+              To implement this field, define one of the methods above (and check for typos)
+              ERR
+              end
             end
+          else
+            raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: query_ctx, field: self)
           end
-        rescue GraphQL::UnauthorizedFieldError => err
-          err.field ||= self
-          ctx.schema.unauthorized_field(err)
-        rescue GraphQL::UnauthorizedError => err
-          ctx.schema.unauthorized_object(err)
-        end
-      rescue GraphQL::ExecutionError => err
-        err
+        end
+      rescue GraphQL::UnauthorizedFieldError => err
+        err.field ||= self
+        begin
+          query_ctx.schema.unauthorized_field(err)
+        rescue GraphQL::ExecutionError => err
+          err
+        end
+      rescue GraphQL::UnauthorizedError => err
+        begin
+          query_ctx.schema.unauthorized_object(err)
+        rescue GraphQL::ExecutionError => err
+          err
+        end
+      rescue ArgumentError
+        if method_receiver && method_to_call
+          assert_satisfactory_implementation(method_receiver, method_to_call, method_args)
+        end
+        # if the line above doesn't raise, re-raise
+        raise
       end
 
       # @param ctx [GraphQL::Query::Context]
@@ -637,70 +718,6 @@ module GraphQL
 
       private
 
-      def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
-        with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
-          begin
-            method_receiver = nil
-            method_to_call = nil
-            if @resolver_class
-              if obj.is_a?(GraphQL::Schema::Object)
-                obj = obj.object
-              end
-              obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
-            end
-
-            # Find a way to resolve this field, checking:
-            #
-            # - A method on the type instance;
-            # - Hash keys, if the wrapped object is a hash;
-            # - A method on the wrapped object;
-            # - Or, raise not implemented.
-            #
-            if obj.respond_to?(resolver_method)
-              method_to_call = resolver_method
-              method_receiver = obj
-              # Call the method with kwargs, if there are any
-              if ruby_kwargs.any?
-                obj.public_send(resolver_method, **ruby_kwargs)
-              else
-                obj.public_send(resolver_method)
-              end
-            elsif obj.object.is_a?(Hash)
-              inner_object = obj.object
-              if @dig_keys
-                inner_object.dig(*@dig_keys)
-              elsif inner_object.key?(@method_sym)
-                inner_object[@method_sym]
-              else
-                inner_object[@method_str]
-              end
-            elsif obj.object.respond_to?(@method_sym)
-              method_to_call = @method_sym
-              method_receiver = obj.object
-              if ruby_kwargs.any?
-                obj.object.public_send(@method_sym, **ruby_kwargs)
-              else
-                obj.object.public_send(@method_sym)
-              end
-            else
-              raise <<-ERR
-            Failed to implement #{@owner.graphql_name}.#{@name}, tried:
-
-            - `#{obj.class}##{resolver_method}`, which did not exist
-            - `#{obj.object.class}##{@method_sym}`, which did not exist
-            - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
-
-            To implement this field, define one of the methods above (and check for typos)
-            ERR
-            end
-          rescue ArgumentError
-            assert_satisfactory_implementation(method_receiver, method_to_call, ruby_kwargs)
-            # if the line above doesn't raise, re-raise
-            raise
-          end
-        end
-      end
-
       def assert_satisfactory_implementation(receiver, method_name, ruby_kwargs)
         method_defn = receiver.method(method_name)
         unsatisfied_ruby_kwargs = ruby_kwargs.dup

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

@@ -11,7 +11,7 @@ module GraphQL
         # @return [void]
         def directive(dir_class, **options)
           @own_directives ||= []
-          remove_directive(dir_class)
+          remove_directive(dir_class) unless dir_class.repeatable?
           @own_directives << dir_class.new(self, **options)
           nil
         end

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

@@ -80,7 +80,7 @@ module GraphQL
             visible_interfaces.concat(superclass.interfaces(context))
           end
 
-          visible_interfaces
+          visible_interfaces.uniq
         end
       end
     end

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

@@ -8,7 +8,15 @@ module GraphQL
           if new_edge_type_class
             @edge_type_class = new_edge_type_class
           else
-            @edge_type_class || find_inherited_value(:edge_type_class, Types::Relay::BaseEdge)
+            # Don't call `ancestor.edge_type_class`
+            # because we don't want a fallback from any ancestors --
+            # only apply the fallback if _no_ ancestor has a configured value!
+            for ancestor in self.ancestors
+              if ancestor.respond_to?(:configured_edge_type_class, true) && (etc = ancestor.configured_edge_type_class)
+                return etc
+              end
+            end
+            Types::Relay::BaseEdge
           end
         end
 
@@ -16,7 +24,15 @@ module GraphQL
           if new_connection_type_class
             @connection_type_class = new_connection_type_class
           else
-            @connection_type_class || find_inherited_value(:connection_type_class, Types::Relay::BaseConnection)
+            # Don't call `ancestor.connection_type_class`
+            # because we don't want a fallback from any ancestors --
+            # only apply the fallback if _no_ ancestor has a configured value!
+            for ancestor in self.ancestors
+              if ancestor.respond_to?(:configured_connection_type_class, true) && (ctc = ancestor.configured_connection_type_class)
+                return ctc
+              end
+            end
+            Types::Relay::BaseConnection
           end
         end
 
@@ -41,6 +57,16 @@ module GraphQL
             end
           end
         end
+
+        protected
+
+        def configured_connection_type_class
+          @connection_type_class
+        end
+
+        def configured_edge_type_class
+          @edge_type_class
+        end
       end
     end
   end

data/lib/graphql/schema/object.rb

@@ -51,12 +51,12 @@ module GraphQL
           trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
 
           maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
-            context.query.with_error_handling do
-              begin
-                authorized?(object, context)
-              rescue GraphQL::UnauthorizedError => err
-                context.schema.unauthorized_object(err)
-              end
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            rescue StandardError => err
+              context.query.handle_or_reraise(err)
             end
           end
 
@@ -98,9 +98,14 @@ module GraphQL
       class << self
         # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
         # It should help with debugging and bug tracker integrations.
-        def inherited(child_class)
-          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
-          super
+        def const_missing(name)
+          if name == :InvalidNullError
+            custom_err_class = GraphQL::InvalidNullError.subclass_for(self)
+            const_set(:InvalidNullError, custom_err_class)
+            custom_err_class
+          else
+            super
+          end
         end
 
         def kind

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -20,7 +20,17 @@ module GraphQL
           @payload_type ||= generate_payload_type
         end
 
-        # alias :type :payload_type
+        def type(new_type = nil, null: nil)
+          if new_type
+            payload_type(new_type)
+            if !null.nil?
+              self.null(null)
+            end
+          else
+            super()
+          end
+        end
+
         alias :type_expr :payload_type
 
         def field_class(new_class = nil)

data/lib/graphql/schema/scalar.rb

@@ -42,11 +42,11 @@ module GraphQL
 
         def validate_non_null_input(value, ctx)
           coerced_result = begin
-            ctx.query.with_error_handling do
-              coerce_input(value, ctx)
-            end
+            coerce_input(value, ctx)
           rescue GraphQL::CoercionError => err
             err
+          rescue StandardError => err
+            ctx.query.handle_or_reraise(err)
           end
 
           if coerced_result.nil?

data/lib/graphql/schema.rb

@@ -693,7 +693,41 @@ module GraphQL
 
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          error_handler.rescue_from(err_class, handler_block)
+          Execution::Errors.register_rescue_from(err_class, error_handlers[:subclass_handlers], handler_block)
+        end
+      end
+
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
+      def error_handlers
+        @error_handlers ||= {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
+      end
+
+      # @api private
+      def handle_or_reraise(context, err)
+        handler = Execution::Errors.find_handler_for(self, err.class)
+        if handler
+          runtime_info = context.namespace(:interpreter) || {}
+          obj = runtime_info[:current_object]
+          args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
+          field = runtime_info[:current_field]
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          handler[:handler].call(err, obj, args, context, field)
+        else
+          raise err
         end
       end
 
@@ -821,11 +855,6 @@ module GraphQL
         ctx.errors.push(parse_err)
       end
 
-      # @return [GraphQL::Execution::Errors]
-      def error_handler
-        @error_handler ||= GraphQL::Execution::Errors.new(self)
-      end
-
       def lazy_resolve(lazy_class, value_method)
         lazy_methods.set(lazy_class, value_method)
       end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -48,7 +48,9 @@ module GraphQL
       end
 
       def tracer
-        options.fetch(:tracer, Datadog.tracer)
+        default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+
+        options.fetch(:tracer, default_tracer)
       end
 
       def analytics_available?

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -148,22 +148,6 @@ module GraphQL
             obj_type.field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
           end
         end
-
-        # By default this calls through to the ConnectionWrapper's edge nodes method,
-        # but sometimes you need to override it to support the `nodes` field
-        def nodes
-          @object.edge_nodes
-        end
-
-        def edges
-          if @object.is_a?(GraphQL::Pagination::Connection)
-            @object.edges
-          else
-            context.schema.after_lazy(object.edge_nodes) do |nodes|
-              nodes.map { |n| self.class.edge_class.new(n, object) }
-            end
-          end
-        end
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.0.1"
+  VERSION = "2.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.4
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-21 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -581,7 +581,7 @@ metadata:
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://tinyletter.com/graphql-ruby
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -596,8 +596,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []