graphql 1.7.14 → 1.8.0.pre1

data/spec/support/jazz.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+# Here's the "application"
+module Jazz
+  module Models
+    Instrument = Struct.new(:name, :family)
+    Ensemble = Struct.new(:name)
+    Musician = Struct.new(:name, :favorite_key)
+    Key = Struct.new(:root, :sharp, :flat) do
+      def self.from_notation(key_str)
+        key, sharp_or_flat = key_str.split("")
+        sharp = sharp_or_flat ==  "♯"
+        flat = sharp_or_flat == "♭"
+        Models::Key.new(key, sharp, flat)
+      end
+
+      def to_notation
+        "#{root}#{sharp ? "♯" : ""}#{flat ? "♭" : ""}"
+      end
+    end
+
+    def self.reset
+      @data = {
+        "Instrument" => [
+          Models::Instrument.new("Banjo", :str),
+          Models::Instrument.new("Flute", "WOODWIND"),
+          Models::Instrument.new("Trumpet", "BRASS"),
+          Models::Instrument.new("Piano", "KEYS"),
+          Models::Instrument.new("Organ", "KEYS"),
+          Models::Instrument.new("Drum Kit", "PERCUSSION"),
+        ],
+        "Ensemble" => [
+          Models::Ensemble.new("Bela Fleck and the Flecktones"),
+        ],
+        "Musician" => [
+          Models::Musician.new("Herbie Hancock", Models::Key.from_notation("B♭")),
+        ]
+      }
+    end
+
+    def self.data
+      @data || reset
+    end
+  end
+
+  class BaseArgument < GraphQL::Schema::Argument
+    def initialize(name, type, desc = nil, custom: nil, **kwargs)
+      @custom = custom
+      super(name, type, desc, **kwargs)
+    end
+
+    def to_graphql
+      arg_defn = super
+      arg_defn.metadata[:custom] = @custom
+      arg_defn
+    end
+  end
+
+  # A custom field class that supports the `upcase:` option
+  class BaseField < GraphQL::Schema::Field
+    argument_class BaseArgument
+    def initialize(*args, options, &block)
+      @upcase = options.delete(:upcase)
+      super(*args, options, &block)
+    end
+
+    def to_graphql
+      field_defn = super
+      if @upcase
+        inner_resolve = field_defn.resolve_proc
+        field_defn.resolve = ->(obj, args, ctx) {
+          inner_resolve.call(obj, args, ctx).upcase
+        }
+      end
+      field_defn
+    end
+  end
+
+  class BaseObject < GraphQL::Schema::Object
+    # Use this overridden field class
+    field_class BaseField
+
+    class << self
+      def config(key, value)
+        configs[key] = value
+      end
+
+      def configs
+        @configs ||= {}
+      end
+
+      def to_graphql
+        type_defn = super
+        configs.each do |k,v|
+          type_defn.metadata[k] = v
+        end
+        type_defn
+      end
+    end
+  end
+
+  class BaseInterface < GraphQL::Schema::Interface
+    # Use this overridden field class
+    field_class BaseField
+  end
+
+
+  # Some arbitrary global ID scheme
+  # *Type suffix is removed automatically
+  class GloballyIdentifiableType < BaseInterface
+    description "A fetchable object in the system"
+    field :id, ID, "A unique identifier for this object", null: false
+    field :upcasedId, ID, null: false, upcase: true, method: :id
+
+    module Implementation
+      def id
+        GloballyIdentifiableType.to_id(@object)
+      end
+    end
+
+    def self.to_id(object)
+      "#{object.class.name.split("::").last}/#{object.name}"
+    end
+
+    def self.find(id)
+      class_name, object_name = id.split("/")
+      Models.data[class_name].find { |obj| obj.name == object_name }
+    end
+  end
+
+  # A legacy-style interface used by new-style types
+  NamedEntity = GraphQL::InterfaceType.define do
+    name "NamedEntity"
+    field :name, !types.String
+  end
+
+  # test field inheritance
+  class ObjectWithUpcasedName < BaseObject
+    # Test extra arguments:
+    field :upcaseName, String, null: false, upcase: true
+
+    def upcase_name
+      @object.name # upcase is applied by the superclass
+    end
+  end
+
+  # Here's a new-style GraphQL type definition
+  class Ensemble < ObjectWithUpcasedName
+    implements GloballyIdentifiableType, NamedEntity
+    description "A group of musicians playing together"
+    config :config, :configged
+    # Test string type names:
+    field :name, "String", null: false
+    field :musicians, "[Jazz::Musician]", null: false
+  end
+
+  class Family < GraphQL::Schema::Enum
+    description "Groups of musical instruments"
+    # support string and symbol
+    value "STRING", "Makes a sound by vibrating strings", value: :str
+    value :WOODWIND, "Makes a sound by vibrating air in a pipe"
+    value :BRASS, "Makes a sound by amplifying the sound of buzzing lips"
+    value "PERCUSSION", "Makes a sound by hitting something that vibrates"
+    value "KEYS", "Neither here nor there, really"
+    value "DIDGERIDOO", "Makes a sound by amplifying the sound of buzzing lips", deprecation_reason: "Merged into BRASS"
+  end
+
+  # Lives side-by-side with an old-style definition
+  using GraphQL::DeprecatedDSL # for ! and types[]
+  InstrumentType = GraphQL::ObjectType.define do
+    name "Instrument"
+    interfaces [NamedEntity]
+    implements GloballyIdentifiableType
+
+    field :id, !types.ID, "A unique identifier for this object", resolve: ->(obj, args, ctx) { GloballyIdentifiableType.to_id(obj) }
+    field :upcasedId, !types.ID, resolve: ->(obj, args, ctx) { GloballyIdentifiableType.to_id(obj).upcase }
+    if RUBY_ENGINE == "jruby"
+      # JRuby doesn't support refinements, so the `using` above won't work
+      field :family, Family.to_non_null_type
+    else
+      field :family, !Family
+    end
+  end
+
+  class Key < GraphQL::Schema::Scalar
+    description "A musical key"
+    def self.coerce_input(val, ctx)
+      Models::Key.from_notation(val)
+    end
+
+    def self.coerce_result(val, ctx)
+      val.to_notation
+    end
+  end
+
+  class Musician < BaseObject
+    implements GloballyIdentifiableType
+    implements NamedEntity
+    description "Someone who plays an instrument"
+    field :instrument, InstrumentType, null: false
+    field :favoriteKey, Key, null: true
+  end
+
+  LegacyInputType = GraphQL::InputObjectType.define do
+    name "LegacyInput"
+    argument :intValue, !types.Int
+  end
+
+  class InspectableInput < GraphQL::Schema::InputObject
+    argument :stringValue, String, required: true
+    argument :nestedInput, InspectableInput, required: false
+    argument :legacyInput, LegacyInputType, required: false
+    def helper_method
+      [
+        # Context is available in the InputObject
+        @context[:message],
+        # A GraphQL::Query::Arguments instance is available
+        @arguments[:stringValue],
+        # Legacy inputs have underscored method access too
+        legacy_input ? legacy_input.int_value : "-",
+        # Access by method call is available
+        "(#{nested_input ? nested_input.helper_method : "-"})",
+      ].join(", ")
+    end
+  end
+
+  class InspectableKey < BaseObject
+    field :root, String, null: false
+    field :isSharp, Boolean, null: false, method: :sharp
+    field :isFlat, Boolean, null: false, method: :flat
+  end
+
+  class PerformingAct < GraphQL::Schema::Union
+    possible_types Musician, Ensemble
+
+    def resolve_type
+      if @object.is_a?(Models::Ensemble)
+        Ensemble
+      else
+        Musician
+      end
+    end
+  end
+
+  # Another new-style definition, with method overrides
+  class Query < BaseObject
+    field :ensembles, [Ensemble], null: false
+    field :find, GloballyIdentifiableType, null: true do
+      argument :id, ID, required: true, custom: :ok
+    end
+    field :instruments, [InstrumentType], null: false do
+      argument :family, Family, required: false
+    end
+    field :inspectInput, [String], null: false do
+      argument :input, InspectableInput, required: true
+    end
+    field :inspectKey, InspectableKey, null: false do
+      argument :key, Key, required: true
+    end
+    field :nowPlaying, PerformingAct, null: false, resolve: ->(o, a, c) { Models.data["Ensemble"].first }
+    # For asserting that the object is initialized once:
+    field :objectId, Integer, null: false
+
+    def ensembles
+      Models.data["Ensemble"]
+    end
+
+    def find(id:)
+      if id == "MagicalSkipId"
+        @context.skip
+      else
+        GloballyIdentifiableType.find(id)
+      end
+    end
+
+    def instruments(family: nil)
+      objs = Models.data["Instrument"]
+      if family
+        objs = objs.select { |i| i.family == family }
+      end
+      objs
+    end
+
+    # This is for testing input object behavior
+    def inspect_input(input:)
+      [
+        input.class.name,
+        input.helper_method,
+        # Access by method
+        input.string_value,
+        # Access by key:
+        input["stringValue"],
+        input[:stringValue],
+      ]
+    end
+
+    def inspect_key(key:)
+      key
+    end
+  end
+
+  class EnsembleInput < GraphQL::Schema::InputObject
+    argument :name, String, required: true
+  end
+
+  class Mutation < BaseObject
+    field :addEnsemble, Ensemble, null: false do
+      argument :input, EnsembleInput, required: true
+    end
+
+    def add_ensemble(input:)
+      ens = Models::Ensemble.new(input.name)
+      Models.data["Ensemble"] << ens
+      ens
+    end
+  end
+
+  class MetadataPlugin
+    def self.use(schema_defn, value:)
+      schema_defn.target.metadata[:plugin_key] = value
+    end
+  end
+
+  # New-style Schema definition
+  class Schema < GraphQL::Schema
+    query(Query)
+    mutation(Mutation)
+    use MetadataPlugin, value: "xyz"
+    def self.resolve_type(type, obj, ctx)
+      class_name = obj.class.name.split("::").last
+      ctx.schema.types[class_name] || raise("No type for #{obj.inspect}")
+    end
+  end
+end

