graphql 1.10.1 → 1.13.0

data/lib/graphql/dataloader.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "graphql/dataloader/null_dataloader"
+require "graphql/dataloader/request"
+require "graphql/dataloader/request_all"
+require "graphql/dataloader/source"
+
+module GraphQL
+  # This plugin supports Fiber-based concurrency, along with {GraphQL::Dataloader::Source}.
+  #
+  # @example Installing Dataloader
+  #
+  #   class MySchema < GraphQL::Schema
+  #     use GraphQL::Dataloader
+  #   end
+  #
+  # @example Waiting for batch-loaded data in a GraphQL field
+  #
+  #   field :team, Types::Team, null: true
+  #
+  #   def team
+  #     dataloader.with(Sources::Record, Team).load(object.team_id)
+  #   end
+  #
+  class Dataloader
+    class << self
+      attr_accessor :default_nonblocking
+    end
+
+    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.
+    #
+    # @param source_class [Class<GraphQL::Dataloader::Source]
+    # @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" || 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_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).
+    #
+    # @return [void]
+    def yield
+      Fiber.yield
+      nil
+    end
+
+    # @api private Nothing to see here
+    def append_job(&job)
+      # Given a block, queue it up to be worked through when `#run` is called.
+      # (If the dataloader is already running, than a Fiber will pick this up later.)
+      @pending_jobs.push(job)
+      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
+      #    - When one of the jobs yields to the dataloader (`Fiber.yield`), then that fiber will pause
+      #    - In that case, if there are still pending jobs, a new Fiber will be created to run jobs
+      #    - Continue until all jobs have been _started_ by a Fiber. (Any number of those Fibers may be waiting to be resumed, after their data is loaded)
+      #  B) Once all known jobs have been run until they are complete or paused for data, run all pending data sources.
+      #    - Similarly, create a Fiber to consume pending sources and tell them to load their data.
+      #    - If one of those Fibers pauses, then create a new Fiber to continue working through remaining pending sources.
+      #    - When a source causes another source to become pending, run the newly-pending source _first_, since it's a dependency of the previous one.
+      #  C) After all pending sources have been completely loaded (there are no more pending sources), resume any Fibers that were waiting for data.
+      #    - Those Fibers assume that source caches will have been populated with the data they were waiting for.
+      #    - Those Fibers may request data from a source again, in which case they will yeilded and be added to a new pending fiber list.
+      #  D) Once all pending fibers have been resumed once, return to `A` above.
+      #
+      # For whatever reason, the best implementation I could find was to order the steps `[D, A, B, C]`, with a special case for skipping `D`
+      # on the first pass. I just couldn't find a better way to write the loops in a way that was DRY and easy to read.
+      #
+      pending_fibers = []
+      next_fibers = []
+      pending_source_fibers = []
+      next_source_fibers = []
+      first_pass = true
+
+      while first_pass || (f = pending_fibers.shift)
+        if first_pass
+          first_pass = false
+        else
+          # These fibers were previously waiting for sources to load data,
+          # resume them. (They might wait again, in which case, re-enqueue them.)
+          resume(f)
+          if f.alive?
+            next_fibers << f
+          end
+        end
+
+        while @pending_jobs.any?
+          # Create a Fiber to consume jobs until one of the jobs yields
+          # or jobs run out
+          f = spawn_fiber {
+            while (job = @pending_jobs.shift)
+              job.call
+            end
+          }
+          resume(f)
+          # In this case, the job yielded. Queue it up to run again after
+          # we load whatever it's waiting for.
+          if f.alive?
+            next_fibers << f
+          end
+        end
+
+        if pending_fibers.empty?
+          # Now, run all Sources which have become pending _before_ resuming GraphQL execution.
+          # Sources might queue up other Sources, which is fine -- those will also run before resuming execution.
+          #
+          # This is where an evented approach would be even better -- can we tell which
+          # fibers are ready to continue, and continue execution there?
+          #
+          if (first_source_fiber = create_source_fiber)
+            pending_source_fibers << first_source_fiber
+          end
+
+          while pending_source_fibers.any?
+            while (outer_source_fiber = pending_source_fibers.pop)
+              resume(outer_source_fiber)
+              if outer_source_fiber.alive?
+                next_source_fibers << outer_source_fiber
+              end
+              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.
+          join_queues(pending_fibers, next_fibers)
+          next_fibers.clear
+        end
+      end
+
+      if @pending_jobs.any?
+        raise "Invariant: #{@pending_jobs.size} pending jobs"
+      elsif pending_fibers.any?
+        raise "Invariant: #{pending_fibers.size} pending fibers"
+      elsif next_fibers.any?
+        raise "Invariant: #{next_fibers.size} next fibers"
+      end
+      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.
+    # Otherwise, return `nil`.
+    #
+    # @return [Fiber, nil]
+    def create_source_fiber
+      pending_sources = nil
+      @source_cache.each_value do |source_by_batch_params|
+        source_by_batch_params.each_value do |source|
+          if source.pending?
+            pending_sources ||= []
+            pending_sources << source
+          end
+        end
+      end
+
+      if pending_sources
+        # By passing the whole array into this Fiber, it's possible that we set ourselves up for a bunch of no-ops.
+        # For example, if you have sources `[a, b, c]`, and `a` is loaded, then `b` yields to wait for `d`, then
+        # the next fiber would be dispatched with `[c, d]`. It would fulfill `c`, then `d`, then eventually
+        # the previous fiber would start up again. `c` would no longer be pending, but it would still receive `.run_pending_keys`.
+        # That method is short-circuited since it isn't pending any more, but it's still a waste.
+        #
+        # This design could probably be improved by maintaining a `@pending_sources` queue which is shared by the fibers,
+        # similar to `@pending_jobs`. That way, when a fiber is resumed, it would never pick up work that was finished by a different fiber.
+        source_fiber = spawn_fiber do
+          pending_sources.each(&:run_pending_keys)
+        end
+      end
+
+      source_fiber
+    end
+
+    def resume(fiber)
+      fiber.resume
+    rescue UncaughtThrowError => e
+      throw e.tag, e.value
+    end
+
+    # Copies the thread local vars into the fiber thread local vars. Many
+    # gems (such as RequestStore, MiniRacer, etc.) rely on thread local vars
+    # to keep track of execution context, and without this they do not
+    # behave as expected.
+    #
+    # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
+    def spawn_fiber
+      fiber_locals = {}
+
+      Thread.current.keys.each do |fiber_var_key|
+        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+      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/assign_global_id_field.rb

