graphql 1.8.0 → 1.12.12

data/lib/graphql/railtie.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
-
 module GraphQL
   class Railtie < Rails::Railtie
+    config.before_configuration do
+      # Bootsnap compile cache has similar expiration properties,
+      # so we assume that if the user has bootsnap setup it's ok
+      # to piggy back on it.
+      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
+        Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
+      end
+    end
+
     rake_tasks do
       # Defer this so that you only need the `parser` gem when you _run_ the upgrader
       def load_upgraders
@@ -40,7 +48,7 @@ module GraphQL
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
+                f.puts "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
               end
             end
 
@@ -48,7 +56,7 @@ module GraphQL
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
+                f.puts "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
               end
             end
 
@@ -56,7 +64,7 @@ module GraphQL
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
+                f.puts "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
               end
             end
 
@@ -64,7 +72,7 @@ module GraphQL
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseUnion < GraphQL::Schema::Union\nend"
+                f.puts "class Types::BaseUnion < GraphQL::Schema::Union\nend"
               end
             end
 
@@ -72,14 +80,14 @@ module GraphQL
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
+                f.puts "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
               end
             end
 
             destination_file = File.join(base_dir, "types", "base_object.rb")
             unless File.exists?(destination_file)
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseObject < GraphQL::Schema::Object\nend"
+                f.puts "class Types::BaseObject < GraphQL::Schema::Object\nend"
               end
             end
           end

data/lib/graphql/rake_task/validate.rb

@@ -7,6 +7,9 @@ module GraphQL
     desc "Get the checksum of a graphql-pro version and compare it to published versions on GitHub and graphql-ruby.org"
     task "graphql:pro:validate", [:gem_version] do |t, args|
       version = args[:gem_version]
+      if version.nil?
+        raise ArgumentError, "A specific version is required, eg `rake graphql:pro:validate[1.12.0]`"
+      end
       check = "\e[32m✓\e[0m"
       ex = "\e[31m✘\e[0m"
       puts "Validating graphql-pro v#{version}"
@@ -37,7 +40,7 @@ module GraphQL
       # Remove final newline from .txt file
       github_digest = Net::HTTP.get(github_uri).chomp
 
-      docs_uri = URI("https://raw.githubusercontent.com/rmosolgo/graphql-ruby/master/guides/pro/checksums/graphql-pro-#{version}.txt")
+      docs_uri = URI("https://graphql-ruby.org/pro/checksums/graphql-pro-#{version}.txt")
       docs_digest = Net::HTTP.get(docs_uri).chomp
 
       if docs_digest == gem_digest && github_digest == gem_digest

data/lib/graphql/rake_task.rb

@@ -76,15 +76,7 @@ module GraphQL
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
-      default_dependencies = if Rake::Task.task_defined?("environment")
-        [:environment]
-      else
-        []
-      end
-
-      all_options = DEFAULT_OPTIONS
-        .merge(dependencies: default_dependencies)
-        .merge(options)
+      all_options = DEFAULT_OPTIONS.merge(options)
       all_options.each do |k, v|
         self.public_send("#{k}=", v)
       end
@@ -106,6 +98,9 @@ module GraphQL
       result = schema.public_send(method_name, only: @only, except: @except, context: context)
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
+      if !result.end_with?("\n")
+        result += "\n"
+      end
       File.write(file, result)
     end
 
@@ -117,18 +112,26 @@ module GraphQL
       File.join(@directory, @json_outfile)
     end
 
+    def load_rails_environment_if_defined
+      if Rake::Task.task_defined?('environment')
+        Rake::Task['environment'].invoke
+      end
+    end
+
     # Use the Rake DSL to add tasks
     def define_task
       namespace(@namespace) do
         namespace("schema") do
           desc("Dump the schema to IDL in #{idl_path}")
           task :idl => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_definition, idl_path)
             puts "Schema IDL dumped into #{idl_path}"
           end
 
           desc("Dump the schema to JSON in #{json_path}")
           task :json => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_json, json_path)
             puts "Schema JSON dumped into #{json_path}"
           end

