graphql 2.5.23 → 2.6.3

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class LoadArgumentStep
+      def initialize(field_resolve_step:, arguments:, load_receiver:, argument_value:, argument_definition:, argument_key:)
+        @field_resolve_step = field_resolve_step
+        @load_receiver = load_receiver
+        @arguments = arguments
+        @argument_value = argument_value
+        @argument_definition = argument_definition
+        @argument_key = argument_key
+        @loaded_value = nil
+        @is_authorized = true
+      end
+
+      def value
+        @field_resolve_step.set_current_field
+        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
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      def call
+        @field_resolve_step.set_current_field
+        context = @field_resolve_step.selections_step.query.context
+        @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)
+          runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+        else
+          assign_value
+        end
+      rescue GraphQL::RuntimeError => 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, 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
+        assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      private
+
+      def assign_value
+        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)
+          @arguments[@argument_key] = @loaded_value
+        end
+
+        field_pending_steps = @field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if @field_resolve_step.arguments && field_pending_steps.size == 0 # rubocop:disable Development/ContextIsPassedCop
+          @field_resolve_step.runner.add_step(@field_resolve_step)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/next.rb

@@ -1,14 +1,44 @@
 # frozen_string_literal: true
-require "graphql/execution/next/prepare_object_step"
-require "graphql/execution/next/field_resolve_step"
-require "graphql/execution/next/load_argument_step"
-require "graphql/execution/next/runner"
-require "graphql/execution/next/selections_step"
+require "graphql/execution/prepare_object_step"
+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, "#{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
+    end
+
+    module PostProcessor
+      def after_resolve(field_results)
+        raise RequiredImplementationMissingError, "#{self.class}#after_resolve should handle `field_results` and return a new value to use"
+      end
+    end
+
     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],
@@ -21,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,
@@ -29,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]
@@ -37,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)
@@ -64,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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class PrepareObjectStep
+      def initialize(object:, runner:, graphql_result:, key:, is_non_null:, field_resolve_step:, next_objects:, next_results:, is_from_array:)
+        @object = object
+        @runner = runner
+        @field_resolve_step = field_resolve_step
+        @is_non_null = is_non_null
+        @next_objects = next_objects
+        @next_results = next_results
+        @graphql_result = graphql_result
+        @resolved_type = nil
+        @authorized_value = nil
+        @authorization_error = nil
+        @key = key
+        @next_step = :resolve_type
+        @is_from_array = is_from_array
+      end
+
+      def value
+        @field_resolve_step.set_current_field
+        if @authorized_value
+          query = @field_resolve_step.selections_step.query
+          query.current_trace.begin_authorized(@resolved_type, @object, query.context)
+          @authorized_value = @field_resolve_step.sync(@authorized_value)
+          query.current_trace.end_authorized(@resolved_type, @object, query.context, @authorized_value)
+        elsif @resolved_type
+          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, 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)
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      def call
+        @field_resolve_step.set_current_field
+        case @next_step
+        when :resolve_type
+          static_type = @field_resolve_step.static_type
+          if static_type.kind.abstract?
+            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
+          if @runner.resolves_lazies && @runner.lazy?(@resolved_type)
+            @next_step = :authorize
+            @runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+          else
+            authorize
+          end
+        when :authorize
+          authorize
+        when :create_result
+          create_result
+        else
+          raise ArgumentError, "This is a bug, unknown step: #{@next_step.inspect}"
+        end
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      def authorize
+        if @field_resolve_step.was_scoped && !@resolved_type.reauthorize_scoped_objects
+          @authorized_value = @object
+          create_result
+          return
+        end
+
+        query = @field_resolve_step.selections_step.query
+        begin
+          query.current_trace.begin_authorized(@resolved_type, @object, query.context)
+          @authorized_value = @resolved_type.authorized?(@object, query.context)
+          query.current_trace.end_authorized(@resolved_type, @object, query.context, @authorized_value)
+        rescue GraphQL::UnauthorizedError => auth_err
+          @authorization_error = auth_err
+        end
+
+        if @runner.resolves_lazies && @runner.lazy?(@authorized_value)
+          @runner.dataloader.lazy_at_depth(@field_resolve_step.path.size, self)
+          @next_step = :create_result
+        else
+          create_result
+        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
+        if !@authorized_value
+          @authorization_error ||= GraphQL::UnauthorizedError.new(object: @object, type: @resolved_type, context: @field_resolve_step.selections_step.query.context)
+        end
+
+        if @authorization_error
+          begin
+            new_obj = @runner.schema.unauthorized_object(@authorization_error)
+            if new_obj
+              @authorized_value = true
+              @object = new_obj
+            elsif @is_non_null
+              @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
+            else
+              @graphql_result[@key] = @field_resolve_step.add_graphql_error(@authorization_error)
+            end
+          rescue GraphQL::RuntimeError => err
+            if @is_non_null
+              @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
+            else
+              @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+            end
+          end
+        end
+
+        if @authorized_value
+          next_result_h = {}
+          @next_results << next_result_h
+          @next_objects << @object
+          @graphql_result[@key] = next_result_h
+          @runner.runtime_type_at[next_result_h] = @resolved_type
+          @runner.static_type_at[next_result_h] = @field_resolve_step.static_type
+        end
+
+        @field_resolve_step.authorized_finished(self)
+      end
+    end
+  end
+end

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