graphql 1.12.11 → 1.12.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e46a535c108ff0ae582fcfa598b21cda8faad15142629b1cdae772f3d24cd7e
-  data.tar.gz: 3185ec249d624c6b23920d9d9fb47167ac031b7645053ff705e3c04acc0fa571
+  metadata.gz: f858de6eaac686676c159e87ae2f200b6c69b9b6c1da8e7459595b49f4f44e7a
+  data.tar.gz: afd8686f7897896919bef91076285f0763e49076759036352bd212d41c1bb47f
 SHA512:
-  metadata.gz: 989c1074a6de63a31002d2bd92da719e1b08682d3eefe361add671a75c1991173b13cc6516f8ede8ff5bcf7499935e514cd8d7d57a2940e85160bc427538e99c
-  data.tar.gz: cb40ba585e721d28856951312755ef84bdd698a7299b1a383dd4f9db77d8b137e8d21ee9a8784b14780b4230a5a5325520d0ceadf90f6bd055781cc7159257b5
+  metadata.gz: 6774f423bdf61cf07d842ca00f517068139a86da2d6e0d6b7e15e7970aaf5ce1b07e58d78c0a13a1ccf0a8db87c48d4061e151ca42bc21731e26958ef96ad922
+  data.tar.gz: 31ca7b94bacf8df5a8c27c0e3c2f831362970e49c65c8b0a284095c1bd392af26347cecc78e60dc91ff4581a9a3d55dc08204eb0230ed641f2907e009a4f7f3e

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/dataloader/null_dataloader.rb

@@ -10,6 +10,7 @@ module GraphQL
       # These are all no-ops because code was
       # executed sychronously.
       def run; end
+      def run_isolated; yield; end
       def yield; end
 
       def append_job

data/lib/graphql/dataloader.rb

@@ -77,6 +77,21 @@ module GraphQL
       nil
     end
 
+    # Use a self-contained queue for the work in the block.
+    def run_isolated
+      prev_queue = @pending_jobs
+      @pending_jobs = []
+      res = nil
+      # Make sure the block is inside a Fiber, so it can `Fiber.yield`
+      append_job {
+        res = yield
+      }
+      run
+      res
+    ensure
+      @pending_jobs = prev_queue
+    end
+
     # @api private Move along, move along
     def run
       # At a high level, the algorithm is:

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

@@ -28,11 +28,12 @@ module GraphQL
         end
 
         def fetch(ast_node, argument_owner, parent_object)
-          @storage[ast_node][argument_owner][parent_object]
           # If any jobs were enqueued, run them now,
           # since this might have been called outside of execution.
           # (The jobs are responsible for updating `result` in-place.)
-          @dataloader.run
+          @dataloader.run_isolated do
+            @storage[ast_node][argument_owner][parent_object]
+          end
           # Ack, the _hash_ is updated, but the key is eventually
           # overridden with an immutable arguments instance.
           # The first call queues up the job,

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,8 +10,6 @@ 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
           # 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`)
@@ -20,14 +18,116 @@ 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
+            # Jump through some hoops to avoid creating this duplicate hash if at all possible.
+            @graphql_metadata = nil
+            @graphql_result_data = {}
+          end
+
           include GraphQLResult
+
+          attr_accessor :graphql_merged_into
+
+          def []=(key, value)
+            # This is a hack.
+            # Basically, this object is merged into the root-level result at some point.
+            # But the problem is, some lazies are created whose closures retain reference to _this_
+            # object. When those lazies are resolved, they cause an update to this object.
+            #
+            # In order to return a proper top-level result, we have to update that top-level result object.
+            # In order to return a proper partial result (eg, for a directive), we have to update this object, too.
+            # Yowza.
+            if (t = @graphql_merged_into)
+              t[key] = value
+            end
+
+            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
+            # Avoid this duplicate allocation if possible -
+            # but it will require some work to keep it up-to-date if it's created.
+            @graphql_metadata = nil
+            @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
+          attr_accessor :graphql_directives
         end
 
         # @return [GraphQL::Query]
@@ -39,9 +139,6 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        # @return [Hash]
-        attr_reader :response
-
         def initialize(query:)
           @query = query
           @dataloader = query.multiplex.dataloader
@@ -50,6 +147,14 @@ module GraphQL
           @multiplex_context = query.multiplex.context
           @interpreter_context = @context.namespace(:interpreter)
           @response = GraphQLResultHash.new
+          # 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
+          schema.directives.each do |name, dir_defn|
+            if dir_defn.method(:resolve).owner != noop_resolve_owner
+              @runtime_directive_names << name
+            end
+          end
           # A cache of { Class => { String => Schema::Field } }
           # Which assumes that MyObject.get_field("myField") will return the same field
           # during the lifetime of a query
@@ -58,10 +163,24 @@ module GraphQL
           @lazy_cache = {}
         end
 
