graphql 2.6.1 → 2.6.2

data/lib/graphql/execution/runner.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Execution
     class Runner
-      def initialize(multiplex, authorization:)
+      def initialize(multiplex)
         @multiplex = multiplex
         @schema = multiplex.schema
         @steps_queue = []
@@ -32,23 +32,13 @@ module GraphQL
         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
+        @authorizes_cache = Hash.new do |h, query_context|
+          h[query_context] = {}.compare_by_identity
+        end.compare_by_identity
       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])
@@ -63,7 +53,7 @@ module GraphQL
         @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
+      attr_reader :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)
@@ -120,6 +110,10 @@ module GraphQL
             trace.execute_query(query: query) do
               begin_execute(isolated_steps, results, query, root_type, root_value)
             end
+          rescue GraphQL::RuntimeError => err
+            err.ast_node = query.selected_operation
+            err.path = query.path
+            query.context.add_error(err)
           end
 
           trace.execute_query_lazy(query: nil, multiplex: @multiplex) do
@@ -137,8 +131,10 @@ module GraphQL
             fin_result = if (!@finalizers&.key?(query) && query.context.errors.empty?) || !query.valid?
               result
             else
-              data = result["data"]
-              data = Finalize.new(query, data, self).run
+              if result
+                data = result["data"]
+                data = Finalize.new(query, data, self).run
+              end
               errors = []
               query.context.errors.each do |err|
                 if err.respond_to?(:to_h)
@@ -154,6 +150,9 @@ module GraphQL
             end
 
             query.result_values = fin_result
+            if query.context.namespace?(:__query_result_extensions__)
+              query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+            end
             query.result
           end
         end
@@ -228,12 +227,13 @@ module GraphQL
 
       def begin_execute(isolated_steps, results, query, root_type, root_value)
         data = {}
+        @static_type_at[data] = root_type
         selected_operation = query.selected_operation
         beginning_path = query.path
 
         case root_type.kind.name
         when "OBJECT"
-          if self.authorization && authorizes?(root_type, query.context)
+          if 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)
@@ -265,10 +265,40 @@ module GraphQL
           objects = [root_value]
           query.current_trace.objects(root_type, objects, query.context)
 
+          if query.is_a?(GraphQL::Query) && uses_runtime_directives && (query_dirs = selected_operation.directives).any? # rubocop:disable Development/NoneWithoutBlockCop
+            continue_execution = true
+            query_dirs.each do |dir_node|
+              dir_defn = runtime_directives[dir_node.name] || raise(GraphQL::Error, "No directive definition found for: #{dir_node.name.inspect}")
+              dir_args, errors = input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+              if errors
+                errors.each { |e|
+                  e.ast_node = dir_node
+                  e.path = beginning_path
+                  query.context.add_error(e)
+                }
+                continue_execution = false
+                break
+              end
+              result = dir_defn.resolve_operation(selected_operation, query, objects, dir_args, query.context)
+              if result.is_a?(Finalizer)
+                result.path = path
+                add_finalizer(query, result, nil, data)
+                if result.is_a?(HaltExecution)
+                  continue_execution = false
+                  break
+                end
+              end
+            end
+
+            if !continue_execution
+              return
+            end
+          end
+
           if query.query?
             isolated_steps[0] << SelectionsStep.new(
               parent_type: root_type,
-              selections: query.selected_operation.selections,
+              selections: selected_operation.selections,
               objects: objects,
               results: [data],
               path: beginning_path,
@@ -313,17 +343,19 @@ module GraphQL
             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 = ResolveTypeStep.resolve_type(root_type, root_value, query)
+          if resolves_lazies && lazy?(resolved_type)
             resolved_type = schema.sync_lazy(resolved_type)
           end
+          resolved_type, root_value = resolved_type
+          ResolveTypeStep.assert_valid_resolved_type(root_type, resolved_type, root_value, nil, query: query)
           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,
+            selections: selected_operation.selections,
             objects: objects,
             results: [data],
             path: beginning_path,
@@ -340,7 +372,7 @@ module GraphQL
             results << { "data" => list_result }
             isolated_steps[0] << SelectionsStep.new(
               parent_type: inner_type,
-              selections: query.selected_operation.selections,
+              selections: selected_operation.selections,
               objects: root_value,
               results: list_result,
               path: beginning_path,
@@ -353,18 +385,21 @@ module GraphQL
         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
+              case dir_node.name
+              when "skip"
+                skip_args, _errors = @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
+              when "include"
+                include_args, _errors = @input_values[query].argument_values(GraphQL::Schema::Directive::Include, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
                 include_args[:if] == false
+              else
+                dir_defn = runtime_directives[dir_node.name]
+                dir_args, _errors = @input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                !dir_defn.include?(nil, dir_args, query.context)
               end
             }
           false

data/lib/graphql/execution/selections_step.rb

@@ -38,7 +38,7 @@ module GraphQL
             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
+                dir_args, _errors = @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)

data/lib/graphql/execution.rb

@@ -15,7 +15,14 @@ module GraphQL
       def ast_nodes=(_ignored); end
 
       def finalize_graphql_result(query, result_data, key)
-        result_data.delete(key)
+        case result_data
+        when Hash
+          result_data.delete(key)
+        when Array
+          result_data.delete_at(key)
+        else
+          raise "Unexpected result data #{result_data.class}: #{result_data}"
+        end
       end
     end
   end

data/lib/graphql/execution_error.rb

@@ -4,17 +4,6 @@ module GraphQL
   # the error will be inserted into the response's `"errors"` key
   # and the field will resolve to `nil`.
   class ExecutionError < GraphQL::RuntimeError
-    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
-    def ast_node
-      ast_nodes&.first
-    end
-
-    def ast_node=(new_node)
-      @ast_nodes = [new_node]
-    end
-
-    attr_accessor :ast_nodes
-
     # @return [String] an array describing the JSON-path into the execution
     # response which corresponds to this error.
     attr_accessor :path
@@ -37,7 +26,12 @@ module GraphQL
     end
 
     def finalize_graphql_result(query, result_data, key)
-      result_data[key] = nil
+      if ast_node.is_a?(GraphQL::Language::Nodes::Directive)
+        # This is for backwards compatibility ... what does the spec say?
+        result_data.delete(key)
+      else
+        result_data[key] = nil
+      end
     end
 
     # @return [Hash] An entry for the response's "errors" key

data/lib/graphql/introspection/entry_points.rb

@@ -2,8 +2,8 @@
 module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
-      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true, resolve_static: :__schema
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true, resolve_static: :__type do
+      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true, resolve_static: true
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true, resolve_static: true do
         argument :name, String
       end
 

data/lib/graphql/introspection/schema_type.rb

@@ -13,12 +13,16 @@ module GraphQL
       field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
       field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false, scope: false
-      field :description, String, resolver_method: :schema_description
+      field :description, String, resolver_method: :schema_description, resolve_static: :schema_description
 
-      def schema_description
+      def self.schema_description(context)
         context.schema.description
       end
 
+      def schema_description
+        self.class.schema_description(context)
+      end
+
       def types
         query_types = context.types.all_types
         types = query_types + context.schema.extra_types

data/lib/graphql/language/lexer.rb

@@ -130,7 +130,7 @@ module GraphQL
         elsif token_name == :STRING
           string_value
         elsif @scanner.matched_size.nil?
-          @scanner.peek(1)
+          @string.byteslice(@scanner.pos - 1, 1)
         else
           token_value
         end

data/lib/graphql/language/parser.rb

@@ -806,7 +806,7 @@ module GraphQL
 
       def expect_token(expected_token_name)
         unless @token_name == expected_token_name
-          raise_parse_error("Expected #{expected_token_name}, actual: #{token_name || "(none)"} (#{debug_token_value.inspect})")
+          raise_parse_error("Expected #{expected_token_name}, #{@token_name == false ? "not end of file" : "actual: #{@token_name} (#{debug_token_value.inspect})"}")
         end
         advance_token
       end

data/lib/graphql/pagination/connections.rb

@@ -85,9 +85,7 @@ module GraphQL
 
       def populate_connection(field, object, value, original_arguments, context)
         if value.is_a? GraphQL::ExecutionError
-          # This isn't even going to work because context doesn't have ast_node anymore
-          context.add_error(value)
-          nil
+          raise value
         elsif value.nil?
           nil
         elsif value.is_a?(GraphQL::Pagination::Connection)

data/lib/graphql/query.rb

@@ -45,8 +45,8 @@ module GraphQL
       end
 
       # @api private
-      def handle_or_reraise(err)
-        @schema.handle_or_reraise(context, err)
+      def handle_or_reraise(err, **kwargs)
+        @schema.handle_or_reraise(context, err, **kwargs)
       end
     end
 

data/lib/graphql/schema/argument.rb

@@ -165,8 +165,8 @@ module GraphQL
         true
       end
 
-      def authorizes?(_context)
-        self.method(:authorized?).owner != GraphQL::Schema::Argument
+      def authorizes?(context)
+        self.method(:authorized?).owner != GraphQL::Schema::Argument || type.unwrap.authorizes?(context)
       end
 
       def authorized?(obj, value, ctx)

data/lib/graphql/schema/directive/feature.rb

@@ -60,6 +60,10 @@ module GraphQL
         def self.enabled?(flag_name, object, context)
           raise GraphQL::RequiredImplementationMissingError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
         end
+
+        def self.resolve_field(...); end
+        def self.resolve_fragment_spread(...); end
+        def self.resolve_inline_fragment(...); end
       end
     end
   end

data/lib/graphql/schema/directive/transform.rb

@@ -54,6 +54,26 @@ module GraphQL
             nil
           end
         end
+
+        def self.resolve_field(ast_nodes, parent_type, field_defn, objects, arguments, context)
+          transform_name = arguments[:by]
+          if TRANSFORMS.include?(transform_name)
+            Transformer.new(transform_name)
+          else
+            nil
+          end
+        end
+
+        class Transformer
+          include Execution::PostProcessor
+          def initialize(transform)
+            @transform = transform
+          end
+          def after_resolve(field_results)
+            field_results.map! { |r| r.respond_to?(@transform) ? r.public_send(@transform) : r }
+            field_results
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/has_single_input_argument.rb

@@ -4,10 +4,30 @@ module GraphQL
   class Schema
     module HasSingleInputArgument
       def resolve_with_support(**inputs)
-        if inputs[:input].is_a?(InputObject)
-          input = inputs[:input].to_kwargs
+        input_kwargs = flatten_arguments(inputs)
+        if !input_kwargs.empty?
+          super(**input_kwargs)
+        else
+          super()
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def call
+        @prepared_arguments = flatten_arguments(@prepared_arguments)
+        super
+      end
+
+      private
+
+      def flatten_arguments(inputs)
+        input = if inputs[:input].is_a?(InputObject)
+          inputs[:input].to_kwargs
         else
-          input = inputs[:input]
+          inputs[:input]
         end
 
         new_extras = field ? field.extras : []
@@ -24,7 +44,6 @@ module GraphQL
         end
 
         if input
-          # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
           input_kwargs = input.to_h
         else
           # Relay Classic Mutations with no `argument`s
@@ -32,15 +51,7 @@ module GraphQL
           input_kwargs = {}
         end
 
-        if !input_kwargs.empty?
-          super(**input_kwargs)
-        else
-          super()
-        end
-      end
-
-      def self.included(base)
-        base.extend(ClassMethods)
+        input_kwargs
       end
 
       module ClassMethods

data/lib/graphql/schema/input_object.rb

@@ -113,6 +113,10 @@ module GraphQL
       end
 
       class << self
+        def authorizes?(ctx)
+          self.method(:authorized?).owner != GraphQL::Schema::InputObject
+        end
+
         def authorized?(obj, value, ctx)
           # Authorize each argument (but this doesn't apply if `prepare` is implemented):
           if value.respond_to?(:key?)

data/lib/graphql/schema/ractor_shareable.rb

@@ -72,6 +72,7 @@ module GraphQL
           # How to support it?
           def lazy?(_obj); false; end
           def sync_lazy(obj); obj; end
+          def resolves_lazies?; false; end
         end
       end
     end

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -25,7 +25,7 @@ module GraphQL
       argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
 
       # The payload should always include this field
-      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", hash_key: :client_mutation_id)
       # Relay classic default:
       null(true)
 
@@ -35,7 +35,6 @@ module GraphQL
         input = inputs[:input].to_kwargs
 
         if input
-          # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
           input_kwargs = input.to_h
           client_mutation_id = input_kwargs.delete(:client_mutation_id)
           inputs[:input] = input_kwargs
@@ -51,6 +50,21 @@ module GraphQL
           return_hash
         end
       end
+
+      def call
+        input = @prepared_arguments[:input]&.to_kwargs
+
+        if input
+          client_mutation_id = input.delete(:client_mutation_id)
+          @prepared_arguments[:input] = input
+        end
+
+        super
+
+        if (return_value = exec_result[exec_index]).is_a?(Hash)
+          return_value[:client_mutation_id] = client_mutation_id
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/resolver.rb

@@ -60,9 +60,6 @@ module GraphQL
       attr_writer :prepared_arguments
 
       def call
-        if self.class < Schema::HasSingleInputArgument
-          @prepared_arguments = @prepared_arguments[:input]
-        end
         q = context.query
         trace_objs = [object]
         q.current_trace.begin_execute_field(field, @prepared_arguments, trace_objs, q)
@@ -96,10 +93,6 @@ module GraphQL
 
         result = if is_authed
           Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
-          if q.subscription? && @field.owner == context.schema.subscription
-            # This needs to use arguments without `loads:`. TODO extract this into subscription-related code somehow?
-            @original_arguments = @field_resolve_step.runner.input_values[q].argument_values(@field, @field_resolve_step.ast_node.arguments, nil)
-          end
           call_resolve(@prepared_arguments)
         elsif new_return_value.nil?
           err = UnauthorizedFieldError.new(object: object, type: @field_resolve_step.parent_type, context: context, field: @field)

data/lib/graphql/schema/subscription.rb

@@ -30,14 +30,47 @@ module GraphQL
         end
       end
 
+      # @api private
+      def call_resolve(args_hash)
+        if @field_resolve_step.nil?
+          super
+        else
+          context.namespace(:subscriptions)[:update_event] = event
+          result = nil
+          unsubscribed = true
+          unsubscribed_result = nil
+          begin
+            result = super
+            unsubscribed = false
+          rescue EarlyUnsubscribe => err
+            unsubscribed_result = err.unsubscribed_result
+          end
+
+
+          if unsubscribed
+            if unsubscribed_result
+              context.namespace(:subscriptions)[:final_update] = true
+              unsubscribed_result
+            else
+              context.skip
+            end
+          else
+            result
+          end
+        end
+      end
+
       # @api private
       def resolve_with_support(**args)
         @original_arguments = args # before `loads:` have been run
         result = nil
         unsubscribed = true
-        unsubscribed_result = catch :graphql_subscription_unsubscribed do
+        unsubscribed_result = nil
+        begin
           result = super
           unsubscribed = false
+        rescue EarlyUnsubscribe => err
+          unsubscribed_result = err.unsubscribed_result
         end
 
 
@@ -114,7 +147,13 @@ module GraphQL
       # @return [void]
       def unsubscribe(update_value = nil)
         context.namespace(:subscriptions)[:unsubscribed] = true
-        throw :graphql_subscription_unsubscribed, update_value
+        err = EarlyUnsubscribe.new
+        err.unsubscribed_result = update_value
+        raise err
+      end
+
+      class EarlyUnsubscribe < GraphQL::RuntimeError
+        attr_accessor :unsubscribed_result
       end
 
       # Call this method to provide a new subscription_scope; OR
@@ -187,12 +226,18 @@ module GraphQL
 
       # @return [Subscriptions::Event] This object is used as a representation of this subscription for the backend
       def event
-        @event ||= Subscriptions::Event.new(
-          name: field.name,
-          arguments: @original_arguments,
-          context: context,
-          field: field,
-        )
+        @event ||= begin
+          if @original_arguments.nil? && @field_resolve_step
+            @original_arguments, _errors = @field_resolve_step.arguments_without_loads
+          end
+
+          Subscriptions::Event.new(
+            name: field.name,
+            arguments: @original_arguments,
+            context: context,
+            field: field,
+          )
+        end
       end
     end
   end

data/lib/graphql/schema/timeout.rb

@@ -68,7 +68,7 @@ module GraphQL
           super
         end
 
-        def execute_field(query:, field:, **_rest)
+        def begin_execute_field(field, _arguments, _objects, query)
           timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
           if timeout_state == false
@@ -84,7 +84,7 @@ module GraphQL
 
             # `handle_timeout` may have set this to be `false`
             if timeout_state != false
-              error
+              raise error
             else
               super
             end

data/lib/graphql/schema/visibility/visit.rb

@@ -102,7 +102,7 @@ module GraphQL
 
             missed_late_types_streak = 0
             while (owner, late_type = @late_bound_types.shift)
-              if (late_type.is_a?(String) && (type = Member::BuildType.constantize(type))) ||
+              if (late_type.is_a?(String) && (type = Member::BuildType.constantize(late_type))) ||
                   (late_type.is_a?(LateBoundType) && (type = @visited_types.find { |t| t.graphql_name == late_type.graphql_name }))
                 missed_late_types_streak = 0 # might succeed next round
                 update_type_owner(owner, type)