graphql 2.0.32 → 2.5.22

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "graphql/types/string"
 
 module GraphQL
   class Schema
@@ -21,6 +20,10 @@ module GraphQL
     # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
+      include GraphQL::Schema::HasSingleInputArgument
+
+      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.")
       # Relay classic default:
@@ -31,34 +34,14 @@ module GraphQL
       def resolve_with_support(**inputs)
         input = inputs[:input].to_kwargs
 
-        new_extras = field ? field.extras : []
-        all_extras = self.class.extras + new_extras
-
-        # Transfer these from the top-level hash to the
-        # shortcutted `input:` object
-        all_extras.each do |ext|
-          # It's possible that the `extra` was not passed along by this point,
-          # don't re-add it if it wasn't given here.
-          if inputs.key?(ext)
-            input[ext] = inputs[ext]
-          end
-        end
-
         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)
-        else
-          # Relay Classic Mutations with no `argument`s
-          # don't require `input:`
-          input_kwargs = {}
+          inputs[:input] = input_kwargs
         end
 
-        return_value = if input_kwargs.any?
-          super(**input_kwargs)
-        else
-          super()
-        end
+        return_value = super(**inputs)
 
         context.query.after_lazy(return_value) do |return_hash|
           # It might be an error
@@ -68,112 +51,6 @@ module GraphQL
           return_hash
         end
       end
-
-      class << self
-        def dummy
-          @dummy ||= begin
-            d = Class.new(GraphQL::Schema::Resolver)
-            d.argument_class(self.argument_class)
-            # TODO make this lazier?
-            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
-            d
-          end
-        end
-
-        def field_arguments(context = GraphQL::Query::NullContext)
-          dummy.arguments(context)
-        end
-
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
-          dummy.get_argument(name, context)
-        end
-
-        def own_field_arguments
-          dummy.own_arguments
-        end
-
-        def all_field_argument_definitions
-          dummy.all_argument_definitions
-        end
-
-        # Also apply this argument to the input type:
-        def argument(*args, own_argument: false, **kwargs, &block)
-          it = input_type # make sure any inherited arguments are already added to it
-          arg = super(*args, **kwargs, &block)
-
-          # This definition might be overriding something inherited;
-          # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
-          prev_args = it.own_arguments[arg.graphql_name]
-          case prev_args
-          when GraphQL::Schema::Argument
-            if prev_args.owner != self
-              it.own_arguments.delete(arg.graphql_name)
-            end
-          when Array
-            prev_args.reject! { |a| a.owner != self }
-            if prev_args.empty?
-              it.own_arguments.delete(arg.graphql_name)
-            end
-          end
-
-          it.add_argument(arg)
-          arg
-        end
-
-        # The base class for generated input object types
-        # @param new_class [Class] The base class to use for generating input object definitions
-        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
-        def input_object_class(new_class = nil)
-          if new_class
-            @input_object_class = new_class
-          end
-          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
-        end
-
-        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
-        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
-        def input_type(new_input_type = nil)
-          if new_input_type
-            @input_type = new_input_type
-          end
-          @input_type ||= generate_input_type
-        end
-
-        private
-
-        # Generate the input type for the `input:` argument
-        # To customize how input objects are generated, override this method
-        # @return [Class] a subclass of {.input_object_class}
-        def generate_input_type
-          mutation_args = all_argument_definitions
-          mutation_class = self
-          Class.new(input_object_class) do
-            class << self
-              def default_graphql_name
-                "#{self.mutation.graphql_name}Input"
-              end
-
-              def description(new_desc = nil)
-                super || "Autogenerated input type of #{self.mutation.graphql_name}"
-              end
-            end
-            mutation(mutation_class)
-            # these might be inherited:
-            mutation_args.each do |arg|
-              add_argument(arg)
-            end
-            argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
-          end
-        end
-      end
-
-      private
-
-      def authorize_arguments(args, values)
-        # remove the `input` wrapper to match values
-        input_args = args["input"].type.unwrap.arguments(context)
-        super(input_args, values)
-      end
     end
   end
 end

data/lib/graphql/schema/resolver.rb

@@ -8,6 +8,7 @@ module GraphQL
     # - Arguments, via `.argument(...)` helper, which will be applied to the field.
     # - Return type, via `.type(..., null: ...)`, which will be applied to the field.
     # - Description, via `.description(...)`, which will be applied to the field
+    # - Comment, via `.comment(...)`, which will be applied to the field
     # - Resolution, via `#resolve(**args)` method, which will be called to resolve the field.
     # - `#object` and `#context` accessors for use during `#resolve`.
     #
