graphql 1.12.3 → 1.12.8

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

@@ -56,17 +56,18 @@ module GraphQL
             # Root .authorized? returned false.
             write_in_response(path, nil)
           else
-            # Prepare this runtime state to be encapsulated in a Fiber
-            @progress_path = path
-            @progress_scoped_context = context.scoped_context
-            @progress_object = object_proxy
-            @progress_object_type = root_type
-            @progress_index = nil
-            @progress_is_eager_selection = root_op_type == "mutation"
-            @progress_selections = gather_selections(object_proxy, root_type, root_operation.selections)
-
+            gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
             # Make the first fiber which will begin execution
-            enqueue_selections_fiber
+            @dataloader.append_job {
+              evaluate_selections(
+                path,
+                context.scoped_context,
+                object_proxy,
+                root_type,
+                root_op_type == "mutation",
+                gathered_selections,
+              )
+            }
           end
           delete_interpreter_context(:current_path)
           delete_interpreter_context(:current_field)
@@ -75,32 +76,6 @@ module GraphQL
           nil
         end
 
-        # Use `@dataloader` to enqueue a fiber that will pick up from the current point.
-        # @return [void]
-        def enqueue_selections_fiber
-          # Read these into local variables so that later assignments don't affect the block below.
-          path = @progress_path
-          scoped_context = @progress_scoped_context
-          owner_object = @progress_object
-          owner_type = @progress_object_type
-          idx = @progress_index
-          is_eager_selection = @progress_is_eager_selection
-          gathered_selections = @progress_selections
-
-          @dataloader.enqueue {
-            evaluate_selections(
-              path,
-              scoped_context,
-              owner_object,
-              owner_type,
-              is_eager_selection: is_eager_selection,
-              after: idx,
-              gathered_selections: gathered_selections,
-            )
-          }
-          nil
-        end
-
         def gather_selections(owner_object, owner_type, selections, selections_by_name = {})
           selections.each do |node|
             # Skip gathering this if the directive says so
@@ -159,39 +134,17 @@ module GraphQL
         NO_ARGS = {}.freeze
 
         # @return [void]
-        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection:, gathered_selections:, after:)
+        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections)
           set_all_interpreter_context(owner_object, nil, nil, path)
 
-          @progress_path = path
-          @progress_scoped_context = scoped_context
-          @progress_object = owner_object
-          @progress_object_type = owner_type
-          @progress_index = nil
-          @progress_is_eager_selection = is_eager_selection
-          @progress_selections = gathered_selections
-
-          # Track `idx` manually to avoid an allocation on this hot path
-          idx = 0
           gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
-            prev_idx = idx
-            idx += 1
-            # TODO: this is how a `progress` resumes where this left off.
-            # Is there a better way to seek in the hash?
-            # I think we could also use the array of keys; it supports seeking just fine.
-            if after && prev_idx <= after
-              next
-            end
-            @progress_index = prev_idx
-            # This is how the current runtime gives itself to `dataloader`
-            # so that the dataloader can enqueue another fiber to resume if needed.
-            @dataloader.current_runtime = self
-            evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection)
-            # The dataloader knows if ^^ that selection halted and later selections were executed in another fiber.
-            # If that's the case, then don't continue execution here.
-            if @dataloader.yielded?(path)
-              break
-            end
+            @dataloader.append_job {
+              evaluate_selection(
+                path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection
+              )
+            }
           end
+
           nil
         end
 
@@ -243,13 +196,21 @@ module GraphQL
             object = authorized_new(field_defn.owner, object, context, next_path)
           end
 
-          begin
-            kwarg_arguments = arguments(object, field_defn, ast_node)
-          rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => e
-            continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
-            return
+          total_args_count = field_defn.arguments.size
+          if total_args_count == 0
+            kwarg_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
+            evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field)
+          else
+            # TODO remove all arguments(...) usages?
+            @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
+              evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field)
+            end
           end
+        end
 
+        def evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field)  # rubocop:disable Metrics/ParameterLists
+          context.scoped_context = scoped_context
+          return_type = field_defn.type
           after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
               continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
@@ -316,10 +277,7 @@ module GraphQL
               end
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node)
-                if RawValue === continue_value
-                  # Write raw value directly to the response without resolving nested objects
-                  write_in_response(next_path, continue_value.resolve)
-                elsif HALT != continue_value
+                if HALT != continue_value
                   continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
                 end
               end
@@ -329,10 +287,11 @@ module GraphQL
             # all of its child fields before moving on to the next root mutation field.
             # (Subselections of this mutation will still be resolved level-by-level.)
             if is_eager_field
-              Interpreter::Resolve.resolve_all([field_result])
+              Interpreter::Resolve.resolve_all([field_result], @dataloader)
+            else
+              # Return this from `after_lazy` because it might be another lazy that needs to be resolved
+              field_result
             end
-
-            nil
           end
         end
 
@@ -370,6 +329,10 @@ module GraphQL
             continue_value(path, next_value, parent_type, field, is_non_null, ast_node)
           elsif GraphQL::Execution::Execute::SKIP == value
             HALT
+          elsif value.is_a?(GraphQL::Execution::Interpreter::RawValue)
+            # Write raw value directly to the response without resolving nested objects
+            write_in_response(path, value.resolve)
+            HALT
           else
             value
           end
@@ -419,7 +382,7 @@ module GraphQL
                 response_hash = {}
                 write_in_response(path, response_hash)
                 gathered_selections = gather_selections(continue_value, current_type, next_selections)
