Merge branch 'master' into alexishr-uses-nestjs

Author: kilhage

.gitignore

@@ -40,7 +40,7 @@ dist/*
 npm-debug.log
 testem.log
 /typings
-
+.angular
 # e2e
 /e2e/*.js
 /e2e/*.map

LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017 Kamil Myśliwiec <http://kamilmysliwiec.com>
+Copyright (c) 2017-2022 Kamil Myśliwiec <http://kamilmysliwiec.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

angular.json

@@ -27,7 +27,8 @@
               "src/_redirects"
             ],
             "styles": [
-              "src/styles.scss"
+              "src/styles.scss",
+              "src/assets/css/perfect-scrollbar.min.css"
             ]
           },
           "configurations": {

content/discover/who-uses.json

@@ -254,6 +254,8 @@
     "https://forwardigital.co.uk",
     "https://rozetka.com.ua",
     "https://www.itrio.net",
-    "https://alexishr.com"
+    "https://alexishr.com",
+    "https://dyrector.io",
+    "https://stijlbreuk.nl"
   ]
 }

content/exception-filters.md

@@ -284,6 +284,8 @@ You can add as many filters with this technique as needed; simply add each to th
 
 In order to catch **every** unhandled exception (regardless of the exception type), leave the `@Catch()` decorator's parameter list empty, e.g., `@Catch()`.
 
+In the example below we have a code that is platform-agnostic because it uses the [HTTP adapter](./faq/http-adapter) to deliver the response, and doesn't use any of the platform-specific objects (`Request` and `Response`) directly:
+
 ```typescript
 import {
   ExceptionFilter,
@@ -292,30 +294,35 @@ import {
   HttpException,
   HttpStatus,
 } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
 
 @Catch()
 export class AllExceptionsFilter implements ExceptionFilter {
-  catch(exception: unknown, host: ArgumentsHost) {
+  constructor(private readonly httpAdapterHost: HttpAdapterHost) {}
+
+  catch(exception: unknown, host: ArgumentsHost): void {
+    // In certain situations `httpAdapter` might not be available in the
+    // constructor method, thus we should resolve it here.
+    const { httpAdapter } = this.httpAdapterHost;
+
     const ctx = host.switchToHttp();
-    const response = ctx.getResponse();
-    const request = ctx.getRequest();
 
-    const status =
+    const httpStatus =
       exception instanceof HttpException
         ? exception.getStatus()
         : HttpStatus.INTERNAL_SERVER_ERROR;
 
-    response.status(status).json({
-      statusCode: status,
+    const responseBody = {
+      statusCode: httpStatus,
       timestamp: new Date().toISOString(),
-      path: request.url,
-    });
+      path: httpAdapter.getRequestUrl(ctx.getRequest()),
+    };
+
+    httpAdapter.reply(ctx.getResponse(), responseBody, httpStatus);
   }
 }
 ```
 
-In the example above the filter will catch each exception thrown, regardless of its type (class).
-
 #### Inheritance
 
 Typically, you'll create fully customized exception filters crafted to fulfill your application requirements. However, there might be use-cases when you would like to simply extend the built-in default **global exception filter**, and override the behavior based on certain factors.

content/faq/serverless.md

@@ -178,7 +178,7 @@ First, let's install the required packages:
 
 ```bash
 $ npm i @vendia/serverless-express aws-lambda
-$ npm i @types/aws-lambda serverless-offline
+$ npm i -D @types/aws-lambda serverless-offline
 ```
 
 > info **Hint** To speed up development cycles, we install the `serverless-offline` plugin which emulates AWS λ and API Gateway.
@@ -263,7 +263,7 @@ $ npx serverless offline
 Once the application is running, open your browser and navigate to `http://localhost:3000/dev/[ANY_ROUTE]` (where `[ANY_ROUTE]` is any endpoint registered in your application).
 
 In the sections above, we've shown that using `webpack` and bundling your app can have significant impact on the overall bootstrap time.
-However, to make it work with our example, there's one additional configuration you must add in your `webpack.config.js` file. Generally,
+However, to make it work with our example, there are a few additional configurations you must add in your `webpack.config.js` file. Generally,
 to make sure our `handler` function will be picked up, we must change the `output.libraryTarget` property to `commonjs2`.
 
 ```javascript
@@ -280,6 +280,31 @@ return {
 
 With this in place, you can now use `$ nest build --webpack` to compile your function's code (and then `$ npx serverless offline` to test it).
 
+It's also recommended (but **not required** as it will slow down your build process) to install the `terser-webpack-plugin` package and override its configuration to keep classnames intact when minifying your production build. Not doing so can result in incorrect behavior when using `class-validator` within your application.
+
+```javascript
+const TerserPlugin = require('terser-webpack-plugin');
+
+return {
+  ...options,
+  externals: [],
+  optimization: {
+    minimizer: [
+      new TerserPlugin({
+        terserOptions: {
+          keep_classnames: true,
+        },
+      }),
+    ],
+  },
+  output: {
+    ...options.output,
+    libraryTarget: 'commonjs2',
+  },
+  // ... the rest of the configuration
+};
+```
+
 #### Using standalone application feature
 
 Alternatively, if you want to keep your function very lightweight and you don't need any HTTP-related features (routing, but also guards, interceptors, pipes, etc.),

content/fundamentals/unit-testing.md

@@ -160,6 +160,41 @@ Instead of using the production version of any provider, you can override it wit
 
 <app-banner-courses></app-banner-courses>
 
+#### Auto mocking
+
+Nest also allows you to define a mock factory to apply to all of your missing dependencies. This is useful for cases where you have a large number of dependencies in a class and mocking all of them will take a long time and a lot of setup. To make use of this feature, the `createTestingModule()` will need to be chained up with the `useMocker()` method, passing a factory for your dependency mocks. This factory can take in an optional token, which is an instance token, any token which is valid for a Nest provider, and returns a mock implementation. The below is an example of creating a generic mocker using [`jest-mock`](https://www.npmjs.com/package/jest-mock) and a specific mock for `CatsService` using `jest.fn()`.
+
+```typescript
+const moduleMocker = new ModuleMocker(global);
+
+describe('CatsController', () => {
+  let controller: CatsController;
+
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      controllers: [CatsController],
+    })
+    .useMocker((token) => {
+      if (token === CatsService) {
+        return { findAll: jest.fn().mockResolveValue(results) };
+      }
+      if (typeof token === 'function') {
+        const mockMetadata = moduleMocker.getMetadata(token) as MockFunctionMetadata<any, any>;
+        const Mock = moduleMocker.generateFromMetadata(mockMetadata);
+        return new Mock();
+      }
+    })
+    .compile();
+    
+    controller = moduleRef.get(CatsController);
+  });
+})
+```
+
+> info **Hint** A general mock factory, like `createMock` from [`@golevelup/ts-jest`](https://github.com/golevelup/nestjs/tree/master/packages/testing) can also be passed directly.
+
+You can also retrieve these mocks out of the testing container as you normally would custom providers, `moduleRef.get(CatsService)`.
+
 #### End-to-end testing
 
 Unlike unit testing, which focuses on individual modules and classes, end-to-end (e2e) testing covers the interaction of classes and modules at a more aggregate level -- closer to the kind of interaction that end-users will have with the production system. As an application grows, it becomes hard to manually test the end-to-end behavior of each API endpoint. Automated end-to-end tests help us ensure that the overall behavior of the system is correct and meets project requirements. To perform e2e tests we use a similar configuration to the one we just covered in **unit testing**. In addition, Nest makes it easy to use the [Supertest](https://github.com/visionmedia/supertest) library to simulate HTTP requests.
@@ -243,26 +278,31 @@ describe('Cats', () => {
 >
 > ```ts
 > let app: NestFastifyApplication;
-> 
+>
 > beforeAll(async () => {
 >   app = moduleRef.createNestApplication<NestFastifyApplication>(
 >     new FastifyAdapter(),
 >   );
 >
 >   await app.init();
 >   await app.getHttpAdapter().getInstance().ready();
-> })
-> 
+> });
+>
 > it(`/GET cats`, () => {
 >   return app
 >     .inject({
 >       method: 'GET',
->       url: '/cats'
->     }).then(result => {
->       expect(result.statusCode).toEqual(200)
->       expect(result.payload).toEqual(/* expectedPayload */)
+>       url: '/cats',
+>     })
+>     .then((result) => {
+>       expect(result.statusCode).toEqual(200);
+>       expect(result.payload).toEqual(/* expectedPayload */);
 >     });