@@ -2,9 +2,9 @@
 module GraphQL
   module Define
     module AssignGlobalIdField
-      def self.call(type_defn, field_name)
+      def self.call(type_defn, field_name, **field_kwargs)
         resolve = GraphQL::Relay::GlobalIdResolve.new(type: type_defn)
-        GraphQL::Define::AssignObjectField.call(type_defn, field_name, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
+        GraphQL::Define::AssignObjectField.call(type_defn, field_name, **field_kwargs, type: GraphQL::DEPRECATED_ID_TYPE.to_non_null_type, resolve: resolve)
       end
     end
   end

data/lib/graphql/define/defined_object_proxy.rb

@@ -34,7 +34,6 @@ module GraphQL
       end
 
       # Lookup a function from the dictionary and call it if it's found.
-      ruby2_keywords
       def method_missing(name, *args, &block)
         definition = @dictionary[name]
         if definition
@@ -44,6 +43,7 @@ module GraphQL
           raise NoDefinitionError, msg, caller
         end
       end
+      ruby2_keywords :method_missing
 
       def respond_to_missing?(name, include_private = false)
         @dictionary[name] || super

data/lib/graphql/define/instance_definable.rb

@@ -3,6 +3,23 @@ module GraphQL
   module Define
     # @api deprecated
     module InstanceDefinable
+      module DeprecatedDefine
+        def define(**kwargs, &block)
+          deprecated_caller = caller(1, 1).first
+          if deprecated_caller.include?("lib/graphql")
+            deprecated_caller = caller(2, 10).find { |c| !c.include?("lib/graphql") }
+          end
+
+          if deprecated_caller
+            GraphQL::Deprecation.warn <<-ERR
+#{self}.define will be removed in GraphQL-Ruby 2.0; use a class-based definition instead. See https://graphql-ruby.org/schema/class_based_api.html.
+  -> called from #{deprecated_caller}
+ERR
+          end
+          deprecated_define(**kwargs, &block)
+        end
+      end
+
       def self.included(base)
         base.extend(ClassMethods)
         base.ensure_defined(:metadata)
@@ -14,7 +31,7 @@ module GraphQL
       end
 
       # @api deprecated
-      def define(**kwargs, &block)
+      def deprecated_define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
         stash_dependent_methods
@@ -22,11 +39,16 @@ module GraphQL
         nil
       end
 
+      # @api deprecated
+      def define(**kwargs, &block)
+        deprecated_define(**kwargs, &block)
+      end
+
       # @api deprecated
       def redefine(**kwargs, &block)
         ensure_defined
         new_inst = self.dup
-        new_inst.define(**kwargs, &block)
+        new_inst.deprecated_define(**kwargs, &block)
         new_inst
       end
 
@@ -54,7 +76,7 @@ module GraphQL
             # 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)
@@ -125,8 +147,16 @@ module GraphQL
       module ClassMethods
         # Create a new instance
         # and prepare a definition using its {.definitions}.
+        # @api deprecated
         # @param kwargs [Hash] Key-value pairs corresponding to defininitions from `accepts_definitions`
         # @param block [Proc] Block which calls helper methods from `accepts_definitions`
+        def deprecated_define(**kwargs, &block)
+          instance = self.new
+          instance.deprecated_define(**kwargs, &block)
+          instance
+        end
+
+        # @api deprecated
         def define(**kwargs, &block)
           instance = self.new
           instance.define(**kwargs, &block)
@@ -200,10 +230,10 @@ module GraphQL
         # Even though we're just using the first value here,
         # We have to add a splat here to use `ruby2_keywords`,
         # so that it will accept a `[{}]` input from the caller.
-        ruby2_keywords
         def call(defn, *value)
           defn.public_send(@attr_assign_method, value.first)
         end
+        ruby2_keywords :call
       end
     end
   end

data/lib/graphql/define/type_definer.rb

@@ -7,11 +7,11 @@ module GraphQL
     class TypeDefiner
       include Singleton
       # rubocop:disable Naming/MethodName
-      def Int;      GraphQL::INT_TYPE;      end
-      def String;   GraphQL::STRING_TYPE;   end
-      def Float;    GraphQL::FLOAT_TYPE;    end
-      def Boolean;  GraphQL::BOOLEAN_TYPE;  end
-      def ID;       GraphQL::ID_TYPE;       end
+      def Int;      GraphQL::DEPRECATED_INT_TYPE;      end
+      def String;   GraphQL::DEPRECATED_STRING_TYPE;   end
+      def Float;    GraphQL::DEPRECATED_FLOAT_TYPE;    end
+      def Boolean;  GraphQL::DEPRECATED_BOOLEAN_TYPE;  end
+      def ID;       GraphQL::DEPRECATED_ID_TYPE;       end
       # rubocop:enable Naming/MethodName
 
       # Make a {ListType} which wraps the input type

data/lib/graphql/deprecated_dsl.rb

@@ -4,13 +4,13 @@ module GraphQL
   #
   # 1. Scoped by file (CRuby only), add to the top of the file:
   #
-  #      using GraphQL::DeprecatedDSL
+  #      using GraphQL::DeprecationDSL
   #
   #   (This is a "refinement", there are also other ways to scope it.)
   #
   # 2. Global application, add before schema definition:
   #
-  #      GraphQL::DeprecatedDSL.activate
+  #      GraphQL::DeprecationDSL.activate
   #
   module DeprecatedDSL
     TYPE_CLASSES = [
@@ -23,19 +23,32 @@ module GraphQL
     ]
 
     def self.activate
+      deprecated_caller = caller(1, 1).first
+      GraphQL::Deprecation.warn "DeprecatedDSL will be removed from GraphQL-Ruby 2.0, use `.to_non_null_type` instead of `!` and remove `.activate` from #{deprecated_caller}"
       TYPE_CLASSES.each { |c| c.extend(Methods) }
       GraphQL::Schema::List.include(Methods)
       GraphQL::Schema::NonNull.include(Methods)
     end
+
     module Methods
       def !
+        deprecated_caller = caller(1, 1).first
+        GraphQL::Deprecation.warn "DeprecatedDSL will be removed from GraphQL-Ruby 2.0, use `.to_non_null_type` instead of `!` at #{deprecated_caller}"
         to_non_null_type
       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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Deprecation
+    def self.warn(message)
+      Kernel.warn(message)
+    end
+  end
+end

data/lib/graphql/directive.rb

@@ -99,9 +99,9 @@ module GraphQL
     def type_class
       metadata[:type_class]
     end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
   end
 end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"

data/lib/graphql/enum_type.rb

@@ -2,6 +2,8 @@
 module GraphQL
   # @api deprecated
   class EnumType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
     ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
     attr_accessor :ast_node
@@ -32,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

@@ -18,17 +18,83 @@ module GraphQL
     #
     class Errors
       def self.use(schema)
-        schema.error_handler = self.new(schema)
+        definition_line = caller(2, 1).first
+        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
       end
 
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
       def initialize(schema)
         @schema = schema
+        @handlers = {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
       end
 
-      class NullErrorHandler
-        def self.with_error_handling(_ctx)
-          yield
+      # @api private
+      def each_rescue
+        handlers = @handlers.values
+        while (handler = handlers.shift) do
+          yield(handler[:class], handler[:handler])
+          handlers.concat(handler[:subclass_handlers].values)
+        end
+      end
+
+      # Register this handler, updating the
+      # internal handler index to maintain least-to-most specific.
+      #
+      # @param error_class [Class<Exception>]
+      # @param error_handler [Proc]
+      # @return [void]
+      def rescue_from(error_class, error_handler)
+        subclasses_handlers = {}
+        this_level_subclasses = []
+        # During this traversal, do two things:
+        # - Identify any already-registered subclasses of this error class
+        #   and gather them up to be inserted _under_ this class
+        # - Find the point in the index where this handler should be inserted
+        #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
+        handlers = @handlers[:subclass_handlers]
+        while (handlers) do
+          this_level_subclasses.clear
+          # First, identify already-loaded handlers that belong
+          # _under_ this one. (That is, they're handlers
+          # for subclasses of `error_class`.)
+          handlers.each do |err_class, handler|
+            if err_class < error_class
+              subclasses_handlers[err_class] = handler
+              this_level_subclasses << err_class
+            end
+          end
+          # Any handlers that we'll be moving, delete them from this point in the index
+          this_level_subclasses.each do |err_class|
+            handlers.delete(err_class)
+          end
+
+          # See if any keys in this hash are superclasses of this new class:
+          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          if next_index_point
+            handlers = next_index_point[1][:subclass_handlers]
+          else
+            # this new handler doesn't belong to any sub-handlers,
+            # so insert it in the current set of `handlers`
+            break
+          end
         end
+        # Having found the point at which to insert this handler,
+        # register it and merge any subclass handlers back in at this point.
+        this_class_handlers = handlers[error_class]
+        this_class_handlers[:handler] = error_handler
+        this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+        nil
       end
 
       # Call the given block with the schema's configured error handlers.
@@ -40,21 +106,58 @@ module GraphQL
       def with_error_handling(ctx)
         yield
       rescue StandardError => err
-        rescues = ctx.schema.rescues
-        _err_class, handler = rescues.find { |err_class, handler| err.is_a?(err_class) }
+        handler = find_handler_for(err.class)
         if handler
           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
           end
-          handler.call(err, obj, args, ctx, field)
+          handler[:handler].call(err, obj, args, ctx, field)
         else
           raise err
         end
       end
+
+      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      def find_handler_for(error_class)
+        handlers = @handlers[:subclass_handlers]
+        handler = nil
+        while (handlers) do
+          _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
+          if next_handler
+            handlers = next_handler[:subclass_handlers]
+            handler = next_handler
+          else
+            # Don't reassign `handler` --
+            # let the previous assignment carry over outside this block.
+            break
+          end
+        end
+
+        # check for a handler from a parent class:
+        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
+          parent_handler = parent_errors.find_handler_for(error_class)
+        end
+
+        # If the inherited handler is more specific than the one defined here,
+        # use it.
+        # If it's a tie (or there is no parent handler), use the one defined here.
+        # If there's an inherited one, but not one defined here, use the inherited one.
+        # Otherwise, there's no handler for this error, return `nil`.
+        if parent_handler && handler && parent_handler[:class] < handler[:class]
+          parent_handler
+        elsif handler
+          handler
+        elsif parent_handler
+          parent_handler
+        else
+          nil
+        end
+      end
     end
   end
 end