graphql 2.5.19 → 2.5.21

data/lib/graphql/execution/next/load_argument_step.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Next
+      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
+        end
+
+        def value
+          @loaded_value = @field_resolve_step.sync(@loaded_value)
+          assign_value
+        end
+
+        def call
+          context = @field_resolve_step.selections_step.query.context
+          @loaded_value = @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
+          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 = err
+          assign_value
+        rescue StandardError => stderr
+          @loaded_value = begin
+            context.query.handle_or_reraise(stderr)
+          rescue GraphQL::ExecutionError => ex_err
+            ex_err
+          end
+          assign_value
+        end
+
+        private
+
+        def assign_value
+          if @loaded_value.is_a?(GraphQL::Error)
+            @loaded_value.path = @field_resolve_step.path
+            @field_resolve_step.arguments = @loaded_value
+          else
+            @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
+end

data/lib/graphql/execution/next/prepare_object_step.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Next
+      class PrepareObjectStep
+        def initialize(static_type:, object:, runner:, graphql_result:, key:, is_non_null:, field_resolve_step:, next_objects:, next_results:, is_from_array:)
+          @static_type = static_type
+          @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
+            ctx.query.current_trace.begin_resolve_type(@static_type, @object, ctx)
+            @resolved_type, _ignored_value = @field_resolve_step.sync(@resolved_type)
+            ctx.query.current_trace.end_resolve_type(@static_type, @object, ctx, @resolved_type)
+          end
+          @runner.add_step(self)
+        end
+
+        def call
+          case @next_step
+          when :resolve_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(@resolve_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::Error => 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::Error => 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] = @static_type
+          end
+
+          @field_resolve_step.authorized_finished(self)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/next/runner.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Next
+      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
+          @selected_operation = nil
+          @dataloader = multiplex.context[:dataloader] ||= @schema.dataloader_class.new
+          @resolves_lazies = @schema.resolves_lazies?
+          @lazy_cache = resolves_lazies ? {}.compare_by_identity : nil
+          @field_resolve_step_class = @schema.uses_raw_value? ? RawValueFieldResolveStep : FieldResolveStep
+          @authorization = authorization
+          if @authorization
+            @authorizes_cache = Hash.new do |h, query_context|
+              h[query_context] = {}.compare_by_identity
+            end.compare_by_identity
+          end
+        end
+
+        def resolve_type(type, object, query)
+          query.current_trace.begin_resolve_type(@static_type, object, query.context)
+          resolved_type, _ignored_new_value = query.resolve_type(type, object)
+          query.current_trace.end_resolve_type(@static_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
+
+        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
+
+              selected_operation = query.document.definitions.first # TODO select named operation
+              data = {}
+
+              root_type = case selected_operation.operation_type
+              when nil, "query"
+                @schema.query
+              when "mutation"
+                @schema.mutation
+              when "subscription"
+                @schema.subscription
+              else
+                raise ArgumentError, "Unknown operation type: #{selected_operation.operation_type.inspect}"
+              end
+
+              if self.authorization && authorizes?(root_type, query.context)
+                query.current_trace.begin_authorized(root_type, query.root_value, query.context)
+                auth_check = schema.sync_lazy(root_type.authorized?(query.root_value, query.context))
+                query.current_trace.end_authorized(root_type, query.root_value, query.context, auth_check)
+                root_value = if auth_check
+                  query.root_value
+                else
+                  begin
+                    auth_err = GraphQL::UnauthorizedError.new(object: query.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
+                    query.context.add_error(ex_err)
+                    nil
+                  end
+                end
+
+                if !auth_check
+                  results << {}
+                  next
+                end
+              else
+                root_value = query.root_value
+              end
+
+              results << { "data" => data }
+
+              case selected_operation.operation_type
+              when nil, "query"
+                isolated_steps[0] << SelectionsStep.new(
+                  parent_type: root_type,
+                  selections: selected_operation.selections,
+                  objects: [root_value],
+                  results: [data],
+                  path: EmptyObjects::EMPTY_ARRAY,
+                  runner: self,
+                  query: query,
+                )
+              when "mutation"
+                fields = {}
+                gather_selections(root_type, selected_operation.selections, nil, query, {}, into: fields)
+                fields.each_value do |field_resolve_step|
+                  isolated_steps << [SelectionsStep.new(
+                    parent_type: root_type,
+                    selections: field_resolve_step.ast_nodes || Array(field_resolve_step.ast_node),
+                    objects: [root_value],
+                    results: [data],
+                    path: EmptyObjects::EMPTY_ARRAY,
+                    runner: self,
+                    query: query,
+                  )]
+                end
+              when "subscription"
+                raise ArgumentError, "TODO implement subscriptions"
+              else
+                raise ArgumentError, "Unhandled operation type: #{operation.operation_type.inspect}"
+              end
+
+              @static_type_at[data] = root_type
+
+              # TODO This is stupid but makes multiplex_spec.rb pass
+              trace.execute_query(query: query) do
+              end
+            end
+
+            while (next_isolated_steps = isolated_steps.shift)
+              next_isolated_steps.each do |step|
+                add_step(step)
+              end
+              @dataloader.run
+            end
+
+            # TODO This is stupid but makes multiplex_spec.rb pass
+            trace.execute_query_lazy(query: nil, multiplex: @multiplex) do
+            end
+
+            queries.each_with_index.map do |query, idx|
+              result = results[idx]
+              fin_result = if query.context.errors.empty?
+                result
+              else
+                data = result["data"]
+                data = propagate_errors(data, query)
+                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
+
+              GraphQL::Query::Result.new(query: query, values: fin_result)
+            end
+          end
+        ensure
+          Fiber[:__graphql_current_multiplex] = nil
+        end
+
+        def gather_selections(type_defn, ast_selections, selections_step, query, 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
+
+                @field_resolve_step_class.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)
+                gather_selections(type_defn, ast_selection.selections, selections_step, query, prototype_result, into: into)
+              end
+            when GraphQL::Language::Nodes::FragmentSpread
+              fragment_definition = query.document.definitions.find { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
+              type_condition = fragment_definition.type.name
+              if type_condition_applies?(query.context, type_defn, type_condition)
+                gather_selections(type_defn, fragment_definition.selections, selections_step, query, 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
+
+        private
+
+        def propagate_errors(data, query)
+          paths_to_check = query.context.errors.map(&:path)
+          paths_to_check.compact! # root-level auth errors currently come without a path
+          # TODO dry with above?
+          # This is also where a query-level "Step" would be used?
+          selected_operation = query.document.definitions.first # TODO pick a selected operation
+          root_type = case selected_operation.operation_type
+          when nil, "query"
+            query.schema.query
+          when "mutation"
+            query.schema.mutation
+          when "subscription"
+            raise "Not implemented yet, TODO"
+          end
+          check_object_result(query, data, root_type, selected_operation.selections, [], [], paths_to_check)
+        end
+
+        def check_object_result(query, result_h, static_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+          current_path_len = current_exec_path.length
+          ast_selections.each do |ast_selection|
+            case ast_selection
+            when Language::Nodes::Field
+              begin
+                key = ast_selection.alias || ast_selection.name
+                current_exec_path << key
+                current_result_path << key
+                if paths_to_check.any? { |path_to_check| path_to_check[current_path_len] == key }
+                  result_value = result_h[key]
+                  field_defn = query.context.types.field(static_type, ast_selection.name)
+                  result_type = field_defn.type
+                  if (result_type_non_null = result_type.non_null?)
+                    result_type = result_type.of_type
+                  end
+                  new_result_value = if result_value.is_a?(GraphQL::Error)
+                    result_value.path = current_result_path.dup
+                    nil
+                  else
+                    if result_type.list?
+                      check_list_result(query, result_value, result_type.of_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+                    elsif result_type.kind.leaf?
+                      result_value
+                    else
+                      check_object_result(query, result_value, result_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+                    end
+                  end
+
+                  if new_result_value.nil? && result_type_non_null
+                    return nil
+                  else
+                    result_h[key] = new_result_value
+                  end
+                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 && type_condition_applies?(query.context, static_type_at_result, ast_selection.type.name)
+                result_h = check_object_result(query, result_h, static_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+              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 && type_condition_applies?(query.context, static_type_at_result, fragment_defn.type.name)
+                result_h = check_object_result(query, result_h, static_type, fragment_defn.selections, current_exec_path, current_result_path, paths_to_check)
+              end
+            end
+          end
+
+          result_h
+        end
+
+        def check_list_result(query, result_arr, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+          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
+          result_arr.map!.with_index do |result_item, idx|
+            current_result_path << idx
+            new_result = if result_item.is_a?(GraphQL::Error)
+              result_item.path = current_result_path.dup
+              nil
+            elsif inner_type.list?
+              check_list_result(query, result_item, inner_type.of_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+            elsif inner_type.kind.leaf?
+              result_item
+            else
+              check_object_result(query, result_item, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+            end
+
+            if new_result.nil? && inner_type_non_null
+              new_invalid_null = true
+              nil
+            else
+              new_result
+            end
+          ensure
+            current_result_path.pop
+          end
+
+          if new_invalid_null
+            nil
+          else
+            result_arr
+          end
+        end
+
+        def dir_arg_value(query, arg_node)
+          if arg_node.value.is_a?(Language::Nodes::VariableIdentifier)
+            var_key = arg_node.value.name
+            if query.variables.key?(var_key)
+              query.variables[var_key]
+            else
+              query.variables[var_key.to_sym]
+            end
+          else
+            arg_node.value
+          end
+        end
+        def directives_include?(query, ast_selection)
+          if ast_selection.directives.any? { |dir_node|
+                if dir_node.name == "skip"
+                  dir_node.arguments.any? { |arg_node| arg_node.name == "if" && dir_arg_value(query, arg_node) == true } # rubocop:disable Development/ContextIsPassedCop
+                elsif dir_node.name == "include"
+                  dir_node.arguments.any? { |arg_node| arg_node.name == "if" && dir_arg_value(query, arg_node) == false } # rubocop:disable Development/ContextIsPassedCop
+                end
+              }
+            false
+          else
+            true
+          end
+        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
+      end
+    end
+  end
+end

data/lib/graphql/execution/next/selections_step.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Next
+      class SelectionsStep
+        def initialize(parent_type:, selections:, objects:, results:, runner:, query:, path:)
+          @path = path
+          @parent_type = parent_type
+          @selections = selections
+          @runner = runner
+          @objects = objects
+          @results = results
+          @query = query
+          @graphql_objects = nil
+        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
+          grouped_selections = {}
+          prototype_result = @results.first
+          @runner.gather_selections(@parent_type, @selections, self, self.query, prototype_result, into: grouped_selections)
+          @results.each { |r| r.replace(prototype_result) }
+          grouped_selections.each_value do |frs|
+            @runner.add_step(frs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/next.rb

@@ -0,0 +1,69 @@
+# 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"
+module GraphQL
+  module Execution
+    module Next
+      module SchemaExtension
+        def execute_next(query_str = nil, context: nil, document: nil, variables: nil, root_value: nil, validate: true, visibility_profile: nil)
+          multiplex_context = if context
+            {
+              backtrace: context[:backtrace],
+              tracers: context[:tracers],
+              trace: context[:trace],
+              dataloader: context[:dataloader],
+              trace_mode: context[:trace_mode],
+            }
+          else
+            {}
+          end
+          query_opts = {
+            query: query_str,
+            document: document,
+            context: context,
+            validate: validate,
+            variables: variables,
+            root_value: root_value,
+            visibility_profile: visibility_profile,
+          }
+          m_results = multiplex_next([query_opts], context: multiplex_context, max_complexity: nil)
+          m_results[0]
+        end
+
+        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)
+        schema.extend(SchemaExtension)
+        schema.execution_next_options = { authorization: authorization }
+      end
+
+      def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+        queries = query_options.map do |opts|
+          case opts
+          when Hash
+            schema.query_class.new(schema, nil, **opts)
+          when GraphQL::Query, GraphQL::Query::Partial
+            opts
+          else
+            raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+          end
+        end
+        multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+        runner = Runner.new(multiplex, **schema.execution_next_options)
+        runner.execute
+      end
+    end
+  end
+end

data/lib/graphql/execution.rb

@@ -4,6 +4,7 @@ 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