-> })
+> });
+>  
+> afterAll(async () => {
+>   await app.close();
+> });
 > ```
 
 In this example, we build on some of the concepts described earlier. In addition to the `compile()` method we used earlier, we now use the `createNestApplication()` method to instantiate a full Nest runtime environment. We save a reference to the running app in our `app` variable so we can use it to simulate HTTP requests.

content/graphql/federation.md

@@ -136,6 +136,10 @@ import { UsersService } from './users.service'; // Not included in this example
 export class AppModule {}
 ```
 
+#### Example
+
+A working example is available [here](https://github.com/nestjs/nest/tree/master/sample/31-graphql-federation-code-first/users-application) in code first mode and [here](https://github.com/nestjs/nest/tree/master/sample/32-graphql-federation-schema-first/users-application) in schema first mode.
+
 #### Federated example: Posts
 
 Our Post service serves aggregated posts via a `getPosts` query, but also extends our `User` type with `user.posts`
@@ -318,6 +322,9 @@ import { PostsService } from './posts.service'; // Not included in example
 })
 export class AppModule {}
 ```
+#### Example
+
+A working example is available [here](https://github.com/nestjs/nest/tree/master/sample/31-graphql-federation-code-first/posts-application) for the code first mode and [here](https://github.com/nestjs/nest/tree/master/sample/32-graphql-federation-schema-first/posts-application) for the schema first mode.
 
 #### Federated example: Gateway
 
@@ -354,6 +361,10 @@ export class AppModule {}
 
 > info **Hint** Apollo recommends that you don't rely on the service discovery in a production environment but use their [Graph Manager](https://www.apollographql.com/docs/graph-manager/federation/) instead.
 
+#### Example
+
+A working example is available [here](https://github.com/nestjs/nest/tree/master/sample/31-graphql-federation-code-first/gateway) for the code first mode and [here](https://github.com/nestjs/nest/tree/master/sample/32-graphql-federation-schema-first/gateway) for the schema first mode.
+
 #### Sharing context
 
 You can customize the requests between the gateway and federated services using a build service. This allows you to share context about the request. You can easily extend the default `RemoteGraphQLDataSource` and implement one of the hooks. Please refer to [Apollo Docs](https://www.apollographql.com/docs/apollo-server/api/apollo-gateway/#remotegraphqldatasource) on `RemoteGraphQLDataSource` for more information about the possibilities.

content/graphql/quick-start.md

@@ -9,7 +9,7 @@ In this chapter, we assume a basic understanding of GraphQL, and focus on how to
 Start by installing the required packages:
 
 ```bash
-$ npm i @nestjs/graphql graphql apollo-server-express
+$ npm i @nestjs/graphql graphql@^15 apollo-server-express
 ```
 
 > info **Hint** If using Fastify, instead of installing `apollo-server-express`, you should install `apollo-server-fastify`.

content/graphql/subscriptions.md

@@ -334,9 +334,14 @@ If you're using the `graphql-ws` package, the signature of the `onConnect` callb
 subscriptions: {
   'graphql-ws': {
     onConnect: (context: Context<any>) => {
-      const { connectionParams } = context;
-      // the rest will remain the same as in the example above
+      const { connectionParams, extra } = context;
+      // user validation will remain the same as in the example above
+      // when using with graphql-ws, additional context value should be stored in the extra field
+      extra.user = { user: {} };
     },
   },
+  context: ({ extra }) => {
+    // you can now access your additional context value through the extra field
+  } 
 },
 ```