graphql 1.12.6 → 1.12.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebd2e71516a89475e1617ee60250d4d88f6d3743090ae8010e6918ce425a71fc
-  data.tar.gz: c0577dd5aac0765abf748f9ba86b3a3a814658abba7a2285b4e0d929959de50f
+  metadata.gz: a0b3eaaf2e8d1d263d8de4e509bbca1413c41981ac69d8f722eba16883fc9023
+  data.tar.gz: e9d0a083c8553cb650a2aff619a4c04bd5a01fb345dc8ae560563db09fe4d0b4
 SHA512:
-  metadata.gz: 832d9464fe69bacc19d4a8715e5d2869d8ff15a4c1c34316d9c092b295e2175ac4f7a746a736773914ac4789478baa28a1f451c57cee732346901d5e4e10e430
-  data.tar.gz: 84f4918a0473bf07c657ca39392866ece0a36ca592272f85580417882b762e7210cd6404ee1671ad651ac7608acdb0103a4a262253e48ccc9b75be2804c5caf4
+  metadata.gz: c1580219b7da1f62566e65eff2b2c11f124415dad818243260b2ebefddb4de5dad2d2e1953bc671f2080d1523c98f31e7eee581edf5b6b830761a96b970796ca
+  data.tar.gz: 1a886d5d664bb4352b9f75f1c448acb5e2d0b8299c6f1cf6debd441df2f700869912b8a7083363aac6c41874ae18dd5bd87955a9979e44b7e5e21811c25539f3

data/lib/graphql/execution/errors.rb

@@ -18,21 +18,83 @@ module GraphQL
     #
     class Errors
       def self.use(schema)
-        if schema.plugins.any? { |(plugin, kwargs)| plugin == self }
-          definition_line = caller(2, 1).first
-          GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
-        end
-        schema.error_handler = self.new(schema)
+        definition_line = caller(2, 1).first
+        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
       end
 
+      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
 
