graphql 1.12.12 → 2.4.8

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`.
     #
@@ -15,20 +16,19 @@ module GraphQL
     #
     # A resolver's configuration may be overridden with other keywords in the `field(...)` call.
     #
-    # See the {.field_options} to see how a Resolver becomes a set of field configuration options.
-    #
     # @see {GraphQL::Schema::Mutation} for a concrete subclass of `Resolver`.
     # @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::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
+      extend Schema::Member::HasDirectives
 
-      # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
+      # @param object [Object] The application object that this field is being resolved on
       # @param context [GraphQL::Query::Context]
       # @param field [GraphQL::Schema::Field]
       def initialize(object:, context:, field:)
@@ -37,10 +37,9 @@ module GraphQL
         @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
-        self.class.arguments.each do |name, arg|
+        context.types.arguments(self.class).each do |arg|
           @arguments_by_keyword[arg.keyword] = arg
         end
-        @arguments_loads_as_type = self.class.arguments_loads_as_type
         @prepared_arguments = nil
       end
 
@@ -68,49 +67,47 @@ module GraphQL
       # @api private
       def resolve_with_support(**args)
         # First call the ready? hook which may raise
-        ready_val = if args.any?
+        raw_ready_val = if !args.empty?
           ready?(**args)
         else
           ready?
         end
-        context.schema.after_lazy(ready_val) do |is_ready, ready_early_return|
-          if ready_early_return
+        context.query.after_lazy(raw_ready_val) do |ready_val|
+          if ready_val.is_a?(Array)
+            is_ready, ready_early_return = ready_val
             if is_ready != false
-              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{ready_early_return.inspect}]"
+              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{ready_early_return.inspect}]"
             else
               ready_early_return
             end
-          elsif is_ready
+          elsif ready_val
             # 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|
+            context.query.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?
+              raw_authorized_val = if !loaded_args.empty?
                 authorized?(**loaded_args)
               else
                 authorized?
               end
-              context.schema.after_lazy(authorized_val) do |(authorized_result, early_return)|
+              context.query.after_lazy(raw_authorized_val) do |authorized_val|
                 # If the `authorized?` returned two values, `false, early_return`,
                 # then use the early return value instead of continuing
-                if early_return
+                if authorized_val.is_a?(Array)
+                  authorized_result, early_return = authorized_val
                   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
+                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
-                  nil
+                  raise GraphQL::UnauthorizedFieldError.new(context: context, object: object, type: field.owner, field: field)
                 end
               end
             end
@@ -118,6 +115,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,23 +152,42 @@ module GraphQL
       # @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_owner = @field # || self.class
+        args = context.types.arguments(arg_owner)
+        authorize_arguments(args, inputs)
+      end
+
+      # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
+      #
+      # By default, the error is re-raised and passed along to {{Schema.unauthorized_object}}.
+      #
+      # Any value returned here will be used _instead of_ of the loaded object.
+      # @param err [GraphQL::UnauthorizedError]
+      def unauthorized_object(err)
+        raise err
+      end
+
+      private
+
+      def authorize_arguments(args, inputs)
+        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
 
-      private
-
       def load_arguments(args)
         prepared_args = {}
         prepare_lazies = []
@@ -170,35 +195,47 @@ module GraphQL
         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
+            prepped_value = prepared_args[key] = arg_defn.load_and_authorize_value(self, value, context)
+            if context.schema.lazy?(prepped_value)
+              prepare_lazies << context.query.after_lazy(prepped_value) do |finished_prepped_value|
+                prepared_args[key] = finished_prepped_value
               end
             end
           else
-            # These are `extras: [...]`
+            # these are `extras:`
             prepared_args[key] = value
           end
         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 load_argument(name, value)
-        public_send("load_#{name}", value)
+      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.instance)
+          arguments(context)
+        end
+
+        def any_field_arguments?
+          any_arguments?
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
+          get_argument(name, context)
+        end
+
+        def all_field_argument_definitions
+          all_argument_definitions
+        end
+
         # Default `:resolve` set below.
         # @return [Symbol] The method to call on instances of this object to resolve the field
         def resolve_method(new_method = nil)
@@ -218,8 +255,10 @@ module GraphQL
           own_extras + (superclass.respond_to?(:extras) ? superclass.extras : [])
         end
 
-        # Specifies whether or not the field is nullable. Defaults to `true`
-        # TODO unify with {#type}
+        # If `true` (default), then the return type for this resolver will be nullable.
+        # If `false`, then the return type is non-null.
+        #
+        # @see #type which sets the return type of this field and accepts a `null:` option
         # @param allow_null [Boolean] Whether or not the response can be null
         def null(allow_null = nil)
           if !allow_null.nil?
@@ -229,6 +268,14 @@ module GraphQL
           @null.nil? ? (superclass.respond_to?(:null) ? superclass.null : true) : @null
         end
 
+        def resolver_method(new_method_name = nil)
+          if new_method_name
+            @resolver_method = new_method_name
+          else
+            @resolver_method || :resolve_with_support
+          end
+        end
+
         # Call this method to get the return type of the field,
         # or use it as a configuration method to assign a return type
         # instead of generating one.
@@ -244,8 +291,8 @@ module GraphQL
             @type_expr = new_type
             @null = null
           else
-            if @type_expr
-              GraphQL::Schema::Member::BuildType.parse_type(@type_expr, null: @null)
+            if type_expr
+              GraphQL::Schema::Member::BuildType.parse_type(type_expr, null: self.null)
             elsif superclass.respond_to?(:type)
               superclass.type
             else
@@ -280,8 +327,8 @@ module GraphQL
         # (`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
