graphql 2.6.2 → 2.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0c0b5ff2af84e07dab381443b1b62137074324bb3063c8387bf6dc777d51d00
-  data.tar.gz: 4e5383e45c9d62ea5a04782867a743d01d6db0d0bc853deadc7a229f26d440e4
+  metadata.gz: 8ece536c0702c8789a3a5c79de82af4bd2ff806a3209d0ac4da88fc968629d19
+  data.tar.gz: 0063f1ea552e7782029083eb027138a0725af89a65265dc643469f2227184134
 SHA512:
-  metadata.gz: 86019205d2eb2dabd464dc615af28ab078c1a48e43c0701a1852dddfd13eded8954e42e91b7176c685eed10679b15bf4bcef2c86c48d9f9ad4b870cdc78bb19a
-  data.tar.gz: b95880ff00058b167fe7574ca5e267814fe7aa9be65df0d2691d658344a796dd1fdafedad6cc35b58c3299c5401b39a964353cb5ab0e3974296ca4c26f9ab504
+  metadata.gz: 2ee406b8ad164004af45d98e3b5dc70d69396f008a80cc68ef83a4bff212698c0a181644dc2b513e8bd1e71d2baf7d1ba2901ad05f497199556b171a6dfb11ab
+  data.tar.gz: 2ffd4e01742bd3b0feb207a316b1935d1edff05be8b28afb1c42e5ba47b4df916df802ee15617bb30bd45cdf6fd4f7a59c22b5d73cbabb3d8ee6658f3246d8ef

data/lib/generators/graphql/field_extractor.rb

@@ -6,7 +6,23 @@ module Graphql
     module FieldExtractor
       def fields
         columns = []
-        columns += (klass&.columns&.map { |c| generate_column_string(c) }  || [])
+        if (model_columns = klass&.columns)
+          filter = if defined?(ActiveSupport::ParameterFilter)
+            fp = if defined?(Rails) && Rails.application && (app_config = Rails.application.config.filter_parameters).present? && !app_config.empty?
+              app_config
+            elsif ActiveSupport.respond_to?(:filter_parameters)
+              ActiveSupport.filter_parameters
+            else
+              []
+            end
+            ActiveSupport::ParameterFilter.new(fp, mask: nil)
+          else
+            nil
+          end
+          columns += model_columns
+            .select { |c| filter ? filter.filter_param(c.name, c.name) : true }
+            .map { |c| generate_column_string(c) }
+        end
         columns + custom_fields
       end
 

data/lib/graphql/analysis/query_complexity.rb

@@ -9,6 +9,8 @@ module GraphQL
         super
         @skip_introspection_fields = !query.schema.max_complexity_count_introspection_fields
         @complexities_on_type_by_query = {}
+        @intersect_cache = Hash.new { |h, k| h[k] = {}.compare_by_identity }.compare_by_identity
+        @possible_types_cache = {}.compare_by_identity
       end
 
       # Override this method to use the complexity result
@@ -27,14 +29,14 @@ module GraphQL
             future_complexity
           end
         when nil
