Local Executors

Creating Executors for your workspace standardizes scripts that are run during your development/building/deploying tasks in order to provide guidance in the terminal with --help and when invoking with Nx Console

This guide shows you how to create, run, and customize executors within your Nx workspace. The examples use the trivial use-case of an echo command.

Creating an executor

If you don't already have a local plugin, use Nx to generate one:

❯

nx add @nx/plugin

❯

nx g @nx/plugin:plugin my-plugin

Use the Nx CLI to generate the initial files needed for your executor.

❯

nx generate @nx/plugin:executor echo --project=my-plugin

After the command is finished, the executor is created in the plugin executors folder.

happynrwl/
├── apps/
├── libs/
│   ├── my-plugin
│   │   ├── src
│   │   │   ├── executors
│   │   │   |   └── echo/
│   │   │   |   |    ├── executor.spec.ts
│   │   │   |   |    ├── executor.ts
│   │   │   |   |    ├── schema.d.ts
│   │   │   |   |    └── schema.json
├── nx.json
├── package.json
└── tsconfig.base.json

schema.json

This file describes the options being sent to the executor (very similar to the schema.json file of generators). Setting the cli property to nx indicates that you're using the Nx Devkit to make this executor.

{
  "$schema": "https://json-schema.org/schema",
  "type": "object",
  "properties": {
    "textToEcho": {
      "type": "string",
      "description": "Text To Echo"
    }
  }
}

This example describes a single option for the executor that is a string called textToEcho. When using this executor, specify a textToEcho property inside the options.

In our executor.ts file, we're creating an Options interface that matches the json object being described here.

executor.ts

The executor.ts contains the actual code for your executor. Your executor's implementation must export a function that takes an options object and returns a Promise<{ success: boolean }>.

import type { ExecutorContext } from '@nx/devkit';
import { exec } from 'child_process';
import { promisify } from 'util';

export interface EchoExecutorOptions {
  textToEcho: string;
}

export default async function echoExecutor(
  options: EchoExecutorOptions,
  context: ExecutorContext
): Promise<{ success: boolean }> {
  console.info(`Executing "echo"...`);
  console.info(`Options: ${JSON.stringify(options, null, 2)}`);

  const { stdout, stderr } = await promisify(exec)(
    `echo ${options.textToEcho}`
  );
  console.log(stdout);
  console.error(stderr);

  const success = !stderr;
  return { success };
}

Running your Executor

Our last step is to add this executor to a given project’s targets object in your project's project.json file:

project.json
{
  //...
  "targets": {
    "build": {
      // ...
    },
    "serve": {
      // ...
    },
    "lint": {
      // ,,,
    },
    "echo": {
      "executor": "@my-org/my-plugin:echo",
      "options": {
        "textToEcho": "Hello World"
      }
    }
  }
}

Finally, you run the executor via the CLI as follows:

❯

nx run my-project:echo

To which we'll see the console output:

~/workspace❯

nx run my-project:echo

1Executing "echo"...
2Options: {
3  "textToEcho": "Hello World"
4}
5Hello World
6

string

Nx uses the paths from tsconfig.base.json when running plugins locally, but uses the recommended tsconfig for node 16 for other compiler options. See https://github.com/tsconfig/bases/blob/main/bases/node16.json

Using Node Child Process

Node’s childProcess is often useful in executors.

Part of the power of the executor API is the ability to compose executors via existing targets. This way you can combine other executors from your workspace into one which could be helpful when the process you’re scripting is a combination of other existing executors provided by the CLI or other custom executors in your workspace.

Here's an example of this (from a hypothetical project), that serves an api (project name: "api") in watch mode, then serves a frontend app (project name: "web-client") in watch mode:

import { ExecutorContext, runExecutor } from '@nx/devkit';

export interface MultipleExecutorOptions {}

export default async function multipleExecutor(
  options: MultipleExecutorOptions,
  context: ExecutorContext
): Promise<{ success: boolean }> {
  const result = await Promise.race([
    await runExecutor(
      { project: 'api', target: 'serve' },
      { watch: true },
      context
    ),
    await runExecutor(
      { project: 'web-client', target: 'serve' },
      { watch: true },
      context
    ),
  ]);
  for await (const res of result) {
    if (!res.success) return res;
  }

  return { success: true };
}

For other ideas on how to create your own executors, you can always check out Nx's own open-source executors as well!

Example repository/nrwl/nx/blob/master/packages/cypress/src/executors/cypress/cypress.impl.ts