The Nx Plugin for Nest contains executors and generators for allowing your workspace to create powerful Nest best in class APIs.

![NestJS logo](/shared/nest-logo.png)

Nest.js is a framework designed for building scalable server-side applications. In many ways, Nest is familiar to Angular developers:

- It has excellent TypeScript support.
- Its dependency injection system is similar to the one in Angular.
- It emphasises testability.
- Its configuration APIs are similar to Angular as well.

Many conventions and best practices used in Angular applications can be also be used in Nest.

## Setting Up Nest

To create a new workspace with Nest, run the following command:

```shell
npx create-nx-workspace my-workspace --preset=nest
```

Yarn users can use the following command instead:

```shell
yarn create nx-workspace my-workspace --preset=nest
```

To add the Nest plugin to an existing workspace, run one the following commands:

```shell
npm install -D @nrwl/nest
```

```shell
yarn add -D @nrwl/nest
```

### Create Applications

You can add a new Nest application with the following command:

```shell
nx g @nrwl/nest:app my-nest-app
```

#### Application Proxies

Generating Nest applications has an option to configure other projects in the workspace to proxy API requests. This can be done by passing the `--frontendProject` with the project name you wish to enable proxy support for.

```shell
nx g @nrwl/nest:app my-nest-app --frontendProject my-angular-app
```

### Create Libraries

You can add a new Nest library with the following command:

```shell
nx g @nrwl/nest:lib my-nest-lib
```

To make the library `buildable`, use the following command:

```shell
nx g @nrwl/nest:lib my-nest-lib --buildable
```

To make the library `publishable`, use the following command:

```shell
nx g @nrwl/nest:lib my-nest-lib --publishable --importPath=@my-workspace/my-nest-lib
```

> Read more about [building and publishing libraries here](/more-concepts/buildable-and-publishable-libraries).

### Nest Generators

The Nest plugin for Nx extends the generators provided by Nest. Any commands that can be used with the Nest CLI can also be used with the `nx` command. The `--project` flag should be used for all Nest generators.

> `--project` is used to infer the root of the project where the generators will generate the files.

## Using Nest

### Build

You can build an application with the following command:

```shell
nx build my-nest-app
```

This applies to `buildable` libraries as well

```shell
nx build my-nest-lib
```

#### Waiting for other builds

Setting the `waitUntilTargets` option with an array of projects (with the following format: `"project:architect"`) will execute those commands before serving the Nest application.

### Serve

You can serve an application with the following command:

```shell
nx serve my-nest-app
```

The `serve` command runs the `build` target, and executes the application.

By default, the serve command will run in `watch` mode. This allows code to be changed, and the Nest application to be rebuilt automatically.

#### Debugging

Nest applications also have the `inspect` flag set, so you can attach your debugger to the running instance.

Debugging is set to use a random port that is available on the system. The port can be changed by setting the port option in the `serve` target in the `project.json`. Or by running the serve command with `--port <number>`.

For additional information on how to debug Node applications, see the [Node.js debugging getting started guide](https://nodejs.org/en/docs/guides/debugging-getting-started/#inspector-clients).

### Lint

You can lint an application with the following command:

```shell
nx lint my-nest-app
```

You can lint a library with the following command:

```shell
nx lint my-nest-lib
```

### Unit Test

You can run unit test for an application with the following command:

```shell
nx test my-nest-app
```

You can run unit test for a library with the following command:

```shell
nx test my-nest-lib
```

## More Documentation

- [Todo Tutorial](/node-tutorial/01-create-application)
- [Using Jest](/packages/jest)


Overview

application

Frontend project that needs to access this application. This sets up proxy configuration.

Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.

Do not add dependencies to `package.json`.

Split the project configuration into `<projectRoot>/project.json` rather than including it inside `workspace.json`.

Nx Application Options Schema

convert-tslint-to-eslint

Convert a NestJS project from TSLint to ESLint. 
_NOTE: Does not work in `--dry-run` mode_.

Convert the NestJS project `myapp` from TSLint to ESLint

If true we will not use existing TSLint config as a reference, we will just reset the project with the latest recommended ESLint config.

The name of the NestJS project to convert.

If this conversion leaves no more TSLint usage in the workspace, it will remove TSLint and related dependencies and configuration.

Convert a NestJS project from TSLint to ESLint

init

Init Nest Plugin

library

Add the Global decorator to the generated module.

The library name used to import it, like @myorg/my-awesome-lib. Must be a valid npm name.

Whether or not to configure the ESLint "parserOptions.project" option. We do not do this by default for lint performance reasons.

Do not update tsconfig.base.json for development experience.

Split the project configuration into <projectRoot>/project.json rather than including it inside workspace.json

Whether to enable tsconfig strict mode or not.

The ES target, Nest suggest using es6 or higher.

The test environment for jest, for node applications this should stay as node unless doing DOM testing.

Create a NestJS Library for Nx

Run the `class` NestJS generator with Nx project support.

class

Directory where the generated files are placed.

Flag to indicate if a directory is created.

Nest Class Options Schema

Run the `controller` NestJS generator with Nx project support.

controller

Allows specification of the declaring module.

Nest Controller Options Schema

Run the `decorator` NestJS generator with Nx project support.

decorator

Nest Decorator Options Schema

Run the `filter` NestJS generator with Nx project support.

filter

Nest Filter Options Schema

Run the `gateway` NestJS generator with Nx project support.

gateway

Nest Gateway Options Schema

Run the `guard` NestJS generator with Nx project support.

guard

Nest Guard Options Schema

Run the `interceptor` NestJS generator with Nx project support.

interceptor

Nest Interceptor Options Schema

Run the `interface` NestJS generator with Nx project support.

interface

Nest Interface Options Schema

Run the `middleware` NestJS generator with Nx project support.

middleware

Nest Middleware Options Schema

Run the `module` NestJS generator with Nx project support.

module

Nest Module Options Schema

Run the `pipe` NestJS generator with Nx project support.

pipe

Nest Pipe Options Schema

Run the `provider` NestJS generator with Nx project support.

provider

Nest Provider Options Schema

Run the `resolver` NestJS generator with Nx project support.

resolver

Nest Resolver Options Schema

Run the `resource` NestJS generator with Nx project support.

resource

When true, CRUD entry points are generated.

Nest Resource Options Schema

Run the `service` NestJS generator with Nx project support.

@nrwl/nest:library

Usage

Examples

Options

buildable

controller

directory

global

importPath

linter

name

publishable

skipFormat

skipTsConfig

service

strict

standaloneConfig

setParserOptionsProject

tags

testEnvironment

target

unitTestRunner