graphql 1.12.10 → 1.13.4

data/lib/graphql/dataloader.rb

@@ -23,23 +23,42 @@ module GraphQL
   #   end
   #
   class Dataloader
-    def self.use(schema)
-      schema.dataloader_class = self
+    class << self
+      attr_accessor :default_nonblocking
     end
 
-    def initialize
-      @source_cache = Hash.new { |h, source_class| h[source_class] = Hash.new { |h2, batch_parameters|
-          source = if RUBY_VERSION < "3"
-            source_class.new(*batch_parameters)
-          else
-            batch_args, batch_kwargs = batch_parameters
-            source_class.new(*batch_args, **batch_kwargs)
-          end
-          source.setup(self)
-          h2[batch_parameters] = source
-        }
+    AsyncDataloader = Class.new(self) { self.default_nonblocking = true }
+
+    def self.use(schema, nonblocking: nil)
+      schema.dataloader_class = if nonblocking
+        AsyncDataloader
+      else
+        self
+      end
+    end
+
+    # Call the block with a Dataloader instance,
+    # then run all enqueued jobs and return the result of the block.
+    def self.with_dataloading(&block)
+      dataloader = self.new
+      result = nil
+      dataloader.append_job {
+        result = block.call(dataloader)
       }
+      dataloader.run
+      result
+    end
+
+    def initialize(nonblocking: self.class.default_nonblocking)
+      @source_cache = Hash.new { |h, k| h[k] = {} }
       @pending_jobs = []
+      if !nonblocking.nil?
+        @nonblocking = nonblocking
+      end
+    end
+
+    def nonblocking?
+      @nonblocking
     end
 
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
@@ -48,17 +67,25 @@ module GraphQL
     # @param batch_parameters [Array<Object>]
     # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
     #   and cached for the lifetime of this {Multiplex}.
-    if RUBY_VERSION < "3"
-      def with(source_class, *batch_parameters)
-        @source_cache[source_class][batch_parameters]
+    if RUBY_VERSION < "3" || RUBY_ENGINE != "ruby" # truffle-ruby wasn't doing well with the implementation below
+      def with(source_class, *batch_args)
+        batch_key = source_class.batch_key_for(*batch_args)
+        @source_cache[source_class][batch_key] ||= begin
+          source = source_class.new(*batch_args)
+          source.setup(self)
+          source
+        end
       end
     else
       def with(source_class, *batch_args, **batch_kwargs)
-        batch_parameters = [batch_args, batch_kwargs]
-        @source_cache[source_class][batch_parameters]
+        batch_key = source_class.batch_key_for(*batch_args, **batch_kwargs)
+        @source_cache[source_class][batch_key] ||= begin
+          source = source_class.new(*batch_args, **batch_kwargs)
+          source.setup(self)
+          source
+        end
       end
     end
-
     # Tell the dataloader that this fiber is waiting for data.
     #
     # Dataloader will resume the fiber after the requested data has been loaded (by another Fiber).
@@ -77,8 +104,39 @@ module GraphQL
       nil
     end
 
+    # Use a self-contained queue for the work in the block.
+    def run_isolated
+      prev_queue = @pending_jobs
+      prev_pending_keys = {}
+      @source_cache.each do |source_class, batched_sources|
+        batched_sources.each do |batch_args, batched_source_instance|
+          if batched_source_instance.pending?
+            prev_pending_keys[batched_source_instance] = batched_source_instance.pending_keys.dup
+            batched_source_instance.pending_keys.clear
+          end
+        end
+      end
+
+      @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
+      prev_pending_keys.each do |source_instance, pending_keys|
+        source_instance.pending_keys.concat(pending_keys)
+      end
+    end
+
     # @api private Move along, move along
     def run
+      if @nonblocking && !Fiber.scheduler
+        raise "`nonblocking: true` requires `Fiber.scheduler`, assign one with `Fiber.set_scheduler(...)` before executing GraphQL."
+      end
       # At a high level, the algorithm is:
       #
       #  A) Inside Fibers, run jobs from the queue one-by-one
@@ -99,6 +157,8 @@ module GraphQL
       #
       pending_fibers = []
       next_fibers = []
+      pending_source_fibers = []
+      next_source_fibers = []
       first_pass = true
 
       while first_pass || (f = pending_fibers.shift)
@@ -136,33 +196,27 @@ module GraphQL
           # This is where an evented approach would be even better -- can we tell which
           # fibers are ready to continue, and continue execution there?
           #
-          source_fiber_stack = if (first_source_fiber = create_source_fiber)
-            [first_source_fiber]
-          else
-            nil
+          if (first_source_fiber = create_source_fiber)
+            pending_source_fibers << first_source_fiber
           end
 
-          if source_fiber_stack
-            # Use a stack with `.pop` here so that when a source causes another source to become pending,
-            # that newly-pending source will run _before_ the one that depends on it.
-            # (See below where the old fiber is pushed to the stack, then the new fiber is pushed on the stack.)
-            while (outer_source_fiber = source_fiber_stack.pop)
+          while pending_source_fibers.any?
+            while (outer_source_fiber = pending_source_fibers.pop)
               resume(outer_source_fiber)
-
               if outer_source_fiber.alive?
-                source_fiber_stack << outer_source_fiber
+                next_source_fibers << outer_source_fiber
               end
-              # If this source caused more sources to become pending, run those before running this one again:
-              next_source_fiber = create_source_fiber
-              if next_source_fiber
-                source_fiber_stack << next_source_fiber
+              if (next_source_fiber = create_source_fiber)
+                pending_source_fibers << next_source_fiber
               end
             end
+            join_queues(pending_source_fibers, next_source_fibers)
+            next_source_fibers.clear
           end
           # Move newly-enqueued Fibers on to the list to be resumed.
           # Clear out the list of next-round Fibers, so that
           # any Fibers that pause can be put on it.
-          pending_fibers.concat(next_fibers)
+          join_queues(pending_fibers, next_fibers)
           next_fibers.clear
         end
       end
@@ -177,6 +231,14 @@ module GraphQL
       nil
     end
 
+    def join_queues(previous_queue, next_queue)
+      if @nonblocking
+        Fiber.scheduler.run
+        next_queue.select!(&:alive?)
+      end
+      previous_queue.concat(next_queue)
+    end
+
     private
 
     # If there are pending sources, return a fiber for running them.
@@ -224,16 +286,23 @@ module GraphQL
     #
     # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
     def spawn_fiber
-      fiber_locals = {} 
+      fiber_locals = {}
 
       Thread.current.keys.each do |fiber_var_key|
         fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
-      end 
+      end
 
-      Fiber.new do 
-        fiber_locals.each { |k, v| Thread.current[k] = v }
-        yield
-      end 
+      if @nonblocking
+        Fiber.new(blocking: false) do
+          fiber_locals.each { |k, v| Thread.current[k] = v }
+          yield
+        end
+      else
+        Fiber.new do
+          fiber_locals.each { |k, v| Thread.current[k] = v }
+          yield
+        end
+      end
     end
   end
 end

data/lib/graphql/define/instance_definable.rb

@@ -76,7 +76,7 @@ ERR
             # Apply definition from `define(...)` kwargs
             defn.define_keywords.each do |keyword, value|
               # Don't splat string hashes, which blows up on Rubies before 2.7
-              if value.is_a?(Hash) && value.each_key.all? { |k| k.is_a?(Symbol) }
+              if value.is_a?(Hash) && !value.empty? && value.each_key.all? { |k| k.is_a?(Symbol) }
                 defn_proxy.public_send(keyword, **value)
               else
                 defn_proxy.public_send(keyword, value)

data/lib/graphql/deprecated_dsl.rb

@@ -38,9 +38,17 @@ module GraphQL
       end
     end
 
-    TYPE_CLASSES.each do |type_class|
-      refine type_class.singleton_class do
-        include Methods
+    if defined?(::Refinement) && Refinement.private_method_defined?(:import_methods)
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          import_methods Methods
+        end
+      end
+    else
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          include Methods
+        end
       end
     end
   end

data/lib/graphql/deprecation.rb

@@ -3,11 +3,7 @@
 module GraphQL
   module Deprecation
     def self.warn(message)
-      if defined?(ActiveSupport::Deprecation)
-        ActiveSupport::Deprecation.warn(message)
-      else
-        Kernel.warn(message)
-      end
+      Kernel.warn(message)
     end
   end
 end

data/lib/graphql/directive/deprecated_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition
+GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive/include_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition
+GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive/skip_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition
+GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive.rb

@@ -105,7 +105,3 @@ module GraphQL
     end
   end
 end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"

data/lib/graphql/enum_type.rb

@@ -34,10 +34,14 @@ module GraphQL
     end
 
     # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
-    def values
+    def values(_context = nil)
       @values_by_name
     end
 
+    def enum_values(_context = nil)
+      values.values
+    end
+
     def kind
       GraphQL::TypeKinds::ENUM
     end

data/lib/graphql/execution/errors.rb

@@ -111,6 +111,7 @@ module GraphQL
           runtime_info = ctx.namespace(:interpreter) || {}
           obj = runtime_info[:current_object]
           args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
           field = runtime_info[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object

data/lib/graphql/execution/execute.rb

@@ -6,7 +6,7 @@ module GraphQL
     class Execute
 
       # @api private
-      class Skip; end
+      class Skip < GraphQL::Error; end
 
       # Just a singleton for implementing {Query::Context#skip}
       # @api private

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

@@ -59,7 +59,7 @@ module GraphQL
           @empty
         end
 
-        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values, :size, :to_h
         def_delegators :argument_values, :each_value
 
         def inspect

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,
@@ -70,11 +71,11 @@ module GraphQL
           when Array
             ast_arg_or_hash_or_value.map { |v| prepare_args_hash(query, v) }
           when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
-            if ast_arg_or_hash_or_value.arguments.empty?
+            if ast_arg_or_hash_or_value.arguments.empty? # rubocop:disable Development/ContextIsPassedCop -- AST-related
               return NO_ARGUMENTS
             end
             args_hash = {}
-            ast_arg_or_hash_or_value.arguments.each do |arg|
+            ast_arg_or_hash_or_value.arguments.each do |arg| # rubocop:disable Development/ContextIsPassedCop -- AST-related
               v = prepare_args_hash(query, arg.value)
               if v != NO_VALUE_GIVEN
                 args_hash[arg.name] = v

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