graphql 1.9.17 → 1.11.7

data/lib/graphql/relay/edge_type.rb

@@ -2,6 +2,7 @@
 module GraphQL
   module Relay
     module EdgeType
+      # @api deprecated
       def self.create_type(wrapped_type, name: nil, &block)
         GraphQL::ObjectType.define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name

data/lib/graphql/relay/edges_instrumentation.rb

@@ -31,7 +31,7 @@ module GraphQL
           if ctx.schema.lazy?(nodes)
             nodes
           else
-            nodes.map { |item| @edge_class.new(item, parent) }
+            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
           end
         end
       end

data/lib/graphql/relay/mutation.rb

@@ -5,92 +5,7 @@ require "graphql/relay/mutation/result"
 
 module GraphQL
   module Relay
-    # Define a Relay mutation:
-    #   - give it a name (used for derived inputs & outputs)
-    #   - declare its inputs
-    #   - declare its outputs
-    #   - declare the mutation procedure
-    #
-    # `resolve` should return a hash with a key for each of the `return_field`s
-    #
-    # Inputs may also contain a `clientMutationId`
-    #
-    # @example Updating the name of an item
-    #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
-    #     name "UpdateName"
-    #
-    #     input_field :name, !types.String
-    #     input_field :itemId, !types.ID
-    #
-    #     return_field :item, ItemType
-    #
-    #     resolve ->(inputs, ctx) {
-    #       item = Item.find_by_id(inputs[:id])
-    #       item.update(name: inputs[:name])
-    #       {item: item}
-    #     }
-    #   end
-    #
-    #   MutationType = GraphQL::ObjectType.define do
-    #     # The mutation object exposes a field:
-    #     field :updateName, field: UpdateNameMutation.field
-    #   end
-    #
-    #   # Then query it:
-    #   query_string = %|
-    #     mutation updateName {
-    #       updateName(input: {itemId: 1, name: "new name", clientMutationId: "1234"}) {
-    #         item { name }
-    #         clientMutationId
-    #     }|
-    #
-    #    GraphQL::Query.new(MySchema, query_string).result
-    #    # {"data" => {
-    #    #   "updateName" => {
-    #    #     "item" => { "name" => "new name"},
-    #    #     "clientMutationId" => "1234"
-    #    #   }
-    #    # }}
-    #
-    # @example Using a GraphQL::Function
-    #   class UpdateAttributes < GraphQL::Function
-    #     attr_reader :model, :return_as, :arguments
-    #
-    #     def initialize(model:, return_as:, attributes:)
-    #       @model = model
-    #       @arguments = {}
-    #       attributes.each do |name, type|
-    #         arg_name = name.to_s
-    #         @arguments[arg_name] = GraphQL::Argument.define(name: arg_name, type: type)
-    #       end
-    #       @arguments["id"] = GraphQL::Argument.define(name: "id", type: !GraphQL::ID_TYPE)
-    #       @return_as = return_as
-    #       @attributes = attributes
-    #     end
-    #
-    #     def type
-    #       fn = self
-    #       GraphQL::ObjectType.define do
-    #         name "Update#{fn.model.name}AttributesResponse"
-    #         field :clientMutationId, types.ID
-    #         field fn.return_as.keys[0], fn.return_as.values[0]
-    #       end
-    #     end
-    #
-    #     def call(obj, args, ctx)
-    #       record = @model.find(args[:inputs][:id])
-    #       new_values = {}
-    #       @attributes.each { |a| new_values[a] = args[a] }
-    #       record.update(new_values)
-    #       { @return_as => record }
-    #     end
-    #   end
-    #
-    #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
-    #     name "UpdateName"
-    #     function UpdateAttributes.new(model: Item, return_as: { item: ItemType }, attributes: {name: !types.String})
-    #   end
-
+    # @api deprecated
     class Mutation
       include GraphQL::Define::InstanceDefinable
       accepts_definitions(

data/lib/graphql/relay/node.rb

@@ -11,7 +11,7 @@ module GraphQL
         field = GraphQL::Types::Relay::NodeField.graphql_definition
 
         if kwargs.any? || block
-          field = field.redefine(kwargs, &block)
+          field = field.redefine(**kwargs, &block)
         end
 
         field
@@ -21,7 +21,7 @@ module GraphQL
         field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
-          field = field.redefine(kwargs, &block)
+          field = field.redefine(**kwargs, &block)
         end
 
         field

data/lib/graphql/relay/range_add.rb

@@ -33,12 +33,21 @@ module GraphQL
       # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
       # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
       # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
-      # @param edge_class [Class] The class to wrap `item` with
-      def initialize(collection:, item:, parent: nil, context: nil, edge_class: Relay::Edge)
-        connection_class = BaseConnection.connection_for_nodes(collection)
+      # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
+      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
+        if context && context.schema.new_connections?
+          conn_class = context.schema.connections.wrapper_for(collection)
+          # The rest will be added by ConnectionExtension
+          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+          @edge = @connection.edge_class.new(item, @connection)
+        else
+          connection_class = BaseConnection.connection_for_nodes(collection)
+          @connection = connection_class.new(collection, {}, parent: parent, context: context)
+          edge_class ||= Relay::Edge
+          @edge = edge_class.new(item, @connection)
+        end
+
         @parent = parent
-        @connection = connection_class.new(collection, {}, parent: parent, context: context)
-        @edge = edge_class.new(item, @connection)
       end
     end
   end

data/lib/graphql/relay/relation_connection.rb

@@ -50,19 +50,17 @@ module GraphQL
       end
 
       def first
-        return @first if defined? @first
-
-        @first = get_limited_arg(:first)
-        @first = max_page_size if @first && max_page_size && @first > max_page_size
-        @first
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       def last
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       private

data/lib/graphql/scalar_type.rb

@@ -1,63 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # # GraphQL::ScalarType
-  #
-  # Scalars are plain values. They are leaf nodes in a GraphQL query tree.
-  #
-  # ## Built-in Scalars
-  #
-  # `GraphQL` comes with standard built-in scalars:
-  #
-  # |Constant | `.define` helper|
-  # |-------|--------|
-  # |`GraphQL::STRING_TYPE` | `types.String`|
-  # |`GraphQL::INT_TYPE` | `types.Int`|
-  # |`GraphQL::FLOAT_TYPE` | `types.Float`|
-  # |`GraphQL::ID_TYPE` | `types.ID`|
-  # |`GraphQL::BOOLEAN_TYPE` | `types.Boolean`|
-  #
-  # (`types` is an instance of `GraphQL::Definition::TypeDefiner`; `.String`, `.Float`, etc are methods which return built-in scalars.)
-  #
-  # ## Custom Scalars
-  #
-  # You can define custom scalars for your GraphQL server. It requires some special functions:
-  #
-  # - `coerce_input` is used to prepare incoming values for GraphQL execution. (Incoming values come from variables or literal values in the query string.)
-  # - `coerce_result` is used to turn Ruby values _back_ into serializable values for query responses.
-  #
-  # @example defining a type for Time
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) { Time.at(Float(value)) }
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  #
-  # You can customize the error message for invalid input values by raising a `GraphQL::CoercionError` within `coerce_input`:
-  #
-  # @example raising a custom error message
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) do
-  #       begin
-  #         Time.at(Float(value))
-  #       rescue ArgumentError
-  #         raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to Float"
-  #       end
-  #     end
-  #
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
-  #
-  # @example custom error response
-  #   {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
-  #
+  # @api deprecated
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result
@@ -124,8 +67,21 @@ module GraphQL
 
     def validate_non_null_input(value, ctx)
       result = Query::InputValidationResult.new
