graphql 1.8.0 → 1.12.12

data/lib/graphql/schema/resolver.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/schema/resolver/has_payload_type"
 
 module GraphQL
   class Schema
@@ -23,12 +24,24 @@ module GraphQL
       # Really we only need description from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasValidators
+      include Schema::Member::HasPath
+      extend Schema::Member::HasPath
 
       # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
       # @param context [GraphQL::Query::Context]
-      def initialize(object:, context:)
+      # @param field [GraphQL::Schema::Field]
+      def initialize(object:, context:, field:)
         @object = object
         @context = context
+        @field = field
+        # Since this hash is constantly rebuilt, cache it for this call
+        @arguments_by_keyword = {}
+        self.class.arguments.each do |name, arg|
+          @arguments_by_keyword[arg.keyword] = arg
+        end
+        @arguments_loads_as_type = self.class.arguments_loads_as_type
+        @prepared_arguments = nil
       end
 
       # @return [Object] The application object this field is being resolved on
@@ -37,10 +50,152 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
+      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
+
+      # This method is _actually_ called by the runtime,
+      # it does some preparation and then eventually calls
+      # the user-defined `#resolve` method.
+      # @api private
+      def resolve_with_support(**args)
+        # First call the ready? hook which may raise
+        ready_val = if args.any?
+          ready?(**args)
+        else
+          ready?
+        end
+        context.schema.after_lazy(ready_val) do |is_ready, ready_early_return|
+          if ready_early_return
+            if is_ready != false
+              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{ready_early_return.inspect}]"
+            else
+              ready_early_return
+            end
+          elsif is_ready
+            # Then call each prepare hook, which may return a different value
+            # for that argument, or may return a lazy object
+            load_arguments_val = load_arguments(args)
+            context.schema.after_lazy(load_arguments_val) do |loaded_args|
+              @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
+              authorized_val = if loaded_args.any?
+                authorized?(**loaded_args)
+              else
+                authorized?
+              end
+              context.schema.after_lazy(authorized_val) do |(authorized_result, early_return)|
+                # If the `authorized?` returned two values, `false, early_return`,
+                # then use the early return value instead of continuing
+                if early_return
+                  if authorized_result == false
+                    early_return
+                  else
+                    raise "Unexpected result from #authorized? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{early_return.inspect}]"
+                  end
+                elsif authorized_result
+                  # 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
+                else
+                  nil
+                end
+              end
+            end
+          end
+        end
+      end
+
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
-        raise NotImplementedError, "#{self.class.name}#resolve should execute the field's logic"
+        raise GraphQL::RequiredImplementationMissingError, "#{self.class.name}#resolve should execute the field's logic"
+      end
+
+      # Called before arguments are prepared.
+      # Implement this hook to make checks before doing any work.
+      #
+      # If it returns a lazy object (like a promise), it will be synced by GraphQL
+      # (but the resulting value won't be used).
+      #
+      # @param args [Hash] The input arguments, if there are any
+      # @raise [GraphQL::ExecutionError] To add an error to the response
+      # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
+      # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
+      def ready?(**args)
+        true
+      end
+
+      # Called after arguments are loaded, but before resolving.
+      #
+      # Override it to check everything before calling the mutation.
+      # @param inputs [Hash] The input arguments
+      # @raise [GraphQL::ExecutionError] To add an error to the response
+      # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
+      # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
+      def authorized?(**inputs)
+        self.class.arguments.each_value 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
+            end
+          else
+            true
+          end
+        end
+      end
+
+      private
+
+      def load_arguments(args)
+        prepared_args = {}
+        prepare_lazies = []
+
+        args.each do |key, value|
+          arg_defn = @arguments_by_keyword[key]
+          if arg_defn
+            if value.nil?
+              prepared_args[key] = value
+            else
+              prepped_value = prepared_args[key] = load_argument(key, value)
+              if context.schema.lazy?(prepped_value)
+                prepare_lazies << context.schema.after_lazy(prepped_value) do |finished_prepped_value|
+                  prepared_args[key] = finished_prepped_value
+                end
+              end
+            end
+          else
+            # These are `extras: [...]`
+            prepared_args[key] = value
+          end
+        end
+
+        # Avoid returning a lazy if none are needed
+        if prepare_lazies.any?
+          GraphQL::Execution::Lazy.all(prepare_lazies).then { prepared_args }
+        else
+          prepared_args
+        end
+      end
+
+      def load_argument(name, value)
+        public_send("load_#{name}", value)
       end
 
       class << self
