graphql 2.5.4 → 2.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fcafc24832a376132e4f15c981133f693685ad070918284587f775d05dd44d7
-  data.tar.gz: 41bba1c56371a6d4ad643f75cece09cc13474dcf02b24dce0b31a1c8c89ee480
+  metadata.gz: 5c2ef756861a779063236ee9f8745d30ae3494138674239c8f638556d7f5105e
+  data.tar.gz: 23592e61f76acb0be2a4c60d953a829e8f1d46534633513ac44797a5d3386d2a
 SHA512:
-  metadata.gz: 308136d27234edd6c84310f1e18d5a5841cdbcbf7ca8fe56eb9dd070fa52c10ad6d4d46022b51d22fe4adbcae9f7428ea6a6d7b756eef5d2be1f1337393a3f3b
-  data.tar.gz: a0a3027d2f155daa8e52156765f6f6dcd53b35057ba010cc9e0ece130c283e2a5292c020eee81882074b6e7524c0085670dba9d47337619279915df18e097655
+  metadata.gz: 5c8db1d976343d569aa1fec1cee02de2c72947e0937fcd9917f8f6e078204efd373d244954e9e03b8dc7fd20066dcf7533bf4b52c706dba0f5640b60ae0465f0
+  data.tar.gz: 38422c543b159cc7243ac4dcc9139ed95b2583cab7942c60e4c557b89d6a4ffaa8fb1df94286fa3fbe4b918f5c116364d5fbe5c2afa611ba9d46d7ac56c18e61

data/lib/graphql/analysis/query_complexity.rb

@@ -28,14 +28,14 @@ module GraphQL
           end
         when nil
           subject.logger.warn <<~GRAPHQL
-            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-docs/#{GraphQL::VERSION}/Schema.html#complexity_cost_cacluation_mode-class_method
+            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
-          max_possible_complexity
+          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}"
         end

data/lib/graphql/dataloader/active_record_association_source.rb

@@ -31,7 +31,12 @@ module GraphQL
       def fetch(records)
         record_classes = Set.new.compare_by_identity
         associated_classes = Set.new.compare_by_identity
+        scoped_fetch = !@scope.nil?
         records.each do |record|
+          if scoped_fetch
+            assoc = record.association(@association)
+            assoc.reset
+          end
           if record_classes.add?(record.class)
             reflection = record.class.reflect_on_association(@association)
             if !reflection.polymorphic? && reflection.klass
@@ -48,9 +53,16 @@ module GraphQL
 
         ::ActiveRecord::Associations::Preloader.new(records: records, associations: @association, available_records: available_records, scope: @scope).call
 
-        loaded_associated_records = records.map { |r| r.public_send(@association) }
+        loaded_associated_records = records.map { |r|
+          assoc = r.association(@association)
+          lar = assoc.target
+          if scoped_fetch
+            assoc.reset
+          end
+          lar
+        }
 
-        if @scope.nil?
+        if !scoped_fetch
           # Don't cache records loaded via scope because they might have reduced `SELECT`s
           # Could check .select_values here?
           records_by_model = {}

data/lib/graphql/dataloader/null_dataloader.rb

@@ -9,8 +9,11 @@ module GraphQL
     class NullDataloader < Dataloader
       # These are all no-ops because code was
       # executed synchronously.
+
+      def initialize(*); end
       def run; end
       def run_isolated; yield; end
+      def clear_cache; end
       def yield(_source)
         raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
       end
@@ -19,6 +22,10 @@ module GraphQL
         yield
         nil
       end
+
+      def with(*)
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
     end
   end
 end

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

@@ -23,9 +23,9 @@ module GraphQL
           if smallest_depth
             lazies = lazies_at_depth.delete(smallest_depth)
             if !lazies.empty?
-              dataloader.append_job {
-                lazies.each(&:value) # resolve these Lazy instances
-              }
+              lazies.each do |l|
+                dataloader.append_job { l.value }
+              end
               # Run lazies _and_ dataloader, see if more are enqueued
               dataloader.run
               resolve_each_depth(lazies_at_depth, dataloader)

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

