graphql 2.4.13 → 2.5.11

data/lib/graphql/dataloader/active_record_association_source.rb

@@ -12,6 +12,14 @@ module GraphQL
         @scope = scope
       end
 
+      def self.batch_key_for(association, scope = nil)
+        if scope
+          [association, scope.to_sql]
+        else
+          [association]
+        end
+      end
+
       def load(record)
         if (assoc = record.association(@association)).loaded?
           assoc.target
@@ -23,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
@@ -40,18 +53,25 @@ 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) }
-        records_by_model = {}
-        loaded_associated_records.each do |record|
-          if record
-            updates = records_by_model[record.class] ||= {}
-            updates[record.id] = record
+        loaded_associated_records = records.map { |r|
+          assoc = r.association(@association)
+          lar = assoc.target
+          if scoped_fetch
+            assoc.reset
           end
-        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 = {}
+          loaded_associated_records.flatten.each do |record|
+            if record
+              updates = records_by_model[record.class] ||= {}
+              updates[record.id] = record
+            end
+          end
           records_by_model.each do |model_class, updates|
             dataloader.with(RECORD_SOURCE_CLASS, model_class).merge(updates)
           end

data/lib/graphql/dataloader/active_record_source.rb

@@ -7,18 +7,39 @@ module GraphQL
       def initialize(model_class, find_by: model_class.primary_key)
         @model_class = model_class
         @find_by = find_by
-        @type_for_column = @model_class.type_for_attribute(@find_by)
+        @find_by_many = find_by.is_a?(Array)
+        if @find_by_many
+          @type_for_column = @find_by.map { |fb| @model_class.type_for_attribute(fb) }
+        else
+          @type_for_column = @model_class.type_for_attribute(@find_by)
+        end
       end
 
-      def load(requested_key)
-        casted_key = @type_for_column.cast(requested_key)
-        super(casted_key)
+      def result_key_for(requested_key)
+        normalize_fetch_key(requested_key)
+      end
+
+      def normalize_fetch_key(requested_key)
+        if @find_by_many
+          requested_key.each_with_index.map do |k, idx|
+            @type_for_column[idx].cast(k)
+          end
+        else
+          @type_for_column.cast(requested_key)
+        end
       end
 
       def fetch(record_ids)
         records = @model_class.where(@find_by => record_ids)
         record_lookup = {}
-        records.each { |r| record_lookup[r.public_send(@find_by)] = r }
+        if @find_by_many
+          records.each do |r|
+            key = @find_by.map { |fb| r.public_send(fb) }
+            record_lookup[key] = r
+          end
+        else
+          records.each { |r| record_lookup[r.public_send(@find_by)] = r }
+        end
         record_ids.map { |id| record_lookup[id] }
       end
     end

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/dataloader/source.rb

@@ -21,7 +21,7 @@ module GraphQL
       def request(value)
         res_key = result_key_for(value)
         if !@results.key?(res_key)
-          @pending[res_key] ||= value
+          @pending[res_key] ||= normalize_fetch_key(value)
         end
         Dataloader::Request.new(self, value)
       end
@@ -35,12 +35,24 @@ module GraphQL
         value
       end
 
+      # Implement this method if varying values given to {load} (etc) should be consolidated
+      # or normalized before being handed off to your {fetch} implementation.
+      #
+      # This is different than {result_key_for} because _that_ method handles unification inside Dataloader's cache,
+      # but this method changes the value passed into {fetch}.
+      #
+      # @param value [Object] The value passed to {load}, {load_all}, {request}, or {request_all}
+      # @return [Object] The value given to {fetch}
+      def normalize_fetch_key(value)
+        value
+      end
+
       # @return [Dataloader::Request] a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
       def request_all(values)
         values.each do |v|
           res_key = result_key_for(v)
           if !@results.key?(res_key)
-            @pending[res_key] ||= v
+            @pending[res_key] ||= normalize_fetch_key(v)
           end
         end
         Dataloader::RequestAll.new(self, values)
@@ -53,7 +65,7 @@ module GraphQL
         if @results.key?(result_key)
           result_for(result_key)
         else
-          @pending[result_key] ||= value
+          @pending[result_key] ||= normalize_fetch_key(value)
           sync([result_key])
           result_for(result_key)
         end
@@ -68,7 +80,7 @@ module GraphQL
           k = result_key_for(v)
           result_keys << k
           if !@results.key?(k)
-            @pending[k] ||= v
+            @pending[k] ||= normalize_fetch_key(v)
             pending_keys << k
           end
         }

data/lib/graphql/dig.rb

@@ -5,7 +5,8 @@ module GraphQL
     # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
-    # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
+    # @param own_key [String, Symbol] A key to retrieve
+    # @param rest_keys [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
     # @return [Object]
     def dig(own_key, *rest_keys)
       val = self[own_key]

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
@@ -44,8 +54,11 @@ module GraphQL
           def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = {}
+            @ordered_result_keys = nil
           end
 
+          attr_accessor :ordered_result_keys
+
           include GraphQLResult
 
           attr_accessor :graphql_merged_into
@@ -63,7 +76,13 @@ module GraphQL
               t.set_leaf(key, value)
             end
 
+            before_size = @graphql_result_data.size
             @graphql_result_data[key] = value