@@ -19,12 +20,16 @@ module GraphQL
     # @see {GraphQL::Function} `Resolver` is a replacement for `GraphQL::Function`
     class Resolver
       include Schema::Member::GraphQLTypeNames
-      # Really we only need description from here, but:
+      # Really we only need description & comment from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasAuthorization
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
+      extend Schema::Member::HasDirectives
+      include Schema::Member::HasDataloader
+      extend Schema::Member::HasDeprecationReason
 
       # @param object [Object] The application object that this field is being resolved on
       # @param context [GraphQL::Query::Context]
@@ -35,26 +40,64 @@ module GraphQL
         @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
-        self.class.arguments(context).each do |name, arg|
+        context.types.arguments(self.class).each do |arg|
           @arguments_by_keyword[arg.keyword] = arg
         end
         @prepared_arguments = nil
       end
 
+      attr_accessor :exec_result, :exec_index, :field_resolve_step
+
       # @return [Object] The application object this field is being resolved on
-      attr_reader :object
+      attr_accessor :object
 
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
-      # @return [GraphQL::Dataloader]
-      def dataloader
-        context.dataloader
-      end
-
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      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)
+        is_authed, new_return_value = authorized?(**@prepared_arguments)
+
+        if (runner = @field_resolve_step.runner).resolves_lazies && runner.schema.lazy?(is_authed)
+          is_authed, new_return_value = runner.schema.sync_lazy(is_authed)
+        end
+
+        result = if is_authed
+          Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
+          call_resolve(@prepared_arguments)
+        else
+          new_return_value
+        end
+        q = context.query
+        q.current_trace.end_execute_field(field, @prepared_arguments, trace_objs, q, [result])
+
+        exec_result[exec_index] = result
+      rescue RuntimeError => err
+        exec_result[exec_index] = err
+      rescue StandardError => stderr
+        exec_result[exec_index] = begin
+          context.query.handle_or_reraise(stderr)
+        rescue GraphQL::ExecutionError => ex_err
+          ex_err
+        end
+      ensure
+        field_pending_steps = field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if field_pending_steps.size == 0 && field_resolve_step.field_results
+          field_resolve_step.runner.add_step(field_resolve_step)
+        end
+      end
+
       def arguments
         @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
       end
@@ -65,7 +108,7 @@ module GraphQL
       # @api private
       def resolve_with_support(**args)
         # First call the ready? hook which may raise
-        raw_ready_val = if args.any?
+        raw_ready_val = if !args.empty?
           ready?(**args)
         else
           ready?
@@ -86,7 +129,7 @@ module GraphQL
               @prepared_arguments = loaded_args
               Schema::Validator.validate!(self.class.validators, object, context, loaded_args, as: @field)
               # Then call `authorized?`, which may raise or may return a lazy object
-              raw_authorized_val = if loaded_args.any?
+              raw_authorized_val = if !loaded_args.empty?
                 authorized?(**loaded_args)
               else
                 authorized?
@@ -103,11 +146,7 @@ module GraphQL
                   end
                 elsif authorized_val
                   # Finally, all the hooks have passed, so resolve it
-                  if loaded_args.any?
-                    public_send(self.class.resolve_method, **loaded_args)
-                  else
-                    public_send(self.class.resolve_method)
-                  end
+                  call_resolve(loaded_args)
                 else
                   raise GraphQL::UnauthorizedFieldError.new(context: context, object: object, type: field.owner, field: field)
                 end
@@ -117,6 +156,15 @@ module GraphQL
         end
       end
 
+      # @api private {GraphQL::Schema::Mutation} uses this to clear the dataloader cache
+      def call_resolve(args_hash)
+        if !args_hash.empty?
+          public_send(self.class.resolve_method, **args_hash)
+        else
+          public_send(self.class.resolve_method)
+        end
+      end
+
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
@@ -146,7 +194,7 @@ module GraphQL
       # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
       def authorized?(**inputs)
         arg_owner = @field # || self.class
-        args = arg_owner.arguments(context)
+        args = context.types.arguments(arg_owner)
         authorize_arguments(args, inputs)
       end
 
@@ -163,19 +211,22 @@ module GraphQL
       private
 
       def authorize_arguments(args, inputs)
-        args.each_value do |argument|
+        args.each do |argument|
           arg_keyword = argument.keyword
           if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
-            arg_auth, err = argument.authorized?(self, arg_value, context)
-            if !arg_auth
-              return arg_auth, err
-            else
-              true
+            auth_result = argument.authorized?(self, arg_value, context)
+            if auth_result.is_a?(Array)
+              # only return this second value if the application returned a second value
+              arg_auth, err = auth_result
+              if !arg_auth
+                return arg_auth, err
+              end
+            elsif auth_result == false
+              return auth_result
             end
