Merge branch 'master' into feautre/recipes/necord

Author: SocketSomeone

.nvmrc

@@ -1 +1 @@
-18.14.0
+18.15.0

content/cli/scripts.md

@@ -16,7 +16,7 @@ The `nest` command is an OS level binary (i.e., runs from the OS command line).
 
 #### Build
 
-`nest build` is a wrapper on top of the standard `tsc` compiler (for [standard projects](https://docs.nestjs.com/cli/overview#project-structure)) or the webpack compiler (for [monorepos](https://docs.nestjs.com/cli/overview#project-structure)). It does not add any other compilation features or steps except for handling `tsconfig-paths` out of the box. The reason it exists is that most developers, especially when starting out with Nest, do not need to adjust compiler options (e.g., `tsconfig.json` file) which can sometimes be tricky.
+`nest build` is a wrapper on top of the standard `tsc` compiler (for [standard projects](https://docs.nestjs.com/cli/overview#project-structure)) or the webpack bundler using the `ts-loader` (for [monorepos](https://docs.nestjs.com/cli/overview#project-structure)). It does not add any other compilation features or steps except for handling `tsconfig-paths` out of the box. The reason it exists is that most developers, especially when starting out with Nest, do not need to adjust compiler options (e.g., `tsconfig.json` file) which can sometimes be tricky.
 
 See the [nest build](https://docs.nestjs.com/cli/usages#nest-build) documentation for more details.
 

content/devtools/ci-cd.md

@@ -51,6 +51,10 @@ To see reports, navigate to the project's corresponding page (see organizations)
 
 <figure><img src="/assets/devtools/report.png" /></figure>
 
+This is particularly helpful in identifying changes that may have gone unnoticed during code reviews. For instance, let's say someone has changed the scope of a **deeply nested provider**. This change might not be immediately obvious to the reviewer, but with Devtools, we can easily spot such changes and make sure that they're intentional. Or if we remove a guard from a specific endpoint, it will show up as affected in the report. Now if we didn't have integration or e2e tests for that route, we might not notice that it's no longer protected, and by the time we do, it could be too late.
+
+Similarly, if we're working on a **large codebase** and we modify a module to be global, we'll see how many edges were added to the graph, and this - in most cases - is a sign that we're doing something wrong.
+
 #### Build preview
 
 For every published graph we can go back in time and preview how it looked before by clicking at the **Preview** button. Furthermore, if the report was generated, we should see the differences higlighted on our graph:
@@ -63,6 +67,8 @@ See screenshot below:
 
 <figure><img src="/assets/devtools/nodes-selection.png" /></figure>
 
+The ability to go back in time lets you investigate and troubleshoot the issue by comparing the current graph with the previous one. Depending on how you set things up, every pull request (or even every commit) will have a corresponding snapshot in the registry, so you can easily go back in time and see what changed. Think of Devtools as a Git but with an understanding of how Nest constructs your application graph, and with the ability to **visualize** it.
+
 #### Integrations: Github Actions
 
 First let's start from creating a new Github workflow in the `.github/workflows` directory in our project and call it, for example, `publish-graph.yml`. Inside this file, let's use the following definition:

content/devtools/overview.md

@@ -21,7 +21,7 @@ Next up, let's install the required dependency:
 $ npm i @nestjs/devtools-integration
 ```
 
-> warning **Warning** If you're using `@nestjs/graphql` package in your application, make sure to install the upcoming `next` version (`npm i @nestjs/graphql@next`).
+> warning **Warning** If you're using `@nestjs/graphql` package in your application, make sure to install the latest version (`npm i @nestjs/graphql@11`).
 
 With this dependency in place, let's open up the `app.module.ts` file and import the `DevtoolsModule` that we just installed:
 
@@ -44,6 +44,8 @@ Once the `DevtoolsModule` is imported and your application is up and running (`n
 
 <figure><img src="/assets/devtools/modules-graph.png" /></figure>
 
+> info **Hint** As you can see on the screenshot above, every module connect to the `InternalCoreModule`. `InternalCoreModule` is a global module that is always imported into the root module. Since it's registered as a global node, Nest automatically creates edges between all of the modules and the `InternalCoreModule` node. Now, if you want to hide global modules from the graph, you can use the "Hide global modules" checkbox (in the sidebar).
+
 So as we can see, `DevtoolsModule` makes your application expose an additional HTTP server (on port 8000) that the Devtools application will use to introspect your app.
 
 Just to double-check that everything works as expected, change the graph view to "Classes". You should see the following screen:
@@ -56,45 +58,113 @@ To focus on a specific node, click on the rectangle and the graph will show a po
 
 <figure><img src="/assets/devtools/node-popup.png" /></figure>
 
+> info **Hint** To export a graph as an image, click on the **Export as PNG** button in the right corner of the graph.
+
 Using the form controls located in the sidebar (on the left), you can control edges proximity to, for example, visualize a specific application sub-tree:
 
 <figure><img src="/assets/devtools/subtree-view.png" /></figure>
 
+This can be particularly useful when you have **new developers** on your team and you want to show them how your application is structured. You can also use this feature to visualize a specific module (e.g. `TasksModule`) and all of its dependencies, which can come in handy when you're breaking down a large application into smaller modules (for example, individual micro-services).
+
+#### Investigating the "Cannot resolve dependency" error
+
+> info **Note** This feature is supported for `@nestjs/core` >= `v9.3.10`.
+
+Probably the most common error message you might have seen is about Nest not being able to resolve dependencies of a provider. Using Nest Devtools, you can effortlessly identify the issue and learn how to resolve it.
+
+First, open up the `main.ts` file and update the `bootstrap()` call, as follows:
+
+```typescript
+bootstrap().catch((err) => {
+  fs.writeFileSync('graph.json', PartialGraphHost.toString() ?? '');
+  process.exit(1);
+});
+```
+
+Also, make sure to set the `abortOnError` to `false`:
+
+```typescript
+const app = await NestFactory.create(AppModule, {
+  snapshot: true,
+  abortOnError: false, // <--- THIS
+});
+```
+
+Now every time your application fails to bootstrap due to the **"Cannot resolve dependency"** error, you'll find the `graph.json` (that represents a partial graph) file in the root directory. You can then drag & drop this file into Devtools (make sure to switch the current mode from "Interactive" to "Preview"):
+
+<figure><img src="/assets/devtools/drag-and-drop.png" /></figure>
+
+Upon successful upload, you should see the following graph & dialog window:
+
+<figure><img src="/assets/devtools/partial-graph-modules-view.png" /></figure>
+
+As you can see, the highlighted `TasksModule` is the one we should look into. Also, in the dialog window you can already see some instructions on how to use fix this issue.
+
+If we switch to the "Classes" view instead, that's what we'll see:
+
+<figure><img src="/assets/devtools/partial-graph-classes-view.png" /></figure>
+
+This graph illustrates that the `DiagnosticsService` which we want to inject into the `TasksService` was not found in the context of the `TasksModule` module, and we should likely just import the `DiagnosticsModule` into the `TasksModule` module to fix this up!
+
 #### Routes explorer
 
 When you navigate to the **Routes explorer** page, you should see all of the registered entrypoints:
 
 <figure><img src="/assets/devtools/routes.png" /></figure>
 
+> info **Hint** This page shows not only HTTP routes, but also all of the other entrypoints (e.g. WebSockets, gRPC, GraphQL resolvers etc.).
+
+Entrypoints are grouped by their host controllers. You can also use the search bar to find a specific entrypoint.
+
+If you click on a specific entrypoint, **a flow graph** will be displayed. This graph shows the execution flow of the entrypoint (e.g. guards, interceptors, pipes, etc. bound to this route). This is particularly useful when you want to understand how the request/response cycle looks for a specific route, or when troubleshooting why a specific guard/interceptor/pipe is not being executed.
+
 #### Sandbox
 
 To execute JavaScript code on the fly & interact with your application in real-time, navigate to the **Sandbox** page:
 
 <figure><img src="/assets/devtools/sandbox.png" /></figure>
 
+The playground can be used to test and debug API endpoints in **real-time**, allowing developers to quickly identify and fix issues without using, for example, an HTTP client. We can also bypass the authentication layer, and so we no longer need that extra step of logging in, or even a special user account for testing purposes. For event-driven applications, we can also trigger events directly from the playground, and see how the application reacts to them.
+
+Anything that gets logged down is streamlined to the playground's console, so we can easily see what's going on.
+
+Just execute the code **on the fly** and see the results instantly, without having to rebuild the application and restart the server.
+
+<figure><img src="/assets/devtools/sandbox-table.png" /></figure>
+
+> info **Hint** To pretty display an array of objects, use the `console.table()` (or just `table()`) function.
+
 #### Bootstrap performance analyzer
 
 To see a list of all class nodes (controllers, providers, enhancers, etc.) and their corresponding instantiation times, navigate to the **Bootstrap performance** page:
 
 <figure><img src="/assets/devtools/bootstrap-performance.png" /></figure>
 
+This page is particularly useful when you want to identify the slowest parts of your application's bootstrap process (e.g. when you want to optimize the application's startup time which is crucial for, for example, serverless environments).
+
 #### Audit
 
 To see the auto-generated audit - errors/warnings/hints that the application came up with while analyzing your serialized graph, navigate to the **Audit** page:
 
 <figure><img src="/assets/devtools/audit.png" /></figure>
 
+> info **Hint** The screenshot above doesn't show all of the available audit rules.
+
+This page comes in handy when you want to identify potential issues in your application.
+
 #### Preview static files
 
 To save a serialized graph to a file, use the following code:
 
 ```typescript
 await app.listen(3000); // OR await app.init()
-writeFileSync('./graph.json', app.get(SerializedGraph).toString());
+fs.writeFileSync('./graph.json', app.get(SerializedGraph).toString());
 ```
 
 > info **Hint** `SerializedGraph` is exported from the `@nestjs/core` package.
 
 Then you can drag and drop this/upload this file:
 
 <figure><img src="/assets/devtools/drag-and-drop.png" /></figure>
+
+This is helpful when you want to share your graph with someone else (e.g., co-worker), or when you want to analyze it offline.

content/discover/who-uses.json

@@ -198,6 +198,11 @@
     {
       "logo": "/assets/logo/amplication.svg",
       "url": "https://amplication.com"
+    },
+    {
+      "logo": "/assets/logo/hingehealth.png",
+      "url": "https://hingehealth.com",
+      "width": "120px"
     }
   ],
   "Body": [

content/faq/errors.md

@@ -4,6 +4,8 @@ During your development with NestJS, you may encounter various errors as you lea
 
 #### "Cannot resolve dependency" error
 
+> info **Hint** Check out the [NestJS Devtools](/devtools/overview#investigating-the-cannot-resolve-dependency-error) which can help you resolve the "Cannot resolve dependency" error effortlessly.
+
 Probably the most common error message is about Nest not being able to resolve dependencies of a provider. The error message usually looks something like this:
 
 ```bash
@@ -30,6 +32,8 @@ If the `<unknown_token>` above is the string `Object`, it means that you're inje
 
 Also, make sure you didn't end up injecting the provider on itself because self-injections are not allowed in NestJS. When this happens, `<unknown_token>` will likely be equal to `<provider>`.
 
+<app-banner-devtools></app-banner-devtools>
+
 If you are in a **monorepo setup**, you may face the same error as above but for core provider called `ModuleRef` as a `<unknown_token>`:
 
 ```bash

content/faq/global-prefix.md

@@ -20,3 +20,5 @@ Alternatively, you can specify route as a string (it will apply to every request
 ```typescript
 app.setGlobalPrefix('v1', { exclude: ['cats'] });
 ```
+
+> info **Hint** The `path` property supports wildcard parameters using the [path-to-regexp](https://github.com/pillarjs/path-to-regexp#parameters) package. Note: this does not accept wildcard asterisks `*`. Instead, you must use parameters (e.g., `(.*)`, `:splat*`).

content/faq/hybrid-application.md

@@ -4,7 +4,7 @@ A hybrid application is one that both listens for HTTP requests, as well as make
 
 ```typescript
 const app = await NestFactory.create(AppModule);
-const microservice = app.connectMicroservice({
+const microservice = app.connectMicroservice<MicroserviceOptions>({
   transport: Transport.TCP,
 });
 
@@ -71,7 +71,7 @@ By default a hybrid application will not inherit global pipes, interceptors, gua
 To inherit these configuration properties from the main application, set the `inheritAppConfig` property in the second argument (an optional options object) of the `connectMicroservice()` call, as follow:
 
 ```typescript
-const microservice = app.connectMicroservice(
+const microservice = app.connectMicroservice<MicroserviceOptions>(
   {
     transport: Transport.TCP,
   },

content/faq/raw-body.md

@@ -9,7 +9,12 @@ One of the most common use-case for having access to the raw request body is per
 First enable the option when creating your Nest Express application:
 
 ```typescript
-const app = await NestFactory.create(AppModule, {
+import { NestFactory } from '@nestjs/core';
+import type { NestExpressApplication } from '@nestjs/platform-express';
+import { AppModule } from './app.module';
+
+// in the "bootstrap" function
+const app = await NestFactory.create<NestExpressApplication>(AppModule, {
   rawBody: true,
 });
 await app.listen(3000);
@@ -30,17 +35,47 @@ class CatsController {
 }
 ```
 
+#### Registering a different parser
+
+By default, only `json` and `urlencoded` parsers are registered. If you want to register a different parser on the fly, you will need to do so explicitly.
+
+For example, to register a `text` parser, you can use the following code:
+
+```typescript
+app.useBodyParser('text');
+```
+
+> warning **Warning** Ensure that you are providing the correct application type to the `NestFactory.create` call. For Express applications, the correct type is `NestExpressApplication`. Otherwise the `.useBodyParser` method will not be found.
+
+#### Body parser size limit
+
+If your application needs to parse a body larger than the default `100kb` of Express, use the following:
+
+```typescript
+app.useBodyParser('json', { limit: '10mb' });
+```
+
+The `.useBodyParser` method will respect the `rawBody` option that is passed in the application options.
+
 #### Use with Fastify
 
 First enable the option when creating your Nest Fastify application:
 
 ```typescript
+import { NestFactory } from '@nestjs/core';
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from '@nestjs/platform-fastify';
+import { AppModule } from './app.module';
+
+// in the "bootstrap" function
 const app = await NestFactory.create<NestFastifyApplication>(
   AppModule,
   new FastifyAdapter(),
   {
     rawBody: true,
-  }
+  },
 );
 await app.listen(3000);
 ```
@@ -59,3 +94,26 @@ class CatsController {
   }
 }
 ```
+
+#### Registering a different parser
+
+By default, only `application/json` and `application/x-www-form-urlencoded` parsers are registered. If you want to register a different parser on the fly, you will need to do so explicitly.
+
+For example, to register a `text/plain` parser, you can use the following code:
+
+```typescript
+app.useBodyParser('text/plain');
+```
+
+> warning **Warning** Ensure that you are providing the correct application type to the `NestFactory.create` call. For Fastify applications, the correct type is `NestFastifyApplication`. Otherwise the `.useBodyParser` method will not be found.
+
+#### Body parser size limit
+
+If your application needs to parse a body larger than the default 1MiB of Fastify, use the following:
+
+```typescript
+const bodyLimit = 10_485_760; // 10MiB
+app.useBodyParser('application/json', { bodyLimit });
+```
+
+The `.useBodyParser` method will respect the `rawBody` option that is passed in the application options.

content/faq/serverless.md

@@ -172,7 +172,7 @@ Also, depending on whether you want to run a typical HTTP application with multi
 your application's code will look different (for example, for the endpoint-per-function approach you could use the `NestFactory.createApplicationContext` instead of booting the HTTP server, setting up middleware, etc.).
 
 Just for illustration purposes, we'll integrate Nest (using `@nestjs/platform-express` and so spinning up the whole, fully functional HTTP router)
-with the [Serverless](https://www.serverless.com/) framework (in this case, targetting AWS Lambda). As we've mentioned earlier, your code will differ depending on the cloud provider you choose, and many other factors.
+with the [Serverless](https://www.serverless.com/) framework (in this case, targeting AWS Lambda). As we've mentioned earlier, your code will differ depending on the cloud provider you choose, and many other factors.
 
 First, let's install the required packages: