graphql 2.0.31 → 2.6.1

data/lib/graphql/execution/finalize.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class Finalize
+      def initialize(query, data, runner)
+        @query = query
+        @data = data
+        @static_type_at = runner.static_type_at
+        @runner = runner
+        @current_exec_path = query.path.dup
+        @current_result_path = query.path.dup
+        @finalizers = runner.finalizers ? runner.finalizers[query] : {}.compare_by_identity
+        @finalizers_count = 0
+        @finalizers.each do |key, values|
+          values.each do |key2, values2|
+            case values2
+            when Array
+              @finalizers_count += values2.size
+            else
+              @finalizers_count += 1
+            end
+          end
+        end
+
+        query.context.errors.each do |err|
+          err_path = err.path - @current_exec_path
+          key = err_path.pop
+          targets = [data]
+          while (part = err_path.shift)
+            targets.map! { |t| t[part] }
+            targets.flatten!
+          end
+
+          targets.each_with_index do |target, idx|
+            if target.is_a?(Hash)
+              if target[key].equal?(err)
+                tf = @finalizers[target] ||= {}.compare_by_identity
+                tf[key] = err
+                @finalizers_count += 1
+              elsif (arr = target[key]).is_a?(Array)
+                arr.each_with_index do |el, idx|
+                  if el.equal?(err)
+                    tf = @finalizers[arr] ||= {}.compare_by_identity
+                    tf[idx] = err
+                    @finalizers_count += 1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def run
+        if (selected_operation = @query.selected_operation) && @data
+          if @data.is_a?(Hash)
+            check_object_result(@data, @query.root_type, selected_operation.selections)
+          elsif @data.is_a?(Array)
+            check_list_result(@data, @query.root_type, selected_operation.selections)
+          elsif @data.is_a?(Finalizer)
+            dummy_data = {}
+            dummy_key = "__dummy"
+            @data.path = @query.path
+            @data.finalize_graphql_result(@query, dummy_data, dummy_key)
+            dummy_data[dummy_key]
+          else
+            raise ArgumentError, "Unexpected @data: #{@data.inspect}"
+          end
+        else
+          @data
+        end
+      end
+
+      private
+
+      def run_finalizers(result_path, finalizer_or_finalizers, result_data, result_key)
+        if finalizer_or_finalizers.is_a?(Array)
+          finalizer_or_finalizers.each { |f|
+            f.path = result_path
+            f.finalize_graphql_result(@query, result_data, result_key)
+          }
+          @finalizers_count -= finalizer_or_finalizers.size
+        else
+          f = finalizer_or_finalizers
+          f.path = result_path
+          f.finalize_graphql_result(@query, result_data, result_key)
+          @finalizers_count -= 1
+        end
+      end
+
+      def finalizers(result_value, key)
+        finalizers_for_value = @finalizers[result_value]
+        finalizers_for_value && finalizers_for_value[key]
+      end
+
+      def check_object_result(result_h, parent_type, ast_selections)
+        if (f = finalizers(result_h, nil))
+          run_finalizers(@current_result_path.dup, f, result_h, nil)
+          return result_h if @finalizers_count == 0
+        end
+
+        if parent_type.kind.abstract?
+          parent_type = @runner.runtime_type_at[result_h]
+        end
+
+        ast_selections.each do |ast_selection|
+          case ast_selection
+          when Language::Nodes::Field
+            key = ast_selection.alias || ast_selection.name
+            if (f = finalizers(result_h, key))
+              result_value = result_h[key]
+              run_finalizers(@current_result_path.dup << key, f, result_h, key)
+              new_result_value = result_h.key?(key) ? result_h[key] : :unassigned
+            end
+            next if !(f || result_h.key?(key))
+            begin
+              @current_exec_path << key
+              @current_result_path << key
+
+              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{static_type.to_type_signature}.#{ast_selection.name}")
+              result_type = field_defn.type
+              if (result_type_non_null = result_type.non_null?)
+                result_type = result_type.of_type
+              end
+
+              if !f
+                result_value = result_h[key]
+                new_result_value = if result_type.list? && result_value
+                  check_list_result(result_value, result_type.of_type, ast_selection.selections)
+                elsif !result_type.kind.leaf? && result_value
+                  check_object_result(result_value, result_type, ast_selection.selections)
+                else
+                  result_value
+                end
+              end
+
+              if new_result_value.nil? && result_type_non_null
+                return nil
+              elsif :unassigned.equal?(new_result_value)
+                # Do nothing
+                break if @finalizers_count == 0
+              elsif !new_result_value.equal?(result_value)
+                result_h[key] = new_result_value
+                break if @finalizers_count == 0
+              end
+            ensure
+              @current_exec_path.pop
+              @current_result_path.pop
+            end
+          when Language::Nodes::InlineFragment
+            static_type_at_result = @static_type_at[result_h]
+            if static_type_at_result && (
+                (t = ast_selection.type).nil? ||
+                @runner.type_condition_applies?(@query.context, static_type_at_result, t.name)
+              )
+              result_h = check_object_result(result_h, parent_type, ast_selection.selections)
+            end
+          when Language::Nodes::FragmentSpread
+            fragment_defn = @query.document.definitions.find { |defn| defn.is_a?(Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
+            static_type_at_result = @static_type_at[result_h]
+            if static_type_at_result && @runner.type_condition_applies?(@query.context, static_type_at_result, fragment_defn.type.name)
+              result_h = check_object_result(result_h, parent_type, fragment_defn.selections)
+            end
+          end
+        end
+
+        result_h
+      end
+
+      def check_list_result(result_arr, inner_type, ast_selections)
+        inner_type_non_null = false
+        if inner_type.non_null?
+          inner_type_non_null = true
+          inner_type = inner_type.of_type
+        end
+
+        new_invalid_null = false
+
+        if (f = finalizers(result_arr, nil))
+          run_finalizers(@current_result_path.dup, f, result_arr, nil)
+          return result_arr if @finalizers_count == 0
+        end
+
+        result_arr.each_with_index do |result_item, idx|
+          @current_result_path << idx
+          new_result = if (f = finalizers(result_arr, idx))
+            run_finalizers(@current_result_path.dup, f, result_arr, idx)
+            result_arr[idx]
+          elsif inner_type.list? && result_item
+            check_list_result(result_item, inner_type.of_type, ast_selections)
+          elsif !inner_type.kind.leaf? && result_item
+            check_object_result(result_item, inner_type, ast_selections)
+          else
+            result_item
+          end
+
+          if new_result.nil? && inner_type_non_null
+            new_invalid_null = true
+            result_arr[idx] = nil
+            break if @finalizers_count == 0
+          elsif !new_result.equal?(result_item)
+            result_arr[idx] = new_result
+            break if @finalizers_count == 0
+          end
+        ensure
+          @current_result_path.pop
+        end
+
+        if new_invalid_null
+          nil
+        else
+          result_arr
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/input_values.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class InputValues
+      def initialize(query, runner)
+        @query = query
+        @runner = runner
+        @variable_values = nil
+      end
+
+      def variable_values
+        @variable_values ||= begin
+          variable_nodes = @query.selected_operation.variables
+          if variable_nodes.empty?
+            EmptyObjects::EMPTY_HASH
+          else
+            raw_values = @query.provided_variables
+            values = {}
+            variable_nodes.each do |var_node|
+              var_ast_value = if raw_values.key?(var_node.name)
+                raw_values[var_node.name]
+              elsif raw_values.key?(sym_name = var_node.name.to_sym)
+                raw_values[sym_name]
+              elsif !var_node.default_value.nil?
+                var_node.default_value
+              else
+                next
+              end
+
+              var_type = @runner.schema.type_from_ast(var_node.type, context: @query.context)
+              values[var_node.name] = variable_value(var_ast_value, var_type)
+            end
+            values
+          end
+        end
+      end
+
+      def argument_values(owner_defn, argument_nodes, field_resolve_step)
+        arg_defns = @query.types.arguments(owner_defn)
+        argument_values = {}
+
+        arg_defns.each do |argument_definition|
+          arg_ruby_key = argument_definition.keyword
+          arg_graphql_key = argument_definition.graphql_name
+          arg_node = argument_nodes.find { |a| a.name == arg_graphql_key }
+          if arg_node.nil? || (arg_node.value.is_a?(Language::Nodes::VariableIdentifier) && !variable_values.key?(arg_node.value.name))
+            if argument_definition.default_value?
+              arg_value = value_from_ast(argument_definition.default_value, argument_definition.type)
+              argument_value(argument_values, arg_ruby_key, argument_definition, arg_value, nil, field_resolve_step)
+            end
+          else
+            arg_value = value_from_ast(arg_node.value, argument_definition.type)
+            argument_value(argument_values, arg_ruby_key, argument_definition, arg_value, nil, field_resolve_step)
+          end
+        end
+
+        argument_values
+      rescue GraphQL::ExecutionError => exec_err
+        exec_err
+      end
+
+      private
+
+      def variable_value(value, type)
+        if type.non_null?
+          type = type.of_type
+        end
+
+        if value.is_a?(Language::Nodes::Enum)
+          value = value.name
+        end
+
+        if value.nil?
+          nil
+        elsif type.list?
+          inner_type = type.of_type
+          if value.is_a?(Array)
+            value.map { |v| variable_value(v, inner_type) }.freeze
+          else
+            [variable_value(value, inner_type)].freeze
+          end
+        elsif type.kind.input_object?
+          coerced_obj = {}
+
+          @query.types.arguments(type).each do |arg|
+            arg_key = arg.keyword
+            if value.key?(arg.graphql_name)
+              arg_value = value[arg.graphql_name]
+            elsif value.key?(sym_name = arg.graphql_name.to_sym)
+              arg_value = value[sym_name]
+            elsif arg.default_value?
+              coerced_obj[arg_key] = arg.default_value
+              next
+            else
+              next
+            end
+
+            coerced_obj[arg_key] = variable_value(arg_value, arg.type)
+          end
+
+          coerced_obj
+        elsif type.kind.leaf?
+          type.coerce_input(value, @query.context)
+        else
+          raise GraphQL::Error, "Unexpected input type: #{type.graphql_name}."
+        end
+      end
+
+      def argument_value(argument_values, argument_key, argument_definition, arg_value, override_type, field_resolve_step)
+        treat_as_type = override_type || argument_definition.type
+        if treat_as_type.non_null?
+          treat_as_type = treat_as_type.of_type
+        end
+
+        if treat_as_type.kind.list? && !arg_value.nil?
+          inner_t = treat_as_type.unwrap
+          arg_value = if arg_value.is_a?(Array)
+            values = Array.new(arg_value.size)
+            arg_value.each_with_index { |inner_v, idx| argument_value(values, idx, argument_definition, inner_v, inner_t, field_resolve_step)}
+            values
+          else
+            values = [nil]
+            argument_value(values, 0, argument_definition, arg_value, inner_t, field_resolve_step)
+            values
+          end
+        end
+
+        if arg_value && treat_as_type.kind.input_object?
+          arg_defns = @query.types.arguments(treat_as_type)
+          new_arg_value = {}
+          arg_defns.each do |inner_arg_defn|
+            inner_arg_key = inner_arg_defn.keyword
+            if arg_value.is_a?(Hash)
+              if arg_value.key?(inner_arg_key)
+                inner_arg_value = arg_value[inner_arg_key]
+                argument_value(new_arg_value, inner_arg_key, inner_arg_defn, inner_arg_value, nil, field_resolve_step)
+              end
+            else
+              inner_arg_name = inner_arg_defn.graphql_name
+              inner_arg_value = arg_value.arguments.find { |a| a.name == inner_arg_name } # rubocop:disable Development/ContextIsPassedCop
+              if inner_arg_value
+                argument_value(new_arg_value, inner_arg_key, inner_arg_defn, inner_arg_value, nil, field_resolve_step)
+              end
+            end
+          end
+          arg_value = treat_as_type.new(nil, ruby_kwargs: new_arg_value, context: @query.context, defaults_used: nil)
+        end
+
+        if override_type.nil? # only on root arguments, not list elements
+          arg_value = begin
+            argument_definition.prepare_value(nil, arg_value, context: @query.context)
+          rescue StandardError => err
+            @runner.schema.handle_or_reraise(@query.context, err)
+          end
+        end
+
+        if field_resolve_step && arg_value && override_type.nil? && argument_definition.loads
+          field_defn = field_resolve_step.field_definition
+          load_receiver = if (r = field_defn.resolver)
+            r.new(field: field_defn, context: @query.context, object: nil)
+          else
+            field_defn
+          end
+          ps = field_resolve_step.pending_steps ||= []
+
+          if argument_definition.type.list?
+            results = Array.new(arg_value.size, nil)
+            argument_values[argument_key] = results
+            arg_value.each_with_index do |inner_v, idx|
+              loads_step = LoadArgumentStep.new(
+                field_resolve_step: field_resolve_step,
+                load_receiver: load_receiver,
+                argument_value: inner_v,
+                argument_definition: argument_definition,
+                arguments: results,
+                argument_key: idx,
+              )
+              ps.push(loads_step)
+              @runner.add_step(loads_step)
+            end
+          else
+            loads_step = LoadArgumentStep.new(
+              field_resolve_step: field_resolve_step,
+              load_receiver: load_receiver,
+              argument_value: arg_value,
+              argument_definition: argument_definition,
+              arguments: argument_values,
+              argument_key: argument_key,
+            )
+            ps.push(loads_step)
+            @runner.add_step(loads_step)
+          end
+        else
+          argument_values[argument_key] = arg_value
+        end
+        nil
+      end
+
+      def value_from_ast(value_node, type)
+        if type.non_null?
+          type = type.of_type
+        end
+
+        if value_node.nil?
+          nil
+        elsif value_node.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          variable_values[value_node.name]
+        elsif value_node.is_a?(GraphQL::Language::Nodes::NullValue)
+          nil
+        elsif type.list?
+          inner_type = type.of_type
+          if value_node.is_a?(Array)
+            coerced_items = value_node.map do |inner_value_node|
+              value_from_ast(inner_value_node, inner_type)
+            end
+            coerced_items.freeze
+          else
+            item_value = value_from_ast(value_node, inner_type)
+            [item_value].freeze
+          end
+
+        elsif type.kind.input_object?
+          coerced_obj = {}
+          arg_nodes_by_name = value_node.arguments.each_with_object({}) do |arg_node, acc| # rubocop:disable Development/ContextIsPassedCop
+            acc[arg_node.name] = arg_node
+          end
+
+          @query.types.arguments(type).each do |arg|
+            arg_node = arg_nodes_by_name[arg.graphql_name]
+            arg_key = arg.keyword
+            if arg_node.nil? || (arg_node.value.is_a?(Language::Nodes::VariableIdentifier) && !variable_values.key?(arg_node.value.name))
+              if arg.default_value?
+                coerced_obj[arg_key] = arg.default_value
+              end
+              next
+            end
+
+            arg_value = value_from_ast(arg_node.value, arg.type)
+            coerced_obj[arg_key] = arg_value
+          end
+
+          coerced_obj
+        elsif type.kind.leaf?
+          if type.kind.enum?
+            if value_node.is_a?(GraphQL::Language::Nodes::Enum)
+              value_node = value_node.name
+            end
+          end
+
+          begin
+            type.coerce_input(value_node, @query.context)
+          rescue GraphQL::UnauthorizedEnumValueError => enum_err
+            @runner.schema.unauthorized_object(enum_err)
+          end
+        else
+          raise "Unexpected input type: #{type.to_type_signature}."
+        end
+      end
+    end
+  end
+end

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

@@ -6,15 +6,19 @@ module GraphQL
       # A container for metadata regarding arguments present in a GraphQL query.
       # @see Interpreter::Arguments#argument_values for a hash of these objects.
       class ArgumentValue
-        def initialize(definition:, value:, default_used:)
+        def initialize(definition:, value:, original_value:, default_used:)
           @definition = definition
           @value = value
+          @original_value = original_value
           @default_used = default_used
         end
 
         # @return [Object] The Ruby-ready value for this Argument
         attr_reader :value
 
+        # @return [Object] The value of this argument _before_ `prepare` is applied.
+        attr_reader :original_value
+
         # @return [GraphQL::Schema::Argument] The definition instance for this argument
         attr_reader :definition
 

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

@@ -8,22 +8,17 @@ module GraphQL
           @query = query
           @dataloader = query.context.dataloader
           @storage = Hash.new do |h, argument_owner|
-            args_by_parent = if argument_owner.arguments_statically_coercible?
+            h[argument_owner] = if argument_owner.arguments_statically_coercible?
               shared_values_cache = {}
               Hash.new do |h2, ignored_parent_object|
                 h2[ignored_parent_object] = shared_values_cache
-              end
+              end.compare_by_identity
             else
               Hash.new do |h2, parent_object|
-                args_by_node = {}
-                args_by_node.compare_by_identity
-                h2[parent_object] = args_by_node
-              end
+                h2[parent_object] = {}.compare_by_identity
+              end.compare_by_identity
             end
-            args_by_parent.compare_by_identity
-            h[argument_owner] = args_by_parent
-          end
-          @storage.compare_by_identity
+          end.compare_by_identity
         end
 
         def fetch(ast_node, argument_owner, parent_object)

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

@@ -5,6 +5,12 @@ module GraphQL
     class Interpreter
       # Wrapper for raw values
       class RawValue
+        include GraphQL::Execution::Finalizer
+
+        def finalize_graphql_result(query, result_data, result_key)
+          result_data[result_key] = @object
+        end
+
         def initialize(obj = nil)
           @object = obj
         end

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

@@ -6,22 +6,31 @@ module GraphQL
       module Resolve
         # Continue field results in `results` until there's nothing else to continue.
         # @return [void]
+        # @deprecated Call `dataloader.run` instead
         def self.resolve_all(results, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
           dataloader.append_job { resolve(results, dataloader) }
           nil
         end
 
+        # @deprecated Call `dataloader.run` instead
         def self.resolve_each_depth(lazies_at_depth, dataloader)
-          depths = lazies_at_depth.keys
-          depths.sort!
-          next_depth = depths.first
-          if next_depth
-            lazies = lazies_at_depth[next_depth]
-            lazies_at_depth.delete(next_depth)
-            if lazies.any?
-              dataloader.append_job {
-                lazies.each(&:value) # resolve these Lazy instances
-              }
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+
+          smallest_depth = nil
+          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 = lazies_at_depth.delete(smallest_depth)
+            if !lazies.empty?
+              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)
@@ -30,20 +39,9 @@ module GraphQL
           nil
         end
 
-        # After getting `results` back from an interpreter evaluation,
-        # continue it until you get a response-ready Ruby value.
-        #
-        # `results` is one level of _depth_ of a query or multiplex.
-        #
-        # Resolve all lazy values in that depth before moving on
-        # to the next level.
-        #
-        # It's assumed that the lazies will
-        # return {Lazy} instances if there's more work to be done,
-        # or return {Hash}/{Array} if the query should be continued.
-        #
-        # @return [void]
+        # @deprecated Call `dataloader.run` instead
         def self.resolve(results, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
           # There might be pending jobs here that _will_ write lazies
           # into the result hash. We should run them out, so we
           # can be sure that all lazies will be present in the result hashes.
@@ -51,7 +49,7 @@ module GraphQL
           # these approaches.
           dataloader.run
           next_results = []
-          while results.any?
+          while !results.empty?
             result_value = results.shift
             if result_value.is_a?(Runtime::GraphQLResultHash) || result_value.is_a?(Hash)
               results.concat(result_value.values)
@@ -77,7 +75,7 @@ module GraphQL
             end
           end
 
-          if next_results.any?
+          if !next_results.empty?
             # Any pending data loader jobs may populate the
             # resutl arrays or result hashes accumulated in
             # `next_results``. Run those **to completion**