Reverted documentation changes in #8267 (#8323)

Author: glen-84

website/src/blog/2019-02-20-schema-stitching.md

@@ -653,7 +653,7 @@ Query delegation rewriters are registered with the dependency injection and not
 services.AddQueryDelegationRewriter<AddCreatedByIdQueryRewriter>();
 ```
 
-> Query delegation rewriters are hosted as scoped services and can be injected with `IStitchingContext` and `Schema` in order to access the remote schemas or the stitched schema for advanced type information.
+> Query delegation rewriters are hosted as scoped services and can be injected with `IStitchingContext` and `ISchema` in order to access the remote schemas or the stitched schema for advanced type information.
 
 With that in place, the stitching engine will always fetch the requested field for us whenever a `Message` object is requested.
 

website/src/blog/2019-04-11-integration-tests.md

@@ -35,7 +35,7 @@ public class Query
 In order to create a schema from that simple type we could just do the following:
 
 ```csharp
-Schema schema = Schema.Create(c => c.RegisterQueryType<Query>());
+ISchema schema = Schema.Create(c => c.RegisterQueryType<Query>());
 ```
 
 OK, now we have a schema against which we can write our tests.
@@ -205,7 +205,7 @@ Our test could look like the following:
 public async Task Ensure_Schema_IsCorrect()
 {
     // arrange
-    Schema schema = Schema.Create(c =>
+    ISchema schema = Schema.Create(c =>
     {
         c.RegisterQueryType<Query>();
     });
@@ -234,7 +234,7 @@ public async Task SayHello_HelloIsReturned()
             .AddSingleton<IDataLayer, MyDataLayer>()
             .BuildServiceProvider();
 
-    Schema schema = Schema.Create(c =>
+    ISchema schema = Schema.Create(c =>
     {
         c.RegisterQueryType<Query>();
     });

website/src/blog/2019-04-12-type-system.md

@@ -19,7 +19,7 @@ We started with version 9.0.0-preview.9 to deliver more and more parts of the ne
 The most prominent API that we are introducing is the new `SchemaBuilder`. The `SchemaBuilder` provides us with a new way to define schemas. Do not worry the current `ISchemaConfiguration` API is still supported and will not go away. In fact, `ISchemaConfiguration` now is just an interface over `SchemaBuilder` and we will evolve both APIs over time so that you can pick the one that you like more.
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddQueryType<FooType>()
     .Create();
 ```
@@ -31,7 +31,7 @@ First, we wanted the builder API to be decoupled from the actual schema, we want
 With the schema builder we are now more flexible in scenarios like schema stitching.
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddQueryType<FooType>()
     .AddDirectiveType<BarType>()
     .AddSchemaFromFile("./Schema.graphql")
@@ -386,7 +386,7 @@ Also, you can define multiple type extensions for a single type.
 So, let us have a look of how we add type extensions to our schema:
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
   .AddQueryType<FooType>()
   .AddType<FooTypeExtension>();
   .Create()

website/src/docs/hotchocolate/v10/execution-engine/validation-rules.md

@@ -12,7 +12,7 @@ The rule interface itself is simple, basically the validation middleware will ca
 ```csharp
 public interface IQueryValidationRule
 {
-    QueryValidationResult Validate(Schema schema, DocumentNode query);
+    QueryValidationResult Validate(ISchema schema, DocumentNode query);
 }
 ```
 

website/src/docs/hotchocolate/v10/schema/index.md

@@ -13,7 +13,7 @@ There are basically two ways to define a schema, with code or with the GraphQL S
 In schema-first we could create a simple hello world schema like the following:
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddDocumentFromString("type Query { hello: String }")
     .AddResolver("Query", "hello", "World")
     .Create();
@@ -29,7 +29,7 @@ public class Query
     public string Hello() => "World";
 }
 
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddQueryType<Query>()
     .Create();
 ```
@@ -50,7 +50,7 @@ public class QueryType
     }
 }
 
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddQueryType<QueryType>()
     .Create();
 ```