-                evaluate_selections(path, context.scoped_context, continue_value, current_type, is_eager_selection: false, gathered_selections: gathered_selections, after: nil)
+                evaluate_selections(path, context.scoped_context, continue_value, current_type, false, gathered_selections)
                 response_hash
               end
             end

data/lib/graphql/execution/multiplex.rb

@@ -35,7 +35,7 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @context[:dataloader] = @dataloader = @schema.dataloader_class.new(context)
+        @context[:dataloader] = @dataloader = @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
@@ -74,6 +74,24 @@ module GraphQL
           end
         end
 
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
         private
 
         def run_as_multiplex(multiplex)
@@ -83,15 +101,13 @@ module GraphQL
           # Do as much eager evaluation of the query as possible
           results = []
           queries.each_with_index do |query, idx|
-            multiplex.dataloader.enqueue {
-              results[idx] = begin_query(query, multiplex)
-            }
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
           end
 
           multiplex.dataloader.run
 
           # Then, work through lazy results in a breadth-first way
-          multiplex.dataloader.enqueue {
+          multiplex.dataloader.append_job {
             multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
           }
           multiplex.dataloader.run
@@ -112,23 +128,6 @@ module GraphQL
           raise
         end
 
-        # @param query [GraphQL::Query]
-        # @return [Hash] The initial result (may not be finished if there are lazy values)
-        def begin_query(query, multiplex)
-          operation = query.selected_operation
-          if operation.nil? || !query.valid? || query.context.errors.any?
-            NO_OPERATION
-          else
-            begin
-              # These were checked to be the same in `#supports_multiplexing?`
-              query.schema.query_execution_strategy.begin_query(query, multiplex)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-        end
-
         # @param data_result [Hash] The result for the "data" key, if any
         # @param query [GraphQL::Query] The query which was run
         # @return [Hash] final result of this query, including all values and errors

data/lib/graphql/introspection.rb

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

data/lib/graphql/introspection/directive_type.rb

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

data/lib/graphql/language.rb

@@ -6,6 +6,7 @@ require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"
+require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/token"
 require "graphql/language/visitor"

data/lib/graphql/language/cache.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'graphql/version'
+require 'digest/sha2'
+
+module GraphQL
+  module Language
+    class Cache
+      def initialize(path)
+        @path = path
+      end
+
+      DIGEST = Digest::SHA256.new << GraphQL::VERSION
+      def fetch(filename)
+        hash = DIGEST.dup << filename
+        begin
+          hash << File.mtime(filename).to_i.to_s
+        rescue SystemCallError
+          return yield
+        end
+        cache_path = @path.join(hash.to_s)
+
+        if cache_path.exist?
+          Marshal.load(cache_path.read)
+        else
+          payload = yield
+          tmp_path = "#{cache_path}.#{rand}"
+
+          @path.mkpath
+          File.binwrite(tmp_path, Marshal.dump(payload))
+          File.rename(tmp_path, cache_path.to_s)
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/parser.rb

@@ -41,12 +41,22 @@ def parse_document
   end
 end
 
-def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
-  self.new(query_string, filename: filename, tracer: tracer).parse_document
-end
+class << self
+  attr_accessor :cache
+
+  def parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+    new(query_string, filename: filename, tracer: tracer).parse_document
+  end
 
-def self.parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
-  self.parse(File.read(filename), filename: filename, tracer: tracer)
+  def parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+    if cache
+      cache.fetch(filename) do
+        parse(File.read(filename), filename: filename, tracer: tracer)
+      end
+    else
+      parse(File.read(filename), filename: filename, tracer: tracer)
+    end
+  end
 end
 
 private

data/lib/graphql/language/parser.y

@@ -462,12 +462,22 @@ def parse_document
   end
 end
 
-def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
-  self.new(query_string, filename: filename, tracer: tracer).parse_document
-end
+class << self
+  attr_accessor :cache
+
+  def parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+    new(query_string, filename: filename, tracer: tracer).parse_document
+  end
 
-def self.parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
-  self.parse(File.read(filename), filename: filename, tracer: tracer)
+  def parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+    if cache
+      cache.fetch(filename) do
+        parse(File.read(filename), filename: filename, tracer: tracer)
+      end
+    else
+      parse(File.read(filename), filename: filename, tracer: tracer)
+    end
+  end
 end
 
 private

data/lib/graphql/object_type.rb

@@ -121,8 +121,6 @@ module GraphQL
           iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
           if iface.is_a?(GraphQL::InterfaceType)
             @clean_inherited_fields.merge!(iface.fields)
-          else
-            pp iface
           end
         end
         @clean_inherited_fields

data/lib/graphql/pagination/active_record_relation_connection.rb

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

data/lib/graphql/pagination/connection.rb

@@ -45,6 +45,9 @@ module GraphQL
         end
       end
 
+      # @return [Hash<Symbol => Object>] The field arguments from the field that returned this connection
+      attr_accessor :arguments
+
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
       # @param parent [Object] The object this collection belongs to
@@ -52,8 +55,9 @@ module GraphQL
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
+      # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil)
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
         @parent = parent
         @context = context
@@ -62,6 +66,7 @@ module GraphQL
         @after_value = after
         @last_value = last
         @before_value = before
+        @arguments = arguments
         @edge_class = edge_class || self.class::Edge
         # This is only true if the object was _initialized_ with an override
         # or if one is assigned later.
@@ -105,6 +110,15 @@ module GraphQL
         end
       end
 
+      # This is called by `Relay::RangeAdd` -- it can be overridden
+      # when `item` needs some modifications based on this connection's state.
+      #
+      # @param item [Object] An item newly added to `items`
+      # @return [Edge]
+      def range_add_edge(item)
+        edge_class.new(item, self)
+      end
+
       attr_writer :last
       # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
       def last