feat(Schema.define) update docs and tests

Author: rmosolgo

guides/defining_your_schema.md

@@ -238,11 +238,11 @@ Some parts of schema definition take types as an input. There are two good ways
 Your schema can be initialized with some options:
 
 ```ruby
-MySchema = GraphQL::Schema.new(
-  query: QueryType,       # root type for read-only queries
-  mutation: MutationType, # root type for mutations
-  max_depth: 7,           # if present, the max depth for incoming queries
-)
+MySchema = GraphQL::Schema.define do
+  query QueryType,       # root type for read-only queries
+  mutation MutationType, # root type for mutations
+  max_depth 7,           # if present, the max depth for incoming queries
+end
 ```
 
 Additionally, you can define error handling and custom middleware as described below.

guides/executing_queries.md

@@ -64,7 +64,7 @@ result = MySchema.execute(query_string, validate: false)
 
 `graphql` includes a serial execution strategy, but you can also create custom strategies to support advanced behavior. See `GraphQL::SerialExecution#execute` the required behavior.
 
-Then, set your schema to use your custom execution strategy with `GraphQL::Schema#mutation_execution_strategy` or `GraphQL::Schema#query_execution_strategy`
+Then, set your schema to use your custom execution strategy with `GraphQL::Schema#{query|mutation|subscription}_execution_strategy`
 
 For example:
 
@@ -81,7 +81,9 @@ end
 
 # ... define your types ...
 
-MySchema = GraphQL::Schema.new(query: MyQueryType, mutation: MyMutationType)
-# Use your custom strategy:
-MySchema.query_execution_strategy = CustomQueryExecutionStrategy
+MySchema = GraphQL::Schema.define do
+  query MyQueryType
+  mutation MyMutationType
+  # Use your custom strategy:
+  query_execution_strategy = CustomQueryExecutionStrategy
 ```

guides/introduction.md

@@ -10,7 +10,10 @@ A GraphQL system exposes your application to the world according to its _schema_
 Once you've defined your query root and mutation root, you can make a schema:
 
 ```ruby
-ApplicationSchema = GraphQL::Schema.new(query: QueryRoot, mutation: MutationRoot)
+ApplicationSchema = GraphQL::Schema.define do
+  query QueryRoot
+  mutation MutationRoot
+end
 ```
 
 At that time, `graphql-ruby` will validate all types and fields.
@@ -80,7 +83,9 @@ The query root has one field, `post`,  which finds a `Post` by ID. The `resolve`
 Lastly, create the schema:
 
 ```ruby
-Schema = GraphQL::Schema.new(query: QueryRoot)
+Schema = GraphQL::Schema.define do
+  query QueryRoot
+end
 ```
 
 This schema could handle queries like:
@@ -136,7 +141,10 @@ end
 After defining your schema, you can evaluate queries with `GraphQL::Query`. For example:
 
 ```ruby
-Schema = GraphQL::Schema.new(query: QueryRoot) # QueryRoot defined above
+Schema = GraphQL::Schema.define do
+  query QueryRoot # QueryRoot defined above
+end
+
 query_string = "query getPost { post(id: 1) { id, title, comments { body } } }"
 
 result_hash = Schema.execute(query_string)

guides/relay.md

@@ -55,9 +55,11 @@ end
 Then assign it to the schema:
 
 ```ruby
-MySchema = GraphQL::Schema.new(...)
-# Assign your node identification helper:
-MySchema.node_identification = NodeIdentification
+MySchema = GraphQL::Schema.define do
+  # ...
+  # Declare your node identification helper:
+  node_identification NodeIdentification
+end
 ```
 
 ### UUID fields
@@ -365,10 +367,10 @@ MutationType = GraphQL::ObjectType.define do
 end
 
 # and pass it to the schema
-MySchema = GraphQL::Schema.new(
-  query: QueryType,
-  mutation: MutationType
-)
+MySchema = GraphQL::Schema.define do
+  query QueryType,
+  mutation MutationType
+end
 ```
 
 Like `QueryType`, `MutationType` is a root of the schema.

guides/security.md

@@ -70,10 +70,10 @@ end
 Then, define your `max_complexity` at the schema-level:
 
 ```ruby
-MySchema = GraphQL::Schema.new(
+MySchema = GraphQL::Schema.define do
  # ...
- max_complexity: 100
-)
+ max_complexity 100
+end
 ```
 
 Or, at the query-level, which overrides the schema-level setting:
@@ -102,10 +102,10 @@ You can also reject queries based on the depth of their nesting. You can define
 
 ```ruby
 # Schema-level:
-MySchema = GraphQL::Schema.new(
+MySchema = GraphQL::Schema.define do
   # ...
   max_depth: 10
-)
+end
 
 # Query-level, which overrides the schema-level setting:
 MySchema.execute(query_string, max_depth: 10)

