graphql 2.6.1 → 2.6.3

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,9 +110,13 @@ 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
+          trace.execute_query_lazy(query: @multiplex.queries.size == 1 ? @multiplex.queries.first : nil, multiplex: @multiplex) do
             while (next_isolated_steps = isolated_steps.shift)
               next_isolated_steps.each do |step|
                 add_step(step)
@@ -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/language.rb

@@ -47,13 +47,19 @@ module GraphQL
     def self.escape_single_quoted_newlines(query_str)
       scanner = StringScanner.new(query_str)
       inside_single_quoted_string = false
+      inside_triple_quoted_string = false
       new_query_str = nil
       while !scanner.eos?
-        if scanner.skip(/(?:\\"|[^"\n\r]|""")+/m)
+        if scanner.skip('"""')
+          inside_triple_quoted_string = !inside_triple_quoted_string
+          new_query_str && (new_query_str << scanner.matched)
+        elsif scanner.skip(/(?:\\"|[^"\n\r])+/m)
           new_query_str && (new_query_str << scanner.matched)
         elsif scanner.skip('"')
           new_query_str && (new_query_str << '"')
-          inside_single_quoted_string = !inside_single_quoted_string
+          if !inside_triple_quoted_string
+            inside_single_quoted_string = !inside_single_quoted_string
+          end
         elsif scanner.skip("\n")
           if inside_single_quoted_string
             new_query_str ||= query_str[0, scanner.pos - 1]

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

@@ -94,7 +94,7 @@ module GraphQL
         end
 
         if required == :nullable
-          self.owner.validates(required: { argument: arg_name })
+          self.owner.validates(required: { argument: @keyword })
         end
 
         if definition_block
@@ -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/interface.rb

@@ -101,7 +101,7 @@ module GraphQL
             end
 
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:ResolverMethods)
+              if ancestor != child_class && ancestor <= GraphQL::Schema::Interface && ancestor.const_defined?(:ResolverMethods, false)
                 child_class.extend(ancestor::ResolverMethods)
               end
             end

data/lib/graphql/schema/introspection_system.rb

@@ -105,11 +105,13 @@ module GraphQL
       end
 
       def load_constant(class_name)
-        const = @custom_namespace.const_get(class_name)
+        const = begin
+          @custom_namespace.const_get(class_name)
+        rescue NameError
+          # Dup the built-in so that the cached fields aren't shared
+          @built_in_namespace.const_get(class_name)
+        end
         dup_type_class(const)
-      rescue NameError
-        # Dup the built-in so that the cached fields aren't shared
-        dup_type_class(@built_in_namespace.const_get(class_name))
       end
 
       def get_fields_from_class(class_sym:)
@@ -133,23 +135,6 @@ module GraphQL
           end
         end
       end
-
-      class PerFieldProxyResolve
-        def initialize(object_class:, inner_resolve:)
-          @object_class = object_class
-          @inner_resolve = inner_resolve
-        end
-
-        def call(obj, args, ctx)
-          query_ctx = ctx.query.context
-          # Remove the QueryType wrapper
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
-          end
-          wrapped_object = @object_class.wrap(obj, query_ctx)
-          @inner_resolve.call(wrapped_object, args, ctx)
-        end
-      end
     end
   end
 end

data/lib/graphql/schema/printer.rb

@@ -58,8 +58,8 @@ module GraphQL
           end
         end
         schema = Class.new(GraphQL::Schema) {
-          use GraphQL::Schema::Visibility
           query(query_root)
+          use GraphQL::Schema::Visibility
           def self.visible?(member, _ctx)
             member.graphql_name != "Root"
           end

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)