graphql 1.12.12 → 1.12.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 296954a3b03f2fd5dae9fae56eaa08ea04b3dfb8f25923201ea27c67147c71fa
-  data.tar.gz: 4de323637c29b729a3eb3f07b620e2014515b37235c485002d016ead490d86e7
+  metadata.gz: 03b30407d3081dad5d25f3a3f9a9e2781cd34db838688816b01c231aaa5a6dc5
+  data.tar.gz: a06092995f8e3ea0ed2c75485124b0123d41a23d77eedd773e15a1d00fad80ab
 SHA512:
-  metadata.gz: fdf50f6c6f170aa4c50d46356e4089c40a939bf3d0dfd4ab7bdb667d169f01a38320c971cdec1dde32353a20823c1756196312df5e425af41a157caa1179e845
-  data.tar.gz: 4202ca4741998ee1f5535eea14ff93c1a8529ff5085625d67171e75736f65f55d0433b93512c272e16f4f9a48dd630eba49cf37a54e49b0e9e3dad5f0496930c
+  metadata.gz: 3af391b8f7394985a42595af2d7b3735a6666310a4583ffd2a9ddce46cf868a6a8d7f2a9cb28ba6a1b85fb70cce8d7425074df847f8b113420e59599bd0379b5
+  data.tar.gz: ca7370709ff588ba437a2f5b277482f2a00543b057ee96e164198ea44f81ad1e470fafe4c7eb89a9e1e64c0aeeddcc128983a67458040c855115516c09adcfd0

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

@@ -7,6 +7,7 @@ module GraphQL
           super
           @used_fields = Set.new
           @used_deprecated_fields = Set.new
+          @used_deprecated_arguments = Set.new
         end
 
         def on_leave_field(node, parent, visitor)
@@ -14,14 +15,36 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
+
+          extract_deprecated_arguments(visitor.query.arguments_for(node, visitor.field_definition).argument_values)
         end
 
         def result
           {
             used_fields: @used_fields.to_a,
-            used_deprecated_fields: @used_deprecated_fields.to_a
+            used_deprecated_fields: @used_deprecated_fields.to_a,
+            used_deprecated_arguments: @used_deprecated_arguments.to_a,
           }
         end
+
+        private
+
+        def extract_deprecated_arguments(argument_values)
+          argument_values.each_pair do |_argument_name, argument|
+            if argument.definition.deprecation_reason
+              @used_deprecated_arguments << argument.definition.path
+            end
+
+            if argument.definition.type.kind.input_object?
+              extract_deprecated_arguments(argument.value.arguments.argument_values)
+            elsif argument.definition.type.list?
+              argument
+                .value
+                .select { |value| value.respond_to?(:arguments) }
+                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) }
+            end
+          end
+        end
       end
     end
   end

data/lib/graphql/backtrace/table.rb

@@ -144,7 +144,7 @@ module GraphQL
       end
 
       def value_at(runtime, path)
-        response = runtime.response
+        response = runtime.final_result
         path.each do |key|
           if response && (response = response[key])
             next

data/lib/graphql/backtrace/tracer.rb

@@ -15,14 +15,17 @@ module GraphQL
           # No query context yet
           nil
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          query = metadata[:query] || metadata[:queries].first
           push_key = []
-          push_data = query
-          multiplex = query.multiplex
+          if (query = metadata[:query]) || ((queries = metadata[:queries]) && (query = queries.first))
+            push_data = query
+            multiplex = query.multiplex
+          elsif (multiplex = metadata[:multiplex])
+            push_data = multiplex.queries.first
+          end
         when "execute_field", "execute_field_lazy"
           query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
           multiplex = query.multiplex
-          push_key = metadata[:path].reject { |i| i.is_a?(Integer) }
+          push_key = metadata[:path]
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
 
           if parent_frame.is_a?(GraphQL::Query)

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

@@ -34,7 +34,10 @@ module GraphQL
           next_results = []
           while results.any?
             result_value = results.shift
-            if result_value.is_a?(Hash)
+            if result_value.is_a?(Runtime::GraphQLResultHash) || result_value.is_a?(Hash)
+              results.concat(result_value.values)
+              next
+            elsif result_value.is_a?(Runtime::GraphQLResultArray)
               results.concat(result_value.values)
               next
             elsif result_value.is_a?(Array)
