Merge pull request #1139 from johnbiundo/biundo/graphql-mapped-types

Biundo/graphql mapped types

Author: kamilmysliwiec

content/cli/usages.md

@@ -55,7 +55,7 @@ $ nest g <schematic> <name> [options]
 
 | Name          | Alias | Description                                                                                         |
 | ------------- | ----- | --------------------------------------------------------------------------------------------------- |
-| `application` |       | Generate a new application within a monorepo (converting to monorepo if it's a standard structure). |
+| `app`         |       | Generate a new application within a monorepo (converting to monorepo if it's a standard structure). |
 | `library`     | `lib` | Generate a new library within a monorepo (converting to monorepo if it's a standard structure).     |
 | `class`       | `cl`  | Generate a new class.                                                                               |
 | `controller`  | `co`  | Generate a controller declaration.                                                                  |

content/cli/workspaces.md

@@ -93,7 +93,7 @@ The `generate app` schematic has reorganized the code - moving each **applicatio
 
 #### Workspace projects
 
-A mono repo uses the concept of a workspace to manage its member entities. Workspaces are composed of **projects**. A project may be either:
+A monorepo uses the concept of a workspace to manage its member entities. Workspaces are composed of **projects**. A project may be either:
 
 - an **application**: a full Nest application including a `main.ts` file to bootstrap the application. Aside from compile and build considerations, an application-type project within a workspace is functionally identical to an application within a _standard mode_ structure.
 - a **library**: a library is a way of packaging a general purpose set of features (modules, providers, controllers, etc.) that can be used within other projects. A library cannot run on its own, and has no `main.ts` file. Read more about libraries [here](/cli/libraries).

content/discover/who-uses.json

@@ -141,6 +141,11 @@
       "logo": "/assets/logo/zeoagency.svg",
       "url": "https://zeo.org/tr/",
       "width": "80px"
+    },
+    {
+      "logo": "/assets/logo/valueadd.png",
+      "url": "https://valueadd.pl/",
+      "width": "120px"
     }
   ],
   "Body": [

content/faq/hybrid-application.md

@@ -1,6 +1,6 @@
 ### Hybrid application
 
-A hybrid application is one that both listens for HTTP requests, as well as makes use of connected microservices. The `INestApplication` instance can be connected with `INestMicroservice` instances through the `connectMicroservice()` method. To connect multiple microservice instances, simply pass additional microservice configuration objects as arguments in a comma-separated list.
+A hybrid application is one that both listens for HTTP requests, as well as makes use of connected microservices. The `INestApplication` instance can be connected with `INestMicroservice` instances through the `connectMicroservice()` method.
 
 ```typescript
 const app = await NestFactory.create(AppModule);
@@ -11,3 +11,26 @@ const microservice = app.connectMicroservice({
 await app.startAllMicroservicesAsync();
 await app.listen(3001);
 ```
+
+To connect multiple microservice instances, issue the call to `connectMicroservice()` for each microservice:
+
+```typescript
+const app = await NestFactory.create(AppModule);
+// microservice #1
+const microserviceTcp = app.connectMicroservice<MicroserviceOptions>({
+  transport: Transport.TCP,
+  options: {
+    port: 3001,
+  },
+});
+// microservice #2
+const microserviceRedis = app.connectMicroservice<MicroserviceOptions>({
+  transport: Transport.REDIS,
+  options: {
+    url: 'redis://localhost:6379',
+  },
+});
+
+await app.startAllMicroservicesAsync();
+await app.listen(3001);
+```

content/fundamentals/dependency-injection.md

@@ -272,7 +272,7 @@ export class AppModule {}
 
 #### Alias providers: `useExisting`
 
-The `useExisting` syntax allows you to create aliases for existing providers. This creates two ways to access the same provider. In the example below, the (string-based) token `'AliasedLoggerService'` is an alias for the (class-based) token `LoggerService`. Assume we have two different dependencies, one for `'AlilasedLoggerService'` and one for `LoggerService`. If both dependencies are specified with `SINGLETON` scope, they'll both resolve to the same instance.
+The `useExisting` syntax allows you to create aliases for existing providers. This creates two ways to access the same provider. In the example below, the (string-based) token `'AliasedLoggerService'` is an alias for the (class-based) token `LoggerService`. Assume we have two different dependencies, one for `'AliasedLoggerService'` and one for `LoggerService`. If both dependencies are specified with `SINGLETON` scope, they'll both resolve to the same instance.
 
 ```typescript
 @Injectable()

content/fundamentals/execution-context.md

@@ -15,14 +15,17 @@ The `ArgumentsHost` class provides methods for retrieving the arguments being pa
 When building generic [guards](/guards), [filters](/exception-filters), and [interceptors](/interceptors) which are meant to run across multiple application contexts, we need a way to determine the type of application that our method is currently running in. Do this with the `getType()` method of `ArgumentsHost`:
 
 ```typescript
-const type = host.getType();
-if (type === 'http') {
-  // HTTP application
-} else if (type === 'rpc') {
-  // Microservice
+if (host.getType() === 'http') {
+  // do something that is only important in the context of regular HTTP requests (REST)
+} else if (host.getType() === 'rpc') {
+  // do something that is only important in the context of Microservice requests
+} else if (host.getType<GqlContextType>() === 'graphql') {
+  // do something that is only important in the context of GraphQL requests
 }
 ```
 
+> info **Hint** The `GqlContextType` is imported from the `@nestjs/graphql` package.
+
 With the application type available, we can write more generic components, as shown below.
 
 #### Host handler arguments

content/graphql/enums.md

@@ -69,10 +69,7 @@ Sometimes a backend forces a different value for an enum internally than in the
 ```typescript
 @Resolver('AllowedColor')
 export class AllowedColorResolver {
-  @ResolveField('RED')
-  getRedColor() {
-    return '#f00';
-  }
+  [AllowedColor.RED]: '#f00'; 
 }
 ```
 

content/graphql/mapped-types.md

@@ -1,14 +1,16 @@
 ### Mapped types
 
-##### This chapter applies only to code first approach
+> warning **Warning** This chapter applies only to the code first approach.
 
-A common task is to take an existing type and make each of its properties optional. This happens often enough that NestJS provides a way to create new types based on old types — mapped types.
+As you build out features like CRUD (Create/Read/Update/Delete) it's often useful to construct variants on a base entity type. Nest provides several utility functions that perform type transformations to make this task more convenient.
 
 #### Partial
 
-Make all properties of a type optional.
+When building input validation types (also called DTOs), it's often useful to build **create** and **update** variations on the same type. For example, the **create** variant may require all fields, while the **update** variant may make all fields optional.
 
-Original type:
+Nest provides the `PartialType()` utility function to make this task easier and minimize boilerplate.
+
+The `PartialType()` function returns a type (class) with all the properties of the input type set to optional. For example, suppose we have a **create** type as follows:
 
 ```typescript
 @InputType()
@@ -24,7 +26,7 @@ class CreateUserInput {
 }
 ```
 
-Mapped type:
+By default, all of these fields are required. To create a type with the same fields, but with each one optional, use `PartialType()` passing the class reference (`CreateUserInput`) as an argument:
 
 ```typescript
 @InputType()
@@ -33,13 +35,16 @@ export class UpdateUserInput extends PartialType(CreateUserInput) {}
 
 > info **Hint** The `PartialType()` function is imported from the `@nestjs/graphql` package.
 
-> warning **Warning** If you want to create an `InputType` based on the `ObjectType`, you must explicitly specify it in the function, as follows: `PartialType(CreateUserInput, InputType)` where `InputType` is a reference to a decorator factory.
+The `PartialType()` function takes an optional second argument that is a reference to the decorator factory of the type being extended. In the example above, we are extending `CreateUserInput` which is annotated with the `@InputType()` decorator. We didn't need to pass `InputType` as the second argument since it's the default value. If you want to extend a class decorated with `@ObjectType`, pass `ObjectType` as the second argument. For example:
 
-#### Pick
+```typescript
+@InputType()
+export class UpdateUserInput extends PartialType(User, ObjectType) {}
+```
 
-Constructs a type by picking the set of properties from type.
+#### Pick
 
-Original type:
+The `PickType()` function constructs a new type (class) by picking a set of properties from an input type. For example, suppose we start with a type like:
 
 ```typescript
 @InputType()
@@ -55,7 +60,7 @@ class CreateUserInput {
 }
 ```
 
-Mapped type:
+We can pick a set of properties from this class using the `PickType()` utility function:
 
 ```typescript
 @InputType()
@@ -64,11 +69,9 @@ export class UpdateEmailInput extends PickType(CreateUserInput, ['email']) {}
 
 > info **Hint** The `PickType()` function is imported from the `@nestjs/graphql` package.
 
-#### Pick
-
-Constructs a type by picking all properties from type and then removing particular set of keys.
+#### Omit
 
-Original type:
+The `OmitType()` function constructs a type by picking all properties from an input type and then removing a particular set of keys. For example, suppose we start with a type like:
 
 ```typescript
 @InputType()
@@ -84,7 +87,7 @@ class CreateUserInput {
 }
 ```
 
-Mapped type:
+We can generate a derived type that has every property **except** `email` as shown below. In this construct, the second argument to `OmitType` is an array of property names.
 
 ```typescript
 @InputType()
@@ -95,13 +98,11 @@ export class UpdateUserInput extends OmitType(CreateUserInput, ['email']) {}
 
 #### Composition
 
-Mapped types are composeable.
-
-Example:
+The type mapping utility functions are composable. For example, the following will produce a type (class) that has all of the properties of the `CreateUserInput` type except for `email`, and those properties will be set to optional:
 
 ```typescript
 @InputType()
-export class UpdateUserInput extends Partial(
+export class UpdateUserInput extends PartialType(
   OmitType(CreateUserInput, ['email']),
 ) {}
 ```

content/graphql/mutations.md

@@ -50,8 +50,6 @@ async upvotePost(
 ) {}
 ```
 
-// Should we add note about Inheritance here? (input types inheritance)
-
 #### Schema first
 
 Let's extend our `AuthorResolver` used in the previous section (see [resolvers](/graphql/resolvers)).

content/graphql/quick-start.md

@@ -173,13 +173,15 @@ A fully working schema first sample is available [here](https://github.com/nestj
 
 #### Accessing generated schema
 
-To access the generated schema (in either code first or schema first approach), use the `GraphQLHost` class:
+In some circumstances (for example end-to-end tests), you may want to get a reference to the generated schema object. In end-to-end tests, you can then run queries using the `graphql` object without using any HTTP listeners.
+
+You can access the generated schema (in either the code first or schema first approach), using the `GraphQLSchemaHost` class:
 
 ```typescript
 const { schema } = app.get(GraphQLSchemaHost);
 ```
 
-> info **Hint** Make sure to call the `GraphQLSchemaHost#schema` getter when the application is already initialized (after the `onModuleInit` hook triggered by either `app.listen()` or `app.init()` method.
+> info **Hint** You must call the `GraphQLSchemaHost#schema` getter after the application has been initialized (after the `onModuleInit` hook has been triggered by either the `app.listen()` or `app.init()` method).
 
 #### Async configuration