The Node Plugin for Nx contains generators and executors to manage Node applications within an Nx workspace.

The Node Plugin contains generators and executors to manage Node applications within an Nx workspace. It provides:

## Setting Up Node

To add the Node plugin to an existing workspace, run one of the following:

```bash
# For npm users
npm install -D @nrwl/node

# For yarn users
yarn add -D @nrwl/node
```

### Creating Applications

You can add a new application with the following:

```bash
nx g @nrwl/node:application my-new-app
```

You can run your application with `nx serve my-new-app`, which starts it in watch mode.

### Creating Libraries

Node libraries are a good way to separate features within your organization. To create a Node library run the following command:

```bash
nx g @nrwl/js:node my-new-lib

# If you want the library to be buildable or publishable to npm
nx g @nrwl/node:lib my-new-lib --buildable
nx g @nrwl/node:lib my-new-lib \
--publishable \
--importPath=@myorg/my-new-lib
```

## Using Node

### Testing Projects

You can run unit tests with:

```bash
nx test my-new-app
nx test my-new-lib
```

Replace `my-new-app` with the name or your project. This command works for both applications and libraries.

### Building Projects

Node applications can be build with:

```bash
nx build my-new-app
```

And if you generated a library with `--buildable`, then you can build a library as well:

```bash
nx build my-new-lib
```

The output is in the `dist` folder. You can customize the output folder by setting `outputPath` in the project's `project.json` file.

### Application Proxies

Generating Node 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.

```bash
nx g @nrwl/node:application my-new-app \
--frontendProject my-react-app
```

### Debugging

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` architect 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).

## More Documentation

- [Using Cypress](/packages/cypress)
- [Using Jest](/packages/jest)


Overview

webpack

Node application build target options for Build Facade.

Read buildable libraries from source instead of building them separately.

Dependencies to keep external to the bundle. (`all` (default), `none`, or an array of module names)

Extract all licenses in a separate file, in the case of production builds only.

Replace files with other files in the build.

Generates a `package.json` file with the project's `node_module` dependencies populated for installing in a container. If a `package.json` exists in the project's directory, it will be reused with dependencies populated.

Number of workers to use for type checking. (defaults to # of CPUS)

Memory limit for type checking service process in MB. (defaults to `2048`)

Defines the optimization level of the build.

Name of the main output file. (defaults to `main.js`)

Log progress to the console while building.

Generates a `stats.json` file which can be analyzed using tools such as: `webpack-bundle-analyzer` or `<https://webpack.github.io/analyse>`.

List of TypeScript Compiler Transfomers Plugins.

The name of the Typescript configuration file.

A set of options used to customize watch mode.

Path to a function which takes a webpack config, context and returns the resulting webpack config. See https://nx.dev/guides/customize-webpack

Node Application Build Target

node

Additional options to pass into the build target.

Ensures the app is starting with debugging.

The port to inspect the process on. Setting port to 0 will assign random free ports to all forked processes.

The targets to run to before starting the node app.

Node executor

init

Init Node Plugin

application

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

Generate JavaScript files rather than TypeScript files.

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

library

Create a Node Library for an Nx workspace.

The compiler used by the build and test targets.

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

Sets the `rootDir` for TypeScript compilation. When not defined, it uses the project's root property, or `srcRootForCompilationRoot` if it is defined.

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

Keep the module name simple (when using `--directory`).

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

Whether to enable tsconfig strict mode or not.

The test environment to use if `unitTestRunner` is set to `jest`.

@nrwl/node:library

Usage

Examples

Options

buildable

babelJest

compiler

directory

importPath

js

linter

name

publishable

pascalCaseFiles

rootDir

simpleModuleName

skipFormat

skipTsConfig

strict

standaloneConfig

setParserOptionsProject

tags

testEnvironment

unitTestRunner