data/spec/support/lazy_helpers.rb

@@ -46,32 +46,30 @@ module LazyHelpers
     end
   end
 
-  LazySum = GraphQL::ObjectType.define do
-    name "LazySum"
-    field :value, types.Int do
-      resolve ->(o, a, c) { o == 13 ? nil : o }
+  class LazySum < GraphQL::Schema::Object
+    field :value, Integer, null: true, resolve: ->(o, a, c) { o == 13 ? nil : o }
+    field :nestedSum, LazySum, null: false do
+      argument :value, Integer, required: true
     end
-    field :nestedSum, !LazySum do
-      argument :value, !types.Int
-      resolve ->(o, args, c) {
-        if args[:value] == 13
-          Wrapper.new(nil)
-        else
-          SumAll.new(c, o + args[:value])
-        end
-      }
+
+    def nested_sum(value:)
+      if value == 13
+        Wrapper.new(nil)
+      else
+        SumAll.new(@context, @object + value)
+      end
     end
 
-    field :nullableNestedSum, LazySum do
-      argument :value, types.Int
-      resolve ->(o, args, c) {
-        if args[:value] == 13
-          Wrapper.new(nil)
-        else
-          SumAll.new(c, o + args[:value])
-        end
-      }
+    field :nullableNestedSum, LazySum, null: true do
+      argument :value, Integer, required: true
     end
