Nx

https://nx.dev/docs
Admin
Nx is a build system and monorepo management tool that provides task caching, code generation,...
Tokens:1,034,399
Snippets:9,282
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Create a new Nx workspace with create-nx-workspace

Source: https://nx.dev/docs/getting-started/start-new-project

Run this command to start the interactive setup for a new Nx workspace. It prompts for a workspace name and starter template, then generates files and installs dependencies.

```shell
$ npx create-nx-workspace@latest
✓ generating workspace files
✓ installing dependencies
→ ready in 20s
```

--------------------------------

### Example project.json

Source: https://nx.dev/docs/kb/pass-args-to-commands

Defines the example project's configuration with sourceRoot, projectType, and empty targets. Used as the starting point for the recipe.

```json
// apps/my-app/project.json
{
  "sourceRoot": "apps/my-app/src",
  "projectType": "application",
  "targets": {}
}
```

--------------------------------

### Install tools with mise using mise.toml

Source: https://nx.dev/docs/kb/launch-template-examples

Configures a launch template to use the pre-built install-mise step. If a mise.toml file exists in the repo, mise automatically installs the tools defined there. The example includes checkout, install-mise, and install-node-modules steps.

```yaml
// .nx/workflows/agents.yaml
launch-templates:
  my-linux-medium-js:
    resource-class: 'docker_linux_amd64/medium'
    image: 'ubuntu22.04-node24.14-v1'
    init-steps:
      - name: Checkout
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/checkout/main.yaml'
      - name: Install mise
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-mise/main.yaml'
      - name: Install Node Modules
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-node-modules/main.yaml'
```

--------------------------------

### Manual nvm installation in Nx Agents launch template

Source: https://nx.dev/docs/kb/launch-template-examples

Shows a manual approach to install a specific Node version using nvm in the launch template. The steps install nvm, source the profile, install the desired Node version, and persist the PATH change to NX_CLOUD_ENV for subsequent steps. This example uses nvm but notes that volta or fnm are alternatives.

```yaml
// .nx/workflows/agents.yaml
launch-templates:
  node-22:
    resource-class: 'docker_linux_amd64/medium'
    image: 'ubuntu22.04-node24.14-v1'
    init-steps:
      - name: Checkout
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/checkout/main.yaml'
      - name: Install nvm
        script: |
          # run nvm install script
          curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
          # source the updated profile to get the nvm command available
          source ~/.profile
          # install the needed version of node via nvm
          nvm install 22.23.2
          # echo the current path (which now includes the nvm-provided version of node) to NX_CLOUD_ENV
          echo "PATH=$PATH" >> $NX_CLOUD_ENV
      - name: Print node version
        # confirm that the node version has changed
        script: node -v
      - name: Install Node Modules
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-node-modules/main.yaml'
      # Continue setup steps as needed
```

--------------------------------

### nx.json with targetDefaults

Source: https://nx.dev/docs/kb/adding-to-existing-project

Example nx.json created by the guided setup, marking build and lint as cacheable with outputs for build. The guided setup asks which scripts are cacheable and what they output.

```json
{
  "$schema": "./node_modules/nx/schemas/nx-schema.json",
  "targetDefaults": {
    "build": {
      "cache": true,
      "outputs": ["{projectRoot}/.next"]
    },
    "lint": {
      "cache": true
    }
  }
}
```

--------------------------------

### GitHub Actions workflow with bun and Nx Cloud

Source: https://nx.dev/docs/kb/use-bun

Example GitHub Actions workflow using bun with Nx Cloud. The jdx/mise-action reads mise.toml and installs Node and bun at pinned versions, so no separate setup-node or setup-bun action is needed. The nx start-nx-agents command runs before dependencies are installed, so it uses npx instead of bunx.

```yaml
// .github/workflows/ci.yml
name: CI
on:
  push:
    branches:
      - main
  pull_request:

permissions:
  actions: read
  contents: read

env:
  NX_CLOUD_ACCESS_TOKEN: ${{ secrets.NX_CLOUD_ACCESS_TOKEN }}

jobs:
  main:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          filter: tree:0

      - run: npx nx start-nx-agents

      - name: Setup toolchains with mise
        uses: jdx/mise-action@v3

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - uses: nrwl/nx-set-shas@v5

      - run: bunx nx record -- nx format:check
      - run: bunx nx run-many -t lint test build
      - run: bunx nx run-many -t e2e

      - name: Self-healing
        run: bunx nx fix-ci
        if: always()
```

