graphql 1.12.5 → 1.12.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ec7a782dba5df306d3e0590820d75d520b86651b9293417b115070057c45b8f
-  data.tar.gz: 731f02ddfda3690ecd54cba1b1f373f9c8a53b65d422f853d44ddc9072fa85d7
+  metadata.gz: 9d314c3a4dbbf6bded442bea6c2fcdd68b0cd7730ebb5e807d3677ffdc838268
+  data.tar.gz: 60a24771181bb8a479f768a4b17f3a474ff9bbc339027b94e18bf92554df296c
 SHA512:
-  metadata.gz: e0783dea9b65037ea2d92b9ab88fc98153a541b0821f7b5d38bb53de3d33024a85d626302c8c92ddc9971606806c1a7896fb7a98da0c8c2261f9a034d87624e2
-  data.tar.gz: c4b6035220bf578fc974a3fa437914dd5e652018b651b0c5af57f355e5d08b113a2faa2a6824242b71d01bab844767592f4d6ea5323e66e2ef05bcd74ad62df3
+  metadata.gz: 25f941249c01ce4dcfe3522dfc7b045b6f2bd3888e1f21b2e25a3ae5de74f0de5f9721c998d6ddd33eb681339c3e883edcdc9d76a196c148b688a1264b1761fa
+  data.tar.gz: 91bde8d0102ae6874511656b6e11140b511aa1813d19b70b91a168cf58cbfc95eb83a6244137fc06abeae19f15694ca005c94c6e728085d0b8be3ad3bb964ebc

data/lib/generators/graphql/install_generator.rb

@@ -122,7 +122,7 @@ module Graphql
         if options.api?
           say("Skipped graphiql, as this rails project is API only")
           say("  You may wish to use GraphiQL.app for development: https://github.com/skevy/graphiql-app")
-        elsif !options[:skip_graphiql]
+        elsif !options[:skip_graphiql] && !File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
           gem("graphiql-rails", group: :development)
 
           # This is a little cheat just to get cleaner shell output:

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -15,9 +15,9 @@ class GraphqlController < ApplicationController
     }
     result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
     render json: result
-  rescue => e
+  rescue StandardError => e
     raise e unless Rails.env.development?
-    handle_error_in_development e
+    handle_error_in_development(e)
   end
 
   private

data/lib/graphql.rb

@@ -4,7 +4,6 @@ require "json"
 require "set"
 require "singleton"
 require "forwardable"
-require_relative "./graphql/railtie" if defined? Rails::Railtie
 
 module GraphQL
   # forwards-compat for argument handling
@@ -82,10 +81,19 @@ end
 # Order matters for these:
 
 require "graphql/execution_error"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
+require "graphql/analysis_error"
+require "graphql/coercion_error"
+require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
+require "graphql/integer_encoding_error"
+require "graphql/string_encoding_error"
+
 require "graphql/define"
 require "graphql/base_type"
 require "graphql/object_type"
-
 require "graphql/enum_type"
 require "graphql/input_object_type"
 require "graphql/interface_type"
@@ -103,13 +111,13 @@ require "graphql/scalar_type"
 require "graphql/name_validator"
 
 require "graphql/language"
+
+require_relative "./graphql/railtie" if defined? Rails::Railtie
+
 require "graphql/analysis"
 require "graphql/tracing"
 require "graphql/dig"
 require "graphql/execution"
-require "graphql/runtime_type_error"
-require "graphql/unresolved_type_error"
-require "graphql/invalid_null_error"
 require "graphql/pagination"
 require "graphql/schema"
 require "graphql/query"
@@ -131,12 +139,6 @@ require "graphql/static_validation"
 require "graphql/dataloader"
 require "graphql/introspection"
 
-require "graphql/analysis_error"
-require "graphql/coercion_error"
-require "graphql/invalid_name_error"
-require "graphql/integer_decoding_error"
-require "graphql/integer_encoding_error"
-require "graphql/string_encoding_error"
 require "graphql/version"
 require "graphql/compatibility"
 require "graphql/function"

data/lib/graphql/dataloader.rb

