graphql 1.9.18 → 1.13.24

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/date_encoding_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::ISO8601Date` is asked to return a value
+  # that cannot be parsed to a Ruby Date.
+  #
+  # @see GraphQL::Types::ISO8601Date which raises this error
+  class DateEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :date_value
+
+    def initialize(value)
+      @date_value = value
+      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+    end
+  end
+end

data/lib/graphql/define/assign_enum_value.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
-    # Turn enum value configs into a {GraphQL::EnumType::EnumValue} and register it with the {GraphQL::EnumType}
+    # @api deprecated
     module AssignEnumValue
       def self.call(enum_type, name, desc = nil, deprecation_reason: nil, value: name, &block)
         enum_value = GraphQL::EnumType::EnumValue.define(

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/assign_object_field.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
-    # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}
+    # @api deprecated
     module AssignObjectField
       def self.call(owner_type, name, type_or_field = nil, desc = nil, function: nil, field: nil, relay_mutation_function: nil, **kwargs, &block)
         name_s = name.to_s

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Define
     # This object delegates most methods to a dictionary of functions, {@dictionary}.
     # {@target} is passed to the specified function, along with any arguments and block.
     # This allows a method-based DSL without adding methods to the defined class.
     class DefinedObjectProxy
+      extend GraphQL::Ruby2Keywords
       # The object which will be defined by definition functions
       attr_reader :target
 
@@ -32,21 +34,16 @@ module GraphQL
       end
 
       # Lookup a function from the dictionary and call it if it's found.
-      def method_missing(name, *args, **kwargs, &block)
+      def method_missing(name, *args, &block)
         definition = @dictionary[name]
         if definition
-          # Avoid passing `kwargs` when it's not used.
-          # Ruby 2.7 does fine here, but older Rubies receive too many arguments.
-          if kwargs.any?
-            definition.call(@target, *args, **kwargs, &block)
-          else
-            definition.call(@target, *args, &block)
-          end
+          definition.call(@target, *args, &block)
         else
           msg = "#{@target.class.name} can't define '#{name}'"
           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

@@ -1,119 +1,37 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
-    # This module provides the `.define { ... }` API for
-    # {GraphQL::BaseType}, {GraphQL::Field} and others.
-    #
-    # Calling `.accepts_definitions(...)` creates:
-    #
-    # - a keyword to the `.define` method
-    # - a helper method in the `.define { ... }` block
-    #
-    # The `.define { ... }` block will be called lazily. To be sure it has been
-    # called, use the private method `#ensure_defined`. That will call the
-    # definition block if it hasn't been called already.
-    #
-    # The goals are:
-    #
-    # - Minimal overhead in consuming classes
-    # - Independence between consuming classes
-    # - Extendable by third-party libraries without monkey-patching or other nastiness
-    #
-    # @example Make a class definable
-    #   class Car
-    #     include GraphQL::Define::InstanceDefinable
-    #     attr_accessor :make, :model, :doors
-    #     accepts_definitions(
-    #       # These attrs will be defined with plain setters, `{attr}=`
-    #       :make, :model,
-    #       # This attr has a custom definition which applies the config to the target
-    #       doors: ->(car, doors_count) { doors_count.times { car.doors << Door.new } }
-    #     )
-    #     ensure_defined(:make, :model, :doors)
-    #
-    #     def initialize
-    #       @doors = []
-    #     end
-    #   end
-    #
-    #   class Door; end;
-    #
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # The custom proc was applied:
-    #   subaru_baja.doors #=> [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Extending the definition of a class
-    #   # Add some definitions:
-    #   Car.accepts_definitions(all_wheel_drive: GraphQL::Define.assign_metadata_key(:all_wheel_drive))
-    #
-    #   # Use it in a definition
-    #   subaru_baja = Car.define do
-    #     # ...
-    #     all_wheel_drive true
-    #   end
-    #
-    #   # Access it from metadata
-    #   subaru_baja.metadata[:all_wheel_drive] # => true
-    #
-    # @example Extending the definition of a class via a plugin
-    #   # A plugin is any object that responds to `.use(definition)`
-    #   module SubaruCar
-    #     extend self
-    #
-    #     def use(defn)
-    #       # `defn` has the same methods as within `.define { ... }` block
-    #       defn.make "Subaru"
-    #       defn.doors 4
-    #     end
-    #   end
-    #
-    #   # Use the plugin within a `.define { ... }` block
-    #   subaru_baja = Car.define do
-    #     use SubaruCar
-    #     model 'Baja'
-    #   end
-    #
-    #   subaru_baja.make # => "Subaru"
-    #   subaru_baja.doors # => [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Making a copy with an extended definition
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # Then extend it with `#redefine`
-    #   two_door_baja = subaru_baja.redefine do
-    #     doors 2
-    #   end
+    # @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)
       end
 
-      # `metadata` can store arbitrary key-values with an object.
-      #
-      # @return [Hash<Object, Object>] Hash for user-defined storage
+      # @api deprecated
       def metadata
         @metadata ||= {}
       end
 
-      # Mutate this instance using functions from its {.definition}s.
-      # Keywords or helpers in the block correspond to keys given to `accepts_definitions`.
-      #
-      # Note that the block is not called right away -- instead, it's deferred until
-      # one of the defined fields is needed.
-      # @return [void]
-      def define(**kwargs, &block)
+      # @api deprecated
+      def deprecated_define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
         stash_dependent_methods
@@ -121,13 +39,16 @@ module GraphQL
         nil
       end
 
-      # Shallow-copy this object, then apply new definitions to the copy.
-      # @see {#define} for arguments
-      # @return [InstanceDefinable] A new instance, with any extended definitions
+      # @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
 
@@ -155,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)
@@ -226,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)
@@ -238,6 +167,21 @@ module GraphQL
         # Each symbol in `accepts` will be assigned with `{key}=`.
         # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
         def accepts_definitions(*accepts)
+          deprecated_caller = caller(0, 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}.accepts_definitions 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_accepts_definitions(*accepts)
+        end
+
+        def deprecated_accepts_definitions(*accepts)
           new_assignments = if accepts.last.is_a?(Hash)
             accepts.pop.dup
           else
@@ -292,13 +236,19 @@ module GraphQL
       end
 
       class AssignAttribute
+        extend GraphQL::Ruby2Keywords
+
         def initialize(attr_name)
           @attr_assign_method = :"#{attr_name}="
         end
 
-        def call(defn, value)
-          defn.public_send(@attr_assign_method, value)
+        # 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.
+        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