--------------------------------

### Start an agent with nx-cloud start-agent

Source: https://nx.dev/docs/reference/nx-cloud-cli

Starts an agent process for bring-your-own-compute setups. The agent waits for Nx Cloud to assign tasks distributed by the main CI job. Without --targets, the agent accepts any task assigned to it.

```shell
npx nx-cloud start-agent
```

--------------------------------

### nx-cloud onboard examples

Source: https://nx.dev/docs/reference/nx-cloud-cli

Example invocations of nx-cloud onboard. The first starts the interactive wizard; the second runs non-interactively with JSON output; the third creates a workspace non-interactively using a specific organization, auto-detecting the repository and writing the returned nxCloudId to nx.json.

```shell
npx nx-cloud onboard
npx nx-cloud onboard --no-interactive --json
npx nx-cloud onboard --no-interactive --org=org_123 --detect-repo --write-config
```

--------------------------------

### Full launch template example with reusable init steps

Source: https://nx.dev/docs/kb/launch-template-examples

Defines common init steps for JavaScript and Rust, and three launch templates (my-linux-medium-js, my-linux-large-js, my-linux-rust-large) with different resource classes. Uses YAML anchors to reduce duplication. The init steps include checkout, caching, installing dependencies, and custom scripts.

```yaml
// ./nx/workflows/agents.yaml
# Define common setup steps that can be reused across templates
common-js-init-steps: &common-js-init-steps
  # using a reusable step in an external GitHub repo,
  # this step is provided by Nx Cloud: https://github.com/nrwl/nx-cloud-workflows/tree/main/workflow-steps
  - name: Checkout
    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/checkout/main.yaml'
  - name: Restore Node Modules Cache
    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/cache/main.yaml'
    # the cache step requires configuration via env vars
    # https://github.com/nrwl/nx-cloud-workflows/tree/main/workflow-steps/cache#options
    inputs:
      # Include patches directories to ensure cache is busted when patches change
      # If you use a custom patches directory, add it to the key as well
      key: 'package-lock.json|yarn.lock|pnpm-lock.yaml|patches/**|.yarn/patches/**'
      paths: |
        ~/.npm
        # or ~/.cache/yarn
        # or ~/.local/share/pnpm/store
      base-branch: 'main'
  - name: Restore Browser Binary Cache
    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/cache/main.yaml'
    inputs:
      key: 'package-lock.json|yarn.lock|pnpm-lock.yaml|"browsers"'
      paths: |
        '~/.cache/Cypress'
      base-branch: 'main'
  - name: Install Node Modules
    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-node-modules/main.yaml'
  - name: Install Browsers (if needed)
    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-browsers/main.yaml'
    # You can also run a custom script to configure various things on the agent machine
  - name: Run a custom script
    script: |
      git config --global user.email test@test.com
      git config --global user.name "Test Test"
  - name: Define Step Env Var
    # this env var will be available to all future steps using these 'common-init-steps' reusable steps
    # persist env vars between steps by writing to the $NX_CLOUD_ENV file
    script: |
      echo "MY_STEP_ENV=step-env-var" >> $NX_CLOUD_ENV

common-rust-init-steps: &common-rust-init-steps
  - name: Checkout
    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/checkout/main.yaml'

  # add Rust-specific steps
  - name: Install Rust
    script: |
      curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh -s -- -y
      source "$HOME/.cargo/env"
      rustup toolchain install stable
      # persist cargo bin into PATH
      echo "PATH=$HOME/.cargo/bin:$PATH" >> $NX_CLOUD_ENV

launch-templates:
  # Custom template name, the name is referenced via 'distribute-on: 3 my-linux-medium-js'
  # You can define as many templates as you need, commonly used to make different sizes or toolchains depending on your workspace needs
  my-linux-medium-js:
    resource-class: 'docker_linux_amd64/medium'
    image: 'ubuntu22.04-node24.14-v1'
    # Define environment variables shared among all steps in this launch template
    env:
      MY_ENV_VAR: shared
    # list out steps to run on the agent before accepting tasks
    # the agent will need a copy of the source code and dependencies installed
    # note we are using yaml anchors to reduce duplication with the below launch-template (they have the same init-steps)
    init-steps: *common-js-init-steps

  # another template which does the same as above, but with a large resource class
  # You're not required to define a template for every resource class, only define what you need!
  my-linux-large-js:
    resource-class: 'docker_linux_amd64/large'
    image: 'ubuntu22.04-node24.14-v1'
    env:
      MY_ENV_VAR: shared
    # note we are using yaml anchors to reduce duplication with the above launch-template (they have the same init-steps)
    init-steps: *common-js-init-steps

  # template that installs rust
  my-linux-rust-large:
    resource-class: 'docker_linux_amd64/large'
    image: 'ubuntu22.04-node24.14-v1'
    init-steps: *common-rust-init-steps

```