@@ -78,7 +233,7 @@ module GraphQL
         # or use it as a configuration method to assign a return type
         # instead of generating one.
         # TODO unify with {#null}
-        # @param new_type [Class, nil] If a type definition class is provided, it will be used as the return type of the field
+        # @param new_type [Class, Array<Class>, nil] If a type definition class is provided, it will be used as the return type of the field
         # @param null [true, false] Whether or not the field may return `nil`
         # @return [Class] The type which this field returns.
         def type(new_type = nil, null: nil)
@@ -99,23 +254,159 @@ module GraphQL
           end
         end
 
+        # Specifies the complexity of the field. Defaults to `1`
+        # @return [Integer, Proc]
+        def complexity(new_complexity = nil)
+          if new_complexity
+            @complexity = new_complexity
+          end
+          @complexity || (superclass.respond_to?(:complexity) ? superclass.complexity : 1)
+        end
+
+        def broadcastable(new_broadcastable)
+          @broadcastable = new_broadcastable
+        end
+
+        # @return [Boolean, nil]
+        def broadcastable?
+          if defined?(@broadcastable)
+            @broadcastable
+          else
+            (superclass.respond_to?(:broadcastable?) ? superclass.broadcastable? : nil)
+          end
+        end
+
+        # Get or set the `max_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited max page size".)
+        # @param max_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `max_page_size` assigned to fields that use this resolver
+        def max_page_size(new_max_page_size = :not_given)
+          if new_max_page_size != :not_given
+            @max_page_size = new_max_page_size
+          elsif defined?(@max_page_size)
+            @max_page_size
+          elsif superclass.respond_to?(:max_page_size)
+            superclass.max_page_size
+          else
+            nil
+          end
+        end
+
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `max_page_size`
+        def has_max_page_size?
+          defined?(@max_page_size) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
+        end
+
         def field_options
