graphql 1.8.7 → 1.9.0

data/spec/support/dummy/schema.rb

@@ -7,40 +7,58 @@ module Dummy
   GraphQL::Field.accepts_definitions(joins: GraphQL::Define.assign_metadata_key(:joins))
   GraphQL::BaseType.accepts_definitions(class_names: GraphQL::Define.assign_metadata_key(:class_names))
 
-  LocalProductInterface = GraphQL::InterfaceType.define do
-    name "LocalProduct"
-    description "Something that comes from somewhere"
-    field :origin, !types.String, "Place the thing comes from"
+  class BaseField < GraphQL::Schema::Field
+    accepts_definition :joins
   end
 
-  EdibleInterface = GraphQL::InterfaceType.define do
-    name "Edible"
-    description "Something you can eat, yum"
-    field :fatContent, !types.Float, "Percentage which is fat"
-    field :origin, !types.String, "Place the edible comes from"
-    field :selfAsEdible, EdibleInterface, resolve: ->(o, a, c) { o }
+  module BaseInterface
+    include GraphQL::Schema::Interface
   end
 
-  EdibleAsMilkInterface = EdibleInterface.redefine do
-    name "EdibleAsMilk"
-    description "Milk :+1:"
-    resolve_type ->(obj, ctx) { MilkType }
+  class BaseObject < GraphQL::Schema::Object
+    field_class BaseField
+    accepts_definition :class_names
   end
 
-  AnimalProductInterface = GraphQL::InterfaceType.define do
-    name "AnimalProduct"
-    description "Comes from an animal, no joke"
-    field :source, !DairyAnimalEnum, "Animal which produced this product"
+  class BaseUnion < GraphQL::Schema::Union
   end
 
-  BeverageUnion = GraphQL::UnionType.define do
-    name "Beverage"
-    description "Something you can drink"
-    possible_types [MilkType]
+  class BaseEnum < GraphQL::Schema::Enum
+  end
+
+  class BaseInputObject < GraphQL::Schema::InputObject
+  end
+
+  class BaseScalar < GraphQL::Schema::Scalar
+  end
+
+  module LocalProduct
+    include BaseInterface
+    description "Something that comes from somewhere"
+    field :origin, String, null: false,
+      description: "Place the thing comes from"
+  end
+
+  module Edible
+    include BaseInterface
+    description "Something you can eat, yum"
+    field :fat_content, Float, null: false, description: "Percentage which is fat"
+    field :origin, String, null: false, description: "Place the edible comes from"
+    field :self_as_edible, Edible, null: true
+    def self_as_edible
+      object
+    end
+  end
+
+  module EdibleAsMilk
+    include Edible
+    description "Milk :+1:"
+    def self.resolve_type(obj, ctx)
+      Milk
+    end
   end
 
-  DairyAnimalEnum = GraphQL::EnumType.define do
-    name "DairyAnimal"
+  class DairyAnimal < BaseEnum
     description "An animal which can yield milk"
     value("COW",      "Animal with black and white spots", value: 1)
     value("DONKEY",   "Animal with fur", value: :donkey)
@@ -50,433 +68,425 @@ module Dummy
     value("YAK",      "Animal with long hair", deprecation_reason: "Out of fashion")
   end
 
-  CheeseType = GraphQL::ObjectType.define do
-    name "Cheese"
+  module AnimalProduct
+    include BaseInterface
+    description "Comes from an animal, no joke"
+    field :source, DairyAnimal, "Animal which produced this product", null: false
+  end
+
+  class Cheese < BaseObject
     class_names ["Cheese"]
     description "Cultured dairy product"
-    interfaces [EdibleInterface, EdibleAsMilkInterface, AnimalProductInterface, LocalProductInterface]
+    implements Edible
+    implements EdibleAsMilk
+    implements AnimalProduct
+    implements LocalProduct
 
-    # Can have (name, type, desc)
-    field :id, !types.Int, "Unique identifier"
-    field :flavor, !types.String, "Kind of Cheese"
-    field :origin, !types.String, "Place the cheese comes from"
+    field :id, Int, "Unique identifier", null: false
+    field :flavor, String, "Kind of Cheese", null: false
+    field :origin, String, "Place the cheese comes from", null: false
 