+    alias :nullable_nested_sum :nested_sum
+  end
+
+  using GraphQL::DeprecatedDSL
+  if RUBY_ENGINE == "jruby"
+    # JRuby doesn't support refinements, so the `using` above won't work
+    GraphQL::DeprecatedDSL.activate
   end
 
   LazyQuery = GraphQL::ObjectType.define do
@@ -136,7 +134,7 @@ module LazyHelpers
     end
   end
 
-  LazySchema = GraphQL::Schema.define do
+  class LazySchema < GraphQL::Schema
     query(LazyQuery)
     mutation(LazyQuery)
     lazy_resolve(Wrapper, :item)

data/spec/support/star_wars/data.rb

@@ -18,12 +18,13 @@ module StarWars
     'Executor',
   ]
 
+  # ActiveRecord::Base.logger = Logger.new(STDOUT)
   `rm -f ./_test_.db`
   # Set up "Bases" in ActiveRecord
 
   if jruby?
     ActiveRecord::Base.establish_connection(adapter: "jdbcsqlite3", database: "./_test_.db")
-    DB = Sequel.connect('jdbc:sqlite:./_test_.db')
+    Sequel.connect('jdbc:sqlite:./_test_.db')
   elsif ENV['DATABASE'] == 'POSTGRESQL'
     ActiveRecord::Base.establish_connection(
       adapter: "postgresql",
@@ -59,13 +60,13 @@ module StarWars
   end
 
   class FactionRecord
-    attr_reader :id, :name, :ships, :bases, :basesClone
-    def initialize(id:, name:, ships:, bases:, basesClone:)
+    attr_reader :id, :name, :ships, :bases, :bases_clone
+    def initialize(id:, name:, ships:, bases:, bases_clone:)
       @id = id
       @name = name
       @ships = ships
       @bases = bases
-      @basesClone = basesClone
+      @bases_clone = bases_clone
     end
   end
 
@@ -74,7 +75,7 @@ module StarWars
     name: 'Alliance to Restore the Republic',
     ships:  ['1', '2', '3', '4', '5'],
     bases: Base.where(faction_id: 1),
-    basesClone: Base.where(faction_id: 1),
+    bases_clone: Base.where(faction_id: 1),
   })
 
 
