graphql 1.13.5 → 1.13.9

data/lib/generators/graphql/type_generator.rb

@@ -8,13 +8,28 @@ require_relative 'core'
 
 module Graphql
   module Generators
-    class TypeGeneratorBase < Rails::Generators::Base
+    class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      argument :type_name,
-        type: :string,
-        banner: "TypeName",
-        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      argument :custom_fields,
+                type: :array,
+                default: [],
+                banner: "name:type name:type ...",
+                desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      
+      attr_accessor :graphql_type
+
+      def create_type_file
+        template "#{graphql_type}.erb", "#{options[:directory]}/types#{subdirectory}/#{type_file_name}.rb"
+      end
 
       # Take a type expression in any combination of GraphQL or Ruby styles
       # and return it in a specified output style
@@ -60,12 +75,12 @@ module Graphql
 
       # @return [String] The user-provided type name, normalized to Ruby code
       def type_ruby_name
-        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+        @type_ruby_name ||= self.class.normalize_type_expression(name, mode: :ruby)[0]
       end
 
       # @return [String] The user-provided type name, as a GraphQL name
       def type_graphql_name
-        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+        @type_graphql_name ||= self.class.normalize_type_expression(name, mode: :graphql)[0]
       end
 
       # @return [String] The user-provided type name, as a file name (without extension)
@@ -82,6 +97,24 @@ module Graphql
         }
       end
 
+      def ruby_class_name
+        class_prefix = 
+          if options[:namespaced_types]
+            "#{graphql_type.pluralize.camelize}::"
+          else
+            ""
+          end
+        @ruby_class_name || class_prefix + type_ruby_name.sub(/^Types::/, "")
+      end
+
+      def subdirectory
+        if options[:namespaced_types]
+          "/#{graphql_type.pluralize}"
+        else
+          ""
+        end
+      end
+
       class NormalizedField
         def initialize(name, type_expr, null)
           @name = name
@@ -89,8 +122,12 @@ module Graphql
           @null = null
         end
 
-        def to_ruby
-          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        def to_object_field
+          "field :#{@name}, #{@type_expr}#{@null ? '' : ', null: false'}"
+        end
+
+        def to_input_argument
+          "argument :#{@name}, #{@type_expr}, required: false"
         end
       end
     end

data/lib/generators/graphql/union_generator.rb

@@ -19,14 +19,14 @@ module Graphql
         banner: "type type ...",
         desc: "Possible types for this union (expressed as Ruby or GraphQL)"
 
-      def create_type_file
-        template "union.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
-      end
-
       private
 
+      def graphql_type
+        "union"
+      end
+
       def normalized_possible_types
-        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
+        custom_fields.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
       end
     end
   end

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

@@ -100,7 +100,8 @@ module GraphQL
         def on_field(node, parent)
           @response_path.push(node.alias || node.name)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name, @query.context)