-          else
-            true
           end
         end
+        true
       end
 
       def load_arguments(args)
@@ -198,23 +249,27 @@ module GraphQL
         end
 
         # Avoid returning a lazy if none are needed
-        if prepare_lazies.any?
+        if !prepare_lazies.empty?
           GraphQL::Execution::Lazy.all(prepare_lazies).then { prepared_args }
         else
           prepared_args
         end
       end
 
-      def get_argument(name, context = GraphQL::Query::NullContext)
+      def get_argument(name, context = GraphQL::Query::NullContext.instance)
         self.class.get_argument(name, context)
       end
 
       class << self
-        def field_arguments(context = GraphQL::Query::NullContext)
+        def field_arguments(context = GraphQL::Query::NullContext.instance)
           arguments(context)
         end
 
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
+        def any_field_arguments?
+          any_arguments?
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
           get_argument(name, context)
         end
 
@@ -380,7 +435,7 @@ module GraphQL
           if superclass.respond_to?(:extensions)
             s_exts = superclass.extensions
             if own_exts
-              if s_exts.any?
+              if !s_exts.empty?
                 own_exts + s_exts
               else
                 own_exts
@@ -393,11 +448,14 @@ module GraphQL
           end
         end
 
+        def inherited(child_class)
+          child_class.description(description)
+          super
+        end
+
         private
 
-        def own_extensions
-          @own_extensions
-        end
+        attr_reader :own_extensions
       end
     end
   end

data/lib/graphql/schema/scalar.rb

@@ -19,9 +19,9 @@ module GraphQL
 
         def specified_by_url(new_url = nil)
           if new_url
-            @specified_by_url = new_url
-          elsif defined?(@specified_by_url)
-            @specified_by_url
+            directive(GraphQL::Schema::Directive::SpecifiedBy, url: new_url)
+          elsif (directive = directives.find { |dir| dir.graphql_name == "specifiedBy" })
+            directive.arguments[:url] # rubocop:disable Development/ContextIsPassedCop
           elsif superclass.respond_to?(:specified_by_url)
             superclass.specified_by_url
           else
@@ -50,12 +50,7 @@ module GraphQL
           end
 
           if coerced_result.nil?
-            str_value = if value == Float::INFINITY
-              ""
-            else
-              " #{GraphQL::Language.serialize(value)}"
-            end
-            Query::InputValidationResult.from_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{graphql_name}")
           elsif coerced_result.is_a?(GraphQL::CoercionError)
             Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
           else

data/lib/graphql/schema/subscription.rb

@@ -19,29 +19,45 @@ module GraphQL
       # propagate null.
       null false
 
+      # @api private
       def initialize(object:, context:, field:)
         super
         # Figure out whether this is an update or an initial subscription
         @mode = context.query.subscription_update? ? :update : :subscribe
+        @subscription_written = false
+        @original_arguments = nil
+        if (subs_ns = context.namespace(:subscriptions)) &&
+          (sub_insts = subs_ns[:subscriptions])
+          sub_insts[context.current_path] = self
+        end
       end
 
+      # @api private
       def resolve_with_support(**args)
+        @original_arguments = args # before `loads:` have been run
         result = nil
         unsubscribed = true
-        catch :graphql_subscription_unsubscribed do
+        unsubscribed_result = catch :graphql_subscription_unsubscribed do
           result = super
           unsubscribed = false
         end
 
 
         if unsubscribed
-          context.skip
+          if unsubscribed_result
+            context.namespace(:subscriptions)[:final_update] = true
+            unsubscribed_result
+          else
+            context.skip
+          end
         else
           result
         end
       end
 
-      # Implement the {Resolve} API
+      # Implement the {Resolve} API.
+      # You can implement this if you want code to run for _both_ the initial subscription
+      # and for later updates. Or, implement {#subscribe} and {#update}
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
         # have an unexpected `@mode`
@@ -49,8 +65,9 @@ module GraphQL
       end
 
       # Wrap the user-defined `#subscribe` hook
+      # @api private
       def resolve_subscribe(**args)
-        ret_val = args.any? ? subscribe(**args) : subscribe
+        ret_val = !args.empty? ? subscribe(**args) : subscribe
         if ret_val == :no_response
           context.skip
         else
@@ -66,8 +83,9 @@ module GraphQL
       end
 
       # Wrap the user-provided `#update` hook
+      # @api private
       def resolve_update(**args)
-        ret_val = args.any? ? update(**args) : update
+        ret_val = !args.empty? ? update(**args) : update
         if ret_val == NO_UPDATE
           context.namespace(:subscriptions)[:no_update] = true
           context.skip