data/lib/graphql/relay/array_connection.rb

@@ -13,7 +13,7 @@ module GraphQL
           sliced_nodes.count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && before
           # The original array is longer than the `before` index
-          index_from_cursor(before) < nodes.length
+          index_from_cursor(before) < nodes.length + 1
         else
           false
         end
@@ -31,24 +31,22 @@ module GraphQL
         end
       end
 
-      private
-
       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
+
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= begin

data/lib/graphql/relay/base_connection.rb

@@ -25,6 +25,10 @@ module GraphQL
         # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
+          # If it's a new-style connection object, it's already ready to go
+          if nodes.is_a?(GraphQL::Pagination::Connection)
+            return nodes
+          end
           # Check for class _names_ because classes can be redefined in Rails development
           nodes.class.ancestors.each do |ancestor|
             conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
@@ -55,6 +59,13 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+
+        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
+        if deprecated_caller
+          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
+        end
+
         @context = context
         @nodes = nodes
         @arguments = arguments
@@ -75,7 +86,13 @@ module GraphQL
       # The value passed as `first:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def first
-        @first ||= get_limited_arg(: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
 
       # The value passed as `after:`, if there was one
@@ -87,7 +104,7 @@ module GraphQL
       # The value passed as `last:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def last
-        @last ||= get_limited_arg(:last)
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       # The value passed as `before:`, if there was one
@@ -137,7 +154,7 @@ module GraphQL
 
       # An opaque operation which returns a connection-specific cursor.
       def cursor_from_node(object)
-        raise NotImplementedError, "must return a cursor for this object/connection pair"
+        raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
       end
 
       def inspect
@@ -146,24 +163,26 @@ module GraphQL
 
       private
 
-      # Return a sanitized `arguments[arg_name]` (don't allow negatives)
-      def get_limited_arg(arg_name)
-        arg_value = arguments[arg_name]
-        if arg_value.nil?
-          arg_value
-        elsif arg_value < 0
-          0
-        else
-          arg_value
+      # @param argument [nil, Integer] `first` or `last`, as provided by the client
+      # @param max_page_size [nil, Integer]
+      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
         end
+        argument
       end
 
       def paged_nodes
-        raise NotImplementedError, "must return nodes for this connection after paging"
+        raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
       end
 
       def sliced_nodes
-        raise NotImplementedError, "must return  all nodes for this connection after chopping off first and last"
+        raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
       end
     end
   end

data/lib/graphql/relay/connection_instrumentation.rb

@@ -7,33 +7,39 @@ module GraphQL
     # The original resolve proc is used to fetch nodes,
     # then a connection implementation is fetched with {BaseConnection.connection_for_nodes}.
     module ConnectionInstrumentation
-      ARGUMENT_DEFINITIONS = [
-          ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
-          ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified global ID."],
-          ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
-          ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified global ID."],
-        ]
+      def self.default_arguments
+        @default_arguments ||= begin
+          argument_definitions = [
+              ["first", GraphQL::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+            ]
 
-      DEFAULT_ARGUMENTS = ARGUMENT_DEFINITIONS.reduce({}) do |memo, arg_defn|
-        argument = GraphQL::Argument.new
-        name, type, description = arg_defn
-        argument.name = name
-        argument.type = type
-        argument.description = description
-        memo[argument.name.to_s] = argument
-        memo
+          argument_definitions.reduce({}) do |memo, arg_defn|
+            argument = GraphQL::Argument.new
+            name, type, description = arg_defn
+            argument.name = name
+            argument.type = type
+            argument.description = description
+            memo[argument.name.to_s] = argument
+            memo
+          end
+        end
       end
 
       # Build a connection field from a {GraphQL::Field} by:
       # - Merging in the default arguments
       # - Transforming its resolve function to return a connection object
       def self.instrument(type, field)
-        if field.connection?
-          connection_arguments = DEFAULT_ARGUMENTS.merge(field.arguments)
+        # Don't apply the wrapper to class-based fields, since they
+        # use Schema::Field::ConnectionFilter
+        if field.connection? && !field.metadata[:type_class]
+          connection_arguments = default_arguments.merge(field.arguments)
           original_resolve = field.resolve_proc
           original_lazy_resolve = field.lazy_resolve_proc
-          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve, lazy: false)
-          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve, lazy: true)
+          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve)
+          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve)
           field.redefine(
             resolve: connection_resolve,
             lazy_resolve: connection_lazy_resolve,

data/lib/graphql/relay/connection_resolve.rb

@@ -2,34 +2,24 @@
 module GraphQL
   module Relay
     class ConnectionResolve
-      def initialize(field, underlying_resolve, lazy:)
+      def initialize(field, underlying_resolve)
         @field = field
         @underlying_resolve = underlying_resolve
         @max_page_size = field.connection_max_page_size
-        @lazy = lazy
       end
 
       def call(obj, args, ctx)
-        if @lazy && obj.is_a?(LazyNodesWrapper)
-          parent = obj.parent
-          obj = obj.lazy_object
-        else
-          parent = obj
-        end
+        # in a lazy resolve hook, obj is the promise,
+        # get the object that the promise was
+        # originally derived from
+        parent = ctx.object
 
         nodes = @underlying_resolve.call(obj, args, ctx)
 
-        if nodes.nil?
-          nil
-        elsif ctx.schema.lazy?(nodes)
-          if !@lazy
-            LazyNodesWrapper.new(obj, nodes)
-          else
-            nodes
-          end
-        elsif nodes.is_a?(GraphQL::Execution::Execute::Skip)
+        if nodes.nil? || ctx.schema.lazy?(nodes) || nodes.is_a?(GraphQL::Execution::Execute::Skip) || ctx.wrapped_connection
           nodes
         else
+          ctx.wrapped_connection = true
           build_connection(nodes, args, parent, ctx)
         end
       end
@@ -48,16 +38,6 @@ module GraphQL
           connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
         end
       end
-
-      # A container for the proper `parent` of connection nodes.
-      # Without this wrapper, the lazy object _itself_ is passed into `build_connection`
-      # and it becomes the parent, which is wrong.
-      #
-      # We can get away with it because we know that this instrumentation will be applied last.
-      # That means its code after `underlying_resolve` will be _last_ on the way in.
-      # And, its code before `underlying_resolve` will be _first_ during lazy resolution.
-      # @api private
-      LazyNodesWrapper = Struct.new(:parent, :lazy_object)
     end
   end
 end

data/lib/graphql/relay/connection_type.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Relay
+    # @api deprecated
     module ConnectionType
       class << self
         # @return [Boolean] If true, connection types get a `nodes` shortcut field
@@ -12,14 +13,14 @@ module GraphQL
       self.default_nodes_field = false
       self.bidirectional_pagination = false
 
-      # Create a connection which exposes edges of this type
+      # @api deprecated
       def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
         custom_edge_class = edge_class
 
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
-        ObjectType.define do
+        ObjectType.deprecated_define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
           edge_type ||= wrapped_type.edge_type
           name("#{type_name}Connection")
@@ -31,6 +32,7 @@ module GraphQL
           end
 
           field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
+          relay_node_type(wrapped_type)
           block && instance_eval(&block)
         end
       end

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
@@ -9,6 +10,7 @@ module GraphQL
           description "An edge in a connection."
           field :node, wrapped_type, "The item at the end of the edge."
           field :cursor, !types.String, "A cursor for use in pagination."
+          relay_node_type(wrapped_type)
           block && instance_eval(&block)
         end
       end

data/lib/graphql/relay/edges_instrumentation.rb

@@ -4,15 +4,12 @@ module GraphQL
     module EdgesInstrumentation
       def self.instrument(type, field)
         if field.edges?
-          edges_resolve = EdgesResolve.new(
-            edge_class: field.edge_class,
-            resolve: field.resolve_proc,
-            lazy_resolve: field.lazy_resolve_proc,
-          )
+          edges_resolve = EdgesResolve.new(edge_class: field.edge_class, resolve: field.resolve_proc)
+          edges_lazy_resolve = EdgesResolve.new(edge_class: field.edge_class, resolve: field.lazy_resolve_proc)
 
           field.redefine(
-            resolve: edges_resolve.method(:resolve),
-            lazy_resolve: edges_resolve.method(:lazy_resolve),
+            resolve: edges_resolve,
+            lazy_resolve: edges_lazy_resolve,
           )
         else
           field
@@ -21,35 +18,22 @@ module GraphQL
 
 
       class EdgesResolve
-        def initialize(edge_class:, resolve:, lazy_resolve:)
+        def initialize(edge_class:, resolve:)
           @edge_class = edge_class
           @resolve_proc = resolve
-          @lazy_resolve_proc = lazy_resolve
         end
 
         # A user's custom Connection may return a lazy object,
         # if so, handle it later.
-        def resolve(obj, args, ctx)
+        def call(obj, args, ctx)
+          parent = ctx.object
           nodes = @resolve_proc.call(obj, args, ctx)
           if ctx.schema.lazy?(nodes)
-            ConnectionResolve::LazyNodesWrapper.new(obj, nodes)
+            nodes
           else
-            build_edges(nodes, obj)
+            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
           end
         end
-
-        # If we get this far, unwrap the wrapper,
-        # resolve the lazy object and make the edges as usual
-        def lazy_resolve(obj, args, ctx)
-          items = @lazy_resolve_proc.call(obj.lazy_object, args, ctx)
-          build_edges(items, obj.parent)
-        end
-
-        private
-
-        def build_edges(items, connection)
-          items.map { |item| @edge_class.new(item, connection) }
-        end
       end
     end
   end

data/lib/graphql/relay/mongo_relation_connection.rb

@@ -36,5 +36,15 @@ module GraphQL
     if defined?(Mongoid::Criteria)
       BaseConnection.register_connection_implementation(Mongoid::Criteria, MongoRelationConnection)
     end
+
+    # Mongoid 5 and 6
+    if defined?(Mongoid::Relations::Targets::Enumerable)
+      BaseConnection.register_connection_implementation(Mongoid::Relations::Targets::Enumerable, MongoRelationConnection)
+    end
+
+    # Mongoid 7
+    if defined?(Mongoid::Association::Referenced::HasMany::Targets::Enumerable)
+      BaseConnection.register_connection_implementation(Mongoid::Association::Referenced::HasMany::Targets::Enumerable, MongoRelationConnection)
+    end
   end
 end

data/lib/graphql/relay/mutation/instrumentation.rb

@@ -12,8 +12,7 @@ module GraphQL
         def self.instrument(type, field)
           if field.mutation.is_a?(GraphQL::Relay::Mutation) || (field.mutation.is_a?(Class) && field.mutation < GraphQL::Schema::RelayClassicMutation)
             new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc)