@@ -21,15 +21,25 @@ module GraphQL
             @graphql_metadata = nil
             @graphql_selections = selections
             @graphql_is_eager = is_eager
+            @base_path = nil
           end
 
+          # TODO test full path in Partial
+          attr_writer :base_path
+
           def path
             @path ||= build_path([])
           end
 
           def build_path(path_array)
             graphql_result_name && path_array.unshift(graphql_result_name)
-            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
+            if @graphql_parent
+              @graphql_parent.build_path(path_array)
+            elsif @base_path
+              @base_path + path_array
+            else
+              path_array
+            end
           end
 
           attr_accessor :graphql_dead

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

@@ -57,53 +57,142 @@ module GraphQL
         end
 
         def final_result
-          @response && @response.graphql_result_data
+          @response.respond_to?(:graphql_result_data) ? @response.graphql_result_data : @response
         end
 
         def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
-        # This _begins_ the execution. Some deferred work
-        # might be stored up in lazies.
         # @return [void]
         def run_eager
-          root_operation = query.selected_operation
-          root_op_type = root_operation.operation_type || "query"
-          root_type = schema.root_type_for_operation(root_op_type)
-          runtime_object = root_type.wrap(query.root_value, context)
-          runtime_object = schema.sync_lazy(runtime_object)
-          is_eager = root_op_type == "mutation"
-          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager, root_operation, nil, nil)
-          st = get_current_runtime_state
-          st.current_result = @response
-
-          if runtime_object.nil?
-            # Root .authorized? returned false.
-            @response = nil
+          root_type = query.root_type
+          case query
+          when GraphQL::Query
+            ast_node = query.selected_operation
+            selections = ast_node.selections
+            object = query.root_value
+            is_eager = ast_node.operation_type == "mutation"
+            base_path = nil
+          when GraphQL::Query::Partial
+            ast_node = query.ast_nodes.first
+            selections = query.ast_nodes.map(&:selections).inject(&:+)
+            object = query.object
+            is_eager = false
+            base_path = query.path
           else
-            call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
-              each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
-                @response.ordered_result_keys ||= ordered_result_keys
-                if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager, root_operation, nil, nil)
-                  selection_response.ordered_result_keys = ordered_result_keys
-                  final_response = @response
-                else
-                  selection_response = @response
-                  final_response = nil
-                end
+            raise ArgumentError, "Unexpected Runnable, can't execute: #{query.class} (#{query.inspect})"
+          end
+          object = schema.sync_lazy(object) # TODO test query partial with lazy root object
+          runtime_state = get_current_runtime_state
+          case root_type.kind.name
+          when "OBJECT"
+            object_proxy = root_type.wrap(object, context)
+            object_proxy = schema.sync_lazy(object_proxy)
+            if object_proxy.nil?
+              @response = nil
+            else
+              @response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
+              @response.base_path = base_path
+              runtime_state.current_result = @response
+              call_method_on_directives(:resolve, object, ast_node.directives) do
+                each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
+                  @response.ordered_result_keys ||= ordered_result_keys
+                  if is_selection_array
+                    selection_response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
+                    selection_response.ordered_result_keys = ordered_result_keys
+                    final_response = @response
+                  else
+                    selection_response = @response
+                    final_response = nil
+                  end
 