+          # This could be nil if the previous field wasn't found:
+          field_definition = parent_type && @schema.get_field(parent_type, node.name, @query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap

data/lib/graphql/dataloader/source.rb

@@ -138,8 +138,8 @@ module GraphQL
       # @api private
       def result_for(key)
         if !@results.key?(key)
-          raise <<-ERR
-Invariant: fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
+          raise GraphQL::InvariantError, <<-ERR
+Fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
 
 This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
 ERR

data/lib/graphql/date_encoding_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::ISO8601Date` is asked to return a value
+  # that cannot be parsed to a Ruby Date.
+  #
+  # @see GraphQL::Types::ISO8601Date which raises this error
+  class DateEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :date_value
+
+    def initialize(value)
+      @date_value = value
+      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+    end
+  end
+end

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

@@ -207,7 +207,7 @@ module GraphQL
             # Root .authorized? returned false.
             @response = nil
           else
-            resolve_with_directives(object_proxy, root_operation.directives) do # execute query level directives
+            call_method_on_directives(:resolve, object_proxy, root_operation.directives) do # execute query level directives
               gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
               # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
               # require isolation during execution (because of runtime directives). In that case,
@@ -227,7 +227,7 @@ module GraphQL
 
                 @dataloader.append_job {
                   set_all_interpreter_context(query.root_value, nil, nil, path)
-                  resolve_with_directives(object_proxy, selections.graphql_directives) do
+                  call_method_on_directives(:resolve, object_proxy, selections.graphql_directives) do
                     evaluate_selections(
                       path,
                       context.scoped_context,
@@ -503,7 +503,7 @@ module GraphQL
               }
             end
 
-            field_result = resolve_with_directives(object, directives) do
+            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
@@ -735,7 +735,7 @@ module GraphQL
                     final_result = nil
                   end
                   set_all_interpreter_context(continue_value, nil, nil, path) # reset this mutable state
-                  resolve_with_directives(continue_value, selections.graphql_directives) do
+                  call_method_on_directives(:resolve, continue_value, selections.graphql_directives) do
                     evaluate_selections(
                       path,
                       context.scoped_context,
@@ -754,6 +754,8 @@ module GraphQL
             end
           when "LIST"
             inner_type = current_type.of_type
+            # This is true for objects, unions, and interfaces
+            use_dataloader_job = !inner_type.unwrap.kind.input?
             response_list = GraphQLResultArray.new(result_name, selection_result)
             response_list.graphql_non_null_list_items = inner_type.non_null?
             set_result(selection_result, result_name, response_list)
@@ -768,12 +770,12 @@ module GraphQL
                 this_idx = idx
                 next_path.freeze
                 idx += 1
-                # This will update `response_list` with the lazy
-                after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
-                  continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node, this_idx, response_list)
-                  if HALT != continue_value
-                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
+                if use_dataloader_job
+                  @dataloader.append_job do
+                    resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
                   end
+                else
+                  resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
                 end
               end
             rescue NoMethodError => err
@@ -793,12 +795,25 @@ module GraphQL
           end
         end
 
-        def resolve_with_directives(object, directives, &block)
+        def resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
+          set_all_interpreter_context(nil, nil, nil, next_path)
+          call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
+            # This will update `response_list` with the lazy
+            after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
+              continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node, this_idx, response_list)
+              if HALT != continue_value
+                continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
+              end
+            end
+          end
+        end
+
+        def call_method_on_directives(method_name, object, directives, &block)
           return yield if directives.nil? || directives.empty?
-          run_directive(object, directives, 0, &block)
+          run_directive(method_name, object, directives, 0, &block)
         end
 
-        def run_directive(object, directives, idx, &block)
+        def run_directive(method_name, object, directives, idx, &block)
           dir_node = directives[idx]
           if !dir_node
             yield
@@ -822,8 +837,8 @@ module GraphQL
             if dir_args == HALT
               nil
             else
-              dir_defn.resolve(object, dir_args, context) do
-                run_directive(object, directives, idx + 1, &block)
+              dir_defn.public_send(method_name, object, dir_args, context) do
+                run_directive(method_name, object, directives, idx + 1, &block)
               end
             end
           end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -6,8 +6,8 @@ module GraphQL
       description "A Directive can be adjacent to many parts of the GraphQL language, "\
                   "a __DirectiveLocation describes one such possible adjacencies."
 
-      GraphQL::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+      GraphQL::Schema::Directive::LOCATIONS.each do |location|
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
       end
       introspection true
     end

data/lib/graphql/introspection/directive_type.rb

@@ -19,6 +19,8 @@ module GraphQL
       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?
 
+      field :is_repeatable, Boolean, method: :repeatable?
+
       def args(include_deprecated:)
         args = @context.warden.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated

data/lib/graphql/introspection/schema_type.rb

@@ -13,6 +13,11 @@ module GraphQL
       field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
       field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :description, String, resolver_method: :schema_description
+
+      def schema_description
+        context.schema.description
+      end
 
       def types
         @context.warden.reachable_types.sort_by(&:graphql_name)

data/lib/graphql/introspection/type_type.rb

@@ -12,7 +12,7 @@ module GraphQL
                   "possible at runtime. List and NonNull types compose other types."
 
       field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
-      field :name, String
+      field :name, String, method: :graphql_name
       field :description, String
       field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] do
         argument :include_deprecated, Boolean, required: false, default_value: false
@@ -27,8 +27,14 @@ module GraphQL
       end
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
 
-      def name
-        object.graphql_name
+      field :specified_by_url, String
+
+      def specified_by_url
+        if object.kind.scalar?
+          object.specified_by_url
+        else
+          nil
+        end
       end
 
       def kind

data/lib/graphql/introspection.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
-    def self.query(include_deprecated_args: false)
+    def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false)
       # The introspection query to end all introspection queries, copied from
       # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
       <<-QUERY
 query IntrospectionQuery {
   __schema {
+    #{include_schema_description ? "description" : ""}
     queryType { name }
     mutationType { name }
     subscriptionType { name }
@@ -17,6 +18,7 @@ query IntrospectionQuery {
       name
       description
       locations
+      #{include_is_repeatable ? "isRepeatable" : ""}
       args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
         ...InputValue
       }
@@ -27,6 +29,7 @@ fragment FullType on __Type {
   kind
   name
   description
+  #{include_specified_by_url ? "specifiedByUrl" : ""}
   fields(includeDeprecated: true) {
     name
     description

data/lib/graphql/pagination/relation_connection.rb

@@ -47,7 +47,7 @@ module GraphQL
       def cursor_for(item)
         load_nodes
         # index in nodes + existing offset + 1 (because it's offset, not index)
-        offset = nodes.index(item) + 1 + (@paged_nodes_offset || 0) + (relation_offset(items) || 0)
+        offset = nodes.index(item) + 1 + (@paged_nodes_offset || 0) - (relation_offset(items) || 0)
         encode(offset.to_s)
       end
 
@@ -116,9 +116,9 @@ module GraphQL
         if defined?(@sliced_nodes_limit)
           return
         else
+          next_offset = relation_offset(items) || 0
           if after_offset
-            previous_offset = relation_offset(items) || 0
-            relation_offset = previous_offset + after_offset
+            next_offset += after_offset
           end
 
           if before_offset && after_offset
@@ -136,7 +136,7 @@ module GraphQL
           end
 
           @sliced_nodes_limit = relation_limit
-          @sliced_nodes_offset = relation_offset || 0
+          @sliced_nodes_offset = next_offset
         end
       end
 

data/lib/graphql/rubocop/graphql/default_required_true.rb

@@ -25,16 +25,16 @@ module GraphQL
 
         def_node_matcher :argument_config_with_required_true?, <<-Pattern
         (
-          send nil? :argument ... (hash <$(pair (sym :required) (true)) ...>)
+          send {nil? _} :argument ... (hash <$(pair (sym :required) (true)) ...>)
         )
         Pattern
 
         def on_send(node)
           argument_config_with_required_true?(node) do |required_config|
             add_offense(required_config) do |corrector|
-                cleaned_node_source = source_without_keyword_argument(node, required_config)
-                corrector.replace(node, cleaned_node_source)
-              end
+              cleaned_node_source = source_without_keyword_argument(node, required_config)
+              corrector.replace(node, cleaned_node_source)
+            end
           end
         end
       end

data/lib/graphql/schema/argument.rb

@@ -48,13 +48,21 @@ module GraphQL
       # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, 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:, validates: nil, directives: nil, deprecation_reason: nil, &definition_block)
+      # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, 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:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
         @null = required != true
         @default_value = default_value
+        if replace_null_with_default
+          if !default_value?
+            raise ArgumentError, "`replace_null_with_default: true` requires a default value, please provide one with `default_value: ...`"
+          end
+          @replace_null_with_default = true
+        end
+
         @owner = owner
         @as = as
         @loads = loads
@@ -97,6 +105,10 @@ module GraphQL
         @default_value != NO_DEFAULT
       end
 
+      def replace_null_with_default?
+        @replace_null_with_default
+      end
+
       attr_writer :description
 
       # @return [String] Documentation for this argument
@@ -253,6 +265,11 @@ module GraphQL
           return
         end
 
+        if value.nil? && replace_null_with_default?
+          value = default_value
+          default_used = true
+        end
+
         loaded_value = nil
         coerced_value = context.schema.error_handler.with_error_handling(context) do
           type.coerce_input(value, context)

data/lib/graphql/schema/directive.rb

@@ -90,6 +90,11 @@ module GraphQL
           yield
         end
 
+        # Continuing is passed as a block, yield to continue.
+        def resolve_each(object, arguments, context)
+          yield
+        end
+
         def on_field?
           locations.include?(FIELD)
         end
@@ -128,6 +133,10 @@ module GraphQL
         @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext)
       end
 
+      def graphql_name
+        self.class.graphql_name
+      end
+
       LOCATIONS = [
         QUERY =                  :QUERY,
         MUTATION =               :MUTATION,
@@ -147,6 +156,7 @@ module GraphQL
         ENUM_VALUE =             :ENUM_VALUE,
         INPUT_OBJECT =           :INPUT_OBJECT,
         INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
+        VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
       ]
 
       DEFAULT_DEPRECATION_REASON = 'No longer supported'
@@ -169,6 +179,7 @@ module GraphQL
         ENUM_VALUE:               'Location adjacent to an enum value definition.',
         INPUT_OBJECT:             'Location adjacent to an input object type definition.',
         INPUT_FIELD_DEFINITION:   'Location adjacent to an input object field definition.',
+        VARIABLE_DEFINITION:      'Location adjacent to a variable definition.',
       }
 
       private

data/lib/graphql/schema/field.rb

@@ -38,7 +38,9 @@ module GraphQL
 
       # @return [Class] The GraphQL type this field belongs to. (For fields defined on mutations, it's the payload type)
       def owner_type
-        @owner_type ||= if owner < GraphQL::Schema::Mutation
+        @owner_type ||= if owner.nil?
+          raise GraphQL::InvariantError, "Field #{original_name.inspect} (graphql name: #{graphql_name.inspect}) has no owner, but all fields should have an owner. How did this happen?!"
+        elsif owner < GraphQL::Schema::Mutation
           owner.payload_type
         else
           owner
@@ -188,6 +190,7 @@ module GraphQL
       # @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`)
       # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+      # @param dig [Array<String, Symbol>] The nested hash keys to lookup on the underlying hash to resolve this field using dig
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
@@ -210,7 +213,7 @@ module GraphQL
       # @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
       # @param legacy_edge_class [Class, nil] (DEPRECATED) If present, pass this along to the legacy field definition