-    field :source, !DairyAnimalEnum,
-      "Animal which produced the milk for this cheese"
+    field :source, DairyAnimal,
+      "Animal which produced the milk for this cheese",
+      null: false
 
-    # Or can define by block, `resolve ->` should override `property:`
-    field :similarCheese, CheeseType, "Cheeses like this one", property: :this_should_be_overriden  do
+    field :similar_cheese, Cheese, "Cheeses like this one", null: true  do
       # metadata test
       joins [:cheeses, :milks]
-      argument :source, !types[!DairyAnimalEnum]
-      argument :nullableSource, types[!DairyAnimalEnum], default_value: [1]
-      resolve ->(t, a, c) {
-        # get the strings out:
-        sources = a["source"]
-        if sources.include?("YAK")
-          raise NoSuchDairyError.new("No cheeses are made from Yak milk!")
-        else
-          CHEESES.values.find { |cheese| sources.include?(cheese.source) }
-        end
-      }
+      argument :source, [DairyAnimal], required: true
+      argument :nullableSource, [DairyAnimal], required: false, default_value: [1]
+    end
+
+    def similar_cheese(source:, nullable_source:)
+      # get the strings out:
+      sources = source
+      if sources.include?("YAK")
+        raise NoSuchDairyError.new("No cheeses are made from Yak milk!")
+      else
+        CHEESES.values.find { |cheese| sources.include?(cheese.source) }
+      end
     end
 
-    field :nullableCheese, CheeseType, "Cheeses like this one" do
-      argument :source, types[!DairyAnimalEnum]
-      resolve ->(t, a, c) { raise("NotImplemented") }
+    field :nullable_cheese, Cheese, "Cheeses like this one", null: true do
+      argument :source, [DairyAnimal], required: false
     end
+    def nullable_cheese; raise("NotImplemented"); end
 
-    field :deeplyNullableCheese, CheeseType, "Cheeses like this one" do
-      argument :source, types[types[DairyAnimalEnum]]
-      resolve ->(t, a, c) { raise("NotImplemented") }
+    field :deeply_nullable_cheese, Cheese, "Cheeses like this one", null: true do
+      argument :source, [[DairyAnimal, null: true], null: true], required: false
     end
+    def deeply_nullable_cheese; raise("NotImplemented"); end
 
     # Keywords can be used for definition methods
-    field :fatContent,
-      property: :fat_content,
-      type: !GraphQL::FLOAT_TYPE,
+    field :fat_content,
+      type: GraphQL::FLOAT_TYPE,
+      null: false,
       description: "Percentage which is milkfat",
       deprecation_reason: "Diet fashion has changed"
   end
 
-  MilkType = GraphQL::ObjectType.define do
-    name "Milk"
+  class Milk < BaseObject
     description "Dairy beverage"
-    interfaces [EdibleInterface, EdibleAsMilkInterface, AnimalProductInterface, LocalProductInterface]
-    field :id, !types.ID
-    field :source, !DairyAnimalEnum, "Animal which produced this milk", hash_key: :source
-    field :origin, !types.String, "Place the milk comes from"
-    field :flavors, types[types.String], "Chocolate, Strawberry, etc" do
-      argument :limit, types.Int
-      resolve ->(milk, args, ctx) {
-        args[:limit] ? milk.flavors.first(args.limit) : milk.flavors
-      }
-    end
-    field :executionError do
-      type GraphQL::STRING_TYPE
-      resolve ->(t, a, c) { raise(GraphQL::ExecutionError, "There was an execution error") }
+    implements Edible
+    implements EdibleAsMilk
+    implements AnimalProduct
+    implements LocalProduct
+
+    field :id, ID, null: false
+    field :source, DairyAnimal, null: false, description: "Animal which produced this milk"
+    field :origin, String, null: false, description: "Place the milk comes from"
+    field :flavors, [String, null: true], null: true, description: "Chocolate, Strawberry, etc" do
+      argument :limit, Int, required: false
     end
 
-    field :allDairy, -> { types[DairyProductUnion] } do
-      resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
+    def flavors(limit: nil)
+      limit ? object.flavors.first(limit) : object.flavors
     end
+
+    field :execution_error, String, null: true
+    def execution_error; raise(GraphQL::ExecutionError, "There was an execution error"); end
+
+    field :all_dairy, ["Dummy::DairyProduct", null: true], null: true
+    def all_dairy; CHEESES.values + MILKS.values; end
   end
 
-  SweetenerInterface = GraphQL::InterfaceType.define do
-    name "Sweetener"
-    field :sweetness, types.Int
+  class Beverage < BaseUnion
+    description "Something you can drink"
+    possible_types Milk
+  end
+
+  module Sweetener
+    include BaseInterface
+    field :sweetness, Integer, null: true
   end
 
   # No actual data; This type is an "orphan", only accessible through Interfaces
-  HoneyType = GraphQL::ObjectType.define do
-    name "Honey"
+  class Honey < BaseObject
     description "Sweet, dehydrated bee barf"
-    field :flowerType, types.String, "What flower this honey came from"
-    interfaces [EdibleInterface, AnimalProductInterface, SweetenerInterface]
+    field :flower_type, String, "What flower this honey came from", null: true
+    implements Edible
+    implements AnimalProduct
+    implements Sweetener
   end
 
-  DairyType = GraphQL::ObjectType.define do
-    name "Dairy"
+  class Dairy < BaseObject
     description "A farm where milk is harvested and cheese is produced"
-    field :id, !types.ID
-    field :cheese, CheeseType
-    field :milks, types[MilkType]
+    field :id, ID, null: false
+    field :cheese, Cheese, null: true
+    field :milks, [Milk, null: true], null: true
   end
 
-  MaybeNullType = GraphQL::ObjectType.define do
-    name "MaybeNull"
+  class MaybeNull < BaseObject
     description "An object whose fields return nil"
-    field :cheese, CheeseType
+    field :cheese, Cheese, null: true
   end
 
-  TracingScalarType = GraphQL::ObjectType.define do
-    name "TracingScalar"
+  class TracingScalar < BaseObject
     description "An object which has traced scalars"
 
-    field :traceNil, types.Int
-    field :traceFalse, types.Int, trace: false
-    field :traceTrue, types.Int, trace: true
+    field :trace_nil, Integer, null: true
+    field :trace_false, Integer, null: true, trace: false
+    field :trace_true, Integer, null: true, trace: true
   end
 
-  DairyProductUnion = GraphQL::UnionType.define do
-    name "DairyProduct"
+  class DairyProduct < BaseUnion
     description "Kinds of food made from milk"
     # Test that these forms of declaration still work:
-    possible_types ["Dummy::MilkType", -> { CheeseType }]
+    possible_types "Dummy::Milk", Cheese
   end
 
-  CowType = GraphQL::ObjectType.define do
-    name "Cow"
+  class Cow < BaseObject
     description "A bovine animal that produces milk"
-    field :id, !types.ID
-    field :name, types.String
-    field :last_produced_dairy, DairyProductUnion
+    field :id, ID, null: false
+    field :name, String, null: true
+    field :last_produced_dairy, DairyProduct, null: true
 
-    field :cantBeNullButIs do
-      type !GraphQL::STRING_TYPE
-      resolve ->(t, a, c) { nil }
-    end
+    field :cant_be_null_but_is, String, null: false
+    def cant_be_null_but_is; nil; end
 
-    field :cantBeNullButRaisesExecutionError do
-      type !GraphQL::STRING_TYPE
-      resolve ->(t, a, c) { raise GraphQL::ExecutionError, "BOOM" }
-    end
+    field :cant_be_null_but_raises_execution_error, String, null: false
+    def cant_be_null_but_raises_execution_error; raise(GraphQL::ExecutionError, "BOOM"); end
   end
 
-  GoatType = GraphQL::ObjectType.define do
-    name "Goat"
+  class Goat < BaseObject
     description "An caprinae animal that produces milk"
-    field :id, !types.ID
-    field :name, types.String
-    field :last_produced_dairy, DairyProductUnion
+    field :id, ID, null: false
+    field :name, String, null: true
+    field :last_produced_dairy, DairyProduct, null: true
   end
 