-          subject.logger.warn <<~GRAPHQL
+          subject.logger.warn <<~MESSAGE
             GraphQL-Ruby's complexity cost system is getting some "breaking fixes" in a future version. See the migration notes at https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#complexity_cost_calculation_mode_for-class_method
 
             To opt into the future behavior, configure your schema (#{subject.schema.name ? subject.schema.name : subject.schema.ancestors}) with:
 
               complexity_cost_calculation_mode(:future) # or `:legacy`, `:compare`
 
-          GRAPHQL
+          MESSAGE
           max_possible_complexity(mode: :legacy)
         else
           raise ArgumentError, "Expected `:future`, `:legacy`, `:compare`, or `nil` from `#{query.schema}.complexity_cost_calculation_mode_for` but got: #{query.schema.complexity_cost_calculation_mode.inspect}"
@@ -159,8 +161,22 @@ module GraphQL
 
       def types_intersect?(query, a, b)
         return true if a == b
-        a_types = query.types.possible_types(a)
-        query.types.possible_types(b).any? { |t| a_types.include?(t) }
+
+        if a.object_id < b.object_id
+          first_cache = @intersect_cache[a]
+          second_key = b
+        else
+          first_cache = @intersect_cache[b]
+          second_key = a
+        end
+
+        if first_cache.key?(second_key)
+          first_cache[second_key]
+        else
+          a_types = @possible_types_cache[a] ||= query.types.possible_types(a).to_set
+          b_types = @possible_types_cache[b] ||= query.types.possible_types(b).to_set
+          first_cache[second_key] = a_types.intersect?(b_types)
+        end
       end
 
       # A hook which is called whenever a field's max complexity is calculated.
@@ -175,18 +191,16 @@ module GraphQL
       # @param inner_selections [Array<Hash<String, ScopedTypeComplexity>>] Field selections for a scope
       # @return [Integer] Total complexity value for all these selections in the parent scope
       def merged_max_complexity(query, inner_selections)
-        # Aggregate a set of all unique field selection keys across all scopes.
-        # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-        unique_field_keys = inner_selections.each_with_object({}) do |inner_selection, memo|
-          memo.merge!(inner_selection)
+        child_scopes_by_key = {}
+        inner_selections.each do |inner_selection|
+          inner_selection.each do |k, v|
+            scopes = child_scopes_by_key[k] ||= []
+            scopes << v
+          end
         end
-
         # Add up the total cost for each unique field name's coalesced selections
-        unique_field_keys.each_key.reduce(0) do |total, field_key|
-          # Collect all child scopes for this field key;
-          # all keys come with at least one scope.
-          child_scopes = inner_selections.filter_map { _1[field_key] }
-
+        total = 0
+        child_scopes_by_key.each do |field_key, child_scopes|
           # Compute maximum possible cost of child selections;
           # composites merge their maximums, while leaf scopes are always zero.
           # FieldsWillMerge validation assures all scopes are uniformly composite or leaf.
@@ -214,8 +228,10 @@ module GraphQL
             child_complexity: maximum_children_cost,
           )
 
-          total + maximum_cost
+          total += maximum_cost
         end
+
+        total
       end
 
       def legacy_merged_max_complexity(query, inner_selections)

data/lib/graphql/backtrace/table.rb

@@ -90,7 +90,16 @@ module GraphQL
 
           if ast_node
             field_defn = query.get_field(result.graphql_result_type, ast_node.name)
-            args = query.arguments_for(ast_node, field_defn).to_h
+            args = begin
+              if (cached_args = query.arguments_cache.cached_arguments_for(ast_node, field_defn))
+                cached_args.to_h
+              else
+                EmptyObjects::EMPTY_HASH
+              end
+            rescue StandardError => err
+              "Failed to load arguments, #{err.class}: #{err.message}"
+            end
+
             field_path = field_defn.path
             if ast_node.alias
               field_path += " as #{ast_node.alias}"

data/lib/graphql/current.rb

@@ -41,7 +41,13 @@ module GraphQL
     # @see GraphQL::Field#path for a string identifying this field
     # @return [GraphQL::Field, nil] The currently-running field, if there is one.
     def self.field
-      Fiber[:__graphql_runtime_info]&.values&.first&.current_field
+      if (interpreter_info = Fiber[:__graphql_runtime_info])
+        interpreter_info.values&.first&.current_field
+      elsif (field = Fiber[:__graphql_current_field])
+        field
+      else
+        nil
+      end
     end
 
     # @return [Class, nil] The currently-running {Dataloader::Source} class, if there is one.

data/lib/graphql/dataloader/async_dataloader.rb

@@ -1,86 +1,324 @@
 # frozen_string_literal: true
+
 module GraphQL
   class Dataloader
     class AsyncDataloader < Dataloader
+      def self.use(...)
+        if !Async::Task.method_defined?(:cancel)
+          Async::Task.alias_method(:cancel, :stop)
+        end
+        if !Async::Task.method_defined?(:graphql_async_dataloader_run)
+          Async::Task.attr_accessor(:graphql_async_dataloader_run)
+          Async::Task.attr_accessor(:graphql_async_dataloader_condition)
+        end
+        super
+      end
+
+      def initialize(...)
+        super
+        create_pending_run
+      end
+
+      def create_pending_run
+        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
+        @pending_run = Run.new(total_fiber_limit, jobs_fiber_limit)
+      end
+
       def yield(source = Fiber[:__graphql_current_dataloader_source])
-        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        task = Async::Task.current
+        run = task.graphql_async_dataloader_run
+        trace = run.trace
         trace&.dataloader_fiber_yield(source)
-        if (condition = Fiber[:graphql_dataloader_next_tick])
-          condition.wait
-        else
-          Fiber.yield
-        end
+        run.finished_tasks.push(task)
+        condition = task.graphql_async_dataloader_condition
+        condition.wait
+        run.started_tasks.push(task)
         trace&.dataloader_fiber_resume(source)
         nil
       end
 
-      def run(trace_query_lazy: nil)
-        trace = Fiber[:__graphql_current_multiplex]&.current_trace
-        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
-        job_fibers = []
-        next_job_fibers = []
-        source_tasks = []
-        next_source_tasks = []
-        first_pass = true
-        sources_condition = Async::Condition.new
-        manager = spawn_fiber do
-          trace&.begin_dataloader(self)
-          while first_pass || !job_fibers.empty?
-            first_pass = false
-            fiber_vars = get_fiber_variables
+      class Run
+        def initialize(total_fiber_limit, jobs_fiber_limit)
+          @root_task = nil
+          @trace = nil
+          @jobs = []
 
-            run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+          @total_fiber_limit = total_fiber_limit
+          @jobs_fiber_limit = jobs_fiber_limit
+          @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
 
-            Sync do |root_task|
-              set_fiber_variables(fiber_vars)
-              while !source_tasks.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-                while (task = (source_tasks.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size + next_source_tasks.size) < total_fiber_limit) && spawn_source_task(root_task, sources_condition, trace))))
-                  if task.alive?
-                    root_task.yield # give the source task a chance to run
-                    next_source_tasks << task
-                  end
-                end
-                sources_condition.signal
-                source_tasks.concat(next_source_tasks)
-                next_source_tasks.clear
+          @finished_tasks = nil
+          @started_tasks = nil
+          @started_count_task = nil
+          @finished_count_task = nil
+          @finished_all_tasks = nil
+          @finished_first_pass = nil
+
+          @snoozed_jobs_condition = Async::Condition.new
+          @snoozed_sources_condition = Async::Condition.new
+        end
+
+        attr_accessor :trace, :root_task
+
+        attr_reader :jobs, :lazies_at_depth, :jobs_fiber_limit, :total_fiber_limit, :finished_tasks, :started_tasks, :snoozed_jobs_condition, :snoozed_sources_condition
+
+        def jobs_bandwidth?
+          running_count < jobs_fiber_limit
+        end
+
+        def allowed_sources_tasks
+          within_limit = total_fiber_limit - running_count
+          if within_limit < 1
+            1
+          else
+            within_limit
+          end
+        end
+
+        def close_queues
+          @finished_tasks.close
+          @finished_count_task.cancel
+
+          @started_tasks.close
+          @started_count_task.cancel
+        end
+
+        def running_count
+          @snoozed_jobs_condition.instance_variable_get(:@ready).num_waiting +
+            @snoozed_sources_condition.instance_variable_get(:@ready).num_waiting +
+            @started_count +
+            @started_tasks.size -
+            @finished_count
+        end
+
+        def wait_for_queues
+          if !@finished_first_pass.resolved?
+            @finished_first_pass.resolve(true)
+          end
+
+          @finished_all_tasks.wait
+          @finished_all_tasks = Async::Promise.new
+        end
+
+        def new_queues
+          @finished_tasks = Async::Queue.new
+          @finished_count = 0
+          @started_tasks = Async::Queue.new
+          @started_count = 0
+          @finished_first_pass = Async::Promise.new
+          @finished_all_tasks = Async::Promise.new
+
+          @started_count_task = @root_task.async do |task|
+            @finished_first_pass.wait
+            while task = @started_tasks.wait
+              @started_count += 1
+              if task.status == :initialized # could also be resumed after waiting
+                task.run
               end
             end
+          end
 
-            if !@lazies_at_depth.empty?
-              with_trace_query_lazy(trace_query_lazy) do
-                run_next_pending_lazies(job_fibers, trace)
-                run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+          @finished_count_task = @root_task.async do |task|
+            while t_or_err = @finished_tasks.wait
+              if t_or_err.is_a?(StandardError)
+                @finished_all_tasks.reject(t_or_err)
+              else
+                @finished_count += 1
+                if @finished_count == @started_count
+                  @finished_all_tasks.resolve(true)
+                end
               end
             end
           end
-          trace&.end_dataloader(self)
         end
 
-        manager.resume
-        if manager.alive?
-          raise "Invariant: Manager didn't terminate successfully: #{manager}"
+        def running?
+          @snoozed_jobs_condition.waiting? || @snoozed_sources_condition.waiting?
         end
+      end
+
+      def append_job(callable = nil, &block)
+        active_run.jobs.push(callable || block)
+        nil
+      end
+
+      def lazy_at_depth(depth, lazy)
+        active_run.lazies_at_depth[depth] << lazy
+      end
+
+      def active_run
+        @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run to append to, GraphQL-Ruby bug")
+      end
 
+      def run_isolated
+        previous_run = Async::Task.current?&.graphql_async_dataloader_run
+        prev_pending_keys = {}
+        # Clear pending loads but keep already-cached records
+        # in case they are useful to the given block.
+        @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.dup
+              batched_source_instance.pending.clear
+            end
+          end
+        end
+
+        res = nil
+        create_pending_run
+        @pending_run.jobs << -> { res = yield }
+        run
+        res
+      ensure
+        if previous_run
+          Async::Task.current.graphql_async_dataloader_run = previous_run
+          # clear the one created in #run:
+          @pending_run = nil
+        end
+        prev_pending_keys.each do |source_instance, pending|
+          pending.each do |key, value|
+            if !source_instance.results.key?(key)
+              source_instance.pending[key] = value
+            end
+          end
+        end
+      end
+
+      def run(trace_query_lazy: nil)
+        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        run = @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
+        @pending_run = nil
+        run.trace = trace
+        first_pass = true
+        trace&.begin_dataloader(self)
+        fiber_vars = get_fiber_variables
+        raised_error = nil
+        jobs = run.jobs
+        Sync do |_maybe_new_task|
+          # Make sure there's a new task instance to hold `.graphql_...` state:
+          task = Async::Task.new do |root_task|
+            run.root_task = root_task
+            root_task.graphql_async_dataloader_run = run
+            set_fiber_variables(fiber_vars)
+
+            while first_pass || run.running? || !jobs.empty?
+              first_pass = false
+              run_pending_steps(run)
+              run_sources(run)
+
+              if !run.lazies_at_depth.empty?
+                with_trace_query_lazy(trace_query_lazy) do
+                  run_next_pending_lazies(run)
+                  run_pending_steps(run)
+                end
+              end
+            end
+          rescue StandardError => err
+            raised_error = err
+            root_task.cancel
+          end
+
+          task.run
+          task.wait
+        end
+        create_pending_run
+        if raised_error
+          raise raised_error
+        end
+        trace&.end_dataloader(self)
       rescue UncaughtThrowError => e
         throw e.tag, e.value
       end
 
       private
 
-      def run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
-        while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
-          if f.alive?
-            finished = run_fiber(f)
-            if !finished
-              next_job_fibers << f
+      def run_pending_steps(run)
+        run.new_queues
+
+        if (unsnoozed = run.snoozed_jobs_condition.waiting?)
+          run.snoozed_jobs_condition.signal
+        end
+        pending_jobs = run.jobs
+        while (!pending_jobs.empty? && (has_limit = run.jobs_bandwidth?)) || (unsnoozed)
+          unsnoozed = false
+          if has_limit
+            spawn_job_task(run)
+          end
+          run.wait_for_queues
+        end
+      ensure
+        run.close_queues
+      end
+
+      def spawn_job_task(run)
+        pending_jobs = run.jobs
+        if !pending_jobs.empty?
+          fiber_vars = get_fiber_variables
+          new_task = Async::Task.new(run.root_task) do |task|
+            run.trace&.dataloader_spawn_execution_fiber(pending_jobs)
+            task.graphql_async_dataloader_run = run
+            task.graphql_async_dataloader_condition = run.snoozed_jobs_condition
+            set_fiber_variables(fiber_vars)
+            while job = pending_jobs.shift
+              job.call
             end
+          ensure
+            cleanup_fiber
+            run.finished_tasks.push($! || task)
+            run.trace&.dataloader_fiber_exit
           end
+          run.started_tasks.push(new_task)
+          new_task
         end
-        job_fibers.concat(next_job_fibers)
-        next_job_fibers.clear
       end
 
-      def spawn_source_task(parent_task, condition, trace)
+      def run_sources(run)
+        run.new_queues
+
+        if (unsnoozed = run.snoozed_sources_condition.waiting?)
+          run.snoozed_sources_condition.signal
+        end
+
+        allowed_tasks = run.allowed_sources_tasks
+        while (has_pending = @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) } ) || unsnoozed
+          unsnoozed = false
+          if has_pending
+            spawn_source_task(run, allowed_tasks)
+          end
+          run.wait_for_queues
+        end
+      ensure
+        run.close_queues
+      end
+
+      #### TODO DRY  Had to duplicate to remove spawn_job_fiber
+      def run_next_pending_lazies(run)
+        smallest_depth = nil
+        run.lazies_at_depth.each_key do |depth_key|
+          smallest_depth ||= depth_key
+          if depth_key < smallest_depth
+            smallest_depth = depth_key
+          end
+        end
+
+        if smallest_depth
+          lazies = run.lazies_at_depth.delete(smallest_depth)
+          if !lazies.empty?
+            begin
+              run.new_queues
+              lazies.each_with_index do |l, idx|
+                append_job { l.value }
+              end
+              spawn_job_task(run) # Todo what was the last `true` condition?
+              run.wait_for_queues
+            ensure
+              run.close_queues
+            end
+          end
+        end
+      end
+
+      def spawn_source_task(run, num_tasks)
         pending_sources = nil
         @source_cache.each_value do |source_by_batch_params|
           source_by_batch_params.each_value do |source|
@@ -92,18 +330,30 @@ module GraphQL
         end
 
         if pending_sources
+          if num_tasks == Float::INFINITY
+            num_tasks = pending_sources.size
+          end
           fiber_vars = get_fiber_variables
-          parent_task.async do
-            trace&.dataloader_spawn_source_fiber(pending_sources)
-            set_fiber_variables(fiber_vars)
-            Fiber[:graphql_dataloader_next_tick] = condition
-            pending_sources.each do |s|
-              trace&.begin_dataloader_source(s)
-              s.run_pending_keys
-              trace&.end_dataloader_source(s)
+          trace = run.trace
+          num_tasks.times do
+            new_task = Async::Task.new(run.root_task) do |task|
+              task.graphql_async_dataloader_run = run
+              task.graphql_async_dataloader_condition = run.snoozed_sources_condition
+              trace&.dataloader_spawn_source_fiber(pending_sources)
+              set_fiber_variables(fiber_vars)
+              while (source = pending_sources.shift)
+                trace&.begin_dataloader_source(source)
+                source.run_pending_keys
+                trace&.end_dataloader_source(source)
+              end
+              nil
+            ensure
+              run.finished_tasks.push($! || task)
+              cleanup_fiber
+              trace&.dataloader_fiber_exit
             end
-            cleanup_fiber
-            trace&.dataloader_fiber_exit
+            run.started_tasks.push(new_task)
+            new_task
           end
         end
       end

data/lib/graphql/dataloader/source.rb

@@ -89,7 +89,8 @@ module GraphQL
           sync(pending_keys)
         end
 
-        result_keys.map { |k| result_for(k) }
+        result_keys.map! { |k| result_for(k) }
+        result_keys
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
@@ -138,22 +139,25 @@ module GraphQL
       # @api private
       # @return [void]
       def run_pending_keys
-        if !@fetching.empty?
-          @fetching.each_key { |k| @pending.delete(k) }
-        end
+        @fetching.each_key { |k| @pending.delete(k) }
         return if @pending.empty?
         fetch_h = @pending
-        @pending = {}
         @fetching.merge!(fetch_h)
+        @pending = {}
         results = fetch(fetch_h.values)
-        fetch_h.each_with_index do |(key, _value), idx|
+        idx = 0
+
+        fetch_h.each_key do |key|
           @results[key] = results[idx]
+          @fetching.delete(key)
+          idx += 1
         end
         nil
       rescue StandardError => error
-        fetch_h.each_key { |key| @results[key] = error }
-      ensure
-        fetch_h && fetch_h.each_key { |k| @fetching.delete(k) }
+        fetch_h.each_key { |key|
+          @results[key] = error
+          @fetching.delete(key)
+        }
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -171,7 +175,11 @@ module GraphQL
       # @param batch_kwargs [Hash]
       # @return [Object]
       def self.batch_key_for(*batch_args, **batch_kwargs)
-        [*batch_args, **batch_kwargs]
+        if batch_kwargs.any? # rubocop:disable Development/NoneWithoutBlockCop
+          [*batch_args, **batch_kwargs]
+        else
+          batch_args
+        end
       end
 
       # Clear any already-loaded objects for this source

data/lib/graphql/dataloader.rb

@@ -58,7 +58,7 @@ module GraphQL
     end
 
     def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.class.default_fiber_limit)
-      @source_cache = Hash.new { |h, k| h[k] = {} }
+      @source_cache = Hash.new { |h, k| h[k] = {} }.compare_by_identity
       @pending_jobs = []
       if !nonblocking.nil?
         @nonblocking = nonblocking

data/lib/graphql/execution/directive_checks.rb

@@ -18,11 +18,13 @@ module GraphQL
           case name
           when SKIP
             args = query.arguments_for(directive_ast_node, directive_defn)
+            next if args.is_a?(GraphQL::ExecutionError)
             if args[:if] == true
               return false
             end
           when INCLUDE
             args = query.arguments_for(directive_ast_node, directive_defn)
+            next if args.is_a?(GraphQL::ExecutionError)
             if args[:if] == false
               return false
             end