-      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, 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, legacy_edge_class: nil, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, 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, legacy_edge_class: nil, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -236,8 +239,8 @@ module GraphQL
         @resolve = resolve
         self.deprecation_reason = deprecation_reason
 
-        if method && hash_key
-          raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
+        if method && hash_key && dig
+          raise ArgumentError, "Provide `method:`, `hash_key:` _or_ `dig:`, not multiple. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}, dig: #{dig.inspect}`)"
         end
 
         if resolver_method
@@ -245,13 +248,14 @@ module GraphQL
             raise ArgumentError, "Provide `method:` _or_ `resolver_method:`, not both. (called with: `method: #{method.inspect}, resolver_method: #{resolver_method.inspect}`)"
           end
 
-          if hash_key
-            raise ArgumentError, "Provide `hash_key:` _or_ `resolver_method:`, not both. (called with: `hash_key: #{hash_key.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          if hash_key || dig
+            raise ArgumentError, "Provide `hash_key:`, `dig:`, _or_ `resolver_method:`, not multiple. (called with: `hash_key: #{hash_key.inspect}, dig: #{dig.inspect}, resolver_method: #{resolver_method.inspect}`)"
           end
         end
 
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
         method_name = method || hash_key || name_s
+        @dig_keys = dig
         resolver_method ||= name_s.to_sym
 
         @method_str = -method_name.to_s
