graphql 2.5.23 → 2.5.25

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

@@ -1,64 +0,0 @@
-# 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 = begin
-            @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
-          rescue GraphQL::UnauthorizedError => auth_err
-            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 = 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

@@ -1,129 +0,0 @@
-# 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(@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::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

@@ -1,411 +0,0 @@
-# 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(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
-
-        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"
-                if !query.subscription_update?
-                  schema.subscriptions.initialize_subscriptions(query)
-                end
-                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,
-                )
-              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]
-              if query.subscription?
-                @schema.subscriptions.finish_subscriptions(query)
-              end
-
-              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
-
-              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, 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?
-          if (selected_operation = query.selected_operation)
-            root_type = case selected_operation.operation_type
-            when nil, "query"
-              query.schema.query
-            when "mutation"
-              query.schema.mutation
-            when "subscription"
-              query.schema.subscription
-            end
-            check_object_result(query, data, root_type, selected_operation.selections, [], [], paths_to_check)
-          end
-        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
-                    result_value.assign_graphql_result(query, result_h, key)
-                    result_h.key?(key) ? result_h[key] : :unassigned
-                  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?
-                      check_object_result(query, result_value, result_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
-                    else
-                      result_value
-                    end
-                  end
-
-                  if new_result_value.nil? && result_type_non_null
-                    return nil
-                  elsif :unassigned.equal?(new_result_value)
-                    # Do nothing
-                  elsif !new_result_value.equal?(result_value)
-                    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.each_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
-              result_item.assign_graphql_result(query, result_arr, idx)
-              result_arr[idx]
-            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?
-              check_object_result(query, result_item, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
-            else
-              result_item
-            end
-
-            if new_result.nil? && inner_type_non_null
-              new_invalid_null = true
-              result_arr[idx] = nil
-            elsif !new_result.equal?(result_item)
-              result_arr[idx] = 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

@@ -1,37 +0,0 @@
-# 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