-      class NullErrorHandler
-        def self.with_error_handling(_ctx)
-          yield
+      # Register this handler, updating the
+      # internal handler index to maintain least-to-most specific.
+      #
+      # @param error_class [Class<Exception>]
+      # @param error_handler [Proc]
+      # @return [void]
+      def rescue_from(error_class, error_handler)
+        subclasses_handlers = {}
+        this_level_subclasses = []
+        # During this traversal, do two things:
+        # - Identify any already-registered subclasses of this error class
+        #   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
+          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|
+            if err_class < error_class
+              subclasses_handlers[err_class] = handler
+              this_level_subclasses << err_class
+            end
+          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)
+          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 }
+          if next_index_point
+            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`
+            break
+          end
         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[:handler] = error_handler
+        this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+        nil
       end
 
       # Call the given block with the schema's configured error handlers.
@@ -44,8 +106,7 @@ module GraphQL
       def with_error_handling(ctx)
         yield
       rescue StandardError => err
-        rescues = ctx.schema.rescues
-        _err_class, handler = rescues.find { |err_class, handler| err.is_a?(err_class) }
+        handler = find_handler_for(err.class)
         if handler
           runtime_info = ctx.namespace(:interpreter) || {}
           obj = runtime_info[:current_object]
@@ -59,6 +120,43 @@ module GraphQL
           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]
+        handler = nil
+        while (handlers) do
+          _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
+          if next_handler
+            handlers = next_handler[:subclass_handlers]
+            handler = next_handler
+          else
+            # Don't reassign `handler` --
+            # let the previous assignment carry over outside this block.
+            break
+          end
+        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)
+        end
+
+        # If the inherited handler is more specific than the one defined here,
+        # use it.
+        # If it's a tie (or there is no parent handler), use the one defined here.
+        # If there's an inherited one, but not one defined here, use the inherited one.
+        # Otherwise, there's no handler for this error, return `nil`.
+        if parent_handler && handler && parent_handler[:class] < handler[:class]
+          parent_handler[:handler]
+        elsif handler
+          handler[:handler]
+        elsif parent_handler
+          parent_handler[:handler]
+        else
+          nil
+        end
+      end
     end
   end
 end

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

@@ -277,10 +277,7 @@ module GraphQL
               end
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node)
-                if RawValue === continue_value
-                  # Write raw value directly to the response without resolving nested objects
-                  write_in_response(next_path, continue_value.resolve)
-                elsif HALT != continue_value
+                if HALT != continue_value
                   continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
                 end
               end
@@ -332,6 +329,10 @@ module GraphQL
             continue_value(path, next_value, parent_type, field, is_non_null, ast_node)
           elsif GraphQL::Execution::Execute::SKIP == value
             HALT
+          elsif value.is_a?(GraphQL::Execution::Interpreter::RawValue)
+            # Write raw value directly to the response without resolving nested objects
+            write_in_response(path, value.resolve)
+            HALT
           else
             value
           end

data/lib/graphql/introspection.rb

@@ -17,7 +17,7 @@ query IntrospectionQuery {
       name
       description
       locations
-      args {
+      args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
         ...InputValue
       }
     }

data/lib/graphql/introspection/directive_type.rb

@@ -12,13 +12,17 @@ module GraphQL
       field :name, String, null: false, method: :graphql_name
       field :description, String, null: true
       field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
-      def args
-        @context.warden.arguments(@object)
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -5,6 +5,13 @@ module GraphQL
   module Pagination
     # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
     class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_larger_than(relation, size)
+        initial_offset = relation.offset_value || 0
+        relation.offset(initial_offset + size).exists?
+      end
+
       def relation_count(relation)
         int_or_hash = if relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)

data/lib/graphql/pagination/relation_connection.rb

@@ -35,7 +35,7 @@ module GraphQL
             if @nodes && @nodes.count < first
               false
             else
-              relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+              relation_larger_than(sliced_nodes, first)
             end
           else
             false
@@ -53,6 +53,13 @@ module GraphQL
 
       private
 
+      # @param relation [Object] A database query object
+      # @param size [Integer] The value against which we check the relation size
+      # @return [Boolean] True if the number of items in this relation is larger than `size`
+      def relation_larger_than(relation, size)
+        relation_count(set_limit(relation, size + 1)) == size + 1
+      end
+
       # @param relation [Object] A database query object
       # @return [Integer, nil] The offset value, or nil if there isn't one
       def relation_offset(relation)

data/lib/graphql/query.rb

@@ -195,9 +195,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
-        }
+        Execution::Multiplex.run_queries(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end

data/lib/graphql/query/validation_pipeline.rb

@@ -36,7 +36,7 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::StaticValidation::Error >] Static validation errors for the query string
+      # @return [Array<GraphQL::StaticValidation::Error, GraphQL::Query::VariableValidationError>] Static validation errors for the query string
       def validation_errors
         ensure_has_validated
         @validation_errors

data/lib/graphql/schema.rb

@@ -711,7 +711,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, :rescues
+    def_delegators :_schema_class, :error_handler
 
 
     # Given this schema member, find the class-based definition object
@@ -989,7 +989,7 @@ module GraphQL
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
 
-        rescues.each do |err_class, handler|
+        error_handler.each_rescue do |err_class, handler|
           schema_defn.rescue_from(err_class, &handler)
         end
 
@@ -1424,7 +1424,7 @@ module GraphQL
 
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          own_rescues[err_class] = handler_block
+          error_handler.rescue_from(err_class, handler_block)
         end
       end
 
@@ -1468,10 +1468,6 @@ module GraphQL
         super
       end
 
-      def rescues
-        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
-      end
-
       def object_from_id(node_id, ctx)
         raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
@@ -1548,15 +1544,10 @@ 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>]
+      # @return [GraphQL::Execution::Errors]
       def error_handler
-        if defined?(@error_handler)
-          @error_handler
-        else
-          find_inherited_value(:error_handler, GraphQL::Execution::Errors::NullErrorHandler)
-        end
+        @error_handler ||= GraphQL::Execution::Errors.new(self)
       end
 
       def lazy_resolve(lazy_class, value_method)
@@ -1744,10 +1735,6 @@ module GraphQL
         @own_plugins ||= []
       end
 
-      def own_rescues
-        @own_rescues ||= {}
-      end
-
       def own_orphan_types
         @own_orphan_types ||= []
       end
@@ -1990,7 +1977,6 @@ module GraphQL
     end
 
     # Install these here so that subclasses will also install it.
-    use(GraphQL::Execution::Errors)
     use(GraphQL::Pagination::Connections)
 
     protected

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -41,7 +41,9 @@ module GraphQL
               error_options = {
                 nodes: parent,
                 type: kind_of_node,
-                argument: node.name
+                argument_name: node.name,
+                argument: arg_defn,
+                value: node.value
               }
               if coerce_extensions
                 error_options[:coerce_extensions] = coerce_extensions

data/lib/graphql/static_validation/rules/argument_literals_are_compatible_error.rb

@@ -4,13 +4,17 @@ module GraphQL
     class ArgumentLiteralsAreCompatibleError < StaticValidation::Error
       attr_reader :type_name
       attr_reader :argument_name
+      attr_reader :argument
+      attr_reader :value
 
-      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil, coerce_extensions: nil)
+      def initialize(message, path: nil, nodes: [], type:, argument_name: nil, extensions: nil, coerce_extensions: nil, argument: nil, value: nil)
         super(message, path: path, nodes: nodes)
         @type_name = type
-        @argument_name = argument
+        @argument_name = argument_name
         @extensions = extensions
         @coerce_extensions = coerce_extensions
+        @argument = argument
+        @value = value
       end
 
       # A hash representation of this Message

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -15,7 +15,8 @@ module GraphQL
             nodes: node,
             name: error_arg_name,
             type: kind_of_node,
-            argument: node.name
+            argument_name: node.name,
+            parent: parent_defn
           ))
         else
           # Some other weird error

data/lib/graphql/static_validation/rules/arguments_are_defined_error.rb

@@ -5,12 +5,14 @@ module GraphQL
       attr_reader :name
       attr_reader :type_name
       attr_reader :argument_name
+      attr_reader :parent
 
-      def initialize(message, path: nil, nodes: [], name:, type:, argument:)
+      def initialize(message, path: nil, nodes: [], name:, type:, argument_name:, parent:)
         super(message, path: path, nodes: nodes)
         @name = name
         @type_name = type
-        @argument_name = argument
+        @argument_name = argument_name
+        @parent = parent
       end
 
       # A hash representation of this Message

data/lib/graphql/subscriptions/broadcast_analyzer.rb

@@ -35,9 +35,6 @@ module GraphQL
           pt = @query.possible_types(current_type)
           pt.each do |object_type|
             ot_field = @query.get_field(object_type, current_field.graphql_name)
-            if !ot_field
-              binding.pry
-            end
             # Inherited fields would be exactly the same object;
             # only check fields that are overrides of the inherited one
             if ot_field && ot_field != current_field

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

@@ -24,6 +24,10 @@ module GraphQL
       #   end
       #   class Types::PostConnection < Types::BaseConnection
       #     edge_type(Types::PostEdge)
+      #     edges_nullable(true)
+      #     edge_nullable(true)
+      #     node_nullable(true)
+      #     has_nodes_field(true)
       #   end
       #
       # @see Relay::BaseEdge for edge types

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

@@ -11,6 +11,7 @@ module GraphQL
           child_class.extend(ClassMethods)
           child_class.extend(Relay::DefaultRelay)
           child_class.default_relay(true)
+          child_class.has_nodes_field(true)
           child_class.node_nullable(true)
           child_class.edges_nullable(true)
           child_class.edge_nullable(true)
@@ -34,7 +35,7 @@ module GraphQL
           # It's called when you subclass this base connection, trying to use the
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable)
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -79,9 +80,9 @@ module GraphQL
           # Use `node_nullable(false)` in your base class to make non-null `node` and `nodes` fields.
           def node_nullable(new_value = nil)
             if new_value.nil?
-              @node_nullable || superclass.node_nullable
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
             else
-              @node_nullable ||= new_value
+              @node_nullable = new_value
             end
           end
 
@@ -89,21 +90,31 @@ module GraphQL
           # Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
           def edges_nullable(new_value = nil)
             if new_value.nil?
-              @edges_nullable || superclass.edges_nullable
+              defined?(@edges_nullable) ? @edges_nullable : superclass.edges_nullable
             else
-              @edges_nullable ||= new_value
+              @edges_nullable = new_value
             end
-          end     
-          
+          end
+
           # Set the default `edge_nullable` for this class and its child classes. (Defaults to `true`.)
           # Use `edge_nullable(false)` in your base class to make non-null `edge` fields.
           def edge_nullable(new_value = nil)
             if new_value.nil?
-              @edge_nullable || superclass.edge_nullable
+              defined?(@edge_nullable) ? @edge_nullable : superclass.edge_nullable
+            else
+              @edge_nullable = new_value
+            end
+          end
+
+          # Set the default `nodes_field` for this class and its child classes. (Defaults to `true`.)
+          # Use `nodes_field(false)` in your base class to prevent adding of a nodes field.
+          def has_nodes_field(new_value = nil)
+            if new_value.nil?
+              defined?(@nodes_field) ? @nodes_field : superclass.has_nodes_field
             else
-              @edge_nullable ||= new_value
+              @nodes_field = new_value
             end
-          end               
+          end
 
           private
 

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

@@ -8,6 +8,7 @@ module GraphQL
           child_class.description("An edge in a connection.")
           child_class.field(:cursor, String, null: false, description: "A cursor for use in pagination.")
           child_class.extend(ClassMethods)
+          child_class.node_nullable(true)
         end
 
         module ClassMethods
@@ -15,7 +16,7 @@ module GraphQL
           #
           # @param node_type [Class] A `Schema::Object` subclass
           # @param null [Boolean]
-          def node_type(node_type = nil, null: true)
+          def node_type(node_type = nil, null: self.node_nullable)
             if node_type
               @node_type = node_type
               # Add a default `node` field
@@ -35,6 +36,16 @@ module GraphQL
           def visible?(ctx)
             node_type.visible?(ctx)
           end
+
+          # Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `node_nullable(false)` in your base class to make non-null `node` field.
+          def node_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
+            else
+              @node_nullable = new_value
+            end
+          end
         end
       end
     end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.6
+  version: 1.12.7
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2021-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips