graphql 2.6.6 → 2.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3366525e188ac8b81b4dc7bdc8e34bb1839153fbec23d8e2a5faf07c02b56aa6
-  data.tar.gz: 414d8f17cee8d40adf8c5923427e83d187efdbd08871c7b9d8bbd4fa13b0e550
+  metadata.gz: 12ae3a5cc9e399639228a8ccfc1654c7bcaf73a6c81339ad72f7ce90b159eb9d
+  data.tar.gz: a998bd1576174777857e365cbe67ffc7b68273bbaa17ad0cd1e609193254417f
 SHA512:
-  metadata.gz: f4423d53187dcf97e67ae1ba93cc9b5135c7db35cab04abc5533b96e97e3abd5d2c4bbbe683a64abc0117a022743a53df804d170e5fbd0fd7430a3987466531b
-  data.tar.gz: c6093a9a53e554aed992da96b80007bbe10df7ac9552c4a1dc0cce19ae8a3f33fd3e2cb0858c117c1e061c4b996a4af8a7b161b31b4f3806ff3a30a84dfaddb2
+  metadata.gz: 2c95b6f2c0aec486d42170e970f59272ece87e9433c5ba8e3fff4838da802993f1de9fcaf3b2c2807fb3365674a7a915265c248470987bf0a9f47d13b90699d1
+  data.tar.gz: 03eb4c0fb7cddfd2cebce9a50ce3a9264f6473d4ca037e8a60ddb5d14b3f880a54c6b249958b2b58100dca9ea9b3ad9de04ad25cd333f0d00e620fd724ff7ff6

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

@@ -26,7 +26,8 @@ class <%= schema_name %> < GraphQL::Schema
     raise(GraphQL::RequiredImplementationMissingError)
   end
 
-  # Limit the size of incoming queries:
+  # Limit the depth and size of incoming queries:
+  max_depth(15)
   max_query_string_tokens(5000)
 
   # Stop validating when it encounters this many errors:

data/lib/graphql/dashboard/application_controller.rb

@@ -22,7 +22,11 @@ module Graphql
 
       def schema_class
         @schema_class ||= begin
-          schema_param = request.query_parameters["schema"] || params[:schema]
+          configured_schemas = Array(request.path_parameters[:schema] || request.path_parameters["schema"])
+          schema_param = request.query_parameters["schema"]
+          schema_param = configured_schemas.find { |schema| schema.to_s == schema_param } if schema_param
+          schema_param ||= configured_schemas.first
+
           case schema_param
           when Class
             schema_param

data/lib/graphql/dashboard.rb

@@ -10,6 +10,9 @@ module Graphql
   # @example Mounting the Dashboard in your app
   #   mount GraphQL::Dashboard, at: "graphql_dashboard", schema: "MySchema"
   #
+  # Pass an array to allow selecting from multiple schemas with the `schema` query parameter.
+  #   mount GraphQL::Dashboard, at: "graphql_dashboard", schema: ["MySchema", "OtherSchema"]
+  #
   # @example Authenticating the Dashboard with HTTP Basic Auth
   #   # config/initializers/graphql_dashboard.rb
   #   GraphQL::Dashboard.middleware.use(Rack::Auth::Basic) do |username, password|

data/lib/graphql/dataloader/async_dataloader.rb

@@ -4,6 +4,11 @@ module GraphQL
   class Dataloader
     class AsyncDataloader < Dataloader
       def self.use(...)
+        install_graphql_methods
+        super
+      end
+
+      def self.install_graphql_methods
         if !Async::Task.method_defined?(:cancel)
           Async::Task.alias_method(:cancel, :stop)
         end
@@ -11,7 +16,6 @@ module GraphQL
           Async::Task.attr_accessor(:graphql_async_dataloader_run)
           Async::Task.attr_accessor(:graphql_async_dataloader_condition)
         end
-        super
       end
 
       def initialize(...)
@@ -54,7 +58,10 @@ module GraphQL
           @running_tasks = nil
           @tasks_channel = nil
           @tasks_channel_task = nil
-          @finished_all_tasks = nil
+          @activity = nil
+          @task_error = nil
+          @expected_resumes = 0
+          @mode = nil
 
           @snoozed_jobs_condition = Async::Condition.new
           @snoozed_sources_condition = Async::Condition.new
@@ -77,20 +84,41 @@ module GraphQL
           @tasks_channel_task.cancel
         end
 
-        def wait_for_queues
-          @finished_all_tasks.wait
-          @finished_all_tasks = Async::Promise.new
+        def wait_for_activity
+          @activity.wait
+        end
+
+        def quiesced?
+          @running_tasks.empty? && @tasks_channel.empty? && @expected_resumes == 0
+        end
+
+        def has_pending_work?
+          @mode == :jobs ? @jobs.any? : @dataloader.pending_sources.any?(&:pending?) # rubocop:disable Development/NoneWithoutBlockCop
+        end
+
+        def has_bandwidth?
+          @mode == :jobs ? jobs_bandwidth? : sources_bandwidth?
+        end
+
+        # Signalled tasks don't appear in any accounting until their first slice
+        # pushes `:resumed_task`, so they have to be counted at signal time:
+        def expect_resumes(count)
+          @expected_resumes = count
         end
 
-        def wait_for_no_running_tasks
-          @no_running_tasks.wait
-          @no_running_tasks = Async::Promise.new
+        def check_error!
+          if (err = @task_error)
+            @task_error = nil
+            raise err
+          end
         end
 
         def new_queues(mode)
+          @mode = mode
           @tasks_channel = Async::Queue.new(parent: @root_task)
-          @no_running_tasks = Async::Promise.new
-          @finished_all_tasks = Async::Promise.new
+          @activity = Async::Condition.new
+          @task_error = nil
+          @expected_resumes = 0
           @running_tasks = []
           @tasks_channel_task = @root_task.async do |_t|
             while ((msg, data) = @tasks_channel.wait)
@@ -99,23 +127,18 @@ module GraphQL
                 @running_tasks.push(data)
                 data.run
               when :resumed_task
+                if @expected_resumes > 0
+                  @expected_resumes -= 1
+                end
                 @running_tasks.push(data)
               when :finished_task, :paused_task
                 @running_tasks.delete(data)
-                has_pending_work = mode == :jobs ? @jobs.any? : @dataloader.pending_sources.any?(&:pending?) # rubocop:disable Development/NoneWithoutBlockCop
-                if @running_tasks.empty?
-                  @no_running_tasks.resolve(true)
-                  has_bandwidth = mode == :jobs ? jobs_bandwidth? : sources_bandwidth?
-                  if (!has_pending_work) || (!has_bandwidth)
-                    @finished_all_tasks.resolve(true)
-                  end
-                end
               when :task_error
-                @no_running_tasks.resolve(true)
-                @finished_all_tasks.reject(data)
+                @task_error ||= data
               else
                 raise ArgumentError, "Unknown tasks_channel action: #{msg.inspect}"
               end
+              @activity.signal
             end
           end
         end
@@ -240,19 +263,20 @@ module GraphQL
       private
 
       def run_queue(run, condition, mode)
-        should_wait_for_all_tasks = false
+        opened_queues = false
 
-        if (unsnoozed = condition.waiting?)
-          should_wait_for_all_tasks = true
+        if condition.waiting?
+          opened_queues = true
           run.new_queues(mode)
+          run.expect_resumes(condition.instance_variable_get(:@ready).num_waiting)
           condition.signal
         end
 
-        while (pending_work = (mode == :jobs) ? (!run.jobs.empty? && run.jobs_bandwidth? ? run.jobs : nil) : (drain_pending_sources)) || unsnoozed
-          unsnoozed = false
+        loop do
+          pending_work = (mode == :jobs) ? (!run.jobs.empty? && run.jobs_bandwidth? ? run.jobs : nil) : (drain_pending_sources)
           if pending_work
-            if should_wait_for_all_tasks == false
-              should_wait_for_all_tasks = true
+            if opened_queues == false
+              opened_queues = true
               run.new_queues(mode)
             end
             num_tasks = mode == :sources ? run.current_sources_fiber_limit : 1
@@ -262,14 +286,23 @@ module GraphQL
             spawn_tasks(run, mode, condition, pending_work, num_tasks)
           end
 
-          run.wait_for_no_running_tasks
-        end
+          if !opened_queues
+            break
+          end
+
+          run.check_error!
 
-        if should_wait_for_all_tasks
-          run.wait_for_queues
+          if run.quiesced?
+            if !run.has_pending_work? || !run.has_bandwidth?
+              break
+            end
+            # Quiesced, but more work appeared - loop around to drain it.
+          else
+            run.wait_for_activity
+          end
         end
       ensure
-        if should_wait_for_all_tasks
+        if opened_queues
           run.close_queues
         end
       end

data/lib/graphql/execution/field_resolve_step.rb

@@ -130,7 +130,7 @@ module GraphQL
         highest_nulled_depth = path.size
         highest_list_depth = nil
         current_field_step = self
-        while current_field_step
+        while current_field_step && current_field_step.field_definition
           return_type = current_field_step.field_definition.type
           if propagating_null && return_type.non_null?
             highest_nulled_depth = current_field_step.path.size
@@ -147,7 +147,7 @@ module GraphQL
 
         if highest_list_depth.nil? || highest_nulled_depth <= highest_list_depth
           kill_field_step = self
-          while kill_field_step && highest_nulled_depth <= kill_field_step.path.size
+          while kill_field_step && kill_field_step.field_definition && highest_nulled_depth <= kill_field_step.path.size
             kill_field_step.selections_step.killed = true
             kill_field_step = kill_field_step.selections_step.field_resolve_step
           end

data/lib/graphql/execution/interpreter.rb

@@ -119,6 +119,12 @@ module GraphQL
               end
 
               results
+            rescue SystemStackError => err
+              queries.map do |query|
+                schema.query_stack_error(query, err)
+                query.result_values ||= { "errors" => query.context.errors.map(&:to_h) }
+                query.result
+              end
             rescue Exception
               # TODO rescue at a higher level so it will catch errors in analysis, too
               # Assign values here so that the query's `@executed` becomes true

data/lib/graphql/execution/runner.rb

@@ -5,7 +5,6 @@ module GraphQL
       def initialize(multiplex)
         @multiplex = multiplex
         @schema = multiplex.schema
-        @steps_queue = []
         @runtime_type_at = {}.compare_by_identity
         @static_type_at = {}.compare_by_identity
         @finalizers = nil
@@ -53,7 +52,7 @@ module GraphQL
         @dataloader.append_job(step)
       end
 
-      attr_reader :steps_queue, :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers, :input_values
+      attr_reader :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers, :input_values
 
       # @return [void]
       def add_finalizer(query, result_value, key, finalizer)

data/lib/graphql/execution/selections_step.rb

@@ -83,12 +83,12 @@ module GraphQL
             end
           end
 
-          continue_selections.each do |frs|
-            @runner.add_step(frs)
-          end
-
           i += 2
         end
+
+        continue_selections.each do |frs|
+          @runner.add_step(frs)
+        end
       end
     end
   end

data/lib/graphql/language/block_string.rb

@@ -21,17 +21,12 @@ module GraphQL
             next
           end
           line_length = line.size
-          line_indent = if line.match?(/\A  [^ ]/)
-            2
-          elsif line.match?(/\A    [^ ]/)
-            4
-          elsif line.match?(/\A[^ ]/)
-            0
-          else
-            line[/\A */].size
+          leading = 0
+          while leading < line_length && line.getbyte(leading) == 32
+            leading += 1
           end
-          if line_indent < line_length && (common_indent.nil? || line_indent < common_indent)
-            common_indent = line_indent
+          if leading < line_length && (common_indent.nil? || leading < common_indent)
+            common_indent = leading
           end
         end
 
@@ -41,7 +36,7 @@ module GraphQL
             if idx == 0
               next
             else
-              line.slice!(0, common_indent)
+              line[0, common_indent] = ""
             end
           end
         end

data/lib/graphql/language/lexer.rb

@@ -175,11 +175,14 @@ module GraphQL
       end
 
       def line_number
-        @scanner.string[0..@pos].count("\n") + 1
+        @scanner.string.byteslice(0, @pos).b.count("\n".b) + 1
       end
 
       def column_number
-        @scanner.string[0..@pos].split("\n").last.length
+        line_prefix = @scanner.string.byteslice(0, @pos)
+        line_prefix = line_prefix.b unless line_prefix.valid_encoding?
+        newline_index = line_prefix.rindex("\n")
+        newline_index ? line_prefix.length - newline_index : line_prefix.length + 1
       end
 
       def raise_parse_error(message, line = line_number, col = column_number)

data/lib/graphql/language/nodes.rb

@@ -304,7 +304,8 @@ module GraphQL
                 children_method_names.map { |m| "#{m}: NO_CHILDREN" } +
                 DEFAULT_INITIALIZE_OPTIONS
 
-              assignments = scalar_method_names.map { |m| "@#{m} = #{m}"} +
+              # Intern descriptions so identical strings across SDL documents share one frozen object.
+              assignments = scalar_method_names.map { |m| m == :description ? "@#{m} = #{m} && -#{m}" : "@#{m} = #{m}" } +
                 children_method_names.map { |m| "@#{m} = #{m}.freeze" }
 
               if name.end_with?("Definition") && name != "FragmentDefinition"

data/lib/graphql/language.rb

@@ -31,7 +31,7 @@ module GraphQL
 
         "[#{serialized_array}]"
       else
-        JSON.generate(value, quirks_mode: true)
+        JSON.generate(value)
       end
     rescue JSON::GeneratorError
       if Float::INFINITY == value

data/lib/graphql/schema/build_from_definition.rb

@@ -82,6 +82,7 @@ module GraphQL
           replace_late_bound_types_with_built_in(types)
 
           schema_extensions = nil
+          definitions_by_name = nil
           document.definitions.each do |definition|
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
@@ -101,9 +102,16 @@ module GraphQL
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
                 if definition.is_a?(GraphQL::Language::Nodes::ObjectTypeDefinition) || definition.is_a?(Language::Nodes::InterfaceTypeDefinition)
                   interface_names = definition.interfaces.map(&:name)
-                  transitive_names = interface_names.map { |n| document.definitions.find { |d| d.respond_to?(:name) && d.name == n }&.interfaces&.map(&:name) }
-                  transitive_names.flatten!
-                  transitive_names.compact!
+                  if !interface_names.empty?
+                    definitions_by_name ||= document.definitions.each_with_object({}) do |d, by_name|
+                      by_name[d.name] ||= d if d.respond_to?(:name)
+                    end
+                    transitive_names = interface_names.map { |n| definitions_by_name[n]&.interfaces&.map(&:name) }
+                    transitive_names.flatten!
+                    transitive_names.compact!
+                  else
+                    transitive_names = interface_names
+                  end
                   if !(missing_transitive_interfaces = transitive_names - interface_names).empty?
                     raise GraphQL::Schema::InvalidDocumentError, "type #{definition.name} is missing one or more transitive interface names: #{missing_transitive_interfaces.join(", ")}. Add them to the type's `implements` list and try again."
                   end

data/lib/graphql/schema/input_object.rb

@@ -172,12 +172,12 @@ module GraphQL
           types = ctx.types
 
           if input.is_a?(Array)
-            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input) })
           end
 
           if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
             # We're not sure it'll act like a hash, so reject it:
-            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input) })
           end
 
 

data/lib/graphql/subscriptions/serialize.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "date"
 require "set"
 module GraphQL
   class Subscriptions
@@ -10,6 +11,7 @@ module GraphQL
       SYMBOL_KEYS_KEY = "__sym_keys__"
       TIMESTAMP_KEY = "__timestamp__"
       TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S.%N%z" # eg '2020-01-01 23:59:59.123456789+05:00'
+      TIMESTAMP_CLASS_NAMES = ["Date", "DateTime", "Time"].freeze
       OPEN_STRUCT_KEY = "__ostruct__"
 
       module_function
@@ -24,7 +26,7 @@ module GraphQL
       # @param obj [Object] Some subscription-related data to dump
       # @return [String] The stringified object
       def dump(obj)
-        JSON.generate(dump_value(obj), quirks_mode: true)
+        JSON.generate(dump_value(obj))
       end
 
       # This is for turning objects into subscription scopes.
@@ -72,15 +74,19 @@ module GraphQL
                 value[SYMBOL_KEY].to_sym
               when TIMESTAMP_KEY
                 timestamp_class_name, *timestamp_args = value[TIMESTAMP_KEY]
-                timestamp_class = Object.const_get(timestamp_class_name)
-                if defined?(ActiveSupport::TimeWithZone) && timestamp_class <= ActiveSupport::TimeWithZone
+                timestamp_class = if TIMESTAMP_CLASS_NAMES.include?(timestamp_class_name)
+                  Object.const_get(timestamp_class_name, false)
+                end
+                if defined?(ActiveSupport::TimeWithZone) && timestamp_class_name == ActiveSupport::TimeWithZone.name
                   zone_name, timestamp_s = timestamp_args
                   zone = ActiveSupport::TimeZone[zone_name]
                   raise "Zone #{zone_name} not found, unable to deserialize" unless zone
                   zone.strptime(timestamp_s, TIMESTAMP_FORMAT)
-                else
+                elsif timestamp_class
                   timestamp_s = timestamp_args.first
                   timestamp_class.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                else
+                  raise ArgumentError, "Unsupported timestamp class: #{timestamp_class_name.inspect}"
                 end
               when OPEN_STRUCT_KEY
                 ostruct_values = load_value(value[OPEN_STRUCT_KEY])

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.6.6"
+  VERSION = "2.6.8"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.6
+  version: 2.6.8
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64