@@ -424,11 +428,14 @@ module GraphQL
         elsif connection?
           arguments = query.arguments_for(nodes.first, self)
           max_possible_page_size = nil
-          if arguments[:first]
-            max_possible_page_size = arguments[:first]
-          end
-          if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
-            max_possible_page_size = arguments[:last]
+          if arguments.respond_to?(:[]) # It might have been an error
+            if arguments[:first]
+              max_possible_page_size = arguments[:first]
+            end
+
+            if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
+              max_possible_page_size = arguments[:last]
+            end
           end
 
           if max_possible_page_size.nil?
@@ -822,7 +829,9 @@ module GraphQL
               end
             elsif obj.object.is_a?(Hash)
               inner_object = obj.object
-              if inner_object.key?(@method_sym)
+              if @dig_keys
+                inner_object.dig(*@dig_keys)
+              elsif inner_object.key?(@method_sym)
                 inner_object[@method_sym]
               else
                 inner_object[@method_str]

data/lib/graphql/schema/input_object.rb

@@ -81,7 +81,7 @@ module GraphQL
 
       def self.authorized?(obj, value, ctx)
         # Authorize each argument (but this doesn't apply if `prepare` is implemented):
-        if value.is_a?(InputObject)
+        if value.respond_to?(:key?)
           arguments(ctx).each do |_name, input_obj_arg|
             input_obj_arg = input_obj_arg.type_class
             if value.key?(input_obj_arg.keyword) &&