-                @dataloader.append_job {
-                  evaluate_selections(
-                    selections,
-                    selection_response,
-                    final_response,
-                    nil,
+                  @dataloader.append_job {
+                    evaluate_selections(
+                      selections,
+                      selection_response,
+                      final_response,
+                      nil,
+                    )
+                  }
+                end
+              end
+            end
+          when "LIST"
+            inner_type = root_type.unwrap
+            case inner_type.kind.name
+            when "SCALAR", "ENUM"
+              result_name = ast_node.alias || ast_node.name
+              field_defn = query.field_definition
+              owner_type = field_defn.owner
+              selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+              selection_result.base_path = base_path
+              selection_result.ordered_result_keys = [result_name]
+              runtime_state = get_current_runtime_state
+              runtime_state.current_result = selection_result
+              runtime_state.current_result_name = result_name
+              continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
+              if HALT != continue_value
+                continue_field(continue_value, owner_type, field_defn, root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+              end
+              @response = selection_result[result_name]
+            else
+              @response = GraphQLResultArray.new(nil, root_type, nil, nil, false, selections, false, ast_node, nil, nil)
+              @response.base_path = base_path
+              idx = nil
+              object.each do |inner_value|
+                idx ||= 0
+                this_idx = idx
+                idx += 1
+                @dataloader.append_job do
+                  runtime_state.current_result_name = this_idx
+                  runtime_state.current_result = @response
+                  continue_field(
+                    inner_value, root_type, nil, inner_type, nil, @response.graphql_selections, false, object_proxy,
+                    nil, this_idx, @response, false, runtime_state
                   )
-                }
+                end
               end
             end
+          when "SCALAR", "ENUM"
+            result_name = ast_node.alias || ast_node.name
+            field_defn = query.field_definition
+            owner_type = field_defn.owner
+            selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+            selection_result.ordered_result_keys = [result_name]
+            selection_result.base_path = base_path
+            runtime_state = get_current_runtime_state
+            runtime_state.current_result = selection_result
+            runtime_state.current_result_name = result_name
+            continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
+            if HALT != continue_value
+              continue_field(continue_value, owner_type, field_defn, query.root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+            end
+            @response = selection_result[result_name]
+          when "UNION", "INTERFACE"
+            resolved_type, _resolved_obj = resolve_type(root_type, object)
+            resolved_type = schema.sync_lazy(resolved_type)
+            object_proxy = resolved_type.wrap(object, context)
+            object_proxy = schema.sync_lazy(object_proxy)
+            @response = GraphQLResultHash.new(nil, resolved_type, object_proxy, nil, false, selections, false, query.ast_nodes.first, nil, nil)
+            @response.base_path = base_path
+            each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
+              @response.ordered_result_keys ||= ordered_result_keys
+              if is_selection_array == true
+                raise "This isn't supported yet"
+              end
+
+              @dataloader.append_job {
+                evaluate_selections(
+                  selections,
+                  @response,
+                  nil,
+                  runtime_state,
+                )
+              }
+            end
+          else
+            raise "Invariant: unsupported type kind for partial execution: #{root_type.kind.inspect} (#{root_type})"
           end
           nil
         end
@@ -209,8 +298,6 @@ module GraphQL
           end
 
           call_method_on_directives(:resolve, selections_result.graphql_application_value, directives) do
-            finished_jobs = 0
-            enqueued_jobs = gathered_selections.size
             gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
               # Field resolution may pause the fiber,
               # so it wouldn't get to the `Resolve` call that happens below.
@@ -221,12 +308,6 @@ module GraphQL
                   evaluate_selection(
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
-                  finished_jobs += 1
-                  if finished_jobs == enqueued_jobs
-                    if target_result
-                      selections_result.merge_into(target_result)
-                    end
-                  end
                   @dataloader.clear_cache
                 }
               else
@@ -234,15 +315,12 @@ module GraphQL
                   evaluate_selection(
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
-                  finished_jobs += 1
-                  if finished_jobs == enqueued_jobs
-                    if target_result
-                      selections_result.merge_into(target_result)
-                    end
-                  end
                 }
               end
             end
+            if target_result
+              selections_result.merge_into(target_result)
+            end
             selections_result
           end
         end
@@ -468,7 +546,7 @@ module GraphQL
           path
         end
 
-        HALT = Object.new
+        HALT = Object.new.freeze
         def continue_value(value, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
           when nil
@@ -586,6 +664,8 @@ module GraphQL
           when "SCALAR", "ENUM"
             r = begin
               current_type.coerce_result(value, context)
+            rescue GraphQL::ExecutionError => ex_err
+              return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
             rescue StandardError => err
               query.handle_or_reraise(err)
             end
@@ -737,6 +817,13 @@ module GraphQL
           else
             dir_defn = @schema_directives.fetch(dir_node.name)
             raw_dir_args = arguments(nil, dir_defn, dir_node)
+            if !raw_dir_args.is_a?(GraphQL::ExecutionError)
+              begin
+                dir_defn.validate!(raw_dir_args, context)
+              rescue GraphQL::ExecutionError => err
+                raw_dir_args = err
+              end
+            end
             dir_args = continue_value(
               raw_dir_args, # value
               nil, # field

data/lib/graphql/execution/interpreter.rb

@@ -26,7 +26,7 @@ module GraphQL
             query = case opts
             when Hash
               schema.query_class.new(schema, nil, **opts)
-            when GraphQL::Query
+            when GraphQL::Query, GraphQL::Query::Partial
               opts
             else
               raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"

data/lib/graphql/language/lexer.rb

@@ -20,6 +20,11 @@ module GraphQL
         @finished
       end
 
+      def freeze
+        @scanner = nil
+        super
+      end
+
       attr_reader :pos, :tokens_count
 
       def advance
@@ -242,7 +247,7 @@ module GraphQL
         :SCALAR,
         nil,
         :FRAGMENT
-      ]
+      ].freeze
 
       # This produces a unique integer for bytes 2 and 3 of each keyword string
       # See https://tenderlovemaking.com/2023/09/02/fast-tokenizers-with-stringscanner.html
@@ -271,7 +276,8 @@ module GraphQL
       PUNCTUATION_NAME_FOR_BYTE = Punctuation.constants.each_with_object([]) { |name, arr|
         punct = Punctuation.const_get(name)
         arr[punct.ord] = name
-      }
+      }.freeze
+
 
       QUOTE =         '"'
       UNICODE_DIGIT = /[0-9A-Za-z]/
@@ -321,6 +327,7 @@ module GraphQL
         punct = Punctuation.const_get(punct_name)
         FIRST_BYTES[punct.ord] = ByteFor::PUNCTUATION
       end
+      FIRST_BYTES.freeze
 
 
       # Replace any escaped unicode or whitespace with the _actual_ characters

data/lib/graphql/language/nodes.rb

@@ -83,7 +83,11 @@ module GraphQL
 
         def to_query_string(printer: GraphQL::Language::Printer.new)
           if printer.is_a?(GraphQL::Language::Printer)
-            @query_string ||= printer.print(self)
+            if frozen?
+              @query_string || printer.print(self)
+            else
+              @query_string ||= printer.print(self)
+            end
           else
             printer.print(self)
           end

data/lib/graphql/language/parser.rb

@@ -2,6 +2,7 @@
 
 require "strscan"
 require "graphql/language/nodes"
+require "graphql/tracing/null_trace"
 
 module GraphQL
   module Language

data/lib/graphql/query/context.rb

@@ -84,7 +84,7 @@ module GraphQL
 
       attr_writer :types
 
-      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path]).freeze
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 

