graphql 2.5.23 → 2.5.24

data/lib/graphql/execution/prepare_object_step.rb

@@ -0,0 +1,128 @@
+# 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
+        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, _ignored_value = @field_resolve_step.sync(@resolved_type)
+          ctx.query.current_trace.end_resolve_type(st, @object, ctx, @resolved_type)
+        end
+        @runner.add_step(self)
+      end
+
+      def call
+        case @next_step
+        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)
+          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
+      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)
+      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/runner.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class Runner
+      def initialize(multiplex, authorization:)
+        @multiplex = multiplex
+        @schema = multiplex.schema
+        @steps_queue = []
+        @runtime_type_at = {}.compare_by_identity
+        @static_type_at = {}.compare_by_identity
+        @finalizers = nil
+        @selected_operation = nil
+        @dataloader = multiplex.context[:dataloader] ||= @schema.dataloader_class.new
+        @resolves_lazies = @schema.resolves_lazies?
+        @input_values = Hash.new do |h, query|
+          h[query] = InputValues.new(query, self)
+        end.compare_by_identity
+
+        @runtime_directives = nil
+        @schema.directives.each do |name, dir_class|
+          if dir_class.runtime? && name != "include" && name != "skip"
+            @runtime_directives ||= {}
+            @runtime_directives[dir_class.graphql_name] = dir_class
+          end
+        end
+
+        if @runtime_directives.nil?
+          @uses_runtime_directives = false
+          @runtime_directives = EmptyObjects::EMPTY_HASH
+        else
+          @uses_runtime_directives = true
+        end
+
+        @lazy_cache = resolves_lazies ? {}.compare_by_identity : nil
+        @authorization = authorization
+        if @authorization
+          @authorizes_cache = Hash.new do |h, query_context|
+            h[query_context] = {}.compare_by_identity
+          end.compare_by_identity
+        end
+      end
+
+      attr_reader :runtime_directives, :uses_runtime_directives, :finalizer_keys
+
+      def resolve_type(type, object, query)
+        query.current_trace.begin_resolve_type(type, object, query.context)
+        resolved_type, _ignored_new_value = query.resolve_type(type, object)
+        query.current_trace.end_resolve_type(type, object, query.context, resolved_type)
+        resolved_type
+      end
+
+      def authorizes?(graphql_definition, query_context)
+        auth_cache = @authorizes_cache[query_context]
+        case (auth_res = auth_cache[graphql_definition])
+        when nil
+          auth_cache[graphql_definition] = graphql_definition.authorizes?(query_context)
+        else
+          auth_res
+        end
+      end
+
+      def add_step(step)
+        @dataloader.append_job(step)
+      end
+
+      attr_reader :authorization, :steps_queue, :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers, :input_values
+
+      # @return [void]
+      def add_finalizer(query, result_value, key, finalizer)
+        @finalizers ||= {}.compare_by_identity
+        f_for_query = @finalizers[query] ||= {}.compare_by_identity
+        f_for_result = f_for_query[result_value] ||= {}.compare_by_identity
+        if (f = f_for_result[key])
+          if f.is_a?(Array)
+            f << finalizer
+          else
+            f_for_result[key] = [f, finalizer]
+          end
+        else
+          f_for_result[key] = finalizer
+        end
+        nil
+      end
+
+      def execute
+        Fiber[:__graphql_current_multiplex] = @multiplex
+        isolated_steps = [[]]
+        trace = @multiplex.current_trace
+        queries = @multiplex.queries
+        multiplex_analyzers = @schema.multiplex_analyzers
+        if @multiplex.max_complexity
+          multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
+        end
+
+        trace.execute_multiplex(multiplex: @multiplex) do
+          trace.begin_analyze_multiplex(@multiplex, multiplex_analyzers)
+          @schema.analysis_engine.analyze_multiplex(@multiplex, multiplex_analyzers)
+          trace.end_analyze_multiplex(@multiplex, multiplex_analyzers)
+
+          results = []
+          queries.each do |query|
+            if query.validate && !query.valid?
+              results << {
+                "errors" => query.static_errors.map(&:to_h)
+              }
+              next
+            end
+
+            root_type = query.root_type
+
+            if root_type.non_null?
+              root_type = root_type.of_type
+            end
+
+            root_value = query.root_value
+            if resolves_lazies
+              root_value = schema.sync_lazy(root_value)
+            end
+
+            trace.execute_query(query: query) do
+              begin_execute(isolated_steps, results, query, root_type, root_value)
+            end
+          end
+
+          trace.execute_query_lazy(query: nil, multiplex: @multiplex) do
+            while (next_isolated_steps = isolated_steps.shift)
+              next_isolated_steps.each do |step|
+                add_step(step)
+              end
+              @dataloader.run
+            end
+          end
+
+          queries.each_with_index.map do |query, idx|
+            result = results[idx]
+
+            fin_result = if (!@finalizers&.key?(query) && query.context.errors.empty?) || !query.valid?
+              result
+            else
+              data = result["data"]
+              data = Finalize.new(query, data, self).run
+              errors = []
+              query.context.errors.each do |err|
+                if err.respond_to?(:to_h)
+                  errors << err.to_h
+                end
+              end
+              res_h = {}
+              if !errors.empty?
+                res_h["errors"] = errors
+              end
+              res_h["data"] = data
+              res_h
+            end
+
+            query.result_values = fin_result
+            query.result
+          end
+        end
+      ensure
+        Fiber[:__graphql_current_multiplex] = nil
+      end
+
+      def gather_selections(type_defn, ast_selections, selections_step, query, all_selections, prototype_result, into:)
+        ast_selections.each do |ast_selection|
+          next if !directives_include?(query, ast_selection)
+
+          case ast_selection
+          when GraphQL::Language::Nodes::Field
+            key = ast_selection.alias || ast_selection.name
+            step = into[key] ||= begin
+              prototype_result[key] = nil
+
+              FieldResolveStep.new(
+                selections_step: selections_step,
+                key: key,
+                parent_type: type_defn,
+                runner: self,
+              )
+            end
+            step.append_selection(ast_selection)
+          when GraphQL::Language::Nodes::InlineFragment
+            type_condition = ast_selection.type&.name
+            if type_condition.nil? || type_condition_applies?(query.context, type_defn, type_condition)
+              if uses_runtime_directives && !ast_selection.directives.empty?
+                all_selections << (into = { __node: ast_selection })
+                all_selections << (prototype_result = {})
+              end
+              gather_selections(type_defn, ast_selection.selections, selections_step, query, all_selections, prototype_result, into: into)
+            end
+          when GraphQL::Language::Nodes::FragmentSpread
+            fragment_definition = query.fragments[ast_selection.name]
+            type_condition = fragment_definition.type.name
+            if type_condition_applies?(query.context, type_defn, type_condition)
+              if uses_runtime_directives && !ast_selection.directives.empty?
+                all_selections << (into = { __node: ast_selection })
+                all_selections << (prototype_result = {})
+              end
+              gather_selections(type_defn, fragment_definition.selections, selections_step, query, all_selections, prototype_result, into: into)
+            end
+          else
+            raise ArgumentError, "Unsupported graphql selection node: #{ast_selection.class} (#{ast_selection.inspect})"
+          end
+        end
+      end
+
+      def lazy?(object)
+        obj_class = object.class
+        is_lazy = @lazy_cache[obj_class]
+        if is_lazy.nil?
+          is_lazy = @lazy_cache[obj_class] = @schema.lazy?(object)
+        end
+        is_lazy
+      end
+
+      def type_condition_applies?(context, concrete_type, type_name)
+        if type_name == concrete_type.graphql_name
+          true
+        else
+          abs_t = @schema.get_type(type_name, context)
+          p_types = @schema.possible_types(abs_t, context)
+          c_p_types = @schema.possible_types(concrete_type, context)
+          p_types.any? { |t| c_p_types.include?(t) }
+        end
+      end
+
+      private
+
+      def begin_execute(isolated_steps, results, query, root_type, root_value)
+        data = {}
+        selected_operation = query.selected_operation
+        beginning_path = query.path
+
+        case root_type.kind.name
+        when "OBJECT"
+          if self.authorization && authorizes?(root_type, query.context)
+            query.current_trace.begin_authorized(root_type, root_value, query.context)
+            auth_check = schema.sync_lazy(root_type.authorized?(root_value, query.context))
+            query.current_trace.end_authorized(root_type, root_value, query.context, auth_check)
+            root_value = if auth_check
+              root_value
+            else
+              begin
+                auth_err = GraphQL::UnauthorizedError.new(object: root_value, type: root_type, context: query.context)
+                new_val = schema.unauthorized_object(auth_err)
+                if new_val
+                  auth_check = true
+                end
+                new_val
+              rescue GraphQL::ExecutionError => ex_err
+                # The old runtime didn't add path and ast_nodes to this
+                ex_err.path = beginning_path
+                query.context.add_error(ex_err)
+                nil
+              end
+            end
+
+            if !auth_check
+              results << {}
+              return
+            end
+          end
+
+          results << { "data" => data }
+          objects = [root_value]
+          query.current_trace.objects(root_type, objects, query.context)
+
+          if query.query?
+            isolated_steps[0] << SelectionsStep.new(
+              parent_type: root_type,
+              selections: query.selected_operation.selections,
+              objects: objects,
+              results: [data],
+              path: beginning_path,
+              runner: self,
+              query: query,
+            )
+          elsif query.mutation?
+            fields = {}
+            all_selections = [fields, (prototype_result = {})]
+            gather_selections(root_type, selected_operation.selections, nil, query, all_selections, prototype_result, into: fields)
+            if all_selections.length > 2
+              # TODO DRY with SelectionsStep with directive handling
+              raise "Directives on root mutation type not implemented yet"
+            end
+            fields.each_value do |field_resolve_step|
+              isolated_steps << [SelectionsStep.new(
+                clobber: false, # `data` is being shared among several selections steps
+                parent_type: root_type,
+                selections: field_resolve_step.ast_nodes || Array(field_resolve_step.ast_node),
+                objects: objects,
+                results: [data],
+                path: beginning_path,
+                runner: self,
+                query: query,
+              )]
+            end
+          elsif query.subscription?
+            if !query.subscription_update?
+              schema.subscriptions.initialize_subscriptions(query)
+              add_finalizer(query, data, nil, schema.subscriptions.finalizer)
+            end
+            isolated_steps[0] << SelectionsStep.new(
+              parent_type: root_type,
+              selections: selected_operation.selections,
+              objects: objects,
+              results: [data],
+              path: beginning_path,
+              runner: self,
+              query: query,
+            )
+          else
+            raise ArgumentError, "Unknown operation type (not query, mutation or subscription): #{query.query_string}"
+          end
+        when "UNION", "INTERFACE"
+          resolved_type = resolve_type(root_type, root_value, query)
+          if resolves_lazies
+            resolved_type = schema.sync_lazy(resolved_type)
+          end
+          objects = [root_value]
+          query.current_trace.objects(resolved_type, objects, query.context)
+          runtime_type_at[data] = resolved_type
+          results << { "data" => data }
+          isolated_steps[0] << SelectionsStep.new(
+            parent_type: resolved_type,
+            selections: query.selected_operation.selections,
+            objects: objects,
+            results: [data],
+            path: beginning_path,
+            runner: self,
+            query: query,
+          )
+        when "LIST"
+          inner_type = root_type.unwrap
+          case inner_type.kind.name
+          when "SCALAR", "ENUM"
+            results << run_isolated_scalar(root_type, query)
+          else
+            list_result = Array.new(root_value.size) { Hash.new.compare_by_identity }
+            results << { "data" => list_result }
+            isolated_steps[0] << SelectionsStep.new(
+              parent_type: inner_type,
+              selections: query.selected_operation.selections,
+              objects: root_value,
+              results: list_result,
+              path: beginning_path,
+              runner: self,
+              query: query,
+            )
+          end
+        when "SCALAR", "ENUM"
+          results << run_isolated_scalar(root_type, query)
+        else
+          raise "Unhandled root type kind: #{root_type.kind.name.inspect}"
+        end
+
+        @static_type_at[data] = root_type
+      end
+
+      def directives_include?(query, ast_selection)
+        if ast_selection.directives.any? { |dir_node|
+              if dir_node.name == "skip"
+                skip_args = @input_values[query].argument_values(GraphQL::Schema::Directive::Skip, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                skip_args[:if] == true
+              elsif dir_node.name == "include"
+                include_args = @input_values[query].argument_values(GraphQL::Schema::Directive::Include, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                include_args[:if] == false
+              end
+            }
+          false
+        else
+          true
+        end
+      end
+
+      def run_isolated_scalar(type, partial)
+        value = partial.root_value
+        dummy_path = partial.path.dup
+        key = dummy_path.pop
+        is_from_array = key.is_a?(Integer)
+
+        if lazy?(value)
+          value = @schema.sync_lazy(value)
+        end
+        selections = partial.ast_nodes
+        dummy_ss = SelectionsStep.new(
+          parent_type: nil,
+          selections: selections,
+          objects: nil,
+          results: nil,
+          path: dummy_path,
+          runner: self,
+          query: partial,
+        )
+        dummy_frs = FieldResolveStep.new(
+          selections_step: dummy_ss,
+          key: key,
+          parent_type: nil,
+          runner: self,
+        )
+        dummy_frs.static_type = type
+        selections.each { |s| dummy_frs.append_selection(s) }
+
+        result = is_from_array ? [] : {}
+        dummy_frs.finish_leaf_result(result, key, value, type, partial.context)
+        { "data" => result[key] }
+      end
+    end
+  end
+end

data/lib/graphql/execution/selections_step.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class SelectionsStep
+      def initialize(parent_type:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
+        @path = path
+        @parent_type = parent_type
+        @selections = selections
+        @runner = runner
+        @objects = objects
+        @results = results
+        @query = query
+        @graphql_objects = nil
+        @all_selections = nil
+        @clobber = clobber
+      end
+
+      attr_reader :path, :query, :objects, :results
+
+      def graphql_objects
+        @graphql_objects ||= @objects.map do |obj|
+          @parent_type.scoped_new(obj, @query.context)
+        end
+      end
+
+      def call
+        @all_selections = [{}, (prototype_result = {})]
+        @runner.gather_selections(@parent_type, @selections, self, self.query, @all_selections, @all_selections[1], into: @all_selections[0])
+        continue_selections = []
+        i = 0
+        l = @all_selections.length
+        while i < l
+          grouped_selections = @all_selections[i]
+          selections_prototype_result = @all_selections[i + 1]
+          if (directives_owner = grouped_selections.delete(:__node))
+            directives = directives_owner.directives
+            continue_execution = true
+            directives.each do |dir_node|
+              dir_defn = @runner.runtime_directives[dir_node.name]
+              if dir_defn # not present for `skip` or `include`
+                dir_args = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                result = case directives_owner
+                when Language::Nodes::FragmentSpread
+                  dir_defn.resolve_fragment_spread(directives_owner, @parent_type, @objects, dir_args, self.query.context)
+                when Language::Nodes::InlineFragment
+                  dir_defn.resolve_inline_fragment(directives_owner, @parent_type, @objects, dir_args, self.query.context)
+                else
+                  raise ArgumentError, "Unhandled directive owner (#{directives_owner.class}): #{directives_owner.inspect}"
+                end
+                if result.is_a?(Finalizer)
+                  result.path = path
+                  @results.each do |r|
+                    @runner.add_finalizer(@query, r, nil, result)
+                  end
+                  if result.is_a?(HaltExecution)
+                    continue_execution = false
+                    break
+                  end
+                end
+
+                if continue_execution
+                  prototype_result.merge!(selections_prototype_result)
+                  grouped_selections.each_value { |v| continue_selections << v }
+                end
+              else
+                grouped_selections.each_value { |v| continue_selections << v }
+              end
+            end
+          else
+            grouped_selections.each_value { |v| continue_selections << v }
+          end
+
+          if @clobber
+            i2 = 0
+            l2 = @results.length
+            while i2 < l2
+              @results[i2].replace(prototype_result)
+              i2 += 1
+            end
+          end
+
+          continue_selections.each do |frs|
+            @runner.add_step(frs)
+          end
+
+          i += 2
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 require "graphql/execution/directive_checks"
+require "graphql/execution/next"
 require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
 require "graphql/execution/lookahead"
 require "graphql/execution/multiplex"
-require "graphql/execution/next"
 require "graphql/execution/errors"
 
 module GraphQL
@@ -14,7 +14,7 @@ module GraphQL
       attr_accessor :path
       def ast_nodes=(_ignored); end
 
-      def assign_graphql_result(query, result_data, key)
+      def finalize_graphql_result(query, result_data, key)
         result_data.delete(key)
       end
     end

data/lib/graphql/execution_error.rb

@@ -36,7 +36,7 @@ module GraphQL
       super(message)
     end
 
-    def assign_graphql_result(query, result_data, key)
+    def finalize_graphql_result(query, result_data, key)
       result_data[key] = nil
     end
 

data/lib/graphql/query/context.rb

@@ -126,6 +126,12 @@ module GraphQL
         nil
       end
 
+      # @param value [Object] Any object to be inserted directly into the final response
+      # @return [GraphQL::Execution::Interpreter::RawValue] Return this from the field
+      def raw_value(value)
+        GraphQL::Execution::Interpreter::RawValue.new(value)
+      end
+
       # @example Print the GraphQL backtrace during field resolution
       #   puts ctx.backtrace
       #