@@ -72,7 +72,7 @@ public class Query
     public string Hello() => "World";
 }
 
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddQueryType<QueryType>()
     .Create();
 ```
@@ -102,7 +102,7 @@ public class QueryTypeExtension
     }
 }
 
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddDocumentFromString("type Query { hello: String }")
     .AddResolver("Query", "hello", "World")
     .AddType<QueryTypeExtension>()
@@ -127,7 +127,7 @@ Types in a schema can be bound to a specific .NET type. When the schema builder
 We can also bind additional types to a single schema type. For instance we can bind the `System.Guid` to our `StringType`.
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     ...
     .BindClrType<Guid, StringType>()
     .Create();
@@ -136,7 +136,7 @@ Schema schema = SchemaBuilder.New()
 You can also rebind scalars with this, so instead of the default `int` to `IntType` binding we could bind that as well to our `StringType`.
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     ...
     .BindClrType<int, StringType>()
     .Create();
@@ -156,7 +156,7 @@ public class MySchema
     }
 }
 
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .AddDocumentFromString("type Query { hello: String }")
     .AddResolver("Query", "hello", "World")
     .SetSchema<MySchema>()

website/src/docs/hotchocolate/v10/schema/relay.md

@@ -37,7 +37,7 @@ This allows now the client APIs to automatically refetch objects from the server
 Hot Chocolate makes implementing this very easy. First, we have to declare on our schema that we want to be relay compliant:
 
 ```csharp
-Schema schema = SchemaBuilder.New()
+ISchema schema = SchemaBuilder.New()
     .EnableRelaySupport()
     ...
     .Create();

website/src/docs/hotchocolate/v10/schema/resolvers.md

@@ -213,7 +213,7 @@ The following resolver context properties can be injected without any attributes
 
 | Member                     | Type                      | Description                                                       |
 | -------------------------- | ------------------------- | ----------------------------------------------------------------- |
-| `Schema`                   | `Schema`                 | The GraphQL schema.                                               |
+| `Schema`                   | `ISchema`                 | The GraphQL schema.                                               |
 | `ObjectType`               | `ObjectType`              | The object type on which the field resolver is being executed.    |
 | `Field`                    | `ObjectField`             | The field on which the field resolver is being executed.          |
 | `QueryDocument`            | `DocumentNode`            | The query that is being executed.                                 |
@@ -273,7 +273,7 @@ public Person GetFriend([State("foo")]Bar bar)
 
 | Member                      | Type                      | Description                                                                           |
 | --------------------------- | ------------------------- | ------------------------------------------------------------------------------------- |
-| `Schema`                    | `Schema`                 | The GraphQL schema.                                                                   |
+| `Schema`                    | `ISchema`                 | The GraphQL schema.                                                                   |
 | `ObjectType`                | `ObjectType`              | The object type on which the field resolver is being executed.                        |
 | `Field`                     | `ObjectField`             | The field on which the field resolver is being executed.                              |
 | `QueryDocument`             | `DocumentNode`            | The query that is being executed.                                                     |

website/src/docs/hotchocolate/v10/server/dependency-injection.md

@@ -21,7 +21,7 @@ You are also able to inject parts from your field resolver context like the sche
 ```csharp
 public class Query
 {
-    public string Bar(Schema schema, [Service]MyCustomService service)
+    public string Bar(ISchema schema, [Service]MyCustomService service)
     {
         return "foo";
     }

website/src/docs/hotchocolate/v10/stitching.md

@@ -646,7 +646,7 @@ Query delegation rewriters are registered with the dependency injection and not
 services.AddQueryDelegationRewriter<AddCreatedByIdQueryRewriter>();
 ```
 
-> Query delegation rewriters are hosted as scoped services and can be injected with `IStitchingContext` and `Schema` in order to access the remote schemas or the stitched schema for advanced type information.
+> Query delegation rewriters are hosted as scoped services and can be injected with `IStitchingContext` and `ISchema` in order to access the remote schemas or the stitched schema for advanced type information.
 
 With that in place, the stitching engine will always fetch the requested field for us whenever a `Message` object is requested.
 

website/src/docs/hotchocolate/v11/api-reference/migrate-from-10-to-11.md

@@ -718,7 +718,7 @@ We have added a couple of test helpers to make the transition to the new configu
 **New:**
 
 ```csharp
-    Schema schema =
+    ISchema schema =
         await new ServiceCollection()
             .AddGraphQL()
             .AddQueryType<Query>()