-      if value.is_a?(GraphQL::Language::Nodes::Enum) || coerce_non_null_input(value, ctx).nil?
+
+      coerced_result = begin
+        coerce_non_null_input(value, ctx)
+      rescue GraphQL::CoercionError => err
+        err
+      end
+
+      if value.is_a?(GraphQL::Language::Nodes::Enum) || coerced_result.nil?
         result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{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

data/lib/graphql/schema/argument.rb

@@ -2,9 +2,14 @@
 module GraphQL
   class Schema
     class Argument
+      if !String.method_defined?(:-@)
+        using GraphQL::StringDedupBackport
+      end
+
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
+      include GraphQL::Schema::Member::HasAstNode
 
       NO_DEFAULT = :__no_default__
 
@@ -40,10 +45,10 @@ module GraphQL
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
       # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, &definition_block)
+      # @param deprecation_reason [String]
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, deprecation_reason: nil, &definition_block)
         arg_name ||= name
-        name_str = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
-        @name = name_str.freeze
+        @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
         @null = !required
@@ -51,11 +56,12 @@ module GraphQL
         @owner = owner
         @as = as
         @loads = loads
-        @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
+        @keyword = as || (arg_name.is_a?(Symbol) ? arg_name : Schema::Member::BuildType.underscore(@name).to_sym)
         @prepare = prepare
         @ast_node = ast_node
         @from_resolver = from_resolver
         @method_access = method_access