--------------------------------

### Start a development server with nx start

Source: https://nx.dev/docs/technologies/react/expo/introduction

Starts a development server for the specified Expo app.

```bash
nx start <app-name>
```

--------------------------------

### Start production server with nx start

Source: https://nx.dev/docs/technologies/react/next/introduction

Serves the production build. Depends on `build` completing first.

```bash
nx start my-app
```

--------------------------------

### .nx/ci-config.yaml example

Source: https://nx.dev/docs/reference/nx-cloud-cli

Example configuration file for start-nx-agents, defining distribution and lifecycle stop conditions.

```yaml
# .nx/ci-config.yaml
dte:
  distribute-on: 5 linux-large
lifecycle:
  stop-after:
    - build
    - test
    - e2e
```

--------------------------------

### Set environment variables for curl examples

Source: https://nx.dev/docs/kb/prometheus-metrics

Sets the environment variables needed to copy-paste the curl examples in this guide. The secret is shown only once and cannot be retrieved again.

```shell
export CLIENT_ID="nx-sa_xxxxxxxxxxxxxxxxxxxxx"
export SECRET="nx-sask_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
export WORKSPACE_ID="<workspace-id>"
export NX_CLOUD_HOST="https://<your-domain>.nx.app"
```

--------------------------------

### Install AWS CLI Manually

Source: https://nx.dev/docs/kb/launch-template-examples

Manually install the AWS CLI in your launch template using the official directions. Requires the `unzip` package to decompress the installation archive. Helpful if a custom installation setup is required; run `aws sts get-caller-identity` to verify authentication.

```yaml
// ./nx/workflows/agents.yaml
launch-templates:
  my-linux-medium-js:
    resource-class: 'docker_linux_amd64/medium'
    image: 'ubuntu22.04-node24.14-v1'
    init-steps:
      # step assumes you've passed all required AWS_* environment variables from the main agent via nx-agents.with-env-vars
      - name: Install AWS CLI
        script: |
          # unzip is required to unzip the AWS CLI installer
          sudo apt install gh unzip -y
          curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
          unzip awscliv2.zip
          # run installer, default location is already in the PATH
          # if installing in a custom location,
          # then update the $PATH like `PATH=$PATH:[extra-path-items] >> $NX_CLOUD_ENV`
          sudo ./aws/install
          # print AWS CLI version to verify command is avaiable
          aws --version
          # verify credentials to AWS is working
          aws sts get-caller-identity
```

--------------------------------

### Start Nx agents in GitHub Actions workflow

Source: https://nx.dev/docs/features/ci-features/distribute-task-execution

Starts the agents early in the CI job, before installing dependencies. Every Nx command in the job then runs its tasks across the three agents.

```yaml
// .github/workflows/ci.yml
name: CI
# ... triggers

jobs:
  main:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          filter: tree:0
      - run: pnpm dlx nx-cloud start-nx-agents
      - uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: 'pnpm'
      # ... install dependencies
      - run: pnpm exec nx affected -t lint test build
```

--------------------------------

### Initialize Nx in an existing project

Source: https://nx.dev/docs/getting-started/start-with-existing-project

Run this command from the repository root to add Nx. The output shows the detection of the workspace structure and the addition of Nx to package.json, completing in about 12 seconds.

```shell
$ npx nx@latest init
✓ detecting workspace structure
✓ adding Nx to package.json
→ ready in 12s
```

--------------------------------

### start-ci-run command with flags

Source: https://nx.dev/docs/kb/migrate-to-ci-config

Example of the start-ci-run command with flags in a GitHub Actions workflow. This is the starting point for migration.

```yaml
# .github/workflows/ci.yml
- run: npx nx-cloud start-ci-run --distribute-on="3 linux-medium-js" --stop-agents-after="build"
```

--------------------------------