@@ -83,7 +84,7 @@ module StarWars
     name: 'Galactic Empire',
     ships: ['6', '7', '8'],
     bases: Base.where(faction_id: 2),
-    basesClone: Base.where(faction_id: 2),
+    bases_clone: Base.where(faction_id: 2),
   })
 
   DATA = {

data/spec/support/star_wars/schema.rb

@@ -3,31 +3,28 @@ module StarWars
   # Adapted from graphql-relay-js
   # https://github.com/graphql/graphql-relay-js/blob/master/src/__tests__/starWarsSchema.js
 
-  Ship = GraphQL::ObjectType.define do
-    name "Ship"
-    interfaces [GraphQL::Relay::Node.interface]
+  class Ship < GraphQL::Schema::Object
+    implements GraphQL::Relay::Node.interface
     global_id_field :id
-    field :name, types.String
+    field :name, String, null: true
     # Test cyclical connection types:
-    connection :ships, Ship.connection_type
+    field :ships, Ship.connection_type, null: false
   end
 
-  BaseType = GraphQL::ObjectType.define do
-    name "Base"
-    interfaces [GraphQL::Relay::Node.interface]
+  class BaseType < GraphQL::Schema::Object
+    graphql_name "Base"
+    implements GraphQL::Relay::Node.interface
     global_id_field :id
-    field :name, !types.String do
-      resolve ->(obj, args, ctx) {
-        LazyWrapper.new {
-          if obj.id.nil?
-            raise GraphQL::ExecutionError, "Boom!"
-          else
-            obj.name
-          end
-        }
+    field :name, String, null: false, resolve: ->(obj, args, ctx) {
+      LazyWrapper.new {
+        if obj.id.nil?
+          raise GraphQL::ExecutionError, "Boom!"
+        else
+          obj.name
+        end
       }
-    end
-    field :planet, types.String
+    }
+    field :planet, String, null: true
   end
 
   # Use an optional block to add fields to the connection type:
@@ -90,103 +87,81 @@ module StarWars
     end
   end
 
-  Faction = GraphQL::ObjectType.define do
-    name "Faction"
-    interfaces [GraphQL::Relay::Node.interface]
-
-    field :id, !types.ID, resolve: GraphQL::Relay::GlobalIdResolve.new(type: Faction)
-    field :name, types.String
-    connection :ships, ShipConnectionWithParentType, max_page_size: 1000 do
-      resolve ->(obj, args, ctx) {
-        all_ships = obj.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
-        if args[:nameIncludes]
-          case args[:nameIncludes]
-          when "error"
-            all_ships = GraphQL::ExecutionError.new("error from within connection")
-          when "raisedError"
-            raise GraphQL::ExecutionError.new("error raised from within connection")
-          when "lazyError"
-            all_ships = LazyWrapper.new { GraphQL::ExecutionError.new("lazy error from within connection") }
-          when "lazyRaisedError"
-            all_ships = LazyWrapper.new { raise GraphQL::ExecutionError.new("lazy raised error from within connection") }
-          when "null"
-            all_ships = nil
-          when "lazyObject"
-            prev_all_ships = all_ships
-            all_ships = LazyWrapper.new { prev_all_ships }
-          else
-            all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
-          end
-        end
-        all_ships
-      }
-      # You can define arguments here and use them in the connection
-      argument :nameIncludes, types.String
-    end
-
-    connection :shipsWithMaxPageSize, max_page_size: 2, function: ShipsWithMaxPageSize.new
+  class Faction < GraphQL::Schema::Object
+    implements GraphQL::Relay::Node.interface
 
-    connection :bases, BaseConnectionWithTotalCountType do
-      # Resolve field should return an Array, the Connection
-      # will do the rest!
-      resolve ->(obj, args, ctx) {
-        all_bases = Base.where(id: obj.bases)
-        if args[:nameIncludes]
-          all_bases = all_bases.where("name LIKE ?", "%#{args[:nameIncludes]}%")
-        end
-        all_bases
-      }
-      argument :nameIncludes, types.String
-    end
-
-    connection :basesClone, BaseType.connection_type
-    connection :basesByName, BaseType.connection_type, property: :bases do
-      argument :order, types.String, default_value: "name"
-      resolve ->(obj, args, ctx) {
-        if args[:order].present?
-          obj.bases.order(args[:order])
+    field :id, ID, null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: Faction)
+    field :name, String, null: true
+    field :ships, ShipConnectionWithParentType, connection: true, max_page_size: 1000, null: true, resolve: ->(obj, args, ctx) {
+      all_ships = obj.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
+      if args[:nameIncludes]
+        case args[:nameIncludes]
+        when "error"
+          all_ships = GraphQL::ExecutionError.new("error from within connection")
+        when "raisedError"
+          raise GraphQL::ExecutionError.new("error raised from within connection")
+        when "lazyError"
+          all_ships = LazyWrapper.new { GraphQL::ExecutionError.new("lazy error from within connection") }
+        when "lazyRaisedError"
+          all_ships = LazyWrapper.new { raise GraphQL::ExecutionError.new("lazy raised error from within connection") }
+        when "null"
+          all_ships = nil
+        when "lazyObject"
+          prev_all_ships = all_ships
+          all_ships = LazyWrapper.new { prev_all_ships }
         else
-          obj.bases
+          all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
         end
-      }
+      end
+      all_ships
+    } do
+      # You can define arguments here and use them in the connection
+      argument :nameIncludes, String, required: false
     end
 
-    connection :basesWithMaxLimitRelation, BaseType.connection_type, max_page_size: 2 do
-      resolve ->(object, args, context) { Base.all }
-    end
+    field :shipsWithMaxPageSize, max_page_size: 2, function: ShipsWithMaxPageSize.new
 
-    connection :basesWithMaxLimitArray, BaseType.connection_type, max_page_size: 2 do
-      resolve ->(object, args, context) { Base.all.to_a }
+    field :bases, BaseConnectionWithTotalCountType, null: true, connection: true, resolve: ->(obj, args, ctx) {
+      all_bases = Base.where(id: obj.bases)
+      if args[:nameIncludes]
+        all_bases = all_bases.where("name LIKE ?", "%#{args[:nameIncludes]}%")
+      end
+      all_bases
+    } do
+      argument :nameIncludes, String, required: false
     end
 
-    connection :basesWithDefaultMaxLimitRelation, BaseType.connection_type do
-      resolve ->(object, args, context) { Base.all }
+    field :basesClone, BaseType.connection_type, null: true
+    field :basesByName, BaseType.connection_type, null: true do
+      argument :order, String, default_value: "name", required: false
     end
-
-    connection :basesWithDefaultMaxLimitArray, BaseType.connection_type do
-      resolve ->(object, args, context) { Base.all.to_a }
+    def bases_by_name(order: nil)
+      if order.present?
+        @object.bases.order(order)
+      else
+        @object.bases
+      end
     end
 
-    connection :basesWithLargeMaxLimitRelation, BaseType.connection_type, max_page_size: 1000 do
-      resolve ->(object, args, context) { Base.all }
-    end
+    field :basesWithMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 2, resolve: Proc.new { Base.all}
+    field :basesWithMaxLimitArray, BaseType.connection_type, null: true, max_page_size: 2, resolve: Proc.new { Base.all.to_a }
+    field :basesWithDefaultMaxLimitRelation, BaseType.connection_type, null: true, resolve: Proc.new { Base.all }
+    field :basesWithDefaultMaxLimitArray, BaseType.connection_type, null: true, resolve: Proc.new { Base.all.to_a }
+    field :basesWithLargeMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 1000, resolve: Proc.new { Base.all }
 
-    connection :basesAsSequelDataset, BaseConnectionWithTotalCountType, max_page_size: 1000 do
-      argument :nameIncludes, types.String
-      resolve ->(obj, args, ctx) {
-        all_bases = SequelBase.where(faction_id: obj.id)
-        if args[:nameIncludes]
-          all_bases = all_bases.where(Sequel.like(:name, "%#{args[:nameIncludes]}%"))
-        end
-        all_bases
-      }
+    field :basesAsSequelDataset, BaseConnectionWithTotalCountType, null: true, connection: true, max_page_size: 1000 do
+      argument :nameIncludes, String, required: false
     end
 
-    connection :basesWithCustomEdge, CustomEdgeBaseConnectionType do
-      resolve ->(o, a, c) {
-        LazyNodesWrapper.new(o.bases)
-      }
+    def bases_as_sequel_dataset(name_includes: nil)
+      all_bases = SequelBase.where(faction_id: @object.id)
+      if name_includes
+        all_bases = all_bases.where(Sequel.like(:name, "%#{name_includes}%"))
+      end
+      all_bases
     end
+
+    field :basesWithCustomEdge, CustomEdgeBaseConnectionType, null: true, connection: true, resolve: ->(o, a, c) { LazyNodesWrapper.new(o.bases) }
   end
 
   # Define a mutation. It will also:
@@ -323,60 +298,52 @@ module StarWars
 
   GraphQL::Relay::BaseConnection.register_connection_implementation(LazyNodesWrapper, LazyNodesRelationConnection)
 
-  QueryType = GraphQL::ObjectType.define do
-    name "Query"
-    field :rebels, Faction do
-      resolve ->(obj, args, ctx) { StarWars::DATA["Faction"]["1"]}
-    end
+  class QueryType < GraphQL::Schema::Object
+    graphql_name "Query"
 
-    field :empire, Faction do
-      resolve ->(obj, args, ctx) { StarWars::DATA["Faction"]["2"]}
-    end
+    field :rebels, Faction, null: true, resolve: ->(obj, args, ctx) { StarWars::DATA["Faction"]["1"]}
 
-    field :largestBase, BaseType do
-      resolve ->(obj, args, ctx) { Base.find(3) }
-    end
+    field :empire, Faction, null: true, resolve: ->(obj, args, ctx) { StarWars::DATA["Faction"]["2"]}
 
-    connection :newestBasesGroupedByFaction, BaseType.connection_type do
-      resolve ->(obj, args, ctx) {
-        Base
-          .having('id in (select max(id) from bases group by faction_id)')
-          .group(:id)
-          .order('faction_id desc')
-      }
-    end
+    field :largestBase, BaseType, null: true, resolve: ->(obj, args, ctx) { Base.find(3) }
 
-    connection :basesWithNullName, BaseType.connection_type do
-      resolve ->(obj, args, ctx) {
-        [OpenStruct.new(id: nil)]
-      }
-    end
+    field :newestBasesGroupedByFaction, BaseType.connection_type, null: true, resolve: ->(obj, args, ctx) {
+      Base
+        .having('id in (select max(id) from bases group by faction_id)')
+        .group(:id)
+        .order('faction_id desc')
+    }
+
+    field :basesWithNullName, BaseType.connection_type, null: false, resolve: ->(obj, args, ctx) {
+      [OpenStruct.new(id: nil)]
+    }
 
-    field :node, GraphQL::Relay::Node.field
+    field :node, field: GraphQL::Relay::Node.field
 
     custom_node_field = GraphQL::Relay::Node.field do
       resolve ->(_, _, _) { StarWars::DATA["Faction"]["1"] }
     end
-    field :nodeWithCustomResolver, custom_node_field
+    field :nodeWithCustomResolver, field: custom_node_field
 
-    field :nodes, GraphQL::Relay::Node.plural_field
-    field :nodesWithCustomResolver, GraphQL::Relay::Node.plural_field(
+    field :nodes, field: GraphQL::Relay::Node.plural_field
+    field :nodesWithCustomResolver, field: GraphQL::Relay::Node.plural_field(
       resolve: ->(_, _, _) { [StarWars::DATA["Faction"]["1"], StarWars::DATA["Faction"]["2"]] }
     )
 
-    field :batchedBase, BaseType do
-      argument :id, !types.ID
-      resolve ->(o, a, c) {
-        LazyLoader.defer(c, Base, a["id"])
-      }
+    field :batchedBase, BaseType, null: true do
+      argument :id, ID, required: true
+    end
+
+    def batched_base(id:)
+      LazyLoader.defer(@context, Base, id)
     end
   end
 
-  MutationType = GraphQL::ObjectType.define do
-    name "Mutation"
+  class MutationType < GraphQL::Schema::Object
+    graphql_name "Mutation"
     # The mutation object exposes a field:
     field :introduceShip, field: IntroduceShipMutation.field
-    field :introduceShipFunction, IntroduceShipFunctionMutation.field
+    field :introduceShipFunction, field: IntroduceShipFunctionMutation.field
   end
 
   class ClassNameRecorder
@@ -399,12 +366,12 @@ module StarWars
     end
   end
 
-  Schema = GraphQL::Schema.define do
+  class Schema < GraphQL::Schema
     query(QueryType)
     mutation(MutationType)
     default_max_page_size 3
 
-    resolve_type ->(type, object, ctx) {
+    def self.resolve_type(type, object, ctx)
       if object == :test_error
         :not_a_type
       elsif object.is_a?(Base)
@@ -416,14 +383,14 @@ module StarWars
       else
         nil
       end
-    }
+    end
 
-    object_from_id ->(node_id, ctx) do
+    def self.object_from_id(node_id, ctx)
       type_name, id = GraphQL::Schema::UniqueWithinType.decode(node_id)
       StarWars::DATA[type_name][id]
     end
 
-    id_from_object ->(object, type, ctx) do
+    def self.id_from_object(object, type, ctx)
       GraphQL::Schema::UniqueWithinType.encode(type.name, object.id)
     end