nx 20.5.0-canary.20250204-bc4ded0 → 21.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.5.0-canary.20250204-bc4ded0",
+  "version": "21.0.0-beta.0",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -63,6 +63,7 @@
     "string-width": "^4.2.3",
     "tar-stream": "~2.2.0",
     "tmp": "~0.2.1",
+    "tree-kill": "^1.2.2",
     "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0",
     "yaml": "^2.6.0",
@@ -82,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-darwin-x64": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-freebsd-x64": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-linux-arm-gnueabihf": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-linux-arm64-gnu": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-linux-arm64-musl": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-linux-x64-gnu": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-linux-x64-musl": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-win32-arm64-msvc": "20.5.0-canary.20250204-bc4ded0",
-    "@nx/nx-win32-x64-msvc": "20.5.0-canary.20250204-bc4ded0"
+    "@nx/nx-darwin-arm64": "21.0.0-beta.0",
+    "@nx/nx-darwin-x64": "21.0.0-beta.0",
+    "@nx/nx-freebsd-x64": "21.0.0-beta.0",
+    "@nx/nx-linux-arm-gnueabihf": "21.0.0-beta.0",
+    "@nx/nx-linux-arm64-gnu": "21.0.0-beta.0",
+    "@nx/nx-linux-arm64-musl": "21.0.0-beta.0",
+    "@nx/nx-linux-x64-gnu": "21.0.0-beta.0",
+    "@nx/nx-linux-x64-musl": "21.0.0-beta.0",
+    "@nx/nx-win32-arm64-msvc": "21.0.0-beta.0",
+    "@nx/nx-win32-x64-msvc": "21.0.0-beta.0"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/graph/graph.js

@@ -629,6 +629,7 @@ function getAllTaskGraphsForWorkspace(projectGraph) {
                 taskGraphs[taskId] = {
                     tasks: {},
                     dependencies: {},
+                    continuousDependencies: {},
                     roots: [],
                 };
                 taskGraphErrors[taskId] = err.message;
@@ -644,6 +645,7 @@ function getAllTaskGraphsForWorkspace(projectGraph) {
                         taskGraphs[taskId] = {
                             tasks: {},
                             dependencies: {},
+                            continuousDependencies: {},
                             roots: [],
                         };
                         taskGraphErrors[taskId] = err.message;

package/src/commands-runner/get-command-projects.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCommandProjects = getCommandProjects;
-const utils_1 = require("../tasks-runner/utils");
 const create_command_graph_1 = require("./create-command-graph");
 function getCommandProjects(projectGraph, projects, nxArgs) {
     const commandGraph = (0, create_command_graph_1.createCommandGraph)(projectGraph, projects.map((project) => project.name), nxArgs);
@@ -13,6 +12,22 @@ function getSortedProjects(commandGraph, sortedProjects = []) {
         return sortedProjects;
     }
     sortedProjects.push(...roots);
-    const newGraph = (0, utils_1.removeIdsFromGraph)(commandGraph, roots, commandGraph.dependencies);
+    const newGraph = removeIdsFromGraph(commandGraph, roots, commandGraph.dependencies);
     return getSortedProjects(newGraph, sortedProjects);
 }
+function removeIdsFromGraph(graph, ids, mapWithIds) {
+    const filteredMapWithIds = {};
+    const dependencies = {};
+    const removedSet = new Set(ids);
+    for (let id of Object.keys(mapWithIds)) {
+        if (!removedSet.has(id)) {
+            filteredMapWithIds[id] = mapWithIds[id];
+            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
+        }
+    }
+    return {
+        mapWithIds: filteredMapWithIds,
+        dependencies: dependencies,
+        roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
+    };
+}

package/src/config/task-graph.d.ts

@@ -84,6 +84,10 @@ export interface Task {
      * Determines if a given task should be parallelizable.
      */
     parallelism: boolean;
+    /**
+     * This denotes if the task runs continuously
+     */
+    continuous?: boolean;
 }
 /**
  * Graph of Tasks to be executed
@@ -101,4 +105,5 @@ export interface TaskGraph {
      * Map of Task IDs to IDs of tasks which the task depends on
      */
     dependencies: Record<string, string[]>;
+    continuousDependencies: Record<string, string[]>;
 }

package/src/config/workspace-json-project-json.d.ts

@@ -238,6 +238,10 @@ export interface TargetConfiguration<T = any> {
      * Default is true
      */
     parallelism?: boolean;
+    /**
+     * Whether this target runs continuously
+     */
+    continuous?: boolean;
     /**
      * List of generators to run before the target to ensure the workspace
      * is up to date.

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -1,23 +1,25 @@
 import { ExecutorContext } from '../../config/misc-interfaces';
+import { ParallelRunningTasks, SeriallyRunningTasks } from './running-tasks';
 export declare const LARGE_BUFFER: number;
 export type Json = {
     [k: string]: any;
 };
+export interface RunCommandsCommandOptions {
+    command: string;
+    forwardAllArgs?: boolean;
+    /**
+     * description was added to allow users to document their commands inline,
+     * it is not intended to be used as part of the execution of the command.
+     */
+    description?: string;
+    prefix?: string;
+    prefixColor?: string;
+    color?: string;
+    bgColor?: string;
+}
 export interface RunCommandsOptions extends Json {
     command?: string | string[];
-    commands?: ({
-        command: string;
-        forwardAllArgs?: boolean;
-        /**
-         * description was added to allow users to document their commands inline,
-         * it is not intended to be used as part of the execution of the command.
-         */
-        description?: string;
-        prefix?: string;
-        prefixColor?: string;
-        color?: string;
-        bgColor?: string;
-    } | string)[];
+    commands?: Array<RunCommandsCommandOptions | string>;
     color?: boolean;
     parallel?: boolean;
     readyWhen?: string | string[];
@@ -55,4 +57,5 @@ export default function (options: RunCommandsOptions, context: ExecutorContext):
     success: boolean;
     terminalOutput: string;
 }>;
+export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext): Promise<ParallelRunningTasks | SeriallyRunningTasks>;
 export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;