-  AnimalUnion = GraphQL::UnionType.define do
-    name "Animal"
+  class Animal < BaseUnion
     description "Species of living things"
-    possible_types [CowType, GoatType]
+    possible_types Cow, Goat
   end
 
-  AnimalAsCowUnion = GraphQL::UnionType.define do
-    name "AnimalAsCow"
+  class AnimalAsCow < BaseUnion
     description "All animals go mooooo!"
-    possible_types [CowType]
-    resolve_type ->(obj, ctx) {
-      CowType
-    }
+    possible_types Cow
+    def self.resolve_type(obj, ctx)
+      Cow
+    end
   end
 
-  ResourceOrderType = GraphQL::InputObjectType.define {
-    name "ResourceOrderType"
+  class ResourceOrder < BaseInputObject
+    graphql_name "ResourceOrderType"
     description "Properties used to determine ordering"
 
-    argument :direction, !types.String do
-      description "ASC or DESC"
-    end
-  }
+    argument :direction, String, required: true, description: "ASC or DESC"
+  end
 
-  DairyProductInputType = GraphQL::InputObjectType.define {
-    name "DairyProductInput"
+  class DairyProductInput < BaseInputObject
     description "Properties for finding a dairy product"
-    input_field :source, !DairyAnimalEnum do
-      # ensure we can define description in block
-      description "Where it came from"
-    end
-
-    input_field :originDairy, types.String, "Dairy which produced it", default_value: "Sugar Hollow Dairy"
+    argument :source, DairyAnimal, required: true, description: "Where it came from"
+    argument :origin_dairy, String, required: false, description: "Dairy which produced it", default_value: "Sugar Hollow Dairy"
+    argument :fat_content, Float, required: false, description: "How much fat it has", default_value: 0.3
+    argument :organic, Boolean, required: false, default_value: false
+    argument :order_by, ResourceOrder, required: false, default_value: { direction: "ASC" }, camelize: false
+  end
 
-    input_field :fatContent, types.Float, "How much fat it has" do
-      # ensure we can define default in block
-      default_value 0.3
+  class DeepNonNull < BaseObject
+    field :non_null_int, Integer, null: false do
+      argument :returning, Integer, required: false
     end
-
-    # ensure default can be false
-    input_field :organic, types.Boolean, default_value: false
-
-    input_field :order_by, -> { ResourceOrderType }, default_value: { direction: 'ASC' }
-  }
-
-  DeepNonNullType = GraphQL::ObjectType.define do
-    name "DeepNonNull"
-    field :nonNullInt, !types.Int do
-      argument :returning, types.Int
-      resolve ->(obj, args, ctx) { args.returning }
+    def non_null_int(returning: nil)
+      returning
     end
 
-    field :deepNonNull, DeepNonNullType.to_non_null_type do
-      resolve ->(obj, args, ctx) { :deepNonNull }
-    end
+    field :deep_non_null, DeepNonNull, null: false
+    def deep_non_null; :deep_non_null; end
   end
 
-  TimeType = GraphQL::ScalarType.define do
-    name "Time"
+  class Time < BaseScalar
     description "Time since epoch in seconds"
 
-    coerce_input ->(value, ctx) do
-      begin
-        Time.at(Float(value))
-      rescue ArgumentError
-        raise GraphQL::CoercionError, 'cannot coerce to Float'
-      end
+    def self.coerce_input(value, ctx)
+      Time.at(Float(value))
+    rescue ArgumentError
+      raise GraphQL::CoercionError, 'cannot coerce to Float'
     end
 
-    coerce_result ->(value, ctx) { value.to_f }
+    def self.coerce_result(value, ctx)
+      value.to_f
+    end
   end
 
-  class FetchItem < GraphQL::Function
-    attr_reader :type, :description, :arguments
+  class FetchItem < GraphQL::Schema::Resolver
+    class << self
+      attr_accessor :data
+    end
 
-    def initialize(type:, data:, id_type: !GraphQL::INT_TYPE)
-      @type = type
-      @data = data
-      @description = "Find a #{type.name} by id"
-      @arguments = self.class.arguments.merge({"id" => GraphQL::Argument.define(name: "id", type: id_type)})
+    def self.build(type:, data:, id_type: "Int")
+      Class.new(self) do
+        self.data = data
+        type(type, null: true)
+        description("Find a #{type.name} by id")
+        argument :id, id_type, required: true
+      end
     end
 