### Verify plugin setup with nx report, show projects, and show project

Source: https://nx.dev/docs/technologies/react/next/introduction

Commands to verify the plugin is correctly set up: check plugin listing, ensure inferred tasks are working, and inspect a specific project configuration.

```bash
nx report
```

```bash
nx show projects --with-target=build
```

```bash
nx show project my-next-app
```

--------------------------------

### package.json with exports pointing to source

Source: https://nx.dev/docs/technologies/typescript/introduction

Example of a package.json that will not get a build task because its exports point directly to source.

```json
{
  "name": "@my-org/my-lib",
  "exports": {
    "./package.json": "./package.json",
    ".": "./src/index.ts"
  }
}
```

--------------------------------

### File replacements example

Source: https://nx.dev/docs/kb/create-config

Demonstrates using file replacements to swap environment files during the build.

```ts
// myapp/rspack.config.ts
import { createConfig } from '@nx/angular-rspack';

export default createConfig({
  options: {
    browser: './src/main.ts',
    server: './src/main.server.ts',
    ssrEntry: './src/server.ts',
    fileReplacements: [
      {
        replace: './src/environments/environment.ts',
        with: './src/environments/environment.prod.ts',
      },
    ],
  },
});
```

--------------------------------

### package.json with exports pointing to dist

Source: https://nx.dev/docs/technologies/typescript/introduction

Example of a package.json that will get a build task because its exports point to compiled output in dist/.

```json
{
  "name": "@my-org/my-lib",
  "exports": {
    "./package.json": "./package.json",
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  }
}
```

--------------------------------

### Start the development server

Source: https://nx.dev/docs/templates/tanstack-start

Runs the web application in development mode with instant HMR.

```bash
npx nx run web:dev
```

--------------------------------

### Files changed by nx init

Source: https://nx.dev/docs/kb/from-turborepo

Shows the files that nx init installs or modifies: .gitignore gets Nx cache directories, nx.json is the converted turbo.json, package.json gets the "nx" dev dependency, and the lockfile is updated.

```diff
.gitignore   | Nx cache directories
nx.json      | The converted turbo.json
package.json | The "nx" dev dependency
<lockfile>   |
```

--------------------------------

### Create a basic nx.json file

Source: https://nx.dev/docs/kb/manual-migration

Create a blank nx.json configuration file. This is the minimal configuration required to start using Nx.

```json
// nx.json
{}
```

--------------------------------

### Setup Docker Buildx in launch template

Source: https://nx.dev/docs/kb/docker-layer-caching

Add this step to the init-steps of the launch template that runs your Docker builds, before any docker build command, to enable BuildKit.

```yaml
- name: Setup Docker Buildx
  uses: 'nrwl/nx-cloud-workflows/main/workflow-steps/setup-docker-buildx/main.yaml'
```

--------------------------------

### project.json i18n configuration

Source: https://nx.dev/docs/kb/internationalization

Example i18n configuration in project.json with sourceLocale and locales. Requires @angular/localize installed and an i18n property in project.json.

```json
{
  "name": "my-app",
  "i18n": {
    "sourceLocale": "en-GB",
    "locales": {
      "fr": {
        "translation": "src/locale/messages.fr.xlf"
      }
    }
  },
  "targets": {
    "extract-i18n": {}
  }
}
```

--------------------------------

### Install AWS CLI with Pre-Built Step

Source: https://nx.dev/docs/kb/launch-template-examples

Use the pre-built step to install the AWS CLI in your launch template. It simplifies setup and provides debugging checks to ensure the AWS CLI is properly authenticated to AWS before continuing. Recommended for most use cases.

```yaml
// ./nx/workflows/agents.yaml
launch-templates:
  my-linux-medium-js:
    resource-class: 'docker_linux_amd64/medium'
    image: 'ubuntu22.04-node24.14-v1'
    init-steps:
      - name: Install AWS CLI
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-aws-cli/main.yaml'
        # no additional inputs required, as all configuration is via environment variables via nx-agents.with-env-vars
```

--------------------------------

### Clone and run the demo

Source: https://nx.dev/docs/kb/vite-module-federation

Clones the demo repository, installs dependencies, and runs the preview command.

```shell
git clone https://github.com/gioboa/react-nx-microfrontend-demo
cd react-nx-microfrontend-demo
pnpm install
pnpm run preview
```

--------------------------------

### Install Node with mise in Nx Agents launch template

