graphql 1.9.0 → 2.1.1

data/lib/graphql/schema/resolver.rb

@@ -15,8 +15,6 @@ 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
@@ -24,20 +22,23 @@ 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 object [Object] The application object that this field is being resolved on
       # @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|
+        self.class.arguments(context).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
@@ -46,45 +47,61 @@ 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?
+        raw_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
+        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?
-                authorized?(loaded_args)
+              raw_authorized_val = if loaded_args.any?
+                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)
@@ -92,7 +109,7 @@ module GraphQL
                     public_send(self.class.resolve_method)
                   end
                 else
-                  nil
+                  raise GraphQL::UnauthorizedFieldError.new(context: context, object: object, type: field.owner, field: field)
                 end
               end
             end
@@ -103,7 +120,7 @@ module GraphQL
       # 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.
@@ -123,16 +140,44 @@ module GraphQL
       # Called after arguments are loaded, but before resolving.
       #
       # Override it to check everything before calling the mutation.
-      # @param args [Hash] The input arguments
+      # @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?(**args)
-        true
+      def authorized?(**inputs)
+        arg_owner = @field # || self.class
+        args = arg_owner.arguments(context)
+        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_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
+
       def load_arguments(args)
         prepared_args = {}
         prepare_lazies = []
@@ -140,18 +185,14 @@ 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
@@ -164,84 +205,27 @@ module GraphQL
         end
       end
 
-      def load_argument(name, value)
-        public_send("load_#{name}", value)
+      def get_argument(name, context = GraphQL::Query::NullContext)
+        self.class.get_argument(name, context)
       end
 
-      class LoadApplicationObjectFailedError < GraphQL::ExecutionError
-        # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
-        attr_reader :argument
-        # @return [String] The ID provided by the client
-        attr_reader :id
-        # @return [Object] The value found with this ID
-        attr_reader :object
-        def initialize(argument:, id:, object:)
-          @id = id
-          @argument = argument
-          @object = object
-          super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
+      class << self
+        def field_arguments(context = GraphQL::Query::NullContext)
+          arguments(context)
         end
-      end
 
-      # Look up the corresponding object for a provided ID.
-      # By default, it uses Relay-style {Schema.object_from_id},
-      # override this to find objects another way.
-      #
-      # @param type [Class, Module] A GraphQL type definition
-      # @param id [String] A client-provided to look up
-      # @param context [GraphQL::Query::Context] the current context
-      def object_from_id(type, id, context)
-        context.schema.object_from_id(id, context)
-      end
+        def any_field_arguments?
+          any_arguments?
+        end
 
-      def load_application_object(arg_kwarg, id)
-        argument = @arguments_by_keyword[arg_kwarg]
-        lookup_as_type = @arguments_loads_as_type[arg_kwarg]
-        # See if any object can be found for this ID
-        loaded_application_object = object_from_id(lookup_as_type, id, context)
-        context.schema.after_lazy(loaded_application_object) do |application_object|
-          if application_object.nil?
-            raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-          end
-          # Double-check that the located object is actually of this type
-          # (Don't want to allow arbitrary access to objects this way)
-          resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
-          context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
-            possible_object_types = context.schema.possible_types(lookup_as_type)
-            if !possible_object_types.include?(application_object_type)
-              raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-            else
-              # This object was loaded successfully
-              # and resolved to the right type,
-              # now apply the `.authorized?` class method if there is one
-              if (class_based_type = application_object_type.metadata[:type_class])
-                context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
-                  if authed
-                    application_object
-                  else
-                    raise GraphQL::UnauthorizedError.new(
-                      object: application_object,
-                      type: class_based_type,
-                      context: context,
-                    )
-                  end
-                end
-              else
-                application_object
-              end
-            end
-          end
+        def get_field_argument(name, context = GraphQL::Query::NullContext)
+          get_argument(name, context)
         end
-      rescue LoadApplicationObjectFailedError => err
-        # pass it to a handler
-        load_application_object_failed(err)
-      end
 
-      def load_application_object_failed(err)
-        raise err
-      end
+        def all_field_argument_definitions
+          all_argument_definitions
+        end
 
-      class << self
         # 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)
@@ -261,8 +245,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?
@@ -272,11 +258,19 @@ 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.
         # 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)
@@ -287,8 +281,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
@@ -306,17 +300,59 @@ module GraphQL
           @complexity || (superclass.respond_to?(:complexity) ? superclass.complexity : 1)
         end
 
-        def field_options
-          {
-            type: type_expr,
-            description: description,
-            extras: extras,
-            resolver_method: :resolve_with_support,
-            resolver_class: self,
-            arguments: arguments,
-            null: null,
-            complexity: complexity,
-          }
+        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_CONFIGURED)
+          if new_max_page_size != NOT_CONFIGURED
+            @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
+
+        # 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
+
+        # @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,60 +363,44 @@ module GraphQL
         # 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(name, type, *rest, loads: nil, **kwargs, &block)
-          if loads
-            name_as_string = name.to_s
-
-            inferred_arg_name = case name_as_string
-            when /_id$/
-              name_as_string.sub(/_id$/, "").to_sym
-            when /_ids$/
-              name_as_string.sub(/_ids$/, "")
-                .sub(/([^s])$/, "\\1s")
-                .to_sym
-            else
-              name
-            end
-
-            kwargs[:as] ||= inferred_arg_name
-            own_arguments_loads_as_type[kwargs[:as]] = loads
-          end
+        def argument(*args, **kwargs, &block)
+          # Use `from_resolver: true` to short-circuit the InputObject's own `loads:` implementation
+          # so that we can support `#load_{x}` methods below.
+          super(*args, from_resolver: true, **kwargs)
+        end
 
-          arg_defn = super(name, type, *rest, **kwargs, &block)
+        # 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
 
-          if loads && arg_defn.type.list?
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(values)
-              GraphQL::Execution::Lazy.all(values.map { |value| load_application_object(:#{arg_defn.keyword}, value) })
-            end
-            RUBY
-          elsif loads
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(value)
-              load_application_object(:#{arg_defn.keyword}, value)
+        # @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
-            RUBY
           else
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(value)
-              value
-            end
-            RUBY
+            own_exts || EMPTY_ARRAY
           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
 
         private
 
-        def own_arguments_loads_as_type
-          @own_arguments_loads_as_type ||= {}
+        def own_extensions
+          @own_extensions
         end
       end
     end

data/lib/graphql/schema/scalar.rb

@@ -2,12 +2,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
@@ -16,27 +13,55 @@ 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
-        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
           end
           @default_scalar
         end
+
+        def default_scalar?
+          @default_scalar ||= false
+        end
+
+        def validate_non_null_input(value, ctx, max_errors: nil)
+          coerced_result = begin
+            coerce_input(value, ctx)
+          rescue GraphQL::CoercionError => err
+            err
+          rescue StandardError => err
+            ctx.query.handle_or_reraise(err)
+          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}")
+          elsif coerced_result.is_a?(GraphQL::CoercionError)
+            Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+          else
+            nil
+          end
+        end
       end
     end
   end