graphql 2.6.1 → 2.6.2

data/lib/graphql/execution/input_values.rb

@@ -38,6 +38,7 @@ module GraphQL
       def argument_values(owner_defn, argument_nodes, field_resolve_step)
         arg_defns = @query.types.arguments(owner_defn)
         argument_values = {}
+        errors = nil
 
         arg_defns.each do |argument_definition|
           arg_ruby_key = argument_definition.keyword
@@ -52,11 +53,12 @@ module GraphQL
             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
+        rescue GraphQL::RuntimeError => exec_err
+          errors ||= []
+          errors << exec_err
         end
 
-        argument_values
-      rescue GraphQL::ExecutionError => exec_err
-        exec_err
+        return argument_values, errors
       end
 
       private
@@ -82,20 +84,43 @@ module GraphQL
         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
+          if value.is_a?(Hash)
+            @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
+
+              if arg_value.nil? && arg.replace_null_with_default?
+                arg_value = arg.default_value
+              end
 
-            coerced_obj[arg_key] = variable_value(arg_value, arg.type)
+              coerced_obj[arg_key] = variable_value(arg_value, arg.type)
+            end
+          else
+            @query.types.arguments(type).each do |arg|
+              arg_key = arg.keyword
+              arg_name = arg.graphql_name
+              if (v_node = value.arguments.find { |a| a.name == arg_name }) # rubocop:disable Development/ContextIsPassedCop
+                arg_value = v_node.value
+                coerced_obj[arg_key] = if arg_value.nil? && arg.replace_null_with_default?
+                  arg.default_value
+                else
+                  variable_value(arg_value, arg.type)
+                end
+              elsif arg.default_value?
+                coerced_obj[arg_key] = arg.default_value
+              else
+                # Nothing
+              end
+            end
           end
 
           coerced_obj
@@ -109,11 +134,18 @@ module GraphQL
       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?
+          if arg_value.nil?
+            treat_as_type.coerce_input(arg_value, @query.context)
+          end
           treat_as_type = treat_as_type.of_type
         end
 
+        if arg_value.nil? && argument_definition.replace_null_with_default?
+          arg_value = argument_definition.default_value
+        end
+
         if treat_as_type.kind.list? && !arg_value.nil?
-          inner_t = treat_as_type.unwrap
+          inner_t = treat_as_type.of_type
           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)}
@@ -150,7 +182,7 @@ module GraphQL
           arg_value = begin
             argument_definition.prepare_value(nil, arg_value, context: @query.context)
           rescue StandardError => err
-            @runner.schema.handle_or_reraise(@query.context, err)
+            @runner.schema.handle_or_reraise(@query.context, err, object: nil, arguments: argument_values, field: field_resolve_step&.field_definition)
           end
         end
 
@@ -205,8 +237,6 @@ module GraphQL
           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)
@@ -214,37 +244,53 @@ module GraphQL
               value_from_ast(inner_value_node, inner_type)
             end
             coerced_items.freeze
+          elsif value_node.is_a?(Language::Nodes::NullValue)
+            nil
           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
+          # TODO manually handle NullValue here?
+          if value_node.is_a?(Hash)
+            @query.types.arguments(type).each do |arg|
+              arg_value = value_node[arg.keyword]
+              arg_key = arg.keyword
+              if arg_value.nil?
+                if arg.default_value?
+                  coerced_obj[arg_key] = arg.default_value
+                end
+                next
               end
-              next
+
+              coerced_obj[arg_key] = value_from_ast(arg_value, arg.type)
+            end
+          else
+            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
 
-            arg_value = value_from_ast(arg_node.value, arg.type)
-            coerced_obj[arg_key] = arg_value
+            @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
           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
+          if value_node.is_a?(Language::Nodes::AbstractNode) || value_node.is_a?(Array)
+            value_node = coerce_untyped_input(value_node)
           end
 
           begin
@@ -256,6 +302,32 @@ module GraphQL
           raise "Unexpected input type: #{type.to_type_signature}."
         end
       end