lib/graphql/schema/printer.rb

@@ -3,8 +3,8 @@ class Schema
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
     # @example print your schema to standard output
-    #   Schema = GraphQL::Schema.new(query: QueryType)
-    #   puts GraphQL::Schema::Printer.print_schema(Schema)
+    #   MySchema = GraphQL::Schema.define(query: QueryType)
+    #   puts GraphQL::Schema::Printer.print_schema(MySchema)
     #
     module Printer
       extend self
@@ -20,7 +20,7 @@ def print_introspection_schema
         query_root = ObjectType.define do
           name "Query"
         end
-        schema = Schema.new(query: query_root)
+        schema = GraphQL::Schema.define(query: query_root)
         print_filtered_schema(schema, method(:is_introspection_type))
       end
 

readme.md

@@ -62,10 +62,10 @@ QueryType = GraphQL::ObjectType.define do
 end
 
 # Then create your schema
-Schema = GraphQL::Schema.new(
-  query: QueryType,
-  max_depth: 8,
-)
+Schema = GraphQL::Schema.define do
+  query QueryType,
+  max_depth 8,
+end
 ```
 
 #### Execute queries

spec/graphql/analysis/query_complexity_spec.rb

@@ -255,7 +255,7 @@
         end
       end
 
-      GraphQL::Schema.new(query: query_type, types: [double_complexity_type])
+      GraphQL::Schema.define(query: query_type, orphan_types: [double_complexity_type])
     }
     let(:query_string) {%|
       {

spec/graphql/argument_spec.rb

@@ -10,7 +10,7 @@
     end
 
     err = assert_raises(GraphQL::Schema::InvalidTypeError) {
-      schema = GraphQL::Schema.new(query: query_type)
+      schema = GraphQL::Schema.define(query: query_type)
       schema.types
     }
 

spec/graphql/field_spec.rb

@@ -82,7 +82,7 @@ def acts_like_default_resolver(field, old_prop, new_prop)
       invalid_field.name = :symbol_name
 
       dummy_query.fields["symbol_name"] = invalid_field
-      dummy_schema = GraphQL::Schema.new(query: dummy_query)
+      dummy_schema = GraphQL::Schema.define(query: dummy_query)
 
       err = assert_raises(GraphQL::Schema::InvalidTypeError) { dummy_schema.types }
       assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message

spec/graphql/query/context_spec.rb

@@ -16,7 +16,7 @@
       resolve -> (target, args, ctx) { ctx.query.class.name }
     end
   }}
-  let(:schema) { GraphQL::Schema.new(query: query_type, mutation: nil)}
+  let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}
   let(:result) { schema.execute(query_string, context: {"some_key" => "some value"})}
 
   describe "access to passed-in values" do

spec/graphql/query/executor_spec.rb

@@ -85,7 +85,7 @@
         end
       end
 
-      GraphQL::Schema.new(query: DummyQueryType, mutation: MutationType)
+      GraphQL::Schema.define(query: DummyQueryType, mutation: MutationType)
     }
     let(:variables) { nil }
     let(:query_string) { %|

spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -30,7 +30,7 @@
       end
     end
   }
-  let(:schema) { GraphQL::Schema.new(query: query_root) }
+  let(:schema) { GraphQL::Schema.define(query: query_root) }
   let(:result) { schema.execute(
     query_string,
   )}

spec/graphql/schema/printer_spec.rb

@@ -60,7 +60,7 @@
       end
     end
 
-    GraphQL::Schema.new(query: query_root)
+    GraphQL::Schema.define(query: query_root)
   }
 
   describe ".print_introspection_schema" do

spec/graphql/schema/reduce_types_spec.rb

@@ -96,7 +96,7 @@ def reduce_types(types)
   end
 
   describe "when a field is only accessible through an interface" do
-    it "is found through Schema.new(types:)" do
+    it "is found through Schema.define(types:)" do
       assert_equal HoneyType, DummySchema.types["Honey"]
     end
   end

spec/graphql/schema/timeout_middleware_spec.rb

@@ -35,7 +35,7 @@
       end
     end
 
-    schema = GraphQL::Schema.new(query: query_type)
+    schema = GraphQL::Schema.define(query: query_type)
     schema.middleware << timeout_middleware
     schema
   }

spec/support/star_wars_schema.rb

@@ -215,5 +215,5 @@ def upcased_parent_name
   field :introduceShip, field: IntroduceShipMutation.field
 end
 
-StarWarsSchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)
+StarWarsSchema = GraphQL::Schema.define(query: QueryType, mutation: MutationType)
 StarWarsSchema.node_identification = NodeIdentification