package/src/executors/run-commands/run-commands.impl.js

@@ -2,25 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LARGE_BUFFER = void 0;
 exports.default = default_1;
+exports.runCommands = runCommands;
 exports.interpolateArgsIntoCommand = interpolateArgsIntoCommand;
-const child_process_1 = require("child_process");
-const path = require("path");
 const yargsParser = require("yargs-parser");
-const npm_run_path_1 = require("npm-run-path");
-const chalk = require("chalk");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const exit_codes_1 = require("../../utils/exit-codes");
-const task_env_1 = require("../../tasks-runner/task-env");
+const running_tasks_1 = require("./running-tasks");
 exports.LARGE_BUFFER = 1024 * 1000000;
-let pseudoTerminal;
-const childProcesses = new Set();
-function loadEnvVarsFile(path, env = {}) {
-    (0, task_env_1.unloadDotEnvFile)(path, env);
-    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
-    if (result.error) {
-        throw result.error;
-    }
-}
 const propKeys = [
     'command',
     'commands',
@@ -41,7 +29,14 @@ const propKeys = [
     'tty',
 ];
 async function default_1(options, context) {
-    registerProcessListener();
+    const task = await runCommands(options, context);
+    const results = await task.getResults();
+    return {
+        ...results,
+        success: results.code === 0,
+    };
+}
+async function runCommands(options, context) {
     const normalized = normalizeOptions(options);
     if (normalized.readyWhenStatus.length && !normalized.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
@@ -50,11 +45,15 @@ async function default_1(options, context) {
         !options.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "prefixColor", "color" and "bgColor" can only be set when "parallel=true".');
     }
+    const pseudoTerminal = !options.parallel && pseudo_terminal_1.PseudoTerminal.isSupported()
+        ? (0, pseudo_terminal_1.getPseudoTerminal)()
+        : null;
     try {
-        const result = options.parallel
-            ? await runInParallel(normalized, context)
-            : await runSerially(normalized, context);
-        return result;
+        const runningTask = options.parallel
+            ? new running_tasks_1.ParallelRunningTasks(normalized, context)
+            : new running_tasks_1.SeriallyRunningTasks(normalized, context, pseudoTerminal);
+        registerProcessListener(runningTask, pseudoTerminal);
+        return runningTask;
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
@@ -63,52 +62,6 @@ async function default_1(options, context) {
         throw new Error(`ERROR: Something went wrong in run-commands - ${e.message}`);
     }
 }
-async function runInParallel(options, context) {
-    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhenStatus, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput, options.tty, options.envFile).then((result) => ({
-        result,
-        command: c.command,
-    })));
-    let terminalOutput = '';
-    if (options.readyWhenStatus.length) {
-        const r = await Promise.race(procs);
-        terminalOutput += r.result.terminalOutput;
-        if (!r.result.success) {
-            const output = `Warning: command "${r.command}" exited with non-zero status code`;
-            terminalOutput += output;
-            if (options.streamOutput) {
-                process.stderr.write(output);
-            }
-            return { success: false, terminalOutput };
-        }
-        else {
-            return { success: true, terminalOutput };
-        }
-    }
-    else {
-        const r = await Promise.all(procs);
-        terminalOutput += r.map((f) => f.result.terminalOutput).join('');
-        const failed = r.filter((v) => !v.result.success);
-        if (failed.length > 0) {
-            const output = failed
-                .map((f) => `Warning: command "${f.command}" exited with non-zero status code`)
-                .join('\r\n');
-            terminalOutput += output;
-            if (options.streamOutput) {
-                process.stderr.write(output);
-            }
-            return {
-                success: false,
-                terminalOutput,
-            };
-        }
-        else {
-            return {
-                success: true,
-                terminalOutput,
-            };
-        }
-    }
-}
 function normalizeOptions(options) {
     if (options.readyWhen && typeof options.readyWhen === 'string') {
         options.readyWhenStatus = [
@@ -156,167 +109,6 @@ function normalizeOptions(options) {
     });
     return options;
 }
-async function runSerially(options, context) {
-    pseudoTerminal ??= pseudo_terminal_1.PseudoTerminal.isSupported() ? (0, pseudo_terminal_1.getPseudoTerminal)() : null;
-    let terminalOutput = '';
-    for (const c of options.commands) {
-        const result = await createProcess(pseudoTerminal, c, [], options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, false, options.usePty, options.streamOutput, options.tty, options.envFile);
-        terminalOutput += result.terminalOutput;
-        if (!result.success) {
-            const output = `Warning: command "${c.command}" exited with non-zero status code`;
-            result.terminalOutput += output;
-            if (options.streamOutput) {
-                process.stderr.write(output);
-            }
-            return { success: false, terminalOutput };
-        }
-    }
-    return { success: true, terminalOutput };
-}
-async function createProcess(pseudoTerminal, commandConfig, readyWhenStatus = [], color, cwd, env, isParallel, usePty = true, streamOutput = true, tty, envFile) {
-    env = processEnv(color, cwd, env, envFile);
-    // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
-    // currently does not work properly in windows
-    if (pseudoTerminal &&
-        process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-        !commandConfig.prefix &&
-        readyWhenStatus.length === 0 &&
-        !isParallel &&
-        usePty) {
-        let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
-        if (streamOutput) {
-            process.stdout.write(terminalOutput);
-        }
-        const cp = pseudoTerminal.runCommand(commandConfig.command, {
-            cwd,
-            jsEnv: env,
-            quiet: !streamOutput,
-            tty,
-        });
-        childProcesses.add(cp);
-        return new Promise((res) => {
-            cp.onOutput((output) => {
-                terminalOutput += output;
-            });
-            cp.onExit((code) => {
-                if (code >= 128) {
-                    process.exit(code);
-                }
-                else {
-                    res({ success: code === 0, terminalOutput });
-                }
-            });
-        });
-    }
-    return nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput);
-}
-function nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput = true) {
-    let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
-    if (streamOutput) {
-        process.stdout.write(terminalOutput);
-    }
-    return new Promise((res) => {
-        const childProcess = (0, child_process_1.exec)(commandConfig.command, {
-            maxBuffer: exports.LARGE_BUFFER,
-            env,
-            cwd,
-            windowsHide: false,
-        });
-        childProcesses.add(childProcess);
-        childProcess.stdout.on('data', (data) => {
-            const output = addColorAndPrefix(data, commandConfig);
-            terminalOutput += output;
-            if (streamOutput) {
-                process.stdout.write(output);
-            }
-            if (readyWhenStatus.length && isReady(readyWhenStatus, data.toString())) {
-                res({ success: true, terminalOutput });
-            }
-        });
-        childProcess.stderr.on('data', (err) => {
-            const output = addColorAndPrefix(err, commandConfig);
-            terminalOutput += output;
-            if (streamOutput) {
-                process.stderr.write(output);
-            }
-            if (readyWhenStatus.length && isReady(readyWhenStatus, err.toString())) {
-                res({ success: true, terminalOutput });
-            }
-        });
-        childProcess.on('error', (err) => {
-            const ouptput = addColorAndPrefix(err.toString(), commandConfig);
-            terminalOutput += ouptput;
-            if (streamOutput) {
-                process.stderr.write(ouptput);
-            }
-            res({ success: false, terminalOutput });
-        });
-        childProcess.on('exit', (code) => {
-            childProcesses.delete(childProcess);
-            if (!readyWhenStatus.length || isReady(readyWhenStatus)) {
-                res({ success: code === 0, terminalOutput });
-            }
-        });
-    });
-}
-function addColorAndPrefix(out, config) {
-    if (config.prefix) {
-        out = out
-            .split('\n')
-            .map((l) => {
-            let prefixText = config.prefix;
-            if (config.prefixColor && chalk[config.prefixColor]) {
-                prefixText = chalk[config.prefixColor](prefixText);
-            }
-            prefixText = chalk.bold(prefixText);
-            return l.trim().length > 0 ? `${prefixText} ${l}` : l;
-        })
-            .join('\n');
-    }
-    if (config.color && chalk[config.color]) {
-        out = chalk[config.color](out);
-    }
-    if (config.bgColor && chalk[config.bgColor]) {
-        out = chalk[config.bgColor](out);
-    }
-    return out;
-}
-function calculateCwd(cwd, context) {
-    if (!cwd)
-        return context.root;
-    if (path.isAbsolute(cwd))
-        return cwd;
-    return path.join(context.root, cwd);
-}
-/**
- * Env variables are processed in the following order:
- * - env option from executor options
- * - env file from envFile option if provided
- * - local env variables
- */
-function processEnv(color, cwd, envOptionFromExecutor, envFile) {
-    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
-    localEnv = {
-        ...process.env,
-        ...localEnv,
-    };
-    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
-        loadEnvVarsFile(envFile, localEnv);
-    }
-    let res = {
-        ...localEnv,
-        ...envOptionFromExecutor,
-    };
-    // need to override PATH to make sure we are using the local node_modules
-    if (localEnv.PATH)
-        res.PATH = localEnv.PATH; // UNIX-like
-    if (localEnv.Path)
-        res.Path = localEnv.Path; // Windows
-    if (color) {
-        res.FORCE_COLOR = `${color}`;
-    }
-    return res;
-}
 function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
     if (command.indexOf('{args.') > -1) {
         const regex = /{args\.([^}]+)}/g;