+        def max_page_size(new_max_page_size = NOT_CONFIGURED)
+          if new_max_page_size != NOT_CONFIGURED
             @max_page_size = new_max_page_size
           elsif defined?(@max_page_size)
             @max_page_size
@@ -294,28 +341,28 @@ module GraphQL
 
         # @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?)
+          (!!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,
-            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
+        # Get or set the `default_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited default page size".)
+        # @param default_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `default_page_size` assigned to fields that use this resolver
+        def default_page_size(new_default_page_size = NOT_CONFIGURED)
+          if new_default_page_size != NOT_CONFIGURED
+            @default_page_size = new_default_page_size
+          elsif defined?(@default_page_size)
+            @default_page_size
+          elsif superclass.respond_to?(:default_page_size)
+            superclass.default_page_size
+          else
+            nil
           end
+        end
 
-          field_opts
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `default_page_size`
+        def has_default_page_size?
+          (!!defined?(@default_page_size)) || (superclass.respond_to?(:has_default_page_size?) && superclass.has_default_page_size?)
         end
 
         # A non-normalized type configuration, without `null` applied
@@ -327,47 +374,9 @@ module GraphQL
         # 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)
+          super(*args, from_resolver: true, **kwargs)
         end
 
         # Registers new extension
@@ -385,7 +394,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
@@ -400,13 +409,7 @@ module GraphQL
 
         private
 
-        def own_extensions
-          @own_extensions
-        end
-
-        def own_arguments_loads_as_type
-          @own_arguments_loads_as_type ||= {}
-        end
+        attr_reader :own_extensions
       end
     end
   end

data/lib/graphql/schema/scalar.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
       class << self
@@ -14,22 +13,22 @@ module GraphQL
           val
         end
 
-        def to_graphql
-          type_defn = GraphQL::ScalarType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          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 specified_by_url(new_url = nil)
+          if new_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
+            nil
+          end
+        end
+
         def default_scalar(is_default = nil)
           if !is_default.nil?
             @default_scalar = is_default
@@ -41,14 +40,13 @@ module GraphQL
           @default_scalar ||= false
         end
 
-        def validate_non_null_input(value, ctx)
-          result = Query::InputValidationResult.new
+        def validate_non_null_input(value, ctx, max_errors: nil)
           coerced_result = begin
-            ctx.query.with_error_handling do
-              coerce_input(value, ctx)
-            end
+            coerce_input(value, ctx)
           rescue GraphQL::CoercionError => err
             err
+          rescue StandardError => err
+            ctx.query.handle_or_reraise(err)
           end
 
           if coerced_result.nil?
@@ -57,11 +55,12 @@ module GraphQL
             else
               " #{GraphQL::Language.serialize(value)}"
             end
-            result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_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)
+            Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+          else
+            nil
           end
-          result
         end
       end
     end

data/lib/graphql/schema/subscription.rb

@@ -14,34 +14,50 @@ module GraphQL
     class Subscription < GraphQL::Schema::Resolver
       extend GraphQL::Schema::Resolver::HasPayloadType
       extend GraphQL::Schema::Member::HasFields
-
+      NO_UPDATE = :no_update
       # The generated payload type is required; If there's no payload,
       # 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
@@ -58,19 +75,18 @@ module GraphQL
         end
       end
 
-      # Default implementation returns the root object.
+      # The default implementation returns nothing on subscribe.
       # Override it to return an object or
-      # `:no_response` to return nothing.
-      #
-      # The default is `:no_response`.
+      # `:no_response` to (explicitly) return nothing.
       def subscribe(args = {})
         :no_response
       end
 
       # Wrap the user-provided `#update` hook
+      # @api private
       def resolve_update(**args)
-        ret_val = args.any? ? update(**args) : update
-        if ret_val == :no_update
+        ret_val = !args.empty? ? update(**args) : update
+        if ret_val == NO_UPDATE
           context.namespace(:subscriptions)[:no_update] = true
           context.skip
         else
@@ -79,7 +95,7 @@ module GraphQL
       end
 
       # The default implementation returns the root object.
-      # Override it to return `:no_update` if you want to
+      # 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
@@ -96,19 +112,22 @@ 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)
-        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)
           @subscription_scope
         else
@@ -116,10 +135,65 @@ module GraphQL
         end
       end
 
-      # Overriding Resolver#field_options to include subscription_scope
-      def self.field_options
-        super.merge(
-          subscription_scope: subscription_scope
+      def self.subscription_scope_optional?
+        if defined?(@subscription_scope_optional)
+          @subscription_scope_optional
+        else
+          find_inherited_value(:subscription_scope_optional, false)
+        end
+      end
+
+      # This is called during initial subscription to get a "name" for this subscription.
+      # Later, when `.trigger` is called, this will be called again to build another "name".
+      # Any subscribers with matching topic will begin the update flow.
+      #
+      # The default implementation creates a string using the field name, subscription scope, and argument keys and values.
+      # In that implementation, only `.trigger` calls with _exact matches_ result in updates to subscribers.
+      #
+      # To implement a filtered stream-type subscription flow, override this method to return a string with field name and subscription scope.
+      # Then, implement {#update} to compare its arguments to the current `object` and return {NO_UPDATE} when an
+      # update should be filtered out.
+      #
+      # @see {#update} for how to skip updates when an event comes with a matching topic.
+      # @param arguments [Hash<String => Object>] The arguments for this topic, in GraphQL-style (camelized strings)
+      # @param field [GraphQL::Schema::Field]
+      # @param scope [Object, nil] A value corresponding to `.trigger(... scope:)` (for updates) or the `subscription_scope` found in `context` (for initial subscriptions).
+      # @return [String] An identifier corresponding to a stream of updates
+      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