Source: https://nx.dev/docs/kb/launch-template-examples

Uses the mise step to install a specific Node version (node=22) in the Nx Agents launch template. The step reads a mise.toml file if present, otherwise the inline tools are used. This example shows the full init-steps sequence including checkout and installing node modules.

```yaml
// .nx/workflows/agents.yaml
launch-templates:
  node-22:
    resource-class: 'docker_linux_amd64/medium'
    image: 'ubuntu22.04-node24.14-v1'
    init-steps:
      - name: Checkout
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/checkout/main.yaml'
      - name: Install mise
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-mise/main.yaml'
        inputs:
          # you can also define a mise.toml in your repo instead of inline tools
          tools: |
            node=22
      - name: Install Node Modules
        uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-node-modules/main.yaml'
```

--------------------------------

### Create a simple application

Source: https://nx.dev/docs/reference/web/generators

Creates an application named `my-app` using the default bundler (vite) and compiler (swc).

```bash
nx g @nx/web:application apps/my-app

```

--------------------------------

### Clone the sample Gradle tutorial repository

Source: https://nx.dev/docs/kb/gradle-tutorial

Clone the forked sample repository to your local machine. Replace <your-username> with your GitHub username.

```shell
git clone https://github.com/<your-username>/gradle-tutorial.git
```

--------------------------------

### Start Metro server with nx start

Source: https://nx.dev/docs/technologies/react/react-native/introduction

Starts the server that communicates with connected devices. Replace <your-app-name> with the app name.

```bash
nx start <your-app-name>

```

--------------------------------

### Comma delimited globs in assignment rules YAML

Source: https://nx.dev/docs/kb/assignment-rules

Defines an assignment rule where each list entry can contain comma-separated globs that must all match. The example matches targets starting with 'e2e-ci' and ending with 'server-test', or starting with 'lint'. Runs on a linux-large agent with parallelism of 5.

```yaml
// .nx/workflows/assignment-rules.yaml
assignment-rules:
  - targets:
      - 'e2e-ci*,*server-test'
      - 'lint*'
    run-on:
      - agent: linux-large
        parallelism: 5

```

--------------------------------

### Migrate @nx/workspace with --from flag

Source: https://nx.dev/docs/reference/nx-commands

Updates @nx/workspace and generates the list of migrations starting from version 8.0.0 of @nx/workspace and @nx/node, regardless of what is installed locally.

```bash
nx migrate @nx/workspace@9.0.0 --from="@nx/workspace@8.0.0,@nx/node@8.0.0"
```

--------------------------------

### Initial project.json for lib1, lib2, lib3

Source: https://nx.dev/docs/kb/reduce-repetitive-configuration

Initial project.json files for three libraries (lib1, lib2, lib3) showing repetitive configuration. Differences: lib1 has extra assets for build, lib2 has testTimeout for test.

```json
// libs/lib1/project.json
{
  "name": "lib1",
  "$schema": "../../node_modules/nx/schemas/project-schema.json",
  "sourceRoot": "libs/lib1/src",
  "projectType": "library",
  "targets": {
    "build": {
      "executor": "@nx/js:tsc",
      "outputs": ["{options.outputPath}"],
      "options": {
        "outputPath": "dist/libs/lib1",
        "main": "libs/lib1/src/index.ts",
        "tsConfig": "libs/lib1/tsconfig.lib.json",
        "assets": ["libs/lib1/*.md", "libs/lib1/src/images/*"]
      }
    },
    "lint": {
      "executor": "@nx/eslint:lint",
      "outputs": ["{options.outputFile}"],
      "options": {
        "lintFilePatterns": ["libs/lib1/**/*.ts"]
      }
    },
    "test": {
      "executor": "@nx/jest:jest",
      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
      "options": {
        "jestConfig": "libs/lib1/jest.config.ts",
        "passWithNoTests": true
      },
      "configurations": {
        "ci": {
          "ci": true,
          "codeCoverage": true
        }
      }
    }
  },
  "tags": []
}
```