@@ -404,7 +196,7 @@ function filterPropKeysFromUnParsedOptions(__unparsed__, parseArgs = {}) {
     return parsedOptions;
 }
 let registered = false;
-function registerProcessListener() {
+function registerProcessListener(runningTask, pseudoTerminal) {
     if (registered) {
         return;
     }
@@ -415,44 +207,24 @@ function registerProcessListener() {
         if (pseudoTerminal) {
             pseudoTerminal.sendMessageToChildren(message);
         }
-        childProcesses.forEach((p) => {
-            if ('connected' in p && p.connected) {
-                p.send(message);
-            }
-        });
+        runningTask.send(message);
     });
     // Terminate any task processes on exit
     process.on('exit', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill();
-            }
-        });
+        runningTask.kill();
     });
     process.on('SIGINT', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill('SIGTERM');
-            }
-        });
+        runningTask.kill('SIGTERM');
         // we exit here because we don't need to write anything to cache.
         process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
     });
     process.on('SIGTERM', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill('SIGTERM');
-            }
-        });
+        runningTask.kill('SIGTERM');
         // no exit here because we expect child processes to terminate which
         // will store results to the cache and will terminate this process
     });
     process.on('SIGHUP', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill('SIGTERM');
-            }
-        });
+        runningTask.kill('SIGTERM');
         // no exit here because we expect child processes to terminate which
         // will store results to the cache and will terminate this process
     });