+            after_size = @graphql_result_data.size
+            if after_size > before_size && @ordered_result_keys[before_size] != key
+              fix_result_order
+            end
+
             # keep this up-to-date if it's been initialized
             @graphql_metadata && @graphql_metadata[key] = value
 
@@ -74,7 +93,13 @@ module GraphQL
             if (t = @graphql_merged_into)
               t.set_child_result(key, value)
             end
+            before_size = @graphql_result_data.size
             @graphql_result_data[key] = value.graphql_result_data
+            after_size = @graphql_result_data.size
+            if after_size > before_size && @ordered_result_keys[before_size] != key
+              fix_result_order
+            end
+
             # If we encounter some part of this response that requires metadata tracking,
             # then create the metadata hash if necessary. It will be kept up-to-date after this.
             (@graphql_metadata ||= @graphql_result_data.dup)[key] = value
@@ -124,6 +149,14 @@ module GraphQL
             end
             @graphql_merged_into = into_result
           end
+
+          def fix_result_order
+            @ordered_result_keys.each do |k|
+              if @graphql_result_data.key?(k)
+                @graphql_result_data[k] = @graphql_result_data.delete(k)
+              end
+            end
+          end
         end
 
         class GraphQLResultArray

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

@@ -57,67 +57,160 @@ 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|
-                if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager, root_operation, nil, nil)
-                  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
 
         def each_gathered_selections(response_hash)
-          gathered_selections = gather_selections(response_hash.graphql_application_value, response_hash.graphql_result_type, response_hash.graphql_selections)
+          ordered_result_keys = []
+          gathered_selections = gather_selections(response_hash.graphql_application_value, response_hash.graphql_result_type, response_hash.graphql_selections, nil, {}, ordered_result_keys)
+          ordered_result_keys.uniq!
           if gathered_selections.is_a?(Array)
             gathered_selections.each do |item|
-              yield(item, true)
+              yield(item, true, ordered_result_keys)
             end
           else
-            yield(gathered_selections, false)
+            yield(gathered_selections, false, ordered_result_keys)
           end
         end
 
-        def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = {})
+        def gather_selections(owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
           selections.each do |node|
             # Skip gathering this if the directive says so
             if !directives_include?(node, owner_object, owner_type)
@@ -126,6 +219,7 @@ module GraphQL
 
             if node.is_a?(GraphQL::Language::Nodes::Field)
               response_key = node.alias || node.name
+              ordered_result_keys << response_key
               selections = selections_by_name[response_key]
               # if there was already a selection of this field,
               # use an array to hold all selections,
@@ -162,14 +256,14 @@ module GraphQL
                   type_defn = query.types.type(node.type.name)
 
                   if query.types.possible_types(type_defn).include?(owner_type)
-                    result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                    result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
                     if !result.equal?(next_selections)
                       selections_to_run = result
                     end
                   end
                 else
                   # it's an untyped fragment, definitely continue
-                  result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                  result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end
@@ -178,7 +272,7 @@ module GraphQL
                 fragment_def = query.fragments[node.name]
                 type_defn = query.types.type(fragment_def.type.name)
                 if query.types.possible_types(type_defn).include?(owner_type)
-                  result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
+                  result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections, ordered_result_keys)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end
@@ -204,10 +298,7 @@ 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.
               # So instead trigger a run from this outer context.
@@ -217,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
@@ -230,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
@@ -464,16 +546,17 @@ 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
             if is_non_null
               set_result(selection_result, result_name, nil, false, is_non_null) do
                 # When this comes from a list item, use the parent object:
-                parent_type = selection_result.is_a?(GraphQLResultArray) ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
+                is_from_array = selection_result.is_a?(GraphQLResultArray)
+                parent_type = is_from_array ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
-                err = parent_type::InvalidNullError.new(parent_type, field, ast_node)
+                err = parent_type::InvalidNullError.new(parent_type, field, ast_node, is_from_array: is_from_array)
                 schema.type_error(err, context)
               end
             else
@@ -581,13 +664,25 @@ 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
             set_result(selection_result, result_name, r, false, is_non_null)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy = resolve_type(current_type, value)
+            resolved_type_or_lazy = begin
+                                      resolve_type(current_type, value)
+                                    rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+                                      return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+                                    rescue StandardError => err
+                                      begin
+                                        query.handle_or_reraise(err)
+                                      rescue GraphQL::ExecutionError => ex_err
+                                        return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+                                      end
+                                    end
             after_lazy(resolved_type_or_lazy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_type_result, runtime_state|
               if resolved_type_result.is_a?(Array) && resolved_type_result.length == 2
                 resolved_type, resolved_value = resolved_type_result
@@ -619,9 +714,11 @@ module GraphQL
               if HALT != continue_value
                 response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
-                each_gathered_selections(response_hash) do |selections, is_selection_array|
+                each_gathered_selections(response_hash) do |selections, is_selection_array, ordered_result_keys|
+                  response_hash.ordered_result_keys ||= ordered_result_keys
                   if is_selection_array
                     this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false, ast_node, arguments, field)
+                    this_result.ordered_result_keys = ordered_result_keys
                     final_result = response_hash
                   else
                     this_result = response_hash
@@ -720,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