@@ -46,7 +49,8 @@ module GraphQL
                 # Since this field returned another lazy,
                 # add it to the same queue
                 results << loaded_value
-              elsif loaded_value.is_a?(Hash) || loaded_value.is_a?(Array)
+              elsif loaded_value.is_a?(Runtime::GraphQLResultHash) || loaded_value.is_a?(Runtime::GraphQLResultArray) ||
+                  loaded_value.is_a?(Hash) || loaded_value.is_a?(Array)
                 # Add these values in wholesale --
                 # they might be modified by later work in the dataloader.
                 next_results << loaded_value

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

@@ -10,9 +10,19 @@ module GraphQL
       class Runtime
 
         module GraphQLResult
-          # These methods are private concerns of GraphQL-Ruby,
-          # they aren't guaranteed to continue working in the future.
-          attr_accessor :graphql_dead, :graphql_parent, :graphql_result_name
+          def initialize(result_name, parent_result)
+            @graphql_parent = parent_result
+            if parent_result && parent_result.graphql_dead
+              @graphql_dead = true
+            end
+            @graphql_result_name = result_name
+            # Jump through some hoops to avoid creating this duplicate storage if at all possible.
+            @graphql_metadata = nil
+          end
+
+          attr_accessor :graphql_dead
+          attr_reader :graphql_parent, :graphql_result_name
+
           # Although these are used by only one of the Result classes,
           # it's handy to have the methods implemented on both (even though they just return `nil`)
           # because it makes it easy to check if anything is assigned.
@@ -20,9 +30,17 @@ module GraphQL
           attr_accessor :graphql_non_null_field_names
           # @return [nil, true]
           attr_accessor :graphql_non_null_list_items
+
+          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
+          attr_accessor :graphql_result_data
         end
 
-        class GraphQLResultHash < Hash
+        class GraphQLResultHash
+          def initialize(_result_name, _parent_result)
+            super
+            @graphql_result_data = {}
+          end
+
           include GraphQLResult
 
           attr_accessor :graphql_merged_into
@@ -39,12 +57,82 @@ module GraphQL
             if (t = @graphql_merged_into)
               t[key] = value
             end
-            super
+
+            if value.respond_to?(:graphql_result_data)
+              @graphql_result_data[key] = value.graphql_result_data
+              # If we encounter some part of this response that requires metadata tracking,
+              # then create the metadata hash if necessary. It will be kept up-to-date after this.
+              (@graphql_metadata ||= @graphql_result_data.dup)[key] = value
+            else
+              @graphql_result_data[key] = value
+              # keep this up-to-date if it's been initialized
+              @graphql_metadata && @graphql_metadata[key] = value
+            end
+
+            value
+          end
+
+          def delete(key)
+            @graphql_metadata && @graphql_metadata.delete(key)
+            @graphql_result_data.delete(key)
+          end
+
+          def each
+            (@graphql_metadata || @graphql_result_data).each { |k, v| yield(k, v) }
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data).values
+          end
+
+          def key?(k)
+            @graphql_result_data.key?(k)
+          end
+
+          def [](k)
+            (@graphql_metadata || @graphql_result_data)[k]
           end
         end
 
-        class GraphQLResultArray < Array
+        class GraphQLResultArray
           include GraphQLResult
+
+          def initialize(_result_name, _parent_result)
+            super
+            @graphql_result_data = []
+          end
+
+          def graphql_skip_at(index)
+            # Mark this index as dead. It's tricky because some indices may already be storing
+            # `Lazy`s. So the runtime is still holding indexes _before_ skipping,
+            # this object has to coordinate incoming writes to account for any already-skipped indices.
+            @skip_indices ||= []
+            @skip_indices << index
+            offset_by = @skip_indices.count { |skipped_idx| skipped_idx < index}
+            delete_at_index = index - offset_by
+            @graphql_metadata && @graphql_metadata.delete_at(delete_at_index)
+            @graphql_result_data.delete_at(delete_at_index)
+          end
+
+          def []=(idx, value)
+            if @skip_indices
+              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
+              idx -= offset_by
+            end
+            if value.respond_to?(:graphql_result_data)
+              @graphql_result_data[idx] = value.graphql_result_data
+              (@graphql_metadata ||= @graphql_result_data.dup)[idx] = value
+            else
+              @graphql_result_data[idx] = value
+              @graphql_metadata && @graphql_metadata[idx] = value
+            end
+
+            value
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data)
+          end
         end
 
         class GraphQLSelectionSet < Hash