@@ -474,14 +246,3 @@ function wrapArgIntoQuotesIfNeeded(arg) {
         return arg;
     }
 }
-function isReady(readyWhenStatus = [], data) {
-    if (data) {
-        for (const readyWhenElement of readyWhenStatus) {
-            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
-                readyWhenElement.found = true;
-                break;
-            }
-        }
-    }
-    return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
-}

package/src/executors/run-commands/running-tasks.d.ts

@@ -0,0 +1,38 @@
+import { Serializable } from 'child_process';
+import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
+import { ExecutorContext } from '../../config/misc-interfaces';
+import { NormalizedRunCommandsOptions } from './run-commands.impl';
+import { PseudoTerminal } from '../../tasks-runner/pseudo-terminal';
+export declare class ParallelRunningTasks implements RunningTask {
+    private readonly childProcesses;
+    private readyWhenStatus;
+    private readonly streamOutput;
+    private exitCallbacks;
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    onExit(cb: (code: number, terminalOutput: string) => void): void;
+    send(message: Serializable): void;
+    kill(signal?: NodeJS.Signals | number): Promise<void>;
+    private run;
+}
+export declare class SeriallyRunningTasks implements RunningTask {
+    private pseudoTerminal?;
+    private terminalOutput;
+    private currentProcess;
+    private exitCallbacks;
+    private code;
+    private error;
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, pseudoTerminal?: PseudoTerminal);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    onExit(cb: (code: number, terminalOutput: string) => void): void;
+    send(message: Serializable): void;
+    kill(signal?: NodeJS.Signals | number): void | Promise<void>;
+    private run;
+    private createProcess;
+}