@@ -29,7 +29,12 @@ module GraphQL
 
     def initialize
       @source_cache = Hash.new { |h, source_class| h[source_class] = Hash.new { |h2, batch_parameters|
-          source = source_class.new(*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
         }
@@ -43,8 +48,15 @@ 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}.
-    def with(source_class, *batch_parameters)
-      @source_cache[source_class][batch_parameters]
+    if RUBY_VERSION < "3"
+      def with(source_class, *batch_parameters)
+        @source_cache[source_class][batch_parameters]
+      end
+    else
+      def with(source_class, *batch_args, **batch_kwargs)
+        batch_parameters = [batch_args, batch_kwargs]
+        @source_cache[source_class][batch_parameters]
+      end
     end
 
     # Tell the dataloader that this fiber is waiting for data.
@@ -104,7 +116,7 @@ module GraphQL
         while @pending_jobs.any?
           # Create a Fiber to consume jobs until one of the jobs yields
           # or jobs run out
-          f = Fiber.new {
+          f = spawn_fiber {
             while (job = @pending_jobs.shift)
               job.call
             end
@@ -191,7 +203,7 @@ module GraphQL
         #
         # 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 = Fiber.new do
+        source_fiber = spawn_fiber do
           pending_sources.each(&:run_pending_keys)
         end
       end
@@ -204,5 +216,24 @@ module GraphQL
     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 
+
+      Fiber.new do 
+        fiber_locals.each { |k, v| Thread.current[k] = v }
+        yield
+      end 
+    end
   end
 end

data/lib/graphql/execution/errors.rb

@@ -18,21 +18,83 @@ module GraphQL
     #
     class Errors
       def self.use(schema)
-        if schema.plugins.any? { |(plugin, kwargs)| plugin == self }
-          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
-        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
+
+      # @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
 
-      class NullErrorHandler
-        def self.with_error_handling(_ctx)
-          yield
+      # 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.
@@ -44,8 +106,7 @@ 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]
@@ -54,11 +115,48 @@ module GraphQL
           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

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

@@ -50,24 +50,27 @@ module GraphQL
           root_type = schema.root_type_for_operation(root_op_type)
           path = []
           set_all_interpreter_context(query.root_value, nil, nil, path)
-          object_proxy = authorized_new(root_type, query.root_value, context, path)
+          object_proxy = authorized_new(root_type, query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
+
           if object_proxy.nil?
             # Root .authorized? returned false.
             write_in_response(path, nil)
           else
-            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,
-              )
-            }
+            resolve_with_directives(object_proxy, root_operation) 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,
+                )
+              }
+            end
           end
           delete_interpreter_context(:current_path)
           delete_interpreter_context(:current_field)
@@ -193,7 +196,7 @@ module GraphQL
           object = owner_object
 
           if is_introspection
-            object = authorized_new(field_defn.owner, object, context, next_path)
+            object = authorized_new(field_defn.owner, object, context)
           end
 
           total_args_count = field_defn.arguments.size
@@ -246,11 +249,17 @@ module GraphQL
                   # Use this flag to tell Interpreter::Arguments to add itself
                   # to the keyword args hash _before_ freezing everything.
                   extra_args[:argument_details] = :__arguments_add_self
+                when :irep_node
+                  # This is used by `__typename` in order to support the legacy runtime,
+                  # but it has no use here (and it's always `nil`).
+                  # Stop adding it here to avoid the overhead of `.merge_extras` below.
                 else
                   extra_args[extra] = field_defn.fetch_extra(extra, context)
                 end
               end
-              resolved_arguments = resolved_arguments.merge_extras(extra_args)
+              if extra_args.any?
+                resolved_arguments = resolved_arguments.merge_extras(extra_args)
+              end
               resolved_arguments.keyword_arguments
             end
 
@@ -277,10 +286,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
@@ -332,6 +338,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
@@ -371,7 +381,7 @@ module GraphQL
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(current_type, value, context, path)
+              authorized_new(current_type, value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
@@ -634,22 +644,8 @@ module GraphQL
           end
         end
 
-        def authorized_new(type, value, context, path)
-          trace_payload = { context: context, type: type, object: value, path: path }
-
-          auth_val = context.query.trace("authorized", trace_payload) do
-            type.authorized_new(value, context)
-          end
-
-          if context.schema.lazy?(auth_val)
-            GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
-                context.schema.sync_lazy(auth_val)
-              end
-            end
-          else
-            auth_val
-          end
+        def authorized_new(type, value, context)
+          type.authorized_new(value, context)
         end
       end
     end

data/lib/graphql/introspection.rb

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