@@ -60,9 +148,6 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        # @return [Hash]
-        attr_reader :response
-
         def initialize(query:)
           @query = query
           @dataloader = query.multiplex.dataloader
@@ -70,7 +155,7 @@ module GraphQL
           @context = query.context
           @multiplex_context = query.multiplex.context
           @interpreter_context = @context.namespace(:interpreter)
-          @response = GraphQLResultHash.new
+          @response = GraphQLResultHash.new(nil, nil)
           # Identify runtime directives by checking which of this schema's directives have overridden `def self.resolve`
           @runtime_directive_names = []
           noop_resolve_owner = GraphQL::Schema::Directive.singleton_class
@@ -87,6 +172,10 @@ module GraphQL
           @lazy_cache = {}
         end
 
+        def final_result
+          @response && @response.graphql_result_data
+        end
+
         def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
@@ -128,7 +217,7 @@ module GraphQL
               # directly evaluated and the results can be written right into the main response hash.
               tap_or_each(gathered_selections) do |selections, is_selection_array|
                 if is_selection_array
-                  selection_response = GraphQLResultHash.new
+                  selection_response = GraphQLResultHash.new(nil, nil)
                   final_response = @response
                 else
                   selection_response = @response
@@ -167,7 +256,7 @@ module GraphQL
               into_result[key] = value
             else
               case value
-              when Hash
+              when GraphQLResultHash
                 deep_merge_selection_result(value, into_result[key])
               else
                 # We have to assume that, since this passed the `fields_will_merge` selection,
@@ -282,6 +371,7 @@ module GraphQL
 
         # @return [void]
         def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_field, selections_result) # rubocop:disable Metrics/ParameterLists
+          return if dead_result?(selections_result)
           # As a performance optimization, the hash key will be a `Node` if
           # there's only one selection of the field. But if there are multiple
           # selections of the field, it will be an Array of nodes
@@ -439,15 +529,7 @@ module GraphQL
         end
 
         def dead_result?(selection_result)
-          r = selection_result
-          while r
-            if r.graphql_dead
-              return true
-            else
-              r = r.graphql_parent
-            end
-          end
-          false
+          selection_result.graphql_dead || ((parent = selection_result.graphql_parent) && parent.graphql_dead)
         end
 
         def set_result(selection_result, result_name, value)
@@ -471,9 +553,7 @@ module GraphQL
                 @response = nil
               else
                 set_result(parent, name_in_parent, nil)
-                # This is odd, but it's how it used to work. Even if `parent` _would_ accept
-                # a `nil`, it's marked dead. TODO: check the spec, is there a reason for this?
-                parent.graphql_dead = true
+                set_graphql_dead(selection_result)
               end
             else
               selection_result[result_name] = value
@@ -481,6 +561,21 @@ module GraphQL
           end
         end
 