-    def call(obj, args, ctx)
-      id_string = args["id"].to_s # Cheese has Int type, Milk has ID type :(
-      _id, item = @data.find { |id, _item| id.to_s == id_string }
+    def resolve(id:)
+      id_string = id.to_s # Cheese has Int type, Milk has ID type :(
+      _id, item = self.class.data.find { |item_id, _item| item_id.to_s == id_string }
       item
     end
   end
 
-  class GetSingleton < GraphQL::Function
-    attr_reader :description, :type
+  class GetSingleton < GraphQL::Schema::Resolver
+    class << self
+      attr_accessor :data
+    end
 
-    def initialize(type:, data:)
-      @description = "Find the only #{type.name}"
-      @type = type
-      @data = data
+    def self.build(type:, data:)
+      Class.new(self) do
+        description("Find the only #{type.name}")
+        type(type, null: true)
+        self.data = data
+      end
     end
 
-    def call(obj, args, ctx)
-      @data
+    def resolve
+      self.class.data
     end
   end
 
-  SourceFieldDefn = Proc.new {
-    type GraphQL::ListType.new(of_type: CheeseType)
-    description "Cheese from source"
-    argument :source, DairyAnimalEnum, default_value: 1
-    resolve ->(target, arguments, context) {
-      CHEESES.values.select{ |c| c.source == arguments["source"] }
-    }
-  }
+  class DairyAppQuery < BaseObject
+    graphql_name "Query"
+    description "Query root of the system"
+    # Returns `root_value:`
+    field :root, String, null: true
+    def root
+      object
+    end
+    field :cheese, resolver: FetchItem.build(type: Cheese, data: CHEESES)
+    field :milk, resolver: FetchItem.build(type: Milk, data: MILKS, id_type: "ID")
+    field :dairy, resolver: GetSingleton.build(type: Dairy, data: DAIRY)
+    field :from_source, [Cheese, null: true], null: true, description: "Cheese from source" do
+      argument :source, DairyAnimal, required: false, default_value: 1
+    end
+    def from_source(source:)
+      CHEESES.values.select { |c| c.source == source }
+    end
 
-  FavoriteFieldDefn = GraphQL::Field.define do
-    name "favoriteEdible"
-    description "My favorite food"
-    type EdibleInterface
-    resolve ->(t, a, c) { MILKS[1] }
-  end
+    field :favorite_edible, Edible, null: true, description: "My favorite food"
+    def favorite_edible
+      MILKS[1]
+    end
 
-  DairyAppQueryType = GraphQL::ObjectType.define do
-    name "Query"
-    description "Query root of the system"
-    field :root, types.String do
-      resolve ->(root_value, args, c) { root_value }
-    end
-    field :cheese, function: FetchItem.new(type: CheeseType, data: CHEESES)
-    field :milk, function: FetchItem.new(type: MilkType, data: MILKS, id_type: !types.ID)
-    field :dairy, function: GetSingleton.new(type: DairyType, data: DAIRY)
-    field :fromSource, &SourceFieldDefn
-    field :favoriteEdible, FavoriteFieldDefn
-    field :cow, function: GetSingleton.new(type: CowType, data: COWS[1])
-    field :searchDairy do
+    field :cow, resolver: GetSingleton.build(type: Cow, data: COWS[1])
+    field :search_dairy, DairyProduct, null: false do
       description "Find dairy products matching a description"
-      type !DairyProductUnion
       # This is a list just for testing 😬
-      argument :product, types[DairyProductInputType], default_value: [{"source" => "SHEEP"}]
-      argument :expiresAfter, TimeType
-      resolve ->(t, args, c) {
-        source = args["product"][0][:source] # String or Sym is ok
-        products = CHEESES.values + MILKS.values
-        if !source.nil?
-          products = products.select { |pr| pr.source == source }
-        end
-        products.first
-      }
+      argument :product, [DairyProductInput, null: true], required: false, default_value: [{source: "SHEEP"}]
+      argument :expires_after, Time, required: false
     end
 
