graphql 2.5.23 → 2.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 724e526bb33dee5a8b39cb04b4d42f2e969e45aafe73581c5bdd02177cfa1347
-  data.tar.gz: f211ca87d49c5077b0ae4744ce5956795835a6405a07e8782970cde14d172d7e
+  metadata.gz: 16abc9c2a5eda0da251dbe7e14433241bc7d038d2527926832ceb29336fb857a
+  data.tar.gz: c89bd2a4b340ca30bfa7b823f51e4671972355d54bd56fdaed598c13a415c3b3
 SHA512:
-  metadata.gz: 5d9c249f5d7bbe3ef06070cf52b04586eedf2df06f7c1fc95c6ab47bdc8182218fff2281d76a3f2a18bef4f1ad9c508901e6c7a3f882d28390afdd2f4dca6fd0
-  data.tar.gz: 5179a34bc5c34769021fab1dff6384c22f73f776dc994a82f9bce635ddf6ead05ec0a3d2ff37bfcedbc892d87d2d7a82b08eab4e4cf319ee390e2c5a34db76fa
+  metadata.gz: 6452d2a517c502b4a8934582d060885a5f6462de244a1f331433f1076dc57a879cdd081e147f70925064a99607e0794fcf6eadad7a3f4a9111a5ab979c552554
+  data.tar.gz: b6a0219606d905fc885ab2192596d1acb1d92bce407defc751bfafb1a7199e9c32275c1d3202f3246251e72b80554698b1f54920f76178f1ddc81b41d628bacd

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
@@ -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/analysis.rb

@@ -40,13 +40,13 @@ module GraphQL
           end
         end
 
-        multiplex_results = multiplex_analyzers.map(&:result)
-        multiplex_errors = analysis_errors(multiplex_results)
 
+        multiplex_analyzers.map!(&:result)
+        multiplex_errors = analysis_errors(EmptyObjects::EMPTY_ARRAY, multiplex_analyzers)
         multiplex.queries.each_with_index do |query, idx|
-          query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+          query.analysis_errors = analysis_errors(multiplex_errors, query_results[idx])
         end
-        multiplex_results
+        multiplex_analyzers
       end
     end
 
@@ -55,13 +55,11 @@ module GraphQL
     # @return [Array<Any>] Results from those analyzers
     def analyze_query(query, analyzers, multiplex_analyzers: [])
       query.current_trace.analyze_query(query: query) do
-        query_analyzers = analyzers
-          .map { |analyzer| analyzer.new(query) }
-          .tap { _1.select!(&:analyze?) }
-
+        query_analyzers = analyzers.map { |analyzer| analyzer.new(query) }
+        query_analyzers.select!(&:analyze?)
         analyzers_to_run = query_analyzers + multiplex_analyzers
-        if !analyzers_to_run.empty?
 
+        if !analyzers_to_run.empty?
           analyzers_to_run.select!(&:visit?)
           if !analyzers_to_run.empty?
             visitor = GraphQL::Analysis::Visitor.new(
@@ -79,18 +77,27 @@ module GraphQL
 
           query_analyzers.map(&:result)
         else
-          []
+          EmptyObjects::EMPTY_ARRAY
         end
       end
     rescue TimeoutError => err
       [err]
     rescue GraphQL::UnauthorizedError, GraphQL::ExecutionError
       # This error was raised during analysis and will be returned the client before execution
-      []
+      EmptyObjects::EMPTY_ARRAY
     end
 
-    def analysis_errors(results)
-      results.flatten.tap { _1.select! { |r| r.is_a?(GraphQL::AnalysisError) } }
+    def analysis_errors(parent_errors, results)
+      if !results.empty?
+        results = results.flatten
+        results.select! { |r| r.is_a?(GraphQL::AnalysisError) }
+      end
+
+      if parent_errors.empty?
+        results
+      else
+        parent_errors + results
+      end
     end
   end
 end

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

@@ -108,7 +108,7 @@ 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}.
-    if RUBY_VERSION < "3" || RUBY_ENGINE != "ruby" # truffle-ruby wasn't doing well with the implementation below
+    if (RUBY_ENGINE == "ruby" && RUBY_ENGINE < "3") || RUBY_ENGINE == "truffleruby" # 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

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