-          {
+          field_opts = {
             type: type_expr,
             description: description,
             extras: extras,
-            method: resolve_method,
+            resolver_method: :resolve_with_support,
             resolver_class: self,
             arguments: arguments,
             null: null,
+            complexity: complexity,
+            extensions: extensions,
+            broadcastable: broadcastable?,
           }
+
+          if has_max_page_size?
+            field_opts[:max_page_size] = max_page_size
+          end
+
+          field_opts
         end
 
         # A non-normalized type configuration, without `null` applied
-        # @api private
         def type_expr
           @type_expr || (superclass.respond_to?(:type_expr) ? superclass.type_expr : nil)
         end
+
+        # Add an argument to this field's signature, but
+        # also add some preparation hook methods which will be used for this argument
+        # @see {GraphQL::Schema::Argument#initialize} for the signature
+        def argument(*args, **kwargs, &block)
+          loads = kwargs[:loads]
+          # Use `from_resolver: true` to short-circuit the InputObject's own `loads:` implementation
+          # so that we can support `#load_{x}` methods below.
+          arg_defn = super(*args, from_resolver: true, **kwargs)
+          own_arguments_loads_as_type[arg_defn.keyword] = loads if loads
+
+          if !method_defined?(:"load_#{arg_defn.keyword}")
+            if loads && arg_defn.type.list?
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(values)
+                argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+                lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+                context.schema.after_lazy(values) do |values2|
+                  GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
+                end
+              end
+              RUBY
+            elsif loads
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(value)
+                argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+                lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+                load_application_object(argument, lookup_as_type, value, context)
+              end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(value)
+                value
+              end
+              RUBY
+            end
+          end
+
+          arg_defn
+        end
+
+        # @api private
+        def arguments_loads_as_type
+          inherited_lookups = superclass.respond_to?(:arguments_loads_as_type) ? superclass.arguments_loads_as_type : {}
+          inherited_lookups.merge(own_arguments_loads_as_type)
+        end
+
+        # Registers new extension
+        # @param extension [Class] Extension class
+        # @param options [Hash] Optional extension options
+        def extension(extension, **options)
+          @own_extensions ||= []
+          @own_extensions << {extension => options}
+        end
+
+        # @api private
+        def extensions
+          own_exts = @own_extensions
+          # Jump through some hoops to avoid creating arrays when we don't actually need them
+          if superclass.respond_to?(:extensions)
+            s_exts = superclass.extensions
+            if own_exts
+              if s_exts.any?
+                own_exts + s_exts
+              else
+                own_exts
+              end
+            else
+              s_exts
+            end
+          else
+            own_exts || EMPTY_ARRAY
+          end
+        end
+
+        private
+
+        def own_extensions
+          @own_extensions
+        end
+
+        def own_arguments_loads_as_type
+          @own_arguments_loads_as_type ||= {}
+        end
       end
     end
   end

data/lib/graphql/schema/scalar.rb

@@ -3,11 +3,9 @@ module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::ValidatesInput
 
       class << self
-        extend Forwardable
-        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
-
         def coerce_input(val, ctx)
           val
         end
@@ -23,12 +21,48 @@ module GraphQL
           type_defn.coerce_result = method(:coerce_result)
           type_defn.coerce_input = method(:coerce_input)
           type_defn.metadata[:type_class] = self
+          type_defn.default_scalar = default_scalar
+          type_defn.ast_node = ast_node
           type_defn
         end
 
         def kind
           GraphQL::TypeKinds::SCALAR
         end
+
+        def default_scalar(is_default = nil)
+          if !is_default.nil?
+            @default_scalar = is_default
+          end
+          @default_scalar
+        end
+
+        def default_scalar?
+          @default_scalar ||= false
+        end
+
+        def validate_non_null_input(value, ctx)
+          result = Query::InputValidationResult.new
+          coerced_result = begin
+            ctx.query.with_error_handling do
+              coerce_input(value, ctx)
+            end
+          rescue GraphQL::CoercionError => err
+            err
+          end
+
+          if coerced_result.nil?
+            str_value = if value == Float::INFINITY
+              ""
+            else
+              " #{GraphQL::Language.serialize(value)}"
+            end
+            result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+          elsif coerced_result.is_a?(GraphQL::CoercionError)
+            result.add_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+          end
+          result
+        end
       end
     end
   end

data/lib/graphql/schema/subscription.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This class can be extended to create fields on your subscription root.
+    #
+    # It provides hooks for the different parts of the subscription lifecycle:
+    #
+    # - `#authorized?`: called before initial subscription and subsequent updates
+    # - `#subscribe`: called for the initial subscription
+    # - `#update`: called for subsequent update
+    #
+    # Also, `#unsubscribe` terminates the subscription.
+    class Subscription < GraphQL::Schema::Resolver
+      extend GraphQL::Schema::Resolver::HasPayloadType
+      extend GraphQL::Schema::Member::HasFields
+
+      # The generated payload type is required; If there's no payload,
+      # propagate null.
+      null false
+
+      def initialize(object:, context:, field:)
+        super
+        # Figure out whether this is an update or an initial subscription
+        @mode = context.query.subscription_update? ? :update : :subscribe
+      end
+
+      def resolve_with_support(**args)
+        result = nil
+        unsubscribed = true
+        catch :graphql_subscription_unsubscribed do
+          result = super
+          unsubscribed = false
+        end
+
+
+        if unsubscribed
+          context.skip
+        else
+          result
+        end
+      end
+
+      # Implement the {Resolve} API
+      def resolve(**args)
+        # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
+        # have an unexpected `@mode`
+        public_send("resolve_#{@mode}", **args)
+      end
+
+      # Wrap the user-defined `#subscribe` hook
+      def resolve_subscribe(**args)
+        ret_val = args.any? ? subscribe(**args) : subscribe
+        if ret_val == :no_response
+          context.skip
+        else
+          ret_val
+        end
+      end
+
+      # Default implementation returns the root object.
+      # Override it to return an object or
+      # `:no_response` to return nothing.
+      #
+      # The default is `:no_response`.
+      def subscribe(args = {})
+        :no_response
+      end
+
+      # Wrap the user-provided `#update` hook
+      def resolve_update(**args)
+        ret_val = args.any? ? update(**args) : update
+        if ret_val == :no_update
+          context.namespace(:subscriptions)[:no_update] = true
+          context.skip
+        else
+          ret_val
+        end
+      end
+
+      # The default implementation returns the root object.
+      # Override it to return `:no_update` if you want to
+      # skip updates sometimes. Or override it to return a different object.
+      def update(args = {})
+        object
+      end
+
+      # If an argument is flagged with `loads:` and no object is found for it,
+      # remove this subscription (assuming that the object was deleted in the meantime,
+      # or that it became inaccessible).
+      def load_application_object_failed(err)
+        if @mode == :update
+          unsubscribe
+        end
+        super
+      end
+
+      # Call this to halt execution and remove this subscription from the system
+      def unsubscribe
+        context.namespace(:subscriptions)[:unsubscribed] = true
+        throw :graphql_subscription_unsubscribed
+      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]
+      # @return [Symbol]
+      def self.subscription_scope(new_scope = READING_SCOPE)
+        if new_scope != READING_SCOPE
+          @subscription_scope = new_scope
+        elsif defined?(@subscription_scope)
+          @subscription_scope
+        else
+          find_inherited_value(:subscription_scope)
+        end
+      end
+
+      # Overriding Resolver#field_options to include subscription_scope
+      def self.field_options
+        super.merge(
+          subscription_scope: subscription_scope
+        )
+      end
+    end
+  end
+end