+
+      private
+
+      def coerce_untyped_input(input_value)
+        case input_value
+        when Language::Nodes::AbstractNode
+          case input_value
+          when Language::Nodes::NullValue
+            nil
+          when Language::Nodes::Enum
+            input_value.name
+          when Language::Nodes::InputObject
+            value_h = {}
+            input_value.arguments.each do |arg| # rubocop:disable Development/ContextIsPassedCop
+              value_h[arg.name] = coerce_untyped_input(arg.value)
+            end
+            value_h
+          else
+            raise "Unhandled untyped input AST node: #{input_value.class}"
+          end
+        when Array
+          input_value.map { |v| coerce_untyped_input(v) }
+        else
+          input_value
+        end
+      end
     end
   end
 end

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

@@ -198,7 +198,7 @@ module GraphQL
 
         def each_gathered_selections(response_hash)
           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)
+          gathered_selections = gather_selections(response_hash, 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|
@@ -209,15 +209,13 @@ module GraphQL
           end
         end
 
-        def gather_selections(owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
+        def gather_selections(graphql_response, 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)
-              next
-            end
-
             if node.is_a?(GraphQL::Language::Nodes::Field)
               response_key = node.alias || node.name
+              if !directives_include?(node, owner_object, owner_type, graphql_response, response_key)
+                next
+              end
               ordered_result_keys << response_key
               selections = selections_by_name[response_key]
               # if there was already a selection of this field,
@@ -234,6 +232,9 @@ module GraphQL
                 selections_by_name[response_key] = node
               end
             else
+              if !directives_include?(node, owner_object, owner_type, graphql_response, nil)
+                next
+              end
               # This is an InlineFragment or a FragmentSpread
               if !@runtime_directive_names.empty? && node.directives.any? { |d| @runtime_directive_names.include?(d.name) }
                 next_selections = {}
@@ -255,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, ordered_result_keys)
+                    result = gather_selections(graphql_response, 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, ordered_result_keys)
+                  result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end
@@ -271,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, ordered_result_keys)
+                  result = gather_selections(graphql_response, 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
@@ -339,7 +340,7 @@ module GraphQL
           end
           field_name = ast_node.name
           owner_type = selections_result.graphql_result_type
-          field_defn = query.types.field(owner_type, field_name)
+          field_defn = query.types.field(owner_type, field_name) || raise(GraphQL::Error, "No field definition found for #{owner_type.graphql_name}.#{field_name} (at #{ast_node.position})")
 
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           runtime_state = get_current_runtime_state
@@ -579,7 +580,7 @@ module GraphQL
                 value.path ||= current_path
                 value.ast_node ||= ast_node
                 context.errors << value
-                if selection_result
+                if selection_result && result_name
                   set_result(selection_result, result_name, nil, false, is_non_null)
                 end
               end
@@ -856,11 +857,31 @@ module GraphQL
         end
 
         # Check {Schema::Directive.include?} for each directive that's present
-        def directives_include?(node, graphql_object, parent_type)
+        def directives_include?(node, graphql_object, parent_type, selection_result, extra_path_part)
           node.directives.each do |dir_node|
             dir_defn = @schema_directives.fetch(dir_node.name)
-            args = arguments(graphql_object, dir_defn, dir_node)
-            if !dir_defn.include?(graphql_object, args, context)
+            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
+
+            if extra_path_part && raw_dir_args.is_a?(GraphQL::ExecutionError)
+              raw_dir_args.path = current_path + [extra_path_part]
+            end
+
+            dir_args = continue_value(
+              raw_dir_args, # value
+              nil, # field
+              false, # is_non_null
+              dir_node, # ast_node
+              nil, # result_name
+              selection_result
+            )
+            if dir_args == HALT || !dir_defn.include?(graphql_object, dir_args, context)
               return false
             end
           end

data/lib/graphql/execution/load_argument_step.rb

@@ -10,10 +10,29 @@ module GraphQL
         @argument_definition = argument_definition
         @argument_key = argument_key
         @loaded_value = nil
+        @is_authorized = true
       end
 
       def value
-        @loaded_value = @field_resolve_step.sync(@loaded_value)
+        schema = @field_resolve_step.runner.schema
+        @loaded_value = schema.sync_lazy(@loaded_value)
+        assign_value
+      rescue GraphQL::UnauthorizedError => auth_err
+        @is_authorized = false
+        schema.unauthorized_object(auth_err)
+      rescue GraphQL::RuntimeError => err
+        @loaded_value = if err.is_a?(Schema::Subscription::EarlyUnsubscribe)
+          err.unsubscribed_result
+        else
+          err
+        end
+        assign_value
+      rescue StandardError => stderr
+        begin
+          @field_resolve_step.selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
+        rescue GraphQL::ExecutionError => ex_err
+          @loaded_value = ex_err
+        end
         assign_value
       end
 
@@ -22,6 +41,7 @@ module GraphQL
         @loaded_value = begin
           @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
         rescue GraphQL::UnauthorizedError => auth_err
+          @is_authorized = false
           context.schema.unauthorized_object(auth_err)
         end
         if (runner = @field_resolve_step.runner).resolves_lazies && runner.lazy?(@loaded_value)
@@ -30,11 +50,16 @@ module GraphQL
           assign_value
         end
       rescue GraphQL::RuntimeError => err
-        @loaded_value = err
+        @loaded_value = if err.is_a?(Schema::Subscription::EarlyUnsubscribe)
+          @is_authorized = false
+          err.unsubscribed_result
+        else
+          err
+        end
         assign_value
       rescue StandardError => stderr
         @loaded_value = begin
-          context.query.handle_or_reraise(stderr)
+          context.query.handle_or_reraise(stderr, field: @field_resolve_step.field_definition, arguments: @field_resolve_step.arguments, object: nil) # rubocop:disable Development/ContextIsPassedCop
         rescue GraphQL::ExecutionError => ex_err
           ex_err
         end
@@ -47,6 +72,13 @@ module GraphQL
         if @loaded_value.is_a?(GraphQL::RuntimeError)
           @loaded_value.path = @field_resolve_step.path
           @field_resolve_step.arguments = @loaded_value
+        elsif @is_authorized == false
+          # An unauthorized_object hook ate the error
+          @field_resolve_step.arguments = EmptyObjects::EMPTY_HASH
+          field_pending_steps = @field_resolve_step.pending_steps
+          field_pending_steps.clear
+          @field_resolve_step.build_errors_result(nil, nil)
+          return
         else
           query = @field_resolve_step.selections_step.query
           query.current_trace.object_loaded(@argument_definition, @loaded_value, query.context)

data/lib/graphql/execution/next.rb

@@ -4,15 +4,27 @@ require "graphql/execution/input_values"
 require "graphql/execution/field_resolve_step"
 require "graphql/execution/finalize"
 require "graphql/execution/load_argument_step"
+require "graphql/execution/resolve_type_step"
 require "graphql/execution/runner"
 require "graphql/execution/selections_step"
 module GraphQL
   module Execution
     module Finalizer
       attr_accessor :path
+
       def finalize_graphql_result(query, result_data, result_key)
-        raise RequiredImplementationMissingError
+        raise RequiredImplementationMissingError, "#{self.class} must implement #finalize_graphql_result(query, result_data, result_key)\n\nresult_data: #{result_data}\nresult_key: #{result_key.inspect}"
+      end
+
+      def ast_node
+        ast_nodes&.first
+      end
+
+      def ast_node=(new_node)
+        @ast_nodes = [new_node]
       end
+
+      attr_accessor :ast_nodes
     end
 
     module HaltExecution
@@ -26,7 +38,7 @@ module GraphQL
 
     module Next
       module SchemaExtension
-        def execute_next(query_str = nil, context: nil, document: nil, operation_name: nil, variables: nil, root_value: nil, validate: true, visibility_profile: nil)
+        def execute_next(query_str = nil, query: nil, subscription_topic: nil, context: nil, document: nil, operation_name: nil, variables: nil, warden: nil, root_value: nil, validate: true, visibility_profile: nil)
           multiplex_context = if context
             {
               backtrace: context[:backtrace],
@@ -39,7 +51,8 @@ module GraphQL
             {}
           end
           query_opts = {
-            query: query_str,
+            query: query || query_str,
+            subscription_topic: subscription_topic,
             document: document,
             context: context,
             validate: validate,
@@ -47,6 +60,7 @@ module GraphQL
             root_value: root_value,
             operation_name: operation_name,
             visibility_profile: visibility_profile,
+            warden: warden,
           }
           m_results = multiplex_next([query_opts], context: multiplex_context, max_complexity: nil)
           m_results[0]
@@ -55,17 +69,11 @@ module GraphQL
         def multiplex_next(query_options, context: {}, max_complexity: self.max_complexity)
           Next.run_all(self, query_options, context: context, max_complexity: max_complexity)
         end
-
-        def execution_next_options
-          @execution_next_options || find_inherited_value(:execution_next_options, EmptyObjects::EMPTY_HASH)
-        end
-
-        attr_writer :execution_next_options
       end
 
-      def self.use(schema, authorization: true)
+      def self.use(schema, as_default: false)
         schema.extend(SchemaExtension)
-        schema.execution_next_options = { authorization: authorization }
+        schema.default_execution_next(as_default)
       end
 
       def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
@@ -82,7 +90,7 @@ module GraphQL
           query
         end
         multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-        runner = Runner.new(multiplex, **schema.execution_next_options)
+        runner = Runner.new(multiplex)
         runner.execute
       end
     end

data/lib/graphql/execution/prepare_object_step.rb

@@ -28,7 +28,11 @@ module GraphQL
           ctx = @field_resolve_step.selections_step.query.context
           st = @field_resolve_step.static_type
           ctx.query.current_trace.begin_resolve_type(st, @object, ctx)
-          @resolved_type, _ignored_value = @field_resolve_step.sync(@resolved_type)
+          @resolved_type, new_value = @field_resolve_step.sync(@resolved_type)
+          ResolveTypeStep.assert_valid_resolved_type(st, @resolved_type, new_value, @field_resolve_step)
+          if new_value
+            @object = new_value
+          end
           ctx.query.current_trace.end_resolve_type(st, @object, ctx, @resolved_type)
         end
         @runner.add_step(self)
@@ -39,10 +43,12 @@ module GraphQL
         when :resolve_type
           static_type = @field_resolve_step.static_type
           if static_type.kind.abstract?
-            ctx = @field_resolve_step.selections_step.query.context
-            ctx.query.current_trace.begin_resolve_type(static_type, @object, ctx)
-            @resolved_type, _ignored_value = @runner.schema.resolve_type(static_type, @object, ctx)
-            ctx.query.current_trace.end_resolve_type(static_type, @object, ctx, @resolved_type)
+            query = @field_resolve_step.selections_step.query
+            @resolved_type, new_value = ResolveTypeStep.resolve_type(static_type, @object, query)
+            if new_value
+              ResolveTypeStep.assert_valid_resolved_type(static_type, @resolved_type, new_value, @field_resolve_step)
+              @object = new_value
+            end
           else
             @resolved_type = static_type
           end
@@ -85,6 +91,13 @@ module GraphQL
         end
       rescue GraphQL::RuntimeError => err
         @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+      rescue StandardError => err
+        query ||= @field_resolve_step.selections_step.query
+        begin
+          query.handle_or_reraise(err, field: @field_resolve_step.field_definition, arguments: @field_resolve_step.arguments, object: @object) # rubocop:disable Development/ContextIsPassedCop
+        rescue GraphQL::RuntimeError => err
+          @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+        end
       end
 
       def create_result

data/lib/graphql/execution/resolve_type_step.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class ResolveTypeStep
+      def self.resolve_type(type, object, query)
+        query.current_trace.begin_resolve_type(type, object, query.context)
+        resolved_type_response = query.resolve_type(type, object)
+        resolved_type = if resolved_type_response.is_a?(Array)
+          resolved_type_response.first
+        else
+          resolved_type_response
+        end
+        query.current_trace.end_resolve_type(type, object, query.context, resolved_type)
+        resolved_type_response
+      end
+
+      def self.assert_valid_resolved_type(abstract_type, resolved_type, object, field_resolution_step, query: field_resolution_step.selections_step.query)
+        possible_types = query.types.possible_types(abstract_type)
+        if !possible_types.include?(resolved_type)
+          err_class = abstract_type::UnresolvedTypeError
+          type_error = err_class.new(object, field_resolution_step.field_definition, abstract_type, resolved_type, possible_types)
+          query.schema.type_error(type_error, query.context)
+        end
+      end
+    end
+  end
+end