graphql 1.8.8 → 1.8.9

data/spec/integration/rails/graphql/query/variables_spec.rb

@@ -69,21 +69,21 @@ describe GraphQL::Query::Variables do
       it "checks for string matches" do
         # These get merged into all the values above
         default_values = {
-          "originDairy"=>"Sugar Hollow Dairy",
-          "organic"=>false,
-          "order_by"=>{"direction"=>"ASC"}
+          origin_dairy: "Sugar Hollow Dairy",
+          organic: false,
+          order_by: { direction: "ASC" },
         }
 
         expected_input_1 = {
-          "source" => 1,
-          "fatContent" => 0.99,
+          source: 1,
+          fat_content: 0.99,
         }.merge(default_values)
 
         assert_equal(expected_input_1, variables["dairy_product_1"].to_h)
 
         expected_input_2 = {
-          "source" => :donkey,
-          "fatContent" => 0.89,
+          source: :donkey,
+          fat_content: 0.89,
         }.merge(default_values)
         assert_equal(expected_input_2, variables["dairy_product_2"].to_h)
       end

data/spec/integration/rails/graphql/schema_spec.rb

@@ -47,9 +47,9 @@ describe GraphQL::Schema do
     it "returns a list of the schema's root types" do
       assert_equal(
         [
-          Dummy::DairyAppQueryType,
-          Dummy::DairyAppMutationType.graphql_definition,
-          Dummy::SubscriptionType
+          Dummy::DairyAppQuery.graphql_definition,
+          Dummy::DairyAppMutation.graphql_definition.graphql_definition,
+          Dummy::Subscription.graphql_definition
         ],
         schema.root_types
       )
@@ -58,7 +58,8 @@ describe GraphQL::Schema do
 
   describe "#references_to" do
     it "returns a list of Field and Arguments of that type" do
-      assert_equal [schema.types["Query"].fields["cow"]], schema.references_to("Cow")
+      cow_field = schema.get_field("Query", "cow")
+      assert_equal [cow_field], schema.references_to("Cow")
     end
 
     it "returns an empty list when type is not referenced by any field or argument" do
@@ -450,7 +451,7 @@ type Query {
     it "returns fields by type or type name" do
       field = schema.get_field("Cheese", "id")
       assert_instance_of GraphQL::Field, field
-      field_2 = schema.get_field(Dummy::CheeseType, "id")
+      field_2 = schema.get_field(Dummy::Cheese.graphql_definition, "id")
       assert_equal field, field_2
     end
   end

data/spec/integration/tmp/app/graphql/types/page_type.rb

@@ -0,0 +1,4 @@
+module Types
+  class PageType < Types::BaseObject
+  end
+end

data/spec/support/dummy/data.rb

@@ -1,27 +1,32 @@
 # frozen_string_literal: true
 require 'ostruct'
 module Dummy
-  Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source) do
-    def ==(other)
-      # This is buggy on purpose -- it shouldn't be called during execution.
-      other.id == id
-    end
+  module Data
+    Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source) do
+      def ==(other)
+        # This is buggy on purpose -- it shouldn't be called during execution.
+        other.id == id
+      end
 
-    # Alias for when this is treated as milk in EdibleAsMilkInterface
-    def fatContent # rubocop:disable Naming/MethodName
-      fat_content
+      # Alias for when this is treated as milk in EdibleAsMilkInterface
+      def fatContent # rubocop:disable Naming/MethodName
+        fat_content
+      end
     end
+
+    Milk = Struct.new(:id, :fat_content, :origin, :source, :flavors)
+    Cow = Struct.new(:id, :name, :last_produced_dairy)
+    Goat = Struct.new(:id, :name, :last_produced_dairy)
   end
 
   CHEESES = {
-    1 => Cheese.new(1, "Brie", "France", 0.19, 1),
-    2 => Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),
-    3 => Cheese.new(3, "Manchego", "Spain", 0.065, "SHEEP")
+    1 => Data::Cheese.new(1, "Brie", "France", 0.19, 1),
+    2 => Data::Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),
+    3 => Data::Cheese.new(3, "Manchego", "Spain", 0.065, "SHEEP")
   }
 
-  Milk = Struct.new(:id, :fatContent, :origin, :source, :flavors)
   MILKS = {
-    1 => Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
+    1 => Data::Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
   }
 
   DAIRY = OpenStruct.new(
@@ -30,13 +35,11 @@ module Dummy
     milks: [MILKS[1]]
   )
 
-  Cow = Struct.new(:id, :name, :last_produced_dairy)
   COWS = {
-    1 => Cow.new(1, "Billy", MILKS[1])
+    1 => Data::Cow.new(1, "Billy", MILKS[1])
   }
 
-  Goat = Struct.new(:id, :name, :last_produced_dairy)
   GOATS = {
-    1 => Goat.new(1, "Gilly", MILKS[1]),
+    1 => Data::Goat.new(1, "Gilly", MILKS[1]),
   }
 end

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
 
-  DairyAnimalEnum = GraphQL::EnumType.define do
-    name "DairyAnimal"
+  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
+
+  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,217 +68,206 @@ 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
+
+  class Beverage < BaseUnion
+    description "Something you can drink"
+    possible_types Milk
   end
 
-  SweetenerInterface = GraphQL::InterfaceType.define do
-    name "Sweetener"
-    field :sweetness, types.Int
+  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
@@ -294,162 +301,146 @@ module Dummy
     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"] }
-    }
-  }
-
   FavoriteFieldDefn = GraphQL::Field.define do
     name "favoriteEdible"
     description "My favorite food"
-    type EdibleInterface
+    type Edible
     resolve ->(t, a, c) { MILKS[1] }
   end
 
-  DairyAppQueryType = GraphQL::ObjectType.define do
-    name "Query"
+  class DairyAppQuery < BaseObject
+    graphql_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
+    # Returns `root_value:`
+    field :root, String, null: true
+    def root
+      object
+    end
+    field :cheese, function: FetchItem.new(type: Cheese, data: CHEESES)
+    field :milk, function: FetchItem.new(type: Milk, data: MILKS, id_type: GraphQL::Types::ID.to_non_null_type)
+    field :dairy, function: GetSingleton.new(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
+
+    field :favorite_edible, field: FavoriteFieldDefn
+    field :cow, function: GetSingleton.new(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, 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, 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]
-  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
-    }
+  class ReplaceValuesInput < BaseInputObject
+    argument :values, [Integer], required: true
   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:)
@@ -459,19 +450,18 @@ module Dummy
     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  }