nx 21.0.0-beta.1 → 21.0.0-beta.10

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

@@ -1,38 +1,43 @@
 import { Serializable } from 'child_process';
-import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
 import { ExecutorContext } from '../../config/misc-interfaces';
+import { PseudoTtyProcess } from '../../tasks-runner/pseudo-terminal';
+import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
 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;
+    private outputCallbacks;
     constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
     }>;
+    onOutput(cb: (terminalOutput: string) => void): void;
     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 readonly tuiEnabled;
     private terminalOutput;
     private currentProcess;
     private exitCallbacks;
     private code;
     private error;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, pseudoTerminal?: PseudoTerminal);
+    private outputCallbacks;
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
     }>;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
+    onOutput(cb: (terminalOutput: string) => void): void;
     send(message: Serializable): void;
     kill(signal?: NodeJS.Signals | number): void | Promise<void>;
     private run;
     private createProcess;
 }
+export declare function runSingleCommandWithPseudoTerminal(normalized: NormalizedRunCommandsOptions, context: ExecutorContext): Promise<PseudoTtyProcess>;

package/src/executors/run-commands/running-tasks.js

@@ -1,16 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SeriallyRunningTasks = exports.ParallelRunningTasks = void 0;
-const child_process_1 = require("child_process");
-const run_commands_impl_1 = require("./run-commands.impl");
-const path_1 = require("path");
+exports.runSingleCommandWithPseudoTerminal = runSingleCommandWithPseudoTerminal;
 const chalk = require("chalk");
+const child_process_1 = require("child_process");
 const npm_run_path_1 = require("npm-run-path");
-const task_env_1 = require("../../tasks-runner/task-env");
+const path_1 = require("path");
 const treeKill = require("tree-kill");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const task_env_1 = require("../../tasks-runner/task-env");
+const exit_codes_1 = require("../../utils/exit-codes");
+const run_commands_impl_1 = require("./run-commands.impl");
 class ParallelRunningTasks {
     constructor(options, context) {
         this.exitCallbacks = [];
+        this.outputCallbacks = [];
         this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile));
         this.readyWhenStatus = options.readyWhenStatus;
         this.streamOutput = options.streamOutput;