-    field :allAnimal, !types[AnimalUnion] do
-      resolve ->(obj, args, ctx) { COWS.values + GOATS.values }
+    def search_dairy(product:, expires_after: nil)
+      source = product[0][:source]
+      products = CHEESES.values + MILKS.values
+      if !source.nil?
+        products = products.select { |pr| pr.source == source }
+      end
+      products.first
     end
 
-    field :allAnimalAsCow, !types[AnimalAsCowUnion] do
-      resolve ->(obj, args, ctx) { COWS.values + GOATS.values }
+    field :all_animal, [Animal, null: true], null: false
+    def all_animal
+      COWS.values + GOATS.values
     end
 
-    field :allDairy, types[DairyProductUnion] do
-      argument :executionErrorAtIndex, types.Int
-      resolve ->(obj, args, ctx) {
-        result = CHEESES.values + MILKS.values
-        result[args.executionErrorAtIndex] = GraphQL::ExecutionError.new("missing dairy") if args.executionErrorAtIndex
-        result
-      }
-    end
+    field :all_animal_as_cow, [AnimalAsCow, null: true], null: false, resolver_method: :all_animal
 
-    field :allEdible, types[EdibleInterface] do
-      resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
+    field :all_dairy, [DairyProduct, null: true], null: true do
+      argument :execution_error_at_index, Integer, required: false
+    end
+    def all_dairy(execution_error_at_index: nil)
+      result = CHEESES.values + MILKS.values
+      if execution_error_at_index
+        result[execution_error_at_index] = GraphQL::ExecutionError.new("missing dairy")
+      end
+      result
     end
 
-    field :allEdibleAsMilk, types[EdibleAsMilkInterface] do
-      resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
+    field :all_edible, [Edible, null: true], null: true
+    def all_edible
+      CHEESES.values + MILKS.values
     end
 
-    field :error do
-      description "Raise an error"
-      type GraphQL::STRING_TYPE
-      resolve ->(t, a, c) { raise("This error was raised on purpose") }
+    field :all_edible_as_milk, [EdibleAsMilk, null: true], null: true, resolver_method: :all_edible
+
+    field :error, String, null: true, description: "Raise an error"
+    def error
+      raise("This error was raised on purpose")
     end
 
-    field :executionError do
-      type GraphQL::STRING_TYPE
-      resolve ->(t, a, c) { raise(GraphQL::ExecutionError, "There was an execution error") }
+    field :execution_error, String, null: true
+    def execution_error
+      raise(GraphQL::ExecutionError, "There was an execution error")
     end
 
-    field :valueWithExecutionError do
-      type !GraphQL::INT_TYPE
-      resolve ->(t, a, c) {
-        c.add_error(GraphQL::ExecutionError.new("Could not fetch latest value"))
-        return 0
-      }
+    field :value_with_execution_error, Integer, null: false, extras: [:execution_errors]
+    def value_with_execution_error(execution_errors:)
+      execution_errors.add("Could not fetch latest value")
+      0
     end
 
-    field :multipleErrorsOnNonNullableField do
-      type !GraphQL::STRING_TYPE
-      resolve ->(t, a, c) {
-        [GraphQL::ExecutionError.new("This is an error message for some error."),
-         GraphQL::ExecutionError.new("This is another error message for a different error.")]
-      }
+    field :multiple_errors_on_non_nullable_field, String, null: false
+    def multiple_errors_on_non_nullable_field
+      [
+        GraphQL::ExecutionError.new("This is an error message for some error."),
+        GraphQL::ExecutionError.new("This is another error message for a different error.")
+      ]
     end
 
-    field :executionErrorWithOptions do
-      type GraphQL::INT_TYPE
-      resolve ->(t, a, c) {
-        GraphQL::ExecutionError.new("Permission Denied!", options: { "code" => "permission_denied" })
-      }
+    field :execution_error_with_options, Integer, null: true
+    def execution_error_with_options
+      GraphQL::ExecutionError.new("Permission Denied!", options: { "code" => "permission_denied" })
     end
 
