Merge branch 'master' of https://github.com/nestjs/docs.nestjs.com

Author: kamilmysliwiec

content/faq/hybrid-application.md

@@ -35,6 +35,35 @@ await app.startAllMicroservicesAsync();
 await app.listen(3001);
 ```
 
+To bind `@MessagePattern()` to only one transport strategy (for example, MQTT) in a hybrid application with multiple microservices, we can pass the second argument of type `Transport` which is an enum with all the built-in transport strategies defined.
+
+```typescript
+@@filename()
+@MessagePattern('time.us.*', Transport.NAST)
+getDate(@Payload() data: number[], @Ctx() context: NatsContext) {
+  console.log(`Subject: ${context.getSubject()}`); // e.g. "time.us.east"
+  return new Date().toLocaleTimeString(...);
+}
+@MessagePattern({ cmd: 'time.us' }, Transport.TCP)
+getTCPDate(@Payload() data: number[]) {
+  return new Date().toLocaleTimeString(...);
+}
+@@switch
+@Bind(Payload(), Ctx())
+@MessagePattern('time.us.*', Transport.NAST)
+getDate(data, context) {
+  console.log(`Subject: ${context.getSubject()}`); // e.g. "time.us.east"
+  return new Date().toLocaleTimeString(...);
+}
+@Bind(Payload(), Ctx())
+@MessagePattern({ cmd: 'time.us' }, Transport.TCP)
+getTCPDate(data, context) {
+  return new Date().toLocaleTimeString(...);
+}
+```
+
+> info **Hint** `@Payload()`, `@Ctx()`, `Transport` and `NatsContext` are imported from `@nestjs/microservices`.
+
 #### Sharing configuration
 
 By default a hybrid application will not inherit global pipes, interceptors, guards and filters configured for the main (HTTP-based) application.

content/graphql/complexity.md

@@ -84,3 +84,14 @@ Alternatively, you can define the estimator function:
 @Field({ complexity: (options: ComplexityEstimatorArgs) => ... })
 title: string;
 ```
+
+#### Query/Mutation-level complexity
+
+In addition, `@Query()` and `@Mutation()` decorators may have a `complexity` property specified like so:
+
+```typescript
+@Query({ complexity: (options: ComplexityEstimatorArgs) => options.args.count * options.childComplexity })
+items(@Args('count') count: number) {
+  return this.itemsService.getItems({ count });
+}
+```

content/microservices/basics.md

@@ -97,7 +97,7 @@ The request-response message style is useful when you need to **exchange** messa
 
 To enable the request-response message type, Nest creates two logical channels - one is responsible for transferring the data while the other waits for incoming responses. For some underlying transports, such as [NATS](https://nats.io/), this dual-channel support is provided out-of-the-box. For others, Nest compensates by manually creating separate channels. There can be overhead for this, so if you do not require a request-response message style, you should consider using the event-based method.
 
-To create a message handler based on the request-response paradigm use the `@MessagePattern()` decorator, which is imported from the `@nestjs/microservices` package.
+To create a message handler based on the request-response paradigm use the `@MessagePattern()` decorator, which is imported from the `@nestjs/microservices` package. This decorator should be used only within the [controller](https://docs.nestjs.com/controllers) classes since they are the entry points for your application. Using them inside providers won't have any effect as they are simply ignored by Nest runtime.
 
 ```typescript
 @@filename(math.controller)
@@ -348,3 +348,27 @@ export interface RequestContext<T = any> {
 ```
 
 The `data` property is the message payload sent by the message producer. The `pattern` property is the pattern used to identify an appropriate handler to handle the incoming message.
+
+
+### Handling timeouts
+
+In distributed systems, sometimes microservices might be down or not available. To avoid infinitely long waiting, you can use Timeouts. A timeout is an incredibly useful pattern when communicating with other services. To apply timeouts to your microservice calls, you can use the `RxJS` timeout operator. If the microservice does not respond to the request within a certain time, an exception is thrown, which can be caught and handled appropriately.
+
+To solve this problem you have to use [rxjs](https://github.com/ReactiveX/rxjs) package. Just use the `timeout` operator in the pipe:
+
+```typescript
+@@filename()
+this.client
+      .send<TResult, TInput>(pattern, data)
+      .pipe(timeout(5000))
+      .toPromise();
+@@switch
+this.client
+      .send(pattern, data)
+      .pipe(timeout(5000))
+      .toPromise();
+```
+
+> info **Hint** The `timeout` operator is imported from the `rxjs/operators` package.
+
+After 5 seconds, if the microservice isn't responding, it will throw an error.