graphql 1.4.0 → 1.4.1

data/spec/graphql/relay/node_spec.rb

@@ -13,24 +13,24 @@ describe GraphQL::Relay::Node do
       before do
         # TODO: make the schema eager-load so we can remove this
         # Ensure the schema is defined:
-        StarWarsSchema.types
+        StarWars::Schema.types
 
-        @previous_id_from_object_proc = StarWarsSchema.id_from_object_proc
-        @previous_object_from_id_proc = StarWarsSchema.object_from_id_proc
+        @previous_id_from_object_proc = StarWars::Schema.id_from_object_proc
+        @previous_object_from_id_proc = StarWars::Schema.object_from_id_proc
 
-        StarWarsSchema.id_from_object = ->(obj, type_name, ctx) {
+        StarWars::Schema.id_from_object = ->(obj, type_name, ctx) {
           "#{type_name}/#{obj.id}"
         }
 
-        StarWarsSchema.object_from_id = ->(global_id, ctx) {
+        StarWars::Schema.object_from_id = ->(global_id, ctx) {
           type_name, id = global_id.split("/")
-          STAR_WARS_DATA[type_name][id]
+          StarWars::DATA[type_name][id]
         }
       end
 
       after do
-        StarWarsSchema.id_from_object = @previous_id_from_object_proc
-        StarWarsSchema.object_from_id = @previous_object_from_id_proc
+        StarWars::Schema.id_from_object = @previous_id_from_object_proc
+        StarWars::Schema.object_from_id = @previous_object_from_id_proc
       end
 
       it "Deconstructs the ID by the custom proc" do

data/spec/graphql/relay/relation_connection_spec.rb

@@ -69,7 +69,7 @@ describe GraphQL::Relay::RelationConnection do
     it 'provides custom fields on the connection type' do
       result = star_wars_query(query_string, "first" => 2)
       assert_equal(
-        Base.where(faction_id: 2).count,
+        StarWars::Base.where(faction_id: 2).count,
         result["data"]["empire"]["bases"]["totalCount"]
       )
     end
@@ -105,6 +105,24 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal([], get_names(result))
     end
 
+    it 'handles grouped connections with only last argument' do
+      grouped_conn_query = <<-GRAPHQL
+      query {
+        newestBasesGroupedByFaction(last: 2) {
+          edges {
+            node {
+              name
+            }
+          }
+        }
+      }
+      GRAPHQL
+
+      result = star_wars_query(grouped_conn_query)
+      names = result['data']['newestBasesGroupedByFaction']['edges'].map { |edge| edge['node']['name'] }
+      assert_equal(['Headquarters', 'Secret Hideout'], names)
+    end
+
     it "applies custom arguments" do
       result = star_wars_query(query_string, "first" => 1, "nameIncludes" => "ea")
       assert_equal(["Death Star"], get_names(result))
@@ -311,7 +329,7 @@ describe GraphQL::Relay::RelationConnection do
       it 'provides custom fields on the connection type' do
         result = star_wars_query(query_string, "first" => 2)
         assert_equal(
-          Base.where(faction_id: 2).count,
+          StarWars::Base.where(faction_id: 2).count,
           result["data"]["empire"]["basesAsSequelDataset"]["totalCount"]
         )
       end
@@ -356,11 +374,11 @@ describe GraphQL::Relay::RelationConnection do
   end
 
   describe "#cursor_from_node" do
-    let(:connection) { GraphQL::Relay::RelationConnection.new(Base.where(faction_id: 1), {}) }
+    let(:connection) { GraphQL::Relay::RelationConnection.new(StarWars::Base.where(faction_id: 1), {}) }
 
     it "returns the cursor for a node in the connection" do
-      assert_equal "MQ==", connection.cursor_from_node(Base.all[0])
-      assert_equal "Mg==", connection.cursor_from_node(Base.all[1])
+      assert_equal "MQ==", connection.cursor_from_node(StarWars::Base.all[0])
+      assert_equal "Mg==", connection.cursor_from_node(StarWars::Base.all[1])
     end
 
     it "raises when the node isn't found" do
@@ -372,7 +390,7 @@ describe GraphQL::Relay::RelationConnection do
   end
 
   it "is chosen for a relation" do
-    relation = Base.where(faction_id: 1)
+    relation = StarWars::Base.where(faction_id: 1)
     assert relation.is_a?(ActiveRecord::Relation)
     connection = GraphQL::Relay::BaseConnection.connection_for_nodes(relation)
     assert_equal GraphQL::Relay::RelationConnection, connection

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -2,15 +2,15 @@
 require "spec_helper"
 
 describe GraphQL::Schema::CatchallMiddleware do
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
   let(:query_string) {%| query noMilk { error }|}
 
   before do
-    DummySchema.middleware << GraphQL::Schema::CatchallMiddleware
+    Dummy::Schema.middleware << GraphQL::Schema::CatchallMiddleware
   end
 
   after do
-    DummySchema.middleware.delete(GraphQL::Schema::CatchallMiddleware)
+    Dummy::Schema.middleware.delete(GraphQL::Schema::CatchallMiddleware)
   end
 
   describe "rescuing errors" do

data/spec/graphql/schema/reduce_types_spec.rb

@@ -8,23 +8,23 @@ describe GraphQL::Schema::ReduceTypes do
 
   it "finds types from a single type and its fields" do
     expected = {
-      "Cheese" => CheeseType,
+      "Cheese" => Dummy::CheeseType,
       "Float" => GraphQL::FLOAT_TYPE,
       "String" => GraphQL::STRING_TYPE,
-      "Edible" => EdibleInterface,
-      "DairyAnimal" => DairyAnimalEnum,
+      "Edible" => Dummy::EdibleInterface,
+      "DairyAnimal" => Dummy::DairyAnimalEnum,
       "Int" => GraphQL::INT_TYPE,
-      "AnimalProduct" => AnimalProductInterface,
-      "LocalProduct" => LocalProductInterface,
+      "AnimalProduct" => Dummy::AnimalProductInterface,
+      "LocalProduct" => Dummy::LocalProductInterface,
     }
-    result = reduce_types([CheeseType])
+    result = reduce_types([Dummy::CheeseType])
     assert_equal(expected.keys, result.keys)
     assert_equal(expected, result.to_h)
   end
 
   it "finds type from arguments" do
-    result = reduce_types([DairyAppQueryType])
-    assert_equal(DairyProductInputType, result["DairyProductInput"])
+    result = reduce_types([Dummy::DairyAppQueryType])
+    assert_equal(Dummy::DairyProductInputType, result["DairyProductInput"])
   end
 
   it "finds types from nested InputObjectTypes" do
@@ -98,7 +98,7 @@ describe GraphQL::Schema::ReduceTypes do
 
   describe "when a field is only accessible through an interface" do
     it "is found through Schema.define(types:)" do
-      assert_equal HoneyType, DummySchema.types["Honey"]
+      assert_equal Dummy::HoneyType, Dummy::Schema.types["Honey"]
     end
   end
 end

data/spec/graphql/schema/type_expression_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::Schema::TypeExpression do
-  let(:types) { DummySchema.types }
+  let(:types) { Dummy::Schema.types }
   let(:ast_node) {
     document = GraphQL.parse("query dostuff($var: #{type_name}) { id } ")
     document.definitions.first.variables.first.type
@@ -13,7 +13,7 @@ describe GraphQL::Schema::TypeExpression do
     describe "simple types" do
       let(:type_name) { "DairyProductInput" }
       it "it gets types from the provided types" do
-        assert_equal(DairyProductInputType, type_expression_result)
+        assert_equal(Dummy::DairyProductInputType, type_expression_result)
       end
     end
 
@@ -28,7 +28,7 @@ describe GraphQL::Schema::TypeExpression do
       let(:type_name) { "[DairyAnimal!]!" }
 
       it "makes list types" do
-        expected = DairyAnimalEnum
+        expected = Dummy::DairyAnimalEnum
           .to_non_null_type
           .to_list_type
           .to_non_null_type

data/spec/graphql/schema/validation_spec.rb

@@ -246,7 +246,7 @@ describe GraphQL::Schema::Validation do
     let(:null_default_value) {
       GraphQL::Argument.define do
         name "NullDefault"
-        type DairyAnimalEnum
+        type Dummy::DairyAnimalEnum
         default_value nil
       end
     }

data/spec/graphql/schema/warden_spec.rb

@@ -96,8 +96,17 @@ module MaskHelpers
     end
   end
 
+  MutationType = GraphQL::ObjectType.define do
+    name "Mutation"
+    field :add_phoneme, PhonemeType do
+      argument :symbol, types.String
+    end
+  end
+
   Schema = GraphQL::Schema.define do
     query QueryType
+    mutation MutationType
+    subscription MutationType
     resolve_type -> (obj, ctx) { PhonemeType }
   end
 
@@ -151,6 +160,52 @@ describe GraphQL::Schema::Warden do
     query_result["errors"].map { |err| err["message"] }
   end
 
+  describe "hiding root types" do
+    let(:mask) { ->(m, ctx) { m == MaskHelpers::MutationType } }
+
+    it "acts as if the root doesn't exist" do
+      query_string = %|mutation { add_phoneme(symbol: "ϕ") { name } }|
+      res = MaskHelpers.query_with_mask(query_string, mask)
+      assert MaskHelpers::Schema.mutation # it _does_ exist
+      assert_equal 1, res["errors"].length
+      assert_equal "Schema is not configured for mutations", res["errors"][0]["message"]
+
+      query_string = %|subscription { add_phoneme(symbol: "ϕ") { name } }|
+      res = MaskHelpers.query_with_mask(query_string, mask)
+      assert MaskHelpers::Schema.subscription # it _does_ exist
+      assert_equal 1, res["errors"].length
+      assert_equal "Schema is not configured for subscriptions", res["errors"][0]["message"]
+    end
+
+    it "doesn't show in introspection" do
+      query_string = <<-GRAPHQL
+      {
+        __schema {
+          queryType {
+            name
+          }
+          mutationType {
+            name
+          }
+          subscriptionType {
+            name
+          }
+          types {
+            name
+          }
+        }
+      }
+      GRAPHQL
+      res = MaskHelpers.query_with_mask(query_string, mask)
+      assert_equal "Query", res["data"]["__schema"]["queryType"]["name"]
+      assert_equal nil, res["data"]["__schema"]["mutationType"]
+      assert_equal nil, res["data"]["__schema"]["subscriptionType"]
+      type_names = res["data"]["__schema"]["types"].map { |t| t["name"] }
+      refute type_names.include?("Mutation")
+      refute type_names.include?("Subscription")
+    end
+  end
+
   describe "hiding fields" do
     let(:mask) {
       -> (member, ctx) { member.metadata[:hidden_field] || member.metadata[:hidden_type] }
@@ -512,4 +567,28 @@ describe GraphQL::Schema::Warden do
       }
     end
   end
+
+  describe "default_mask" do
+    let(:default_mask) {
+      -> (member, ctx) { member.metadata[:hidden_enum_value] }
+    }
+    let(:schema) {
+      MaskHelpers::Schema.redefine(default_mask: default_mask)
+    }
+    let(:query_str) { <<-GRAPHQL
+      {
+        enum: __type(name: "Manner") { enumValues { name } }
+        input: __type(name: "WithinInput") { name }
+      }
+    GRAPHQL
+    }
+
+    it "is additive with query filters" do
+      query_except = -> (member, ctx) { member.metadata[:hidden_input_object_type] }
+      res = schema.execute(query_str, except: query_except)
+      assert_equal nil, res["data"]["input"]
+      enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
+      refute_includes enum_values, "TRILL"
+    end
+  end
 end

data/spec/graphql/schema_spec.rb

@@ -2,8 +2,8 @@
 require "spec_helper"
 
 describe GraphQL::Schema do
-  let(:schema) { DummySchema }
-  let(:relay_schema)  { StarWarsSchema }
+  let(:schema) { Dummy::Schema }
+  let(:relay_schema)  { StarWars::Schema }
   let(:empty_schema) { GraphQL::Schema.define }
 
   describe "#rescue_from" do

data/spec/graphql/static_validation/rules/fragments_are_used_spec.rb

@@ -33,7 +33,7 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
     let(:query_string) {%|
       # I am a comment.
     |}
-    let(:result) { DummySchema.execute(query_string) }
+    let(:result) { Dummy::Schema.execute(query_string) }
     it "handles them gracefully" do
       assert_equal({}, result)
     end

data/spec/graphql/static_validation/type_stack_spec.rb

@@ -22,8 +22,8 @@ describe GraphQL::StaticValidation::TypeStack do
     fragment edibleFields on Edible { fatContent @skip(if: false)}
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [TypeCheckValidator]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema, rules: [TypeCheckValidator]) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
 
 
   it "stores up types" do

data/spec/graphql/static_validation/validator_spec.rb

@@ -2,8 +2,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::Validator do
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
   let(:errors) { validator.validate(query)[:errors].map(&:to_h) }
 
 

data/spec/graphql/union_type_spec.rb

@@ -27,7 +27,7 @@ describe GraphQL::UnionType do
   end
 
   describe "typecasting from union to union" do
-    let(:result) { DummySchema.execute(query_string) }
+    let(:result) { Dummy::Schema.execute(query_string) }
     let(:query_string) {%|
       {
         allDairy {
@@ -55,7 +55,7 @@ describe GraphQL::UnionType do
 
   describe "list of union type" do
     describe "fragment spreads" do
-      let(:result) { DummySchema.execute(query_string) }
+      let(:result) { Dummy::Schema.execute(query_string) }
       let(:query_string) {%|
         {
           allDairy {

data/spec/spec_helper.rb

@@ -48,5 +48,5 @@ end
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 def star_wars_query(string, variables={})
-  GraphQL::Query.new(StarWarsSchema, string, variables: variables).result
+  GraphQL::Query.new(StarWars::Schema, string, variables: variables).result
 end

data/spec/support/dummy/data.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'ostruct'
+module Dummy
+  Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source)
+  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")
+  }
+
+  Milk = Struct.new(:id, :fatContent, :origin, :source, :flavors)
+  MILKS = {
+    1 => Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
+  }
+
+  DAIRY = OpenStruct.new(
+    id: 1,
+    cheese: CHEESES[1],
+    milks: [MILKS[1]]
+  )
+
+  COW = OpenStruct.new(
+    id: 1,
+    name: "Billy",
+    last_produced_dairy: MILKS[1]
+  )
+end

data/spec/support/dummy/schema.rb

@@ -0,0 +1,369 @@
+# frozen_string_literal: true
+module Dummy
+  class NoSuchDairyError < StandardError; end
+
+  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"
+  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 }
+  end
+
+  AnimalProductInterface = GraphQL::InterfaceType.define do
+    name "AnimalProduct"
+    description "Comes from an animal, no joke"
+    field :source, !types.String, "Animal which produced this product"
+  end
+
+  BeverageUnion = GraphQL::UnionType.define do
+    name "Beverage"
+    description "Something you can drink"
+    possible_types [MilkType]
+  end
+
+  DairyAnimalEnum = GraphQL::EnumType.define do
+    name "DairyAnimal"
+    description "An animal which can yield milk"
+    value("COW",      "Animal with black and white spots", value: 1)
+    value("DONKEY",   "Animal with fur", value: :donkey)
+    value("GOAT",     "Animal with horns")
+    value("REINDEER", "Animal with horns", value: 'reindeer')
+    value("SHEEP",    "Animal with wool")
+    value("YAK",      "Animal with long hair", deprecation_reason: "Out of fashion")
+  end
+
+  CheeseType = GraphQL::ObjectType.define do
+    name "Cheese"
+    class_names ["Cheese"]
+    description "Cultured dairy product"
+    interfaces [EdibleInterface, AnimalProductInterface, LocalProductInterface]
+
+    # 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 :source, !DairyAnimalEnum,
+      "Animal which produced the milk for this cheese"
+
+    # Or can define by block, `resolve ->` should override `property:`
+    field :similarCheese, CheeseType, "Cheeses like this one", property: :this_should_be_overriden  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 { |c| sources.include?(c.source) }
+        end
+      }
+    end
+
+    field :nullableCheese, CheeseType, "Cheeses like this one" do
+      argument :source, types[!DairyAnimalEnum]
+      resolve ->(t, a, c) { raise("NotImplemented") }
+    end
+
+    field :deeplyNullableCheese, CheeseType, "Cheeses like this one" do
+      argument :source, types[types[DairyAnimalEnum]]
+      resolve ->(t, a, c) { raise("NotImplemented") }
+    end
+
+    # Keywords can be used for definition methods
+    field :fatContent,
+      property: :fat_content,
+      type: !GraphQL::FLOAT_TYPE,
+      description: "Percentage which is milkfat",
+      deprecation_reason: "Diet fashion has changed"
+  end
+
+  MilkType = GraphQL::ObjectType.define do
+    name "Milk"
+    description "Dairy beverage"
+    interfaces [EdibleInterface, 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") }
+    end
+
+    field :allDairy, -> { types[DairyProductUnion] } do
+      resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
+    end
+  end
+
+  SweetenerInterface = GraphQL::InterfaceType.define do
+    name "Sweetener"
+    field :sweetness, types.Int
+  end
+
+  # No actual data; This type is an "orphan", only accessible through Interfaces
+  HoneyType = GraphQL::ObjectType.define do
+    name "Honey"
+    description "Sweet, dehydrated bee barf"
+    field :flowerType, types.String, "What flower this honey came from"
+    interfaces [EdibleInterface, AnimalProductInterface, SweetenerInterface]
+  end
+
+  DairyType = GraphQL::ObjectType.define do
+    name "Dairy"
+    description "A farm where milk is harvested and cheese is produced"
+    field :id, !types.ID
+    field :cheese, CheeseType
+    field :milks, types[MilkType]
+  end
+
+  MaybeNullType = GraphQL::ObjectType.define do
+    name "MaybeNull"
+    description "An object whose fields return nil"
+    field :cheese, CheeseType
+  end
+
+  DairyProductUnion = GraphQL::UnionType.define do
+    name "DairyProduct"
+    description "Kinds of food made from milk"
+    # Test that these forms of declaration still work:
+    possible_types ["Dummy::MilkType", -> { CheeseType }]
+  end
+
+  CowType = GraphQL::ObjectType.define do
+    name "Cow"
+    description "A farm where milk is harvested and cheese is produced"
+    field :id, !types.ID
+    field :name, types.String
+    field :last_produced_dairy, DairyProductUnion
+
+    field :cantBeNullButIs do
+      type !GraphQL::STRING_TYPE
+      resolve ->(t, a, c) { nil }
+    end
+
+    field :cantBeNullButRaisesExecutionError do
+      type !GraphQL::STRING_TYPE
+      resolve ->(t, a, c) { raise GraphQL::ExecutionError, "BOOM" }
+    end
+  end
+
+  DairyProductInputType = GraphQL::InputObjectType.define {
+    name "DairyProductInput"
+    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" do
+      description   "Ignored because arg takes precedence"
+      default_value "Ignored because keyword arg takes precedence"
+    end
+
+    input_field :fatContent, types.Float, "How much fat it has" do
+      # ensure we can define default in block
+      default_value 0.3
+    end
+
+    # ensure default can be false
+    input_field :organic, types.Boolean, default_value: false
+  }
+
+  DeepNonNullType = GraphQL::ObjectType.define do
+    name "DeepNonNull"
+    field :nonNullInt, !types.Int do
+      argument :returning, types.Int
+      resolve ->(obj, args, ctx) { args[:returning] }
+    end
+
+    field :deepNonNull, DeepNonNullType.to_non_null_type do
+      resolve ->(obj, args, ctx) { :deepNonNull }
+    end
+  end
+
+  class FetchField
+    def self.create(type:, data:, id_type: !GraphQL::INT_TYPE)
+      desc = "Find a #{type.name} by id"
+      return_type = type
+      GraphQL::Field.define do
+        type(return_type)
+        description(desc)
+        argument :id, id_type
+
+        resolve ->(t, a, c) {
+          id_string = a["id"].to_s # Cheese has Int type, Milk has ID type :(
+          id, item = data.find { |id, item| id.to_s == id_string }
+          item
+        }
+      end
+    end
+  end
+
+  class SingletonField
+    def self.create(type:, data:)
+      desc = "Find the only #{type.name}"
+      return_type = type
+      GraphQL::Field.define do
+        type(return_type)
+        description(desc)
+
+        resolve ->(t, a, c) {data}
+      end
+    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
+    resolve ->(t, a, c) { 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, field: FetchField.create(type: CheeseType, data: CHEESES)
+    field :milk, field: FetchField.create(type: MilkType, data: MILKS, id_type: !types.ID)
+    field :dairy, field: SingletonField.create(type: DairyType, data: DAIRY)
+    field :fromSource, &SourceFieldDefn
+    field :favoriteEdible, FavoriteFieldDefn
+    field :cow, field: SingletonField.create(type: CowType, data: COW)
+    field :searchDairy 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"}]
+      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
+      }
+    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 :allEdible, types[EdibleInterface] do
+      resolve ->(obj, args, ctx) { 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") }
+    end
+
+    field :executionError do
+      type GraphQL::STRING_TYPE
+      resolve ->(t, a, c) { 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
+      }
+    end
+
+    # To test possibly-null fields
+    field :maybeNull, MaybeNullType do
+      resolve ->(t, a, c) { OpenStruct.new(cheese: nil) }
+    end
+
+    field :deepNonNull, !DeepNonNullType do
+      resolve ->(o, a, c) { :deepNonNull }
+    end
+  end
+
+  GLOBAL_VALUES = []
+
+  ReplaceValuesInputType = GraphQL::InputObjectType.define do
+    name "ReplaceValuesInput"
+    input_field :values, !types[!types.Int]
+  end
+
+  DairyAppMutationType = GraphQL::ObjectType.define do
+    name "Mutation"
+    description "The root for mutations in this schema"
+    field :pushValue, !types[!types.Int] do
+      description("Push a value onto a global array :D")
+      argument :value, !types.Int
+      resolve ->(o, args, ctx) {
+        GLOBAL_VALUES << args[:value]
+        GLOBAL_VALUES
+      }
+    end
+
+    field :replaceValues, !types[!types.Int] do
+      description("Replace the global array with new values")
+      argument :input, !ReplaceValuesInputType
+      resolve ->(o, args, ctx) {
+        GLOBAL_VALUES.clear
+        GLOBAL_VALUES.push(*args[:input][:values])
+        GLOBAL_VALUES
+      }
+    end
+  end
+
+  SubscriptionType = GraphQL::ObjectType.define do
+    name "Subscription"
+    field :test, types.String do
+      resolve ->(o, a, c) { "Test" }
+    end
+  end
+
+  Schema = GraphQL::Schema.define do
+    query DairyAppQueryType
+    mutation DairyAppMutationType
+    subscription SubscriptionType
+    max_depth 5
+    orphan_types [HoneyType, BeverageUnion]
+
+    rescue_from(NoSuchDairyError) { |err| err.message  }
+
+    resolve_type ->(obj, ctx) {
+      Schema.types[obj.class.name.split("::").last]
+    }
+  end
+end