data/lib/graphql/schema/loader.rb

@@ -34,6 +34,7 @@ module GraphQL
         Class.new(GraphQL::Schema) do
           orphan_types(types.values)
           directives(directives)
+          description(schema["description"])
 
           def self.resolve_type(*)
             raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
@@ -141,6 +142,7 @@ module GraphQL
               Class.new(GraphQL::Schema::Scalar) do
                 graphql_name(type["name"])
                 description(type["description"])
+                specified_by_url(type["specifiedByUrl"])
               end
             end
           when "UNION"
@@ -160,6 +162,7 @@ module GraphQL
             graphql_name(directive["name"])
             description(directive["description"])
             locations(*directive["locations"].map(&:to_sym))
+            repeatable(directive["isRepeatable"])
             loader.build_arguments(self, directive["args"], type_resolver)
           end
         end

data/lib/graphql/schema/scalar.rb

@@ -32,6 +32,18 @@ module GraphQL
           GraphQL::TypeKinds::SCALAR
         end
 
+        def specified_by_url(new_url = nil)
+          if new_url
+            @specified_by_url = new_url
+          elsif defined?(@specified_by_url)
+            @specified_by_url
+          elsif superclass.respond_to?(:specified_by_url)
+            superclass.specified_by_url
+          else
+            nil
+          end
+        end
+
         def default_scalar(is_default = nil)
           if !is_default.nil?
             @default_scalar = is_default

data/lib/graphql/schema.rb

@@ -892,6 +892,17 @@ module GraphQL
         GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
       end
 
+      # @return [String, nil]
+      def description(new_description = nil)
+        if new_description
+          @description = new_description
+        elsif defined?(@description)
+          @description
+        else
+          find_inherited_value(:description, nil)
+        end
+      end
+
       def find(path)
         if !@finder
           @find_cache = {}
@@ -1247,11 +1258,7 @@ module GraphQL
         when Module
           type_or_name
         else
-          raise ArgumentError, <<-ERR
-Invariant: unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})
-
-This is probably a bug in GraphQL-Ruby, please report this error on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new?template=bug_report.md
-ERR
+          raise GraphQL::InvariantError, "Unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
         end
 
         if parent_type.kind.fields? && (field = parent_type.get_field(field_name, context))