+        # Mark this node and any already-registered children as dead,
+        # so that it accepts no more writes.
+        def set_graphql_dead(selection_result)
+          case selection_result
+          when GraphQLResultArray
+            selection_result.graphql_dead = true
+            selection_result.values.each { |v| set_graphql_dead(v) }
+          when GraphQLResultHash
+            selection_result.graphql_dead = true
+            selection_result.each { |k, v| set_graphql_dead(v) }
+          else
+            # It's a scalar, no way to mark it dead.
+          end
+        end
+
         HALT = Object.new
         def continue_value(path, value, parent_type, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
@@ -500,11 +595,13 @@ module GraphQL
             # to avoid the overhead of checking three different classes
             # every time.
             if value.is_a?(GraphQL::ExecutionError)
-              if !dead_result?(selection_result)
+              if selection_result.nil? || !dead_result?(selection_result)
                 value.path ||= path
                 value.ast_node ||= ast_node
                 context.errors << value
-                set_result(selection_result, result_name, nil)
+                if selection_result
+                  set_result(selection_result, result_name, nil)
+                end
               end
               HALT
             elsif value.is_a?(GraphQL::UnauthorizedError)
@@ -517,6 +614,17 @@ module GraphQL
               end
               continue_value(path, next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
             elsif GraphQL::Execution::Execute::SKIP == value
+              # It's possible a lazy was already written here
+              case selection_result
+              when GraphQLResultHash
+                selection_result.delete(result_name)
+              when GraphQLResultArray
+                selection_result.graphql_skip_at(result_name)
+              when nil
+                # this can happen with directives
+              else
+                raise "Invariant: unexpected result class #{selection_result.class} (#{selection_result.inspect})"
+              end
               HALT
             else
               # What could this actually _be_? Anyhow,
@@ -526,13 +634,15 @@ module GraphQL
           when Array
             # It's an array full of execution errors; add them all.
             if value.any? && value.all? { |v| v.is_a?(GraphQL::ExecutionError) }
-              if !dead_result?(selection_result)
+              if selection_result.nil? || !dead_result?(selection_result)
                 value.each_with_index do |error, index|
                   error.ast_node ||= ast_node
-                  error.path ||= path + (field.type.list? ? [index] : [])
+                  error.path ||= path + ((field && field.type.list?) ? [index] : [])
                   context.errors << error
                 end
-                set_result(selection_result, result_name, nil)
+                if selection_result
+                  set_result(selection_result, result_name, nil)
+                end
               end
               HALT
             else
@@ -593,9 +703,7 @@ module GraphQL
             after_lazy(object_proxy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |inner_object|
               continue_value = continue_value(path, inner_object, owner_type, field, is_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
-                response_hash = GraphQLResultHash.new
-                response_hash.graphql_parent = selection_result
-                response_hash.graphql_result_name = result_name
+                response_hash = GraphQLResultHash.new(result_name, selection_result)
                 set_result(selection_result, result_name, response_hash)
                 gathered_selections = gather_selections(continue_value, current_type, next_selections)
                 # There are two possibilities for `gathered_selections`:
@@ -608,9 +716,7 @@ module GraphQL
                 #    (Technically, it's possible that one of those entries _doesn't_ require isolation.)
                 tap_or_each(gathered_selections) do |selections, is_selection_array|
                   if is_selection_array
-                    this_result = GraphQLResultHash.new
-                    this_result.graphql_parent = selection_result
-                    this_result.graphql_result_name = result_name
+                    this_result = GraphQLResultHash.new(result_name, selection_result)
                     final_result = response_hash
                   else
                     this_result = response_hash
@@ -635,16 +741,15 @@ module GraphQL
             end
           when "LIST"
             inner_type = current_type.of_type
-            response_list = GraphQLResultArray.new
+            response_list = GraphQLResultArray.new(result_name, selection_result)
             response_list.graphql_non_null_list_items = inner_type.non_null?
-            response_list.graphql_parent = selection_result
-            response_list.graphql_result_name = result_name
             set_result(selection_result, result_name, response_list)
 
             idx = 0
             scoped_context = context.scoped_context
             begin
               value.each do |inner_value|
+                break if dead_result?(response_list)
                 next_path = path.dup
                 next_path << idx
                 this_idx = idx
@@ -689,9 +794,24 @@ module GraphQL
             if !dir_defn.is_a?(Class)
               dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
-            dir_args = arguments(nil, dir_defn, dir_node)
-            dir_defn.resolve(object, dir_args, context) do
-              run_directive(object, directives, idx + 1, &block)
+            raw_dir_args = arguments(nil, dir_defn, dir_node)
+            dir_args = continue_value(
+              @context[:current_path], # path
+              raw_dir_args, # value
+              dir_defn, # parent_type
+              nil, # field
+              false, # is_non_null
+              dir_node, # ast_node
+              nil, # result_name
+              nil, # selection_result
+            )
+
+            if dir_args == HALT
+              nil
+            else
+              dir_defn.resolve(object, dir_args, context) do
+                run_directive(object, directives, idx + 1, &block)
+              end
             end
           end
         end

data/lib/graphql/execution/interpreter.rb

@@ -18,7 +18,7 @@ module GraphQL
       def execute(_operation, _root_type, query)
         runtime = evaluate(query)
         sync_lazies(query: query)
-        runtime.response
+        runtime.final_result
       end
 
       def self.use(schema_class)
@@ -56,7 +56,7 @@ module GraphQL
 
       def self.finish_query(query, _multiplex)
         {
-          "data" => query.context.namespace(:interpreter)[:runtime].response
+          "data" => query.context.namespace(:interpreter)[:runtime].final_result
         }
       end
 
@@ -87,7 +87,7 @@ module GraphQL
         final_values = queries.map do |query|
           runtime = query.context.namespace(:interpreter)[:runtime]
           # it might not be present if the query has an error
-          runtime ? runtime.response : nil
+          runtime ? runtime.final_result : nil
         end
         final_values.compact!
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do

data/lib/graphql/execution/lazy.rb

@@ -48,7 +48,11 @@ module GraphQL
           end
         end
 
-        if @value.is_a?(StandardError)
+        # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+        # (fewer clauses in a hot `case` block), but now it requires special handling here.
+        # I think it's still worth it for the performance win, but if the number of special
+        # cases grows, then maybe it's worth rethinking somehow.
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::Execute::SKIP
           raise @value
         else
           @value

data/lib/graphql/pagination/connections.rb

@@ -130,6 +130,11 @@ module GraphQL
         if defined?(Mongoid::Association::Referenced::HasMany::Targets::Enumerable)
           add(Mongoid::Association::Referenced::HasMany::Targets::Enumerable, Pagination::MongoidRelationConnection)
         end
+
+        # Mongoid 7.3+
+        if defined?(Mongoid::Association::Referenced::HasMany::Enumerable)
+          add(Mongoid::Association::Referenced::HasMany::Enumerable, Pagination::MongoidRelationConnection)
+        end
       end
     end
   end

data/lib/graphql/query.rb

@@ -270,7 +270,7 @@ module GraphQL
     # @return [String, nil] Returns nil if the query is invalid.
     def sanitized_query_string(inline_variables: true)
       with_prepared_ast {
-        GraphQL::Language::SanitizedPrinter.new(self, inline_variables: inline_variables).sanitized_query_string
+        schema.sanitized_printer.new(self, inline_variables: inline_variables).sanitized_query_string
       }
     end
 

data/lib/graphql/schema/build_from_definition.rb

@@ -47,10 +47,16 @@ module GraphQL
           # _while_ building the schema.
           # It will dig for a type if it encounters a custom type. This could be a problem if there are cycles.
           directive_type_resolver = nil
-          directive_type_resolver = build_resolve_type(GraphQL::Schema::BUILT_IN_TYPES, directives, ->(type_name) {
+          directive_type_resolver = build_resolve_type(types, directives, ->(type_name) {
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
-              build_definition_from_node(defn, directive_type_resolver, default_resolve)
+              if defn
+                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+              elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+                built_in_defn
+              else
+                raise "No definition for #{type_name.inspect} found in schema document or built-in types. Add a definition for it or remove it."
+              end
             end
           })
 

data/lib/graphql/schema/directive/transform.rb

@@ -39,7 +39,7 @@ module GraphQL
           transform_name = arguments[:by]
           if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
             return_value = return_value.public_send(transform_name)
-            response = context.namespace(:interpreter)[:runtime].response
+            response = context.namespace(:interpreter)[:runtime].final_result
             *keys, last = path
             keys.each do |key|
               if response && (response = response[key])

data/lib/graphql/schema/enum.rb

@@ -24,6 +24,15 @@ module GraphQL
       extend GraphQL::Schema::Member::ValidatesInput
 
       class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+        def initialize(value:, enum:, context:)
+          fix_message = ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
+          message = if (cp = context[:current_path]) && (cf = context[:current_field])
+            "`#{cf.path}` returned `#{value.inspect}` at `#{cp.join(".")}`#{fix_message}"
+          else
+            "`#{value.inspect}` was returned for `#{enum.graphql_name}`#{fix_message}"
+          end
+          super(message)
+        end
       end
 
       class << self
@@ -100,7 +109,7 @@ module GraphQL
           if enum_value
             enum_value.graphql_name
           else
-            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise self::UnresolvedValueError.new(enum: self, value: value, context: ctx)
           end
         end
 

data/lib/graphql/schema/input_object.rb

@@ -11,6 +11,14 @@ module GraphQL
 
       include GraphQL::Dig
 
+      # @return [GraphQL::Query::Context] The context for this query
+      attr_reader :context
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
+      attr_reader :arguments
+
+      # Ruby-like hash behaviors, read-only
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
+
       def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
         if ruby_kwargs
@@ -54,19 +62,8 @@ module GraphQL
         @maybe_lazies = maybe_lazies
       end
 
-      # @return [GraphQL::Query::Context] The context for this query
-      attr_reader :context
-
-      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
-      attr_reader :arguments
-
-      # Ruby-like hash behaviors, read-only
-      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
-
       def to_h
-        @ruby_style_hash.inject({}) do |h, (key, value)|
-          h.merge(key => unwrap_value(value))
-        end
+        unwrap_value(@ruby_style_hash)
       end
 
       def to_hash
@@ -91,8 +88,8 @@ module GraphQL
         when Array
           value.map { |item| unwrap_value(item) }
         when Hash
-          value.inject({}) do |h, (key, value)|
-            h.merge(key => unwrap_value(value))
+          value.reduce({}) do |h, (key, value)|
+            h.merge!(key => unwrap_value(value))
           end
         when InputObject
           value.to_h
@@ -162,7 +159,6 @@ module GraphQL
         # @api private
         INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
 
-
         def validate_non_null_input(input, ctx)
           result = GraphQL::Query::InputValidationResult.new
 

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

@@ -124,6 +124,7 @@ module GraphQL
         end
 
         def camelize(string)
+          return string if string == '_'
           return string unless string.include?("_")
           camelized = string.split('_').map(&:capitalize).join
           camelized[0] = camelized[0].downcase

data/lib/graphql/schema/printer.rb

@@ -4,37 +4,32 @@ module GraphQL
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
     # @example print your schema to standard output (via helper)
-    #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.print_schema(MySchema)
     #
     # @example print your schema to standard output
-    #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.new(MySchema).print_schema
     #
     # @example print a single type to standard output
-    #   query_root = GraphQL::ObjectType.define do
-    #     name "Query"
+    #   class Types::Query < GraphQL::Schema::Object
     #     description "The query root of this schema"
     #
-    #     field :post do
-    #       type post_type
-    #       resolve ->(obj, args, ctx) { Post.find(args["id"]) }
-    #     end
+    #     field :post, Types::Post, null: true
     #   end
     #
-    #   post_type = GraphQL::ObjectType.define do
-    #     name "Post"
+    #   class Types::Post < GraphQL::Schema::Object
     #     description "A blog post"
     #
-    #     field :id, !types.ID
-    #     field :title, !types.String
-    #     field :body, !types.String
+    #     field :id, ID, null: false
+    #     field :title, String, null: false
+    #     field :body, String, null: false
     #   end
     #
-    #   MySchema = GraphQL::Schema.define(query: query_root)
+    #   class MySchema < GraphQL::Schema
+    #     query(Types::Query)
+    #   end
     #
     #   printer = GraphQL::Schema::Printer.new(MySchema)
-    #   puts printer.print_type(post_type)
+    #   puts printer.print_type(Types::Post)
     #
     class Printer < GraphQL::Language::Printer
       attr_reader :schema, :warden
@@ -87,7 +82,7 @@ module GraphQL
 
       # Return a GraphQL schema string for the defined types in the schema
       def print_schema
-        print(@document)
+        print(@document) + "\n"
       end
 
       def print_type(type)

data/lib/graphql/schema/resolver.rb

@@ -307,10 +307,15 @@ module GraphQL
             arguments: arguments,
             null: null,
             complexity: complexity,
-            extensions: extensions,
             broadcastable: broadcastable?,
           }
 
+          # If there aren't any, then the returned array is `[].freeze`,
+          # but passing that along breaks some user code.
+          if (exts = extensions).any?
+            field_opts[:extensions] = exts
+          end
+
           if has_max_page_size?
             field_opts[:max_page_size] = max_page_size
           end

data/lib/graphql/schema/subscription.rb

@@ -116,6 +116,26 @@ module GraphQL
         end
       end
 
+      # This is called during initial subscription to get a "name" for this subscription.
+      # Later, when `.trigger` is called, this will be called again to build another "name".
+      # Any subscribers with matching topic will begin the update flow.
+      #
+      # The default implementation creates a string using the field name, subscription scope, and argument keys and values.
+      # In that implementation, only `.trigger` calls with _exact matches_ result in updates to subscribers.
+      #
+      # To implement a filtered stream-type subscription flow, override this method to return a string with field name and subscription scope.
+      # Then, implement {#update} to compare its arguments to the current `object` and return `:no_update` when an
+      # update should be filtered out.
+      #
+      # @see {#update} for how to skip updates when an event comes with a matching topic.
+      # @param arguments [Hash<String => Object>] The arguments for this topic, in GraphQL-style (camelized strings)
+      # @param field [GraphQL::Schema::Field]
+      # @param scope [Object, nil] A value corresponding to `.trigger(... scope:)` (for updates) or the `subscription_scope` found in `context` (for initial subscriptions).
+      # @return [String] An identifier corresponding to a stream of updates
+      def self.topic_for(arguments:, field:, scope:)
+        Subscriptions::Serialize.dump_recursive([scope, field.graphql_name, arguments])
+      end
+
       # Overriding Resolver#field_options to include subscription_scope
       def self.field_options
         super.merge(

data/lib/graphql/schema.rb

@@ -1631,6 +1631,14 @@ module GraphQL
         find_inherited_value(:multiplex_analyzers, EMPTY_ARRAY) + own_multiplex_analyzers
       end
 
+      def sanitized_printer(new_sanitized_printer = nil)
+        if new_sanitized_printer
+          @own_sanitized_printer = new_sanitized_printer
+        else
+          @own_sanitized_printer || GraphQL::Language::SanitizedPrinter
+        end
+      end
+
       # Execute a query on itself.
       # @see {Query#initialize} for arguments.
       # @return [Hash] query result, ready to be serialized as JSON

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -95,6 +95,14 @@ module GraphQL
         @action_cable = action_cable
         @action_cable_coder = action_cable_coder
         @serializer = serializer
+        @serialize_with_context = case @serializer.method(:load).arity
+        when 1
+          false
+        when 2
+          true
+        else
+          raise ArgumentError, "#{@serializer} must repond to `.load` accepting one or two arguments"
+        end
         @transmit_ns = namespace
         super
       end
@@ -154,7 +162,7 @@ module GraphQL
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first
               first_subscription_id = first_event.context.fetch(:subscription_id)
-              object ||= @serializer.load(message)
+              object ||= load_action_cable_message(message, first_event.context)
               result = execute_update(first_subscription_id, first_event, object)
               # Having calculated the result _once_, send the same payload to all subscribers
               events.each do |event|
@@ -167,6 +175,18 @@ module GraphQL
         end
       end
 
+      # This is called to turn an ActionCable-broadcasted string (JSON)
+      # into a query-ready application object.
+      # @param message [String] n ActionCable-broadcasted string (JSON)
+      # @param context [GraphQL::Query::Context] the context of the first event for a given subscription fingerprint
+      def load_action_cable_message(message, context)
+        if @serialize_with_context
+          @serializer.load(message, context)
+        else
+          @serializer.load(message)
+        end
+      end
+
       # Return the query from "storage" (in memory)
       def read_subscription(subscription_id)
         query = @subscriptions[subscription_id]

data/lib/graphql/subscriptions/event.rb

@@ -29,26 +29,10 @@ module GraphQL
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(name, arguments, field, scope:)
-        normalized_args = case arguments
-        when GraphQL::Query::Arguments
-          arguments
-        when Hash
-          if field.is_a?(GraphQL::Schema::Field)
-            stringify_args(field, arguments)
-          else
-            GraphQL::Query::LiteralInput.from_arguments(
-              arguments,
-              field,
-              nil,
-            )
-          end
-        else
-          raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
-        end
-
-        sorted_h = stringify_args(field, normalized_args.to_h)
-        Serialize.dump_recursive([scope, name, sorted_h])
+      def self.serialize(_name, arguments, field, scope:)
+        subscription = field.resolver || GraphQL::Schema::Subscription
+        normalized_args = stringify_args(field, arguments.to_h)
+        subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
 
       # @return [String] a logical identifier for this event. (Stable when the query is broadcastable.)

data/lib/graphql/types/big_int.rb

@@ -6,7 +6,7 @@ module GraphQL
       description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
 
       def self.coerce_input(value, _ctx)
-        value && Integer(value)
+        value && parse_int(value)
       rescue ArgumentError
         nil
       end
@@ -14,6 +14,10 @@ module GraphQL
       def self.coerce_result(value, _ctx)
         value.to_i.to_s
       end
+
+      def self.parse_int(value)
+        value.is_a?(Numeric) ? value : Integer(value, 10)
+      end
     end
   end
 end

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

@@ -3,6 +3,7 @@
 module GraphQL
   module Types
     module Relay
+      # Include this module to your root Query type to get a Relay-compliant `node(id: ID!): Node` field that uses the schema's `object_from_id` hook.
       module HasNodeField
         def self.included(child_class)
           child_class.field(**field_options, &field_block)
@@ -12,7 +13,6 @@ module GraphQL
           def field_options
             {
               name: "node",
-              owner: nil,
               type: GraphQL::Types::Relay::Node,
               null: true,
               description: "Fetches an object given its ID.",

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

@@ -3,6 +3,7 @@
 module GraphQL
   module Types
     module Relay
+      # Include this module to your root Query type to get a Relay-style `nodes(id: ID!): [Node]` field that uses the schema's `object_from_id` hook.
       module HasNodesField
         def self.included(child_class)
           child_class.field(**field_options, &field_block)
@@ -12,7 +13,6 @@ module GraphQL
           def field_options
             {
               name: "nodes",
-              owner: nil,
               type: [GraphQL::Types::Relay::Node, null: true],
               null: false,
               description: "Fetches a list of objects given a list of IDs.",

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

@@ -6,7 +6,7 @@ module GraphQL
       # or use it for inspiration for your own field definition.
       #
       # @example Adding this field directly
-      #   add_field(GraphQL::Types::Relay::NodeField)
+      #   include GraphQL::Types::Relay::HasNodeField
       #
       # @example Implementing a similar field in your own Query root
       #
@@ -19,7 +19,7 @@ module GraphQL
       #     context.schema.object_from_id(id, context)
       #   end
       #
-      NodeField = GraphQL::Schema::Field.new(**HasNodeField.field_options, &HasNodeField.field_block)
+      NodeField = GraphQL::Schema::Field.new(owner: nil, **HasNodeField.field_options, &HasNodeField.field_block)
     end
   end
 end

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

@@ -6,7 +6,7 @@ module GraphQL
       # or use it for inspiration for your own field definition.
       #
       # @example Adding this field directly
-      #   add_field(GraphQL::Types::Relay::NodesField)
+      #   include GraphQL::Types::Relay::HasNodesField
       #
       # @example Implementing a similar field in your own Query root
       #
@@ -21,7 +21,7 @@ module GraphQL
       #     end
       #   end
       #
-      NodesField = GraphQL::Schema::Field.new(**HasNodesField.field_options, &HasNodesField.field_block)
+      NodesField = GraphQL::Schema::Field.new(owner: nil, **HasNodesField.field_options, &HasNodesField.field_block)
     end
   end
 end

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -57,22 +57,26 @@ module GraphQL
   end
 
   # Support Ruby 2.2 by implementing `-"str"`. If we drop 2.2 support, we can remove this backport.
-  module StringDedupBackport
-    refine String do
-      def -@
-        if frozen?
-          self
-        else
-          self.dup.freeze
+  if !String.method_defined?(:-@)
+    module StringDedupBackport
+      refine String do
+        def -@
+          if frozen?
+            self
+          else
+            self.dup.freeze
+          end
         end
       end
     end
   end
 
-  module StringMatchBackport
-    refine String do
-      def match?(pattern)
-        self =~ pattern
+  if !String.method_defined?(:match?)
+    module StringMatchBackport
+      refine String do
+        def match?(pattern)
+          self =~ pattern
+        end
       end
     end
   end

data/readme.md

@@ -2,9 +2,6 @@
 
 [![CI Suite](https://github.com/rmosolgo/graphql-ruby/actions/workflows/ci.yaml/badge.svg)](https://github.com/rmosolgo/graphql-ruby/actions/workflows/ci.yaml)
 [![Gem Version](https://badge.fury.io/rb/graphql.svg)](https://rubygems.org/gems/graphql)
-[![Code Climate](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/gpa.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
-[![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
-[![built with love](https://cloud.githubusercontent.com/assets/2231765/6766607/d07992c6-cfc9-11e4-813f-d9240714dd50.png)](https://rmosolgo.github.io/react-badges/)
 
 A Ruby implementation of [GraphQL](https://graphql.org/).
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.12
+  version: 1.12.16
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-31 00:00:00.000000000 Z
+date: 2021-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -150,20 +136,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: '0.68'
-- !ruby/object:Gem::Dependency
-  name: stackprof
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
@@ -713,7 +685,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
@@ -728,8 +700,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []