graphql 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3efbb5d392546a7fce8398ec727d1a3a3580f8d7af6e544eab427c899f03eead
-  data.tar.gz: f51809ef796336903cafcfaf70ded342d380ef7c0f91d3a267bc217ce6ab8217
+  metadata.gz: a1caad3d02e9d64f06c086fd46c324a0df1fc66c35353aef62dd716fe7ea4b9c
+  data.tar.gz: 8c53383e4fe8b0e7d5199d42460e0a5920940ae27965a7223f5ef020b1c594cc
 SHA512:
-  metadata.gz: 32822e5ddaf9f83e0d905e812c61464d770379ec2cd4ef05a66f4fe261aa15868eb8955527054fa4aaeb2282f32956d3631e5df120494be79e4bbfd9ccde910a
-  data.tar.gz: 0d32a3f57eda3e26c032bf3f93f4605df643387e20f6429c84cc66ca76a41fa362c66cb420a8b6daa98616a0189a380d8bedf07b5f55f723d94119dd6a35d061
+  metadata.gz: ae189d6de14b18dbee6781688a43d1f15cfb1418fa9ceb45ca099f577a5cd9339c6e16d8402e7b15ba62c64afbfbaed64f3d5d64b253a51597fb50d586d5a6dd
+  data.tar.gz: ab5860a939248086c5b8df11f0f638edce805110e75f51b068addce3e0956a9ffeda17836bf02962a943b137e4defccd48e3c18f836973f0c780c4ef225f7bd0

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -16,10 +16,11 @@ module GraphQL
           max_possible_complexity
         end
 
-        class ScopedTypeComplexity
-          # A single proc for {#scoped_children} hashes. Use this to avoid repeated allocations,
-          # since the lexical binding isn't important.
-          HASH_CHILDREN = ->(h, k) { h[k] = {} }
+        # ScopedTypeComplexity models a tree of GraphQL types mapped to inner selections, ie:
+        # Hash<GraphQL::BaseType, Hash<String, ScopedTypeComplexity>>
+        class ScopedTypeComplexity < Hash
+          # A proc for defaulting empty namespace requests as a new scope hash.
+          DEFAULT_PROC = ->(h, k) { h[k] = {} }
 
           attr_reader :field_definition, :response_path, :query
 
@@ -27,32 +28,19 @@ module GraphQL
           # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
           # @param query [GraphQL::Query] Used for `query.possible_types`
           # @param response_path [Array<String>] The path to the response key for the field
+          # @return [Hash<GraphQL::BaseType, Hash<String, ScopedTypeComplexity>>]
           def initialize(parent_type, field_definition, query, response_path)
+            super(&DEFAULT_PROC)
             @parent_type = parent_type
             @field_definition = field_definition
             @query = query
             @response_path = response_path
-            @scoped_children = nil
             @nodes = []
           end
 
           # @return [Array<GraphQL::Language::Nodes::Field>]
           attr_reader :nodes
 
-          # Returns true if this field has no selections, ie, it's a scalar.
-          # We need a quick way to check whether we should continue traversing.
-          def terminal?
-            @scoped_children.nil?
-          end
-
-          # This value is only calculated when asked for to avoid needless hash allocations.
-          # Also, if it's never asked for, we determine that this scope complexity
-          # is a scalar field ({#terminal?}).
-          # @return [Hash<Hash<Class => ScopedTypeComplexity>]
-          def scoped_children
-            @scoped_children ||= Hash.new(&HASH_CHILDREN)
-          end
-
           def own_complexity(child_complexity)
             @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
           end
@@ -65,19 +53,14 @@ module GraphQL
           return if visitor.skipping?
           parent_type = visitor.parent_type_definition
           field_key = node.alias || node.name
-          # Find the complexity calculation for this field --
-          # if we're re-entering a selection, we'll already have one.
-          # Otherwise, make a new one and store it.
-          #
-          # `node` and `visitor.field_definition` may appear from a cache,
-          # but I think that's ok. If the arguments _didn't_ match,
-          # then the query would have been rejected as invalid.
-          complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
-
-          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
-          complexity.nodes.push(node)
-          # Push it on the stack.
-          complexities_on_type.push(complexity)
+
+          # Find or create a complexity scope stack for this query.
+          scopes_stack = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
+
+          # Find or create the complexity costing node for this field.
+          scope = scopes_stack.last[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
+          scope.nodes.push(node)
+          scopes_stack.push(scope)
         end
 
         def on_leave_field(node, parent, visitor)
@@ -85,89 +68,61 @@ module GraphQL
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
-          complexities_on_type = @complexities_on_type_by_query[visitor.query]
-          complexities_on_type.pop
+          scopes_stack = @complexities_on_type_by_query[visitor.query]
+          scopes_stack.pop
         end
 
         private
 
         # @return [Integer]
         def max_possible_complexity
-          @complexities_on_type_by_query.reduce(0) do |total, (query, complexities_on_type)|
-            root_complexity = complexities_on_type.last
-            # Use this entry point to calculate the total complexity
-            total_complexity_for_query = merged_max_complexity_for_scopes(query, [root_complexity.scoped_children])
-            total + total_complexity_for_query
+          @complexities_on_type_by_query.reduce(0) do |total, (query, scopes_stack)|
+            total + merged_max_complexity_for_scopes(query, [scopes_stack.first])
           end
         end
 
         # @param query [GraphQL::Query] Used for `query.possible_types`
-        # @param scoped_children_hashes [Array<Hash>] Array of scoped children hashes
+        # @param scopes [Array<ScopedTypeComplexity>] Array of scoped type complexities
         # @return [Integer]
-        def merged_max_complexity_for_scopes(query, scoped_children_hashes)
-          # Figure out what scopes are possible here.
+        def merged_max_complexity_for_scopes(query, scopes)
+          # Aggregate a set of all possible scope types encountered (scope keys).
           # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-          all_scopes = {}
-          scoped_children_hashes.each do |h|
-            all_scopes.merge!(h)
+          possible_scope_types = scopes.each_with_object({}) do |scope, memo|
+            memo.merge!(scope)
           end
 
-          # If an abstract scope is present, but _all_ of its concrete types
-          # are also in the list, remove it from the list of scopes to check,
-          # because every possible type is covered by a concrete type.
-          # (That is, there are no remainder types to check.)
-          prev_keys = all_scopes.keys
-          prev_keys.each do |scope|
-            next unless scope.kind.abstract?
-
-            missing_concrete_types = query.possible_types(scope).select { |t| !all_scopes.key?(t) }
-            # This concrete type is possible _only_ as a member of the abstract type.
-            # So, attribute to it the complexity which belongs to the abstract type.
-            missing_concrete_types.each do |concrete_scope|
-              all_scopes[concrete_scope] = all_scopes[scope]
+          # Expand abstract scope types into their concrete implementations;
+          # overlapping abstracts coalesce through their intersecting types.
+          possible_scope_types.keys.each do |possible_scope_type|
+            next unless possible_scope_type.kind.abstract?
+
+            query.possible_types(possible_scope_type).each do |impl_type|
+              possible_scope_types[impl_type] ||= true
             end
-            all_scopes.delete(scope)
+            possible_scope_types.delete(possible_scope_type)
           end
 
-          # This will hold `{ type => int }` pairs, one for each possible branch
-          complexity_by_scope = {}
-
-          # For each scope,
-          # find the lexical selections that might apply to it,
-          # and gather them together into an array.
-          # Then, treat the set of selection hashes
-          # as a set and calculate the complexity for them as a unit
-          all_scopes.each do |scope, _|
-            # These will be the selections on `scope`
-            children_for_scope = []
-            scoped_children_hashes.each do |sc_h|
-              sc_h.each do |inner_scope, children_hash|
-                if applies_to?(query, scope, inner_scope)
-                  children_for_scope << children_hash
-                end
+          # Aggregate the lexical selections that may apply to each possible type,
+          # and then return the maximum cost among possible typed selections.
+          possible_scope_types.each_key.reduce(0) do |max, possible_scope_type|
+            # Collect inner selections from all scopes that intersect with this possible type.
+            all_inner_selections = scopes.each_with_object([]) do |scope, memo|
+              scope.each do |scope_type, inner_selections|
+                memo << inner_selections if types_intersect?(query, scope_type, possible_scope_type)
               end
             end
 
-            # Calculate the complexity for `scope`, merging all
-            # possible lexical branches.
-            complexity_value = merged_max_complexity(query, children_for_scope)
-            complexity_by_scope[scope] = complexity_value
+            # Find the maximum complexity for the scope type among possible lexical branches.
+            complexity = merged_max_complexity(query, all_inner_selections)
+            complexity > max ? complexity : max
           end
-
-          # Return the max complexity among all scopes
-          complexity_by_scope.each_value.max
         end
 
-        def applies_to?(query, left_scope, right_scope)
-          if left_scope == right_scope
-            # This can happen when several branches are being analyzed together
-            true
-          else
-            # Check if these two scopes have _any_ types in common.
-            possible_right_types = query.possible_types(right_scope)
-            possible_left_types = query.possible_types(left_scope)
-            !(possible_right_types & possible_left_types).empty?
-          end
+        def types_intersect?(query, a, b)
+          return true if a == b
+
+          a_types = query.possible_types(a)
+          query.possible_types(b).any? { |t| a_types.include?(t) }
         end
 
         # A hook which is called whenever a field's max complexity is calculated.
@@ -179,50 +134,47 @@ module GraphQL
         def field_complexity(scoped_type_complexity, max_complexity:, child_complexity: nil)
         end
 
-        # @param children_for_scope [Array<Hash>] An array of `scoped_children[scope]` hashes
-        # (`{field_key => complexity}`)
-        # @return [Integer] Complexity value for all these selections in the current scope
-        def merged_max_complexity(query, children_for_scope)
-          all_keys = []
-          children_for_scope.each do |c|
-            all_keys.concat(c.keys)
+        # @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)
           end
-          all_keys.uniq!
-          complexity_for_keys = {}
-
-          all_keys.each do |child_key|
-            scoped_children_for_key = nil
-            complexity_for_key = nil
-            children_for_scope.each do |children_hash|
-              next unless children_hash.key?(child_key)
-
-              complexity_for_key = children_hash[child_key]
-              if complexity_for_key.terminal?
-                # Assume that all terminals would return the same complexity
-                # Since it's a terminal, its child complexity is zero.
-                complexity = complexity_for_key.own_complexity(0)
-                complexity_for_keys[child_key] = complexity
-
-                field_complexity(complexity_for_key, max_complexity: complexity, child_complexity: nil)
+
+          # Add up the total cost for each unique field name's coalesced selections
+          unique_field_keys.each_key.reduce(0) do |total, field_key|
+            composite_scopes = nil
+            field_cost = 0
+
+            # Collect composite selection scopes for further aggregation,
+            # leaf selections report their costs directly.
+            inner_selections.each do |inner_selection|
+              child_scope = inner_selection[field_key]
+              next unless child_scope
+
+              # Empty child scopes are leaf nodes with zero child complexity.
+              if child_scope.empty?
+                field_cost = child_scope.own_complexity(0)
+                field_complexity(child_scope, max_complexity: field_cost, child_complexity: nil)
               else
-                scoped_children_for_key ||= []
-                scoped_children_for_key << complexity_for_key.scoped_children
+                composite_scopes ||= []
+                composite_scopes << child_scope
               end
             end
 
-            next unless scoped_children_for_key
+            if composite_scopes
+              child_complexity = merged_max_complexity_for_scopes(query, composite_scopes)
 
-            child_complexity = merged_max_complexity_for_scopes(query, scoped_children_for_key)
-            # This is the _last_ one we visited; assume it's representative.
-            max_complexity = complexity_for_key.own_complexity(child_complexity)
-
-            field_complexity(complexity_for_key, max_complexity: max_complexity, child_complexity: child_complexity)
+              # This is the last composite scope visited; assume it's representative (for backwards compatibility).
+              # Note: it would be more correct to score each composite scope and use the maximum possibility.
+              field_cost = composite_scopes.last.own_complexity(child_complexity)
+              field_complexity(composite_scopes.last, max_complexity: field_cost, child_complexity: child_complexity)
+            end
 
-            complexity_for_keys[child_key] = max_complexity
+            total + field_cost
           end
-
-          # Calculate the child complexity by summing the complexity of all selections
-          complexity_for_keys.each_value.inject(0, &:+)
         end
       end
     end

data/lib/graphql/dataloader/source.rb

@@ -169,7 +169,7 @@ module GraphQL
         nil
       end
 
-      attr_reader :pending
+      attr_reader :pending, :results
 
       private
 

data/lib/graphql/dataloader.rb

@@ -119,12 +119,7 @@ module GraphQL
     #
     # @return [void]
     def yield
-      if use_fiber_resume?
-        Fiber.yield
-      else
-        parent_fiber = Thread.current[:parent_fiber]
-        parent_fiber.transfer
-      end
+      Fiber.yield
       nil
     end
 
@@ -169,7 +164,11 @@ module GraphQL
     ensure
       @pending_jobs = prev_queue
       prev_pending_keys.each do |source_instance, pending|
-        source_instance.pending.merge!(pending)
+        pending.each do |key, value|
+          if !source_instance.results.key?(key)
+            source_instance.pending[key] = value
+          end
+        end
       end
     end
 
@@ -183,7 +182,7 @@ module GraphQL
         while first_pass || job_fibers.any?
           first_pass = false
 
-          while (f = job_fibers.shift || spawn_job_fiber)
+          while (f = (job_fibers.shift || spawn_job_fiber))
             if f.alive?
               finished = run_fiber(f)
               if !finished
@@ -204,38 +203,37 @@ module GraphQL
             end
             join_queues(source_fibers, next_source_fibers)
           end
-
         end
       end
 
       run_fiber(manager)
 
+      if manager.alive?
+        raise "Invariant: Manager fiber didn't terminate properly."
+      end
+
+      if job_fibers.any?
+        raise "Invariant: job fibers should have exited but #{job_fibers.size} remained"
+      end
+      if source_fibers.any?
+        raise "Invariant: source fibers should have exited but #{source_fibers.size} remained"
+      end
     rescue UncaughtThrowError => e
       throw e.tag, e.value
     end
 
     def run_fiber(f)
-      if use_fiber_resume?
-        f.resume
-      else
-        f.transfer
-      end
+      f.resume
     end
 
     def spawn_fiber
       fiber_vars = get_fiber_variables
-      parent_fiber = use_fiber_resume? ? nil : Fiber.current
       Fiber.new(blocking: !@nonblocking) {
         set_fiber_variables(fiber_vars)
-        Thread.current[:parent_fiber] = parent_fiber
         yield
         # With `.transfer`, you have to explicitly pass back to the parent --
         # if the fiber is allowed to terminate normally, control is passed to the main fiber instead.
-        if parent_fiber
-          parent_fiber.transfer(true)
-        else
-          true
-        end
+        true
       }
     end
 
@@ -247,15 +245,6 @@ module GraphQL
       new_queue.clear
     end
 
-    def use_fiber_resume?
-      Fiber.respond_to?(:scheduler) &&
-        (
-          (defined?(::DummyScheduler) && Fiber.scheduler.is_a?(::DummyScheduler)) ||
-          (defined?(::Evt) && ::Evt::Scheduler.singleton_class::BACKENDS.any? { |be| Fiber.scheduler.is_a?(be) }) ||
-          (defined?(::Libev) && Fiber.scheduler.is_a?(::Libev::Scheduler))
-        )
-    end
-
     def spawn_job_fiber
       if @pending_jobs.any?
         spawn_fiber do

data/lib/graphql/language/parser.rb

@@ -62,11 +62,13 @@ module GraphQL
 
       def document
         any_tokens = advance_token
-        if !any_tokens
+        defns = []
+        if any_tokens
+          defns << definition
+        else
           # Only ignored characters is not a valid document
           raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @graphql_str)
         end
-        defns = []
         while !@lexer.eos?
           defns << definition
         end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.2.2
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-20 00:00:00.000000000 Z
+date: 2023-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: racc