+        def final_result
+          @response && @response.graphql_result_data
+        end
+
         def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
+        def tap_or_each(obj_or_array)
+          if obj_or_array.is_a?(Array)
+            obj_or_array.each do |item|
+              yield(item, true)
+            end
+          else
+            yield(obj_or_array, false)
+          end
+        end
+
         # This _begins_ the execution. Some deferred work
         # might be stored up in lazies.
         # @return [void]
@@ -78,20 +197,40 @@ module GraphQL
             # Root .authorized? returned false.
             @response = nil
           else
-            resolve_with_directives(object_proxy, root_operation) do # execute query level directives
+            resolve_with_directives(object_proxy, root_operation.directives) do # execute query level directives
               gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
-              # Make the first fiber which will begin execution
-              @dataloader.append_job {
-                evaluate_selections(
-                  path,
-                  context.scoped_context,
-                  object_proxy,
-                  root_type,
-                  root_op_type == "mutation",
-                  gathered_selections,
-                  @response,
-                )
-              }
+              # 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,
+              # make a new, isolated result hash for writing the result into. (That isolated response
+              # is eventually merged back into the main response)
+              #
+              # Otherwise, `gathered_selections` is a hash of selections which can be
+              # 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
+                  final_response = @response
+                else
+                  selection_response = @response
+                  final_response = nil
+                end
+
+                @dataloader.append_job {
+                  set_all_interpreter_context(query.root_value, nil, nil, path)
+                  resolve_with_directives(object_proxy, selections.graphql_directives) do
+                    evaluate_selections(
+                      path,
+                      context.scoped_context,
+                      object_proxy,
+                      root_type,
+                      root_op_type == "mutation",
+                      selections,
+                      selection_response,
+                      final_response,
+                    )
+                  end
+                }
+              end
             end
           end
           delete_interpreter_context(:current_path)
@@ -101,15 +240,36 @@ module GraphQL
           nil
         end
 
-        def gather_selections(owner_object, owner_type, selections, selections_by_name = {})
+        # @return [void]
+        def deep_merge_selection_result(from_result, into_result)
+          from_result.each do |key, value|
+            if !into_result.key?(key)
+              into_result[key] = value
+            else
+              case value
+              when GraphQLResultHash
+                deep_merge_selection_result(value, into_result[key])
+              else
+                # We have to assume that, since this passed the `fields_will_merge` selection,
+                # that the old and new values are the same.
+                # There's no special handling of arrays because currently, there's no way to split the execution
+                # of a list over several concurrent flows.
+                into_result[key] = value
+              end
+            end
+          end
+          from_result.graphql_merged_into = into_result
+          nil
+        end
+
+        def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = GraphQLSelectionSet.new)
           selections.each do |node|
             # Skip gathering this if the directive says so
             if !directives_include?(node, owner_object, owner_type)
               next
             end
 
-            case node
-            when GraphQL::Language::Nodes::Field
+            if node.is_a?(GraphQL::Language::Nodes::Field)
               response_key = node.alias || node.name
               selections = selections_by_name[response_key]
               # if there was already a selection of this field,
@@ -125,52 +285,77 @@ module GraphQL
                 # No selection was found for this field yet
                 selections_by_name[response_key] = node
               end
-            when GraphQL::Language::Nodes::InlineFragment
-              if node.type
-                type_defn = schema.get_type(node.type.name)
-                # Faster than .map{}.include?()
-                query.warden.possible_types(type_defn).each do |t|
+            else
+              # This is an InlineFragment or a FragmentSpread
+              if @runtime_directive_names.any? && node.directives.any? { |d| @runtime_directive_names.include?(d.name) }
+                next_selections = GraphQLSelectionSet.new
+                next_selections.graphql_directives = node.directives
+                if selections_to_run
+                  selections_to_run << next_selections
+                else
+                  selections_to_run = []
+                  selections_to_run << selections_by_name
+                  selections_to_run << next_selections
+                end
+              else
+                next_selections = selections_by_name
+              end
+
+              case node
+              when GraphQL::Language::Nodes::InlineFragment
+                if node.type
+                  type_defn = schema.get_type(node.type.name)
+
+                  # Faster than .map{}.include?()
+                  query.warden.possible_types(type_defn).each do |t|
+                    if t == owner_type
+                      gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                      break
+                    end
+                  end
+                else
+                  # it's an untyped fragment, definitely continue
+                  gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                end
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment_def = query.fragments[node.name]
+                type_defn = schema.get_type(fragment_def.type.name)
+                possible_types = query.warden.possible_types(type_defn)
+                possible_types.each do |t|
                   if t == owner_type
-                    gather_selections(owner_object, owner_type, node.selections, selections_by_name)
+                    gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
                     break
                   end
                 end
               else