@@ -23,6 +27,9 @@ class ParallelRunningTasks {
             });
         });
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
@@ -44,6 +51,11 @@ class ParallelRunningTasks {
     async run() {
         if (this.readyWhenStatus.length) {
             let { childProcess, result: { code, terminalOutput }, } = await Promise.race(this.childProcesses.map((childProcess) => new Promise((res) => {
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
                 childProcess.onExit((code, terminalOutput) => {
                     res({
                         childProcess,
@@ -63,10 +75,18 @@ class ParallelRunningTasks {
             }
         }
         else {
-            const results = await Promise.all(this.childProcesses.map((childProcess) => childProcess.getResults().then((result) => ({
-                childProcess,
-                result,
-            }))));
+            const results = await Promise.all(this.childProcesses.map(async (childProcess) => {
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
+                const result = await childProcess.getResults();
+                return {
+                    childProcess,
+                    result,
+                };
+            }));
             let terminalOutput = results
                 .map((r) => r.result.terminalOutput)
                 .join('\r\n');
@@ -93,12 +113,13 @@ class ParallelRunningTasks {
 }
 exports.ParallelRunningTasks = ParallelRunningTasks;
 class SeriallyRunningTasks {
-    constructor(options, context, pseudoTerminal) {
-        this.pseudoTerminal = pseudoTerminal;
+    constructor(options, context, tuiEnabled) {
+        this.tuiEnabled = tuiEnabled;
         this.terminalOutput = '';
         this.currentProcess = null;
         this.exitCallbacks = [];
         this.code = 0;
+        this.outputCallbacks = [];
         this.run(options, context)
             .catch((e) => {
             this.error = e;
@@ -124,6 +145,9 @@ class SeriallyRunningTasks {
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     send(message) {
         throw new Error('Not implemented');
     }
@@ -132,8 +156,13 @@ class SeriallyRunningTasks {
     }
     async run(options, context) {
         for (const c of options.commands) {
-            const childProcess = await this.createProcess(c, [], options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, false, options.usePty, options.streamOutput, options.tty, options.envFile);
+            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, options.usePty, options.streamOutput, options.tty, options.envFile);
             this.currentProcess = childProcess;
+            childProcess.onOutput((output) => {
+                for (const cb of this.outputCallbacks) {
+                    cb(output);
+                }
+            });
             let { code, terminalOutput } = await childProcess.getResults();
             this.terminalOutput += terminalOutput;
             this.code = code;
@@ -149,18 +178,18 @@ class SeriallyRunningTasks {
             }
         }
     }
-    async createProcess(commandConfig, readyWhenStatus = [], color, cwd, env, isParallel, usePty = true, streamOutput = true, tty, envFile) {
+    async createProcess(commandConfig, color, cwd, env, usePty = true, streamOutput = true, tty, 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 (this.pseudoTerminal &&
-            process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+        if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
             !commandConfig.prefix &&
-            readyWhenStatus.length === 0 &&
-            !isParallel &&
-            usePty) {
-            return createProcessWithPseudoTty(this.pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile);
+            usePty &&
+            pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+            registerProcessListener(this, pseudoTerminal);
+            return createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile);
         }
-        return new RunningNodeProcess(commandConfig, color, cwd, env, readyWhenStatus, streamOutput, envFile);
+        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile);
     }
 }
 exports.SeriallyRunningTasks = SeriallyRunningTasks;
@@ -169,6 +198,7 @@ class RunningNodeProcess {
         this.readyWhenStatus = readyWhenStatus;
         this.terminalOutput = '';
         this.exitCallbacks = [];
+        this.outputCallbacks = [];
         env = processEnv(color, cwd, env, envFile);
         this.command = commandConfig.command;
         this.terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
@@ -190,6 +220,9 @@ class RunningNodeProcess {
             });
         });
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
@@ -208,10 +241,16 @@ class RunningNodeProcess {
             });
         });
     }
+    triggerOutputListeners(output) {
+        for (const cb of this.outputCallbacks) {
+            cb(output);
+        }
+    }
     addListeners(commandConfig, streamOutput) {
         this.childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             this.terminalOutput += output;
+            this.triggerOutputListeners(output);
             if (streamOutput) {
                 process.stdout.write(output);
             }
@@ -225,6 +264,7 @@ class RunningNodeProcess {
         this.childProcess.stderr.on('data', (err) => {
             const output = addColorAndPrefix(err, commandConfig);
             this.terminalOutput += output;
+            this.triggerOutputListeners(output);
             if (streamOutput) {
                 process.stderr.write(output);
             }
@@ -254,22 +294,19 @@ class RunningNodeProcess {
         });
     }
 }
+async function runSingleCommandWithPseudoTerminal(normalized, context) {
+    const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+    const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, normalized.commands[0], normalized.color, calculateCwd(normalized.cwd, context), normalized.env, normalized.streamOutput, pseudoTerminal ? normalized.isTTY : false, normalized.envFile);
+    registerProcessListener(pseudoTtyProcess, pseudoTerminal);
+    return pseudoTtyProcess;
+}
 async function createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput = true, tty, envFile) {
-    let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
-    if (streamOutput) {
-        process.stdout.write(terminalOutput);
-    }
-    env = processEnv(color, cwd, env, envFile);
-    const childProcess = pseudoTerminal.runCommand(commandConfig.command, {
+    return pseudoTerminal.runCommand(commandConfig.command, {
         cwd,
-        jsEnv: env,
+        jsEnv: processEnv(color, cwd, env, envFile),
         quiet: !streamOutput,
         tty,
     });
-    childProcess.onOutput((output) => {
-        terminalOutput += output;
-    });
-    return childProcess;
 }
 function addColorAndPrefix(out, config) {
     if (config.prefix) {
@@ -347,3 +384,39 @@ function loadEnvVarsFile(path, env = {}) {
         throw result.error;
     }
 }
+let registered = false;
+function registerProcessListener(runningTask, pseudoTerminal) {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    // When the nx process gets a message, it will be sent into the task's process
+    process.on('message', (message) => {
+        // this.publisher.publish(message.toString());
+        if (pseudoTerminal) {
+            pseudoTerminal.sendMessageToChildren(message);
+        }
+        if ('send' in runningTask) {
+            runningTask.send(message);
+        }
+    });
+    // Terminate any task processes on exit
+    process.on('exit', () => {
+        runningTask.kill();
+    });
+    process.on('SIGINT', () => {
+        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', () => {
+        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', () => {
+        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
+    });
+}

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const path = require("path");
-const package_manager_1 = require("../../utils/package-manager");
 const child_process_1 = require("child_process");
+const path = require("path");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const package_manager_1 = require("../../utils/package-manager");
 async function default_1(options, context) {
     const pm = (0, package_manager_1.getPackageManagerCommand)();
     try {
@@ -39,7 +39,8 @@ function nodeProcess(command, cwd, env) {
     });
 }
 async function ptyProcess(command, cwd, env) {
-    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+    const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+    await terminal.init();
     return new Promise((res, rej) => {
         const cp = terminal.runCommand(command, { cwd, jsEnv: env });
         cp.onExit((code) => {

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatChangedFilesWithPrettierIfAvailable = formatChangedFilesWithPrettierIfAvailable;
 exports.formatFilesWithPrettierIfAvailable = formatFilesWithPrettierIfAvailable;
 const path = require("path");
+const is_using_prettier_1 = require("../../utils/is-using-prettier");
 /**
  * Formats all the created or updated files using Prettier
  * @param tree - the file system tree
@@ -19,6 +20,13 @@ async function formatFilesWithPrettierIfAvailable(files, root, options) {
     let prettier;
     try {
         prettier = await Promise.resolve().then(() => require('prettier'));
+        /**
+         * Even after we discovered prettier in node_modules, we need to be sure that the user is intentionally using prettier
+         * before proceeding to format with it.
+         */
+        if (!(0, is_using_prettier_1.isUsingPrettier)(root)) {
+            return results;
+        }
     }
     catch { }
     if (!prettier) {

package/src/generators/testing-utils/create-tree.js

@@ -6,5 +6,9 @@ const tree_1 = require("../tree");
  * Creates a host for testing.
  */
 function createTree() {
-    return new tree_1.FsTree('/virtual', false);
+    const tree = new tree_1.FsTree('/virtual', false);
+    // Allow prettier formatting to be applied to the tree for backwards compatibility within v20
+    // TODO: Decouple formatFiles and other formatting utilities from prettier to avoid this
+    tree.write('.prettierrc', '{}');
+    return tree;
 }

package/src/migrations/{update-17-0-0/rm-default-collection-npm-scope.d.ts → update-21-0-0/release-version-config-changes.d.ts}

@@ -1,2 +1,2 @@
-import { Tree } from '../../generators/tree';
+import type { Tree } from '../../generators/tree';
 export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-21-0-0/release-version-config-changes.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const node_path_1 = require("node:path");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const json_1 = require("../../generators/utils/json");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+async function update(tree) {
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    if (!nxJson) {
+        return;
+    }
+    // If the user has explicitly set the useLegacyVersioning property to true, do nothing
+    if (nxJson.release?.version?.useLegacyVersioning === true) {
+        return;
+    }
+    function updateProperties(versionConfig) {
+        // If the user is using a generator other than the @nx/js one, set useLegacyVersioning to true and nothing else
+        if ('generator' in versionConfig &&
+            versionConfig.generator !== '@nx/js:release-version') {
+            versionConfig.useLegacyVersioning =
+                true;
+            return;
+        }
+        // These options used to live inside of generatorOptions, but are now like for like top-level nx core options
+        const coreOptionsToPromoteToTopLevel = [
+            'specifierSource',
+            'currentVersionResolver',
+            'currentVersionResolverMetadata',
+            'fallbackCurrentVersionResolver',
+            'versionPrefix',
+            'updateDependents',
+            'logUnchangedProjects',
+        ];
+        if ('generatorOptions' in versionConfig) {
+            for (const option of coreOptionsToPromoteToTopLevel) {
+                if (versionConfig.generatorOptions[option]) {
+                    versionConfig[option] = versionConfig.generatorOptions[option];
+                }
+            }
+            // preserveLocalDependencyProtocols has changed to true by default, so remove it if explicitly true, otherwise set to false explicitly
+            if (versionConfig.generatorOptions.preserveLocalDependencyProtocols) {
+                delete versionConfig.generatorOptions.preserveLocalDependencyProtocols;
+            }
+            else {
+                versionConfig.preserveLocalDependencyProtocols = false;
+            }
+            // packageRoot has been replaced by manifestRootsToUpdate
+            if (typeof versionConfig.generatorOptions.packageRoot === 'string') {
+                versionConfig.manifestRootsToUpdate =
+                    [versionConfig.generatorOptions.packageRoot];
+                delete versionConfig.generatorOptions.packageRoot;
+            }
+            // These options have been moved to versionActionsOptions
+            const versionActionsOptions = [
+                'skipLockFileUpdate',
+                'installArgs',
+                'installIgnoreScripts',
+            ];
+            for (const option of versionActionsOptions) {
+                if (versionConfig.generatorOptions[option]) {
+                    versionConfig.versionActionsOptions =
+                        versionConfig
+                            .versionActionsOptions || {};
+                    versionConfig.versionActionsOptions[option] =
+                        versionConfig.generatorOptions[option];
+                    delete versionConfig.generatorOptions[option];
+                }
+            }
+            delete versionConfig.generatorOptions;
+        }
+    }
+    // nx.json
+    if (nxJson.release) {
+        // Top level version config
+        if (nxJson.release.version) {
+            updateProperties(nxJson.release.version);
+        }
+        // Version config for each group
+        if (nxJson.release.groups) {
+            for (const group of Object.values(nxJson.release.groups)) {
+                if (group.version) {
+                    updateProperties(group.version);
+                }
+            }
+        }
+    }
+    // project.json or package.json
+    const projects = (0, project_configuration_1.getProjects)(tree);
+    for (const project of projects.values()) {
+        const projectJsonPath = (0, node_path_1.join)(project.root, 'project.json');
+        if (tree.exists(projectJsonPath)) {
+            const projectJson = (0, json_1.readJson)(tree, projectJsonPath);
+            if (projectJson.release?.version) {
+                updateProperties(projectJson.release.version);
+                (0, json_1.writeJson)(tree, projectJsonPath, projectJson);
+            }
+        }
+        const packageJsonPath = (0, node_path_1.join)(project.root, 'package.json');
+        if (tree.exists(packageJsonPath)) {
+            const packageJson = (0, json_1.readJson)(tree, packageJsonPath);
+            if (packageJson.nx?.release?.version) {
+                updateProperties(packageJson.nx.release.version);
+                (0, json_1.writeJson)(tree, packageJsonPath, packageJson);
+            }
+        }
+    }
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}