@@ -94,19 +112,20 @@ module GraphQL
       end
 
       # Call this to halt execution and remove this subscription from the system
-      def unsubscribe
+      # @param update_value [Object] if present, deliver this update before unsubscribing
+      # @return [void]
+      def unsubscribe(update_value = nil)
         context.namespace(:subscriptions)[:unsubscribed] = true
-        throw :graphql_subscription_unsubscribed
+        throw :graphql_subscription_unsubscribed, update_value
       end
 
-      READING_SCOPE = ::Object.new
       # Call this method to provide a new subscription_scope; OR
       # call it without an argument to get the subscription_scope
       # @param new_scope [Symbol]
       # @param optional [Boolean] If true, then don't require `scope:` to be provided to updates to this subscription.
       # @return [Symbol]
-      def self.subscription_scope(new_scope = READING_SCOPE, optional: false)
-        if new_scope != READING_SCOPE
+      def self.subscription_scope(new_scope = NOT_CONFIGURED, optional: false)
+        if new_scope != NOT_CONFIGURED
           @subscription_scope = new_scope
           @subscription_scope_optional = optional
         elsif defined?(@subscription_scope)
@@ -143,6 +162,40 @@ module GraphQL
       def self.topic_for(arguments:, field:, scope:)
         Subscriptions::Serialize.dump_recursive([scope, field.graphql_name, arguments])
       end
+
+      # Calls through to `schema.subscriptions` to register this subscription with the backend.
+      # This is automatically called by GraphQL-Ruby after a query finishes successfully,
+      # but if you need to commit the subscription during `#subscribe`, you can call it there.
+      # (This method also sets a flag showing that this subscription was already written.)
+      #
+      # If you call this method yourself, you may also need to {#unsubscribe}
+      # or call `subscriptions.delete_subscription` to clean up the database if the query crashes with an error
+      # later in execution.
+      # @return [void]
+      def write_subscription
+        if subscription_written?
+          raise GraphQL::Error, "`write_subscription` was called but `#{self.class}#subscription_written?` is already true. Remove a call to `write subscription`."
+        else
+          @subscription_written = true
+          context.schema.subscriptions.write_subscription(context.query, [event])
+        end
+        nil
+      end
+
+      # @return [Boolean] `true` if {#write_subscription} was called already
+      def subscription_written?
+        @subscription_written
+      end
+
+      # @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,
+        )
+      end
     end
   end
 end

data/lib/graphql/schema/timeout.rb

@@ -71,15 +71,23 @@ module GraphQL
         def execute_field(query:, field:, **_rest)
           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 && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+          if timeout_state == false
+            super
+          elsif Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
             error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
               @timeout.handle_timeout(error, query)
+              timeout_state = query.context.namespace(@timeout).fetch(:state)
             end
 
-            error
+            # `handle_timeout` may have set this to be `false`
+            if timeout_state != false
+              error
+            else
+              super
+            end
           else
             super
           end
@@ -102,6 +110,15 @@ module GraphQL
         # override to do something interesting
       end
 
+      # Call this method (eg, from {#handle_timeout}) to disable timeout tracking
+      # for the given query.
+      # @param query [GraphQL::Query]
+      # @return [void]
+      def disable_timeout(query)
+        query.context.namespace(self)[:state] = false
+        nil
+      end
+
       # This error is raised when a query exceeds `max_seconds`.
       # Since it's a child of {GraphQL::ExecutionError},
       # its message will be added to the response's `errors` key.

data/lib/graphql/schema/type_expression.rb

@@ -5,13 +5,13 @@ module GraphQL
     module TypeExpression
       # Fetch a type from a type map by its AST specification.
       # Return `nil` if not found.
-      # @param type_owner [#get_type] A thing for looking up types by name
+      # @param type_owner [#type] A thing for looking up types by name
       # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
       # @return [Class, GraphQL::Schema::NonNull, GraphQL::Schema:List]
       def self.build_type(type_owner, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
-          type_owner.get_type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
+          type_owner.type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
           inner_type = build_type(type_owner, ast_inner_type)

data/lib/graphql/schema/union.rb

@@ -10,8 +10,8 @@ module GraphQL
           super
         end
 
-        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
-          if types.any?
+        def possible_types(*types, context: GraphQL::Query::NullContext.instance, **options)
+          if !types.empty?
             types.each do |t|
               assert_valid_union_member(t)
               type_memberships << type_membership_class.new(self, t, **options)

data/lib/graphql/schema/unique_within_type.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'graphql/schema/base_64_bp'
+require "base64"
 
 module GraphQL
   class Schema