data/lib/graphql/query/partial.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This class is _like_ a {GraphQL::Query}, except it can run on an arbitrary path within a query string.
+    #
+    # It depends on a "parent" {Query}.
+    #
+    # During execution, it calls query-related tracing hooks but passes itself as `query:`.
+    #
+    # The {Partial} will use your {Schema.resolve_type} hook to find the right GraphQL type to use for
+    # `object` in some cases.
+    #
+    # @see Query#run_partials Run via {Query#run_partials}
+    class Partial
+      include Query::Runnable
+
+      # @param path [Array<String, Integer>] A path in `query.query_string` to start executing from
+      # @param object [Object] A starting object for execution
+      # @param query [GraphQL::Query] A full query instance that this partial is based on. Caches are shared.
+      # @param context [Hash] Extra context values to merge into `query.context`, if provided
+      # @param fragment_node [GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::FragmentDefinition]
+      def initialize(path: nil, object:, query:, context: nil, fragment_node: nil, type: nil)
+        @path = path
+        @object = object
+        @query = query
+        @schema = query.schema
+        context_vals = @query.context.to_h
+        if context
+          context_vals = context_vals.merge(context)
+        end
+        @context = GraphQL::Query::Context.new(query: self, schema: @query.schema, values: context_vals)
+        @multiplex = nil
+        @result_values = nil
+        @result = nil
+
+        if fragment_node
+          @ast_nodes = [fragment_node]
+          @root_type = type || raise(ArgumentError, "Pass `type:` when using `node:`")
+          # This is only used when `@leaf`
+          @field_definition = nil
+        elsif path.nil?
+          raise ArgumentError, "`path:` is required if `node:` is not given; add `path:`"
+        else
+          set_type_info_from_path
+        end
+
+        @leaf = @root_type.unwrap.kind.leaf?
+      end
+
+      def leaf?
+        @leaf
+      end
+
+      attr_reader :context, :query, :ast_nodes, :root_type, :object, :field_definition, :path, :schema
+
+      attr_accessor :multiplex, :result_values
+
+      class Result < GraphQL::Query::Result
+        def path
+          @query.path
+        end
+
+        # @return [GraphQL::Query::Partial]
+        def partial
+          @query
+        end
+      end
+
+      def result
+        @result ||= Result.new(query: self, values: result_values)
+      end
+
+      def current_trace
+        @query.current_trace
+      end
+
+      def types
+        @query.types
+      end
+
+      def resolve_type(...)
+        @query.resolve_type(...)
+      end
+
+      def variables
+        @query.variables
+      end
+
+      def fragments
+        @query.fragments
+      end
+
+      def valid?
+        @query.valid?
+      end
+
+      def analyzers
+        EmptyObjects::EMPTY_ARRAY
+      end
+
+      def analysis_errors=(_ignored)
+        # pass
+      end
+
+      def subscription?
+        @query.subscription?
+      end
+
+      def selected_operation
+        ast_nodes.first
+      end
+
+      def static_errors
+        @query.static_errors
+      end
+
+      def selected_operation_name
+        @query.selected_operation_name
+      end
+
+      private
+
+      def set_type_info_from_path
+        selections = [@query.selected_operation]
+        type = @query.root_type
+        parent_type = nil
+        field_defn = nil
+
+        @path.each do |name_in_doc|
+          if name_in_doc.is_a?(Integer)
+            if type.list?
+              type = type.unwrap
+              next
+            else
+              raise ArgumentError, "Received path with index `#{name_in_doc}`, but type wasn't a list. Type: #{type.to_type_signature}, path: #{@path}"
+            end
+          end
+
+          next_selections = []
+          selections.each do |selection|
+            selections_to_check = []
+            selections_to_check.concat(selection.selections)
+            while (sel = selections_to_check.shift)
+              case sel
+              when GraphQL::Language::Nodes::InlineFragment
+                selections_to_check.concat(sel.selections)
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment = @query.fragments[sel.name]
+                selections_to_check.concat(fragment.selections)
+              when GraphQL::Language::Nodes::Field
+                if sel.alias == name_in_doc || sel.name == name_in_doc
+                  next_selections << sel
+                end
+              else
+                raise "Unexpected selection in partial path: #{sel.class}, #{sel.inspect}"
+              end
+            end
+          end
+
+          if next_selections.empty?
+            raise ArgumentError, "Path `#{@path.inspect}` is not present in this query. `#{name_in_doc.inspect}` was not found. Try a different path or rewrite the query to include it."
+          end
+          field_name = next_selections.first.name
+          field_defn = @schema.get_field(type, field_name, @query.context) || raise("Invariant: no field called #{field_name} on #{type.graphql_name}")
+          parent_type = type
+          type = field_defn.type
+          if type.non_null?
+            type = type.of_type
+          end
+          selections = next_selections
+        end
+
+        @ast_nodes = selections
+        @root_type = type
+        @field_definition = field_defn
+      end
+    end
+  end
+end