+        self.deprecation_reason = deprecation_reason
 
         if definition_block
           if definition_block.arity == 1
@@ -85,6 +91,18 @@ module GraphQL
         end
       end
 
+      # @return [String] Deprecation reason for this argument
+      def deprecation_reason(text = nil)
+        if text
+          validate_deprecated_or_optional(null: @null, deprecation_reason: text)
+          @deprecation_reason = text
+        else
+          @deprecation_reason
+        end
+      end
+
+      alias_method :deprecation_reason=, :deprecation_reason
+
       def visible?(context)
         true
       end
@@ -93,7 +111,37 @@ module GraphQL
         true
       end
 
-      def authorized?(obj, ctx)
+      def authorized?(obj, value, ctx)
+        authorized_as_type?(obj, value, ctx, as_type: type)
+      end
+
+      def authorized_as_type?(obj, value, ctx, as_type:)
+        if value.nil?
+          return true
+        end
+
+        if as_type.kind.non_null?
+          as_type = as_type.of_type
+        end
+
+        if as_type.kind.list?
+          value.each do |v|
+            if !authorized_as_type?(obj, v, ctx, as_type: as_type.of_type)
+              return false
+            end
+          end
+        elsif as_type.kind.input_object?
+          as_type.arguments.each do |_name, input_obj_arg|
+            input_obj_arg = input_obj_arg.type_class
+            # TODO: this skips input objects whose values were alread replaced with application objects.
+            # See: https://github.com/rmosolgo/graphql-ruby/issues/2633
+            if value.respond_to?(:key?) && value.key?(input_obj_arg.keyword) && !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+              return false
+            end
+          end
+        end
+        # None of the early-return conditions were activated,
+        # so this is authorized.
         true
       end
 
@@ -104,23 +152,49 @@ module GraphQL
         argument.description = @description
         argument.metadata[:type_class] = self
         argument.as = @as
+        argument.ast_node = ast_node
         argument.method_access = @method_access
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end
+        if @deprecation_reason
+          argument.deprecation_reason = @deprecation_reason
+        end
         argument
       end
 
+      def type=(new_type)
+        validate_input_type(new_type)
+        # This isn't true for LateBoundTypes, but we can assume those will
+        # be updated via this codepath later in schema setup.
+        if new_type.respond_to?(:non_null?)
+          validate_deprecated_or_optional(null: !new_type.non_null?, deprecation_reason: deprecation_reason)
+        end
+        @type = new_type
+      end
+
       def type
-        @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
-      rescue StandardError => err
-        raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+        @type ||= begin
+          parsed_type = begin
+            Member::BuildType.parse_type(@type_expr, null: @null)
+          rescue StandardError => err
+            raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+          end
+          # Use the setter method to get validations
+          self.type = parsed_type
+        end
+      end
+
+      def statically_coercible?
+        return @statically_coercible if defined?(@statically_coercible)
+
+        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
       end
 
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private
-      def prepare_value(obj, value)
+      def prepare_value(obj, value, context: nil)
         if value.is_a?(GraphQL::Schema::InputObject)
           value = value.prepare
         end
@@ -128,13 +202,41 @@ module GraphQL
         if @prepare.nil?
           value
         elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)
-          obj.public_send(@prepare, value)
+          if obj.nil?
+            # The problem here is, we _used to_ prepare while building variables.
+            # But now we don't have the runtime object there.
+            #
+            # This will have to be called later, when the runtime object _is_ available.
+            value
+          else
+            obj.public_send(@prepare, value)
+          end
         elsif @prepare.respond_to?(:call)
-          @prepare.call(value, obj.context)
+          @prepare.call(value, context || obj.context)
         else
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
         end
       end
+
+      private
+
+      def validate_input_type(input_type)
+        if input_type.is_a?(String) || input_type.is_a?(GraphQL::Schema::LateBoundType)
+          # Do nothing; assume this will be validated later
+        elsif input_type.kind.non_null? || input_type.kind.list?
+          validate_input_type(input_type.unwrap)
+        elsif !input_type.kind.input?
+          raise ArgumentError, "Invalid input type for #{path}: #{input_type.graphql_name}. Must be scalar, enum, or input object, not #{input_type.kind.name}."
+        else
+          # It's an input type, we're OK
+        end
+      end
+
+      def validate_deprecated_or_optional(null:, deprecation_reason:)
+        if deprecation_reason && !null
+          raise ArgumentError, "Required arguments cannot be deprecated: #{path}."
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/base_64_encoder.rb

@@ -13,6 +13,8 @@ module GraphQL
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
         Base64Bp.urlsafe_decode64(encoded_text)
+      rescue ArgumentError
+        raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end
     end
   end

data/lib/graphql/schema/build_from_definition/resolve_map/default_resolve.rb

@@ -20,7 +20,7 @@ module GraphQL
           def call(obj, args, ctx)
             method_name = @field_name
             if !obj.respond_to?(method_name)
-              raise KeyError, "Can't resolve field #{method_name} on #{obj}"
+              raise KeyError, "Can't resolve field #{method_name} on #{obj.inspect}"
             else
               method_arity = obj.method(method_name).arity
               resolver = case method_arity

data/lib/graphql/schema/build_from_definition/resolve_map.rb

@@ -14,6 +14,12 @@ module GraphQL
       #
       # @api private
       class ResolveMap
+        module NullScalarCoerce
+          def self.call(val, _ctx)
+            val
+          end
+        end
+
         def initialize(user_resolve_hash)
           @resolve_hash = Hash.new do |h, k|
             # For each type name, provide a new hash if one wasn't given:
@@ -21,7 +27,7 @@ module GraphQL
               if k2 == "coerce_input" || k2 == "coerce_result"
                 # This isn't an object field, it's a scalar coerce function.
                 # Use a passthrough
-                Builder::NullScalarCoerce
+                NullScalarCoerce
               else
                 # For each field, provide a resolver that will
                 # make runtime checks & replace itself
@@ -39,8 +45,10 @@ module GraphQL
                 @resolve_hash[type_name_s][field_name.to_s] = resolve_fn
               end
             when Proc
-              # for example, __resolve_type
+              # for example, "resolve_type"
               @resolve_hash[type_name_s] = fields
+            else
+              raise ArgumentError, "Unexpected resolve hash value for #{type_name.inspect}: #{fields.inspect} (#{fields.class})"
             end
           end
 
@@ -53,16 +61,16 @@ module GraphQL
         end
 
         def call(type, field, obj, args, ctx)
-          resolver = @resolve_hash[type.name][field.name]
+          resolver = @resolve_hash[type.graphql_name][field.graphql_name]
           resolver.call(obj, args, ctx)
         end
 
         def coerce_input(type, value, ctx)
-          @resolve_hash[type.name]["coerce_input"].call(value, ctx)
+          @resolve_hash[type.graphql_name]["coerce_input"].call(value, ctx)
         end
 
         def coerce_result(type, value, ctx)
-          @resolve_hash[type.name]["coerce_result"].call(value, ctx)
+          @resolve_hash[type.graphql_name]["coerce_result"].call(value, ctx)
         end
       end
     end