```json
// libs/lib2/project.json
{
  "name": "lib2",
  "$schema": "../../node_modules/nx/schemas/project-schema.json",
  "sourceRoot": "libs/lib2/src",
  "projectType": "library",
  "targets": {
    "build": {
      "executor": "@nx/js:tsc",
      "outputs": ["{options.outputPath}"],
      "options": {
        "outputPath": "dist/libs/lib2",
        "main": "libs/lib2/src/index.ts",
        "tsConfig": "libs/lib2/tsconfig.lib.json",
        "assets": ["libs/lib2/*.md"]
      }
    },
    "lint": {
      "executor": "@nx/eslint:lint",
      "outputs": ["{options.outputFile}"],
      "options": {
        "lintFilePatterns": ["libs/lib2/**/*.ts"]
      }
    },
    "test": {
      "executor": "@nx/jest:jest",
      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
      "options": {
        "jestConfig": "libs/lib2/jest.config.ts",
        "passWithNoTests": true,
        "testTimeout": 10000
      },
      "configurations": {
        "ci": {
          "ci": true,
          "codeCoverage": true
        }
      }
    }
  },
  "tags": []
}
```

```json
// libs/lib3/project.json
{
  "name": "lib3",
  "$schema": "../../node_modules/nx/schemas/project-schema.json",
  "sourceRoot": "libs/lib3/src",
  "projectType": "library",
  "targets": {
    "build": {
      "executor": "@nx/js:tsc",
      "outputs": ["{options.outputPath}"],
      "options": {
        "outputPath": "dist/libs/lib3",
        "main": "libs/lib3/src/index.ts",
        "tsConfig": "libs/lib3/tsconfig.lib.json",
        "assets": ["libs/lib3/*.md"]
      }
    },
    "lint": {
      "executor": "@nx/eslint:lint",
      "outputs": ["{options.outputFile}"],
      "options": {
        "lintFilePatterns": ["libs/lib3/**/*.ts"]
      }
    },
    "test": {
      "executor": "@nx/jest:jest",
      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
      "options": {
        "jestConfig": "libs/lib3/jest.config.ts",
        "passWithNoTests": true
      },
      "configurations": {
        "ci": {
          "ci": true,
          "codeCoverage": true
        }
      }
    }
  },
  "tags": []
}
```

--------------------------------

### Update snapshot guide link in .snap file

Source: https://nx.dev/docs/technologies/test-tools/jest/migrations

Shows the required change in a .snap file: the legacy snapshot guide link is replaced with the new Jest v30 URL. The before version uses https://goo.gl/fbAQLP, which Jest v30 rejects at test setup time; the after version uses https://jestjs.io/docs/snapshot-testing.

```text
// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`renders correctly 1`] = `"hello"`;
```

```text
// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing

exports[`renders correctly 1`] = `"hello"`;
```

--------------------------------

### Show project configuration

Source: https://nx.dev/docs/kb/sandboxing

Run `nx show project` to get a broader view of the full project configuration.

```shell
nx show project <project>
```

--------------------------------

### Define parallel step group in launch-templates

Source: https://nx.dev/docs/kb/launch-templates

Defines a launch template with a parallel step group (Install Dependencies) that runs Rust, NPM, Poetry, and Localstack installs concurrently, followed by sequential Playwright and service startup steps. The parallel group writes CARGO_PATH and POETRY_PATH to $NX_CLOUD_ENV, and the final Start services step writes the combined PATH once to avoid overwrites. Playwright runs after the group because it shares NPM and filesystem resources with npm install.

```yaml
// .nx/workflows/agents.yaml
launch-templates:
  template-one:
    init-steps:
      - group-name: Install Dependencies
        parallel: true
        # all the below steps will start at the same time and run in parallel
        steps:
          - name: Install Rust
            script: |
              curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh -s -- -y
              source "~/workspace/.cargo/env"
              # we write the CARGO_PATH now so that it can be set in the "Start Services" step below
              echo "CARGO_PATH=~/workspace/.cargo/bin" >> $NX_CLOUD_ENV
              rustc --version
              rustup target add wasm32-wasip1-threads
              cargo fetch
              cargo check --locked
          - name: NPM Install
            uses: 'nrwl/nx-cloud-workflows/main/workflow-steps/install-node-modules/main.yaml'
          - name: Install Poetry
            script: |
              curl -sSL https://install.python-poetry.org | python3 -
              # we write the POETRY_PATH now so that it can be set in the "Start Services" step below
              export POETRY_PATH="/home/workflows/.local/bin"
              export PATH="$POETRY_PATH:$PATH"
              echo "POETRY_PATH=$POETRY_PATH" >> $NX_CLOUD_ENV
              poetry --version
              poetry install
          - name: Install Localstack
            script: |
              curl --output localstack-cli-3.7.0-linux-amd64-onefile.tar.gz --location https://github.com/localstack/localstack-cli/releases/download/v3.7.0/localstack-cli-3.7.0-linux-amd64-onefile.tar.gz
              sudo tar xvzf localstack-cli-3.7.0-linux-*-onefile.tar.gz -C /usr/local/bin
      # because both playwright and "npm install" use NPM and write to a lot of the same places on the filesystem, it would be slower to run them both in parallel
      # so we run playwright after the parallel group above
      - name: Install Playwright
        script: npx playwright install --with-deps
      - name: Start services
        script: |
          # we create the PATH here
          echo "PATH=$CARGO_PATH:$POETRY_PATH:$PATH" >> $NX_CLOUD_ENV
          npm run start-docker-services
```