data/lib/graphql/schema/timeout.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This plugin will stop resolving new fields after `max_seconds` have elapsed.
+    # After the time has passed, any remaining fields will be `nil`, with errors added
+    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
+    # you'll get a partial response.
+    #
+    # You can subclass `GraphQL::Schema::Timeout` and override `max_seconds` and/or `handle_timeout`
+    # to provide custom logic when a timeout error occurs.
+    #
+    # Note that this will stop a query _in between_ field resolutions, but
+    # it doesn't interrupt long-running `resolve` functions. Be sure to use
+    # timeout options for external connections. For more info, see
+    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
+    #
+    # @example Stop resolving fields after 2 seconds
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Schema::Timeout, max_seconds: 2
+    #   end
+    #
+    # @example Notifying Bugsnag and logging a timeout
+    #   class MyTimeout < GraphQL::Schema::Timeout
+    #     def handle_timeout(error, query)
+    #        Rails.logger.warn("GraphQL Timeout: #{error.message}: #{query.query_string}")
+    #        Bugsnag.notify(error, {query_string: query.query_string})
+    #     end
+    #   end
+    #
+    #   class MySchema < GraphQL::Schema
+    #     use MyTimeout, max_seconds: 2
+    #   end
+    #
+    class Timeout
+      def self.use(schema, **options)
+        tracer = new(**options)
+        schema.tracer(tracer)
+      end
+
+      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+      def initialize(max_seconds:)
+        @max_seconds = max_seconds
+      end
+
+      def trace(key, data)
+        case key
+        when 'execute_multiplex'
+          data.fetch(:multiplex).queries.each do |query|
+            timeout_duration_s = max_seconds(query)
+            timeout_state = if timeout_duration_s == false
+              # if the method returns `false`, don't apply a timeout
+              false
+            else
+              now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+              timeout_at = now + (max_seconds(query) * 1000)
+              {
+                timeout_at: timeout_at,
+                timed_out: false
+              }
+            end
+            query.context.namespace(self.class)[:state] = timeout_state
+          end
+
+          yield
+        when 'execute_field', 'execute_field_lazy'
+          query_context = data[:context] || data[:query].context
+          timeout_state = query_context.namespace(self.class).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)
+            error = if data[:context]
+              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
+            else
+              field = data.fetch(:field)
+              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
+            end
+
+            # Only invoke the timeout callback for the first timeout
+            if !timeout_state[:timed_out]
+              timeout_state[:timed_out] = true
+              handle_timeout(error, query_context.query)
+            end
+
+            error
+          else
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      # Called at the start of each query.
+      # The default implementation returns the `max_seconds:` value from installing this plugin.
+      #
+      # @param query [GraphQL::Query] The query that's about to run
+      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      def max_seconds(query)
+        @max_seconds
+      end
+
+      # Invoked when a query times out.
+      # @param error [GraphQL::Schema::Timeout::TimeoutError]
+      # @param query [GraphQL::Error]
+      def handle_timeout(error, query)
+        # override to do something interesting
+      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.
+      #
+      # To raise an error that will stop query resolution, use a custom block
+      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+      # such as `RuntimeError`.
+      class TimeoutError < GraphQL::ExecutionError
+        def initialize(parent_type, field)
+          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/timeout_middleware.rb

@@ -23,21 +23,24 @@ module GraphQL
     #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
     #   end
     #
+    # @api deprecated
+    # @see Schema::Timeout
     class TimeoutMiddleware
       # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:, context_key: nil, &block)
         @max_seconds = max_seconds
         if context_key
-          warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
+          GraphQL::Deprecation.warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
         end
         @error_handler = block
       end
 
       def call(parent_type, parent_object, field_definition, field_args, query_context)
-        ns = query_context.namespace(TimeoutMiddleware)
-        timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
+        ns = query_context.namespace(self.class)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        timeout_at = ns[:timeout_at] ||= now + @max_seconds
 
-        if timeout_at < Time.now
+        if timeout_at < now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
         else
           yield