-    field :executionErrorWithExtensions do
-      type GraphQL::INT_TYPE
-      resolve ->(t, a, c) {
-        GraphQL::ExecutionError.new("Permission Denied!", extensions: { "code" => "permission_denied" })
-      }
+    field :execution_error_with_extensions, Integer, null: true
+    def execution_error_with_extensions
+      GraphQL::ExecutionError.new("Permission Denied!", extensions: { "code" => "permission_denied" })
     end
 
     # To test possibly-null fields
-    field :maybeNull, MaybeNullType do
-      resolve ->(t, a, c) { OpenStruct.new(cheese: nil) }
+    field :maybe_null, MaybeNull, null: true
+    def maybe_null
+      OpenStruct.new(cheese: nil)
     end
 
-    field :tracingScalar, TracingScalarType do
-      resolve ->(o, a, c) do
-        OpenStruct.new(
-          traceNil: 2,
-          traceFalse: 3,
-          tracetrue: 5,
-        )
-      end
+    field :tracing_scalar, TracingScalar, null: true
+    def tracing_scalar
+      OpenStruct.new(
+        trace_nil: 2,
+        trace_false: 3,
+        trace_true: 5,
+      )
     end
 
-    field :deepNonNull, !DeepNonNullType do
-      resolve ->(o, a, c) { :deepNonNull }
-    end
+    field :deep_non_null, DeepNonNull, null: false
+    def deep_non_null; :deep_non_null; end
   end
 
   GLOBAL_VALUES = []
 
-  ReplaceValuesInputType = GraphQL::InputObjectType.define do
-    name "ReplaceValuesInput"
-    input_field :values, !types[!types.Int]
+  class ReplaceValuesInput < BaseInputObject
+    argument :values, [Integer], required: true
   end
 
-  PushValueField = GraphQL::Field.define do
-    name :pushValue
-    type !types[!types.Int]
-    description("Push a value onto a global array :D")
-    argument :value, !types.Int, as: :val
-    resolve ->(o, args, ctx) {
-      GLOBAL_VALUES << args.val
-      GLOBAL_VALUES
-    }
-  end
-
-  class DairyAppMutationType < GraphQL::Schema::Object
+  class DairyAppMutation < BaseObject
     graphql_name "Mutation"
     description "The root for mutations in this schema"
-    # Test the `field:` compatibility option
-    field :pushValue, field: PushValueField
+    field :push_value, [Integer], null: false, description: "Push a value onto a global array :D" do
+      argument :value, Integer, required: true, as: :val
+    end
+    def push_value(val:)
+      GLOBAL_VALUES << val
+      GLOBAL_VALUES
+    end
 
     field :replaceValues, [Integer], "Replace the global array with new values", null: false do
-      argument :input, ReplaceValuesInputType, required: true
+      argument :input, ReplaceValuesInput, required: true
     end
 
     def replace_values(input:)
       GLOBAL_VALUES.clear
-      GLOBAL_VALUES.concat(input["values"])
+      GLOBAL_VALUES.concat(input[:values])
       GLOBAL_VALUES
     end
   end
 
-  SubscriptionType = GraphQL::ObjectType.define do
-    name "Subscription"
-    field :test, types.String do
-      resolve ->(o, a, c) { "Test" }
-    end
+  class Subscription < BaseObject
+    field :test, String, null: true
+    def test; "Test"; end
   end
 
   class Schema < GraphQL::Schema
-    query DairyAppQueryType
-    mutation DairyAppMutationType
-    subscription SubscriptionType
+    query DairyAppQuery
+    mutation DairyAppMutation
+    subscription Subscription
     max_depth 5
-    orphan_types [HoneyType, BeverageUnion]
+    # TODO why is `.graphql_definition` required here?
+    orphan_types Honey, Beverage.graphql_definition
 
     rescue_from(NoSuchDairyError) { |err| err.message  }
 
     def self.resolve_type(type, obj, ctx)
       Schema.types[obj.class.name.split("::").last]
     end
+
+    # This is used to confirm that the hook is called:
+    MAGIC_INT_COERCE_VALUE = -1
+
+    def self.type_error(err, ctx)
+      if err.is_a?(GraphQL::IntegerEncodingError) && err.integer_value == 99**99
+        MAGIC_INT_COERCE_VALUE
+      else
+        super
+      end
+    end
+
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+    end
   end
 end