-            new_lazy_resolve = Mutation::Resolve.new(field.mutation, field.lazy_resolve_proc)
-            field.redefine(resolve: new_resolve, lazy_resolve: new_lazy_resolve)
+            field.redefine(resolve: new_resolve)
           else
             field
           end

data/lib/graphql/relay/mutation/resolve.rb

@@ -21,10 +21,8 @@ module GraphQL
             err
           end
 
-          if ctx.schema.lazy?(mutation_result)
-            mutation_result
-          else
-            build_result(mutation_result, args, ctx)
+          ctx.schema.after_lazy(mutation_result) do |res|
+            build_result(res, args, ctx)
           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(
@@ -101,7 +16,8 @@ module GraphQL
         return_field: GraphQL::Define::AssignObjectField,
         function: GraphQL::Define::AssignMutationFunction,
       )
-      attr_accessor :name, :description, :fields, :arguments, :return_type, :return_interfaces
+      attr_accessor :name, :description, :fields, :arguments
+      attr_writer :return_type, :return_interfaces
 
       ensure_defined(
         :input_fields, :return_fields, :name, :description,
@@ -114,6 +30,7 @@ module GraphQL
       alias :input_fields :arguments
 
       def initialize
+        GraphQL::Deprecation.warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
         @fields = {}
         @arguments = {}
         @has_generated_return_type = false