-                # it's an untyped fragment, definitely continue
-                gather_selections(owner_object, owner_type, node.selections, selections_by_name)
+                raise "Invariant: unexpected selection class: #{node.class}"
               end
-            when GraphQL::Language::Nodes::FragmentSpread
-              fragment_def = query.fragments[node.name]
-              type_defn = schema.get_type(fragment_def.type.name)
-              possible_types = query.warden.possible_types(type_defn)
-              possible_types.each do |t|
-                if t == owner_type
-                  gather_selections(owner_object, owner_type, fragment_def.selections, selections_by_name)
-                  break
-                end
-              end
-            else
-              raise "Invariant: unexpected selection class: #{node.class}"
             end
           end
-          selections_by_name
+          selections_to_run || selections_by_name
         end
 
         NO_ARGS = {}.freeze
 
         # @return [void]
-        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections, selections_result)
+        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result) # rubocop:disable Metrics/ParameterLists
           set_all_interpreter_context(owner_object, nil, nil, path)
 
+          finished_jobs = 0
+          enqueued_jobs = gathered_selections.size
           gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
             @dataloader.append_job {
               evaluate_selection(
                 path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection, selections_result
               )
+              finished_jobs += 1
+              if target_result && finished_jobs == enqueued_jobs
+                deep_merge_selection_result(selections_result, target_result)
+              end
             }
           end
 
-          nil
+          selections_result
         end
 
         attr_reader :progress_path
@@ -292,12 +477,17 @@ module GraphQL
             # Optimize for the case that field is selected only once
             if field_ast_nodes.nil? || field_ast_nodes.size == 1
               next_selections = ast_node.selections
+              directives = ast_node.directives
             else
               next_selections = []
-              field_ast_nodes.each { |f| next_selections.concat(f.selections) }
+              directives = []
+              field_ast_nodes.each { |f|
+                next_selections.concat(f.selections)
+                directives.concat(f.directives)
+              }
             end
 
-            field_result = resolve_with_directives(object, ast_node) do
+            field_result = resolve_with_directives(object, directives) do
               # Actually call the field resolver and capture the result
               app_result = begin
                 query.with_error_handling do
@@ -329,15 +519,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)
@@ -361,9 +543,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
@@ -371,6 +551,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
@@ -390,11 +585,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)
@@ -407,6 +604,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,
@@ -416,13 +624,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
@@ -488,8 +698,39 @@ module GraphQL
                 response_hash.graphql_result_name = result_name
                 set_result(selection_result, result_name, response_hash)
                 gathered_selections = gather_selections(continue_value, current_type, next_selections)
-                evaluate_selections(path, context.scoped_context, continue_value, current_type, false, gathered_selections, response_hash)
-                response_hash
+                # There are two possibilities for `gathered_selections`:
+                # 1. All selections of this object should be evaluated together (there are no runtime directives modifying execution).
+                #    This case is handled below, and the result can be written right into the main `response_hash` above.
+                #    In this case, `gathered_selections` is a hash of selections.
+                # 2. Some selections of this object have runtime directives that may or may not modify execution.
+                #    That part of the selection is evaluated in an isolated way, writing into a sub-response object which is
+                #    eventually merged into the final response. In this case, `gathered_selections` is an array of things to run in isolation.
+                #    (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
+                    final_result = response_hash
+                  else
+                    this_result = response_hash
+                    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
+                    evaluate_selections(
+                      path,
+                      context.scoped_context,
+                      continue_value,
+                      current_type,
+                      false,
+                      selections,
+                      this_result,
+                      final_result,
+                    )
+                    this_result
+                  end
+                end
               end
             end
           when "LIST"
@@ -534,13 +775,13 @@ module GraphQL
           end
         end
 
-        def resolve_with_directives(object, ast_node, &block)
-          return yield if ast_node.directives.empty?
-          run_directive(object, ast_node, 0, &block)
+        def resolve_with_directives(object, directives, &block)
+          return yield if directives.nil? || directives.empty?
+          run_directive(object, directives, 0, &block)
         end
 
-        def run_directive(object, ast_node, idx, &block)
-          dir_node = ast_node.directives[idx]
+        def run_directive(object, directives, idx, &block)
+          dir_node = directives[idx]
           if !dir_node
             yield
           else
@@ -548,9 +789,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).keyword_arguments
-            dir_defn.resolve(object, dir_args, context) do
-              run_directive(object, ast_node, 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
@@ -559,7 +815,7 @@ module GraphQL
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
             dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
-            args = arguments(graphql_object, dir_defn, dir_node).keyword_arguments
+            args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false
             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/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.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/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.11"
+  VERSION = "1.12.15"
 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.11
+  version: 1.12.15
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-28 00:00:00.000000000 Z
+date: 2021-08-23 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
@@ -699,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
@@ -714,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: []