--------------------------------

### Migrate from nx@14.5.0 excluding applied migrations

Source: https://nx.dev/docs/reference/nx-commands

Collects package updates and migrations starting with version 14.5.0 of 'nx' (and Nx first-party plugins), regardless of what is installed locally, while excluding migrations that should have been applied on previous updates.

```bash
nx migrate latest --from=nx@14.5.0 --exclude-applied-migrations
```

--------------------------------

### GitHub Actions pipeline with assignment rules

Source: https://nx.dev/docs/kb/assignment-rules

Example GitHub Actions workflow that starts Nx Agents with different launch templates. The NX_AGENT_LAUNCH_TEMPLATE value must match one of the 'run-on' values defined in the assignment rules.

```yaml
// .github/workflows/ci.yaml
---
jobs:
  main:
    name: Main Job
    runs-on: ubuntu-latest
    steps:
      - ... # setup steps for your main job

      - run: npx nx start-nx-agents

      - ... # Nx commands you want to distribute

  medium-agents:
    name: Agents ${{ matrix.agent }}
    runs-on:
      group: medium-agents
    strategy:
      matrix:
        agent: [1, 2, 3]
    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: 'npm'

      - ... # other setup steps you may need

      - name: Install dependencies
        run: npm ci

      - name: Start Agent ${{ matrix.agent }}
        run: npx nx start-agent
        env:
          NX_AGENT_NAME: ${{ matrix.agent }}
          NX_AGENT_LAUNCH_TEMPLATE: 'linux-medium' # This value needs to match one of the 'run-on' values defined in the assignment rules

  large-agents:
    name: Agents ${{ matrix.agent }}
    runs-on:
      group: large-agents
    strategy:
      matrix:
        agent: [4, 5, 6]

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: 'npm'

      - ... # other setup steps you may need

      - name: Install dependencies
        run: npm ci

      - name: Start Agent ${{ matrix.agent }}
        run: npx nx start-agent
        env:
          NX_AGENT_NAME: ${{ matrix.agent }}
          NX_AGENT_LAUNCH_TEMPLATE: 'linux-large' # This value needs to match one of the 'run-on' values defined in the assignment rules
```

--------------------------------

### Render example video

Source: https://nx.dev/docs/templates/remotion

Renders the example video as an Nx task. The output is cached and can be distributed with Nx Cloud.

```bash
npx nx run video:render
```

--------------------------------

### Git log output with default commit prefix

Source: https://nx.dev/docs/guides/tips-n-tricks/advanced-update

Example output of `git log` after running `nx migrate --run-migrations --create-commits`. Each migration gets a commit with the default prefix `chore: [nx migration] `.

```text
git log

commit 8c862c780106ab8736985c01de1477309a403548
Author: YOUR_GIT_USERNAME <your_git_email@example.com>
Date:   Thu Apr 14 18:35:44 2022 +0400

    chore: [nx migration] name-of-the-second-migration-which-ran

commit eb83bca97927af26aae731a2cf51ad62cc75efa3
Author: YOUR_GIT_USERNAME <your_git_email@example.com>
Date:   Thu Apr 14 18:35:44 2022 +0400

    chore: [nx migration] name-of-the-first-migration-which-ran

etc
```

--------------------------------

### Install @nx/plugin and generate plugin

Source: https://nx.dev/docs/kb/organization-specific-plugin

Installs the @nx/plugin package and generates a plugin project named 'recommended' in the tools/recommended directory.

```shell
npx nx add @nx/plugin
npx nx g @nx/plugin:plugin tools/recommended
```
Tokens:
Raw