nx 18.1.1 → 18.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.1.1",
+  "version": "18.1.3",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -66,7 +66,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "18.1.1"
+    "@nrwl/tao": "18.1.3"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "18.1.1",
-    "@nx/nx-darwin-arm64": "18.1.1",
-    "@nx/nx-linux-x64-gnu": "18.1.1",
-    "@nx/nx-linux-x64-musl": "18.1.1",
-    "@nx/nx-win32-x64-msvc": "18.1.1",
-    "@nx/nx-linux-arm64-gnu": "18.1.1",
-    "@nx/nx-linux-arm64-musl": "18.1.1",
-    "@nx/nx-linux-arm-gnueabihf": "18.1.1",
-    "@nx/nx-win32-arm64-msvc": "18.1.1",
-    "@nx/nx-freebsd-x64": "18.1.1"
+    "@nx/nx-darwin-x64": "18.1.3",
+    "@nx/nx-darwin-arm64": "18.1.3",
+    "@nx/nx-linux-x64-gnu": "18.1.3",
+    "@nx/nx-linux-x64-musl": "18.1.3",
+    "@nx/nx-win32-x64-msvc": "18.1.3",
+    "@nx/nx-linux-arm64-gnu": "18.1.3",
+    "@nx/nx-linux-arm64-musl": "18.1.3",
+    "@nx/nx-linux-arm-gnueabihf": "18.1.3",
+    "@nx/nx-win32-arm64-msvc": "18.1.3",
+    "@nx/nx-freebsd-x64": "18.1.3"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -55,7 +55,7 @@ async function installPackage(pkgName, version) {
         nxJson.installation.plugins[pkgName] = version;
         (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
         try {
-            await (0, child_process_2.runNxAsync)('');
+            await (0, child_process_2.runNxAsync)('--help', { silent: true });
         }
         catch (e) {
             // revert adding the plugin to nx.json

package/src/command-line/init/init-v2.js

@@ -32,6 +32,12 @@ async function initHandler(options) {
             console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx.bat --help`');
         }
         (0, add_nx_scripts_1.generateDotNxSetup)(version);
+        const { plugins } = await detectPlugins();
+        plugins.forEach((plugin) => {
+            (0, child_process_2.execSync)(`./nx add ${plugin}`, {
+                stdio: 'inherit',
+            });
+        });
         // invokes the wrapper, thus invoking the initial installation process
         (0, child_process_1.runNxSync)('--version', { stdio: 'ignore' });
         return;
@@ -45,8 +51,8 @@ async function initHandler(options) {
         return;
     }
     output_1.output.log({ title: '🧐 Checking dependencies' });
-    const detectPluginsResponse = await detectPlugins();
-    if (!detectPluginsResponse?.plugins.length) {
+    const { plugins, updatePackageScripts } = await detectPlugins();
+    if (!plugins.length) {
         // If no plugins are detected/chosen, guide users to setup
         // their targetDefaults correctly so their package scripts will work.
         const packageJson = (0, fileutils_1.readJsonFile)('package.json');
@@ -66,19 +72,17 @@ async function initHandler(options) {
         const pmc = (0, package_manager_1.getPackageManagerCommand)();
         (0, utils_1.createNxJsonFile)(repoRoot, [], [], {});
         (0, utils_1.updateGitIgnore)(repoRoot);
-        (0, utils_1.addDepsToPackageJson)(repoRoot, detectPluginsResponse.plugins);
+        (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
         output_1.output.log({ title: '📦 Installing Nx' });
         (0, utils_1.runInstall)(repoRoot, pmc);
         output_1.output.log({ title: '🔨 Configuring plugins' });
-        for (const plugin of detectPluginsResponse.plugins) {
-            (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${detectPluginsResponse.updatePackageScripts
-                ? '--updatePackageScripts'
-                : ''} --no-interactive`, {
+        for (const plugin of plugins) {
+            (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${updatePackageScripts ? '--updatePackageScripts' : ''} --no-interactive`, {
                 stdio: [0, 1, 2],
                 cwd: repoRoot,
             });
         }
-        if (!detectPluginsResponse.updatePackageScripts) {
+        if (!updatePackageScripts) {
             const rootPackageJsonPath = (0, path_1.join)(repoRoot, 'package.json');
             const json = (0, fileutils_1.readJsonFile)(rootPackageJsonPath);
             json.nx = { includedScripts: [] };
@@ -146,9 +150,16 @@ async function detectPlugins() {
             }
         }
     }
+    if ((0, fs_1.existsSync)('gradlew') || (0, fs_1.existsSync)('gradlew.bat')) {
+        detectedPlugins.add('@nx/gradle');
+    }
     const plugins = Array.from(detectedPlugins);
-    if (plugins.length === 0)
-        return undefined;
+    if (plugins.length === 0) {
+        return {
+            plugins: [],
+            updatePackageScripts: false,
+        };
+    }
     output_1.output.log({
         title: `Recommended Plugins:`,
         bodyLines: [
@@ -165,25 +176,26 @@ async function detectPlugins() {
         },
     ]).then((r) => r.plugins);
     if (pluginsToInstall?.length === 0)
-        return undefined;
-    const updatePackageScripts = await (0, enquirer_1.prompt)([
-        {
-            name: 'updatePackageScripts',
-            type: 'autocomplete',
-            message: `Do you want to start using Nx in your package.json scripts?`,
-            choices: [
-                {
-                    name: 'Yes',
-                },
-                {
-                    name: 'No',
-                },
-            ],
-            initial: 0,
-        },
-    ]).then((r) => r.updatePackageScripts === 'Yes');
-    return {
-        plugins: pluginsToInstall,
-        updatePackageScripts,
-    };
+        return {
+            plugins: [],
+            updatePackageScripts: false,
+        };
+    const updatePackageScripts = (0, fs_1.existsSync)('package.json') &&
+        (await (0, enquirer_1.prompt)([
+            {
+                name: 'updatePackageScripts',
+                type: 'autocomplete',
+                message: `Do you want to start using Nx in your package.json scripts?`,
+                choices: [
+                    {
+                        name: 'Yes',
+                    },
+                    {
+                        name: 'No',
+                    },
+                ],
+                initial: 0,
+            },
+        ]).then((r) => r.updatePackageScripts === 'Yes'));
+    return { plugins: pluginsToInstall, updatePackageScripts };
 }

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

@@ -10,6 +10,7 @@ const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("./executor-utils");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const child_process_1 = require("child_process");
 function printRunHelp(opts, schema, plugin) {
     (0, print_help_1.printHelp)(`run ${opts.project}:${opts.target}`, schema, {
         mode: 'run',
@@ -66,13 +67,22 @@ async function printTargetRunHelpInternal({ project, target }, root, projectsCon
         executor === 'run-commands' &&
         targetConfig.options.command) {
         const command = targetConfig.options.command.split(' ')[0];
-        const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
-        await new Promise(() => {
-            const cp = terminal.runCommand(`${command} --help`);
-            cp.onExit((code) => {
+        const helpCommand = `${command} --help`;
+        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+            await new Promise(() => {
+                const cp = terminal.runCommand(helpCommand);
+                cp.onExit((code) => {
+                    process.exit(code);
+                });
+            });
+        }
+        else {
+            const cp = (0, child_process_1.exec)(helpCommand);
+            cp.on('exit', (code) => {
                 process.exit(code);
             });
-        });
+        }
     }
     else {
         process.exit(0);

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

@@ -47,11 +47,10 @@ async function default_1(options, context) {
         !options.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "color" and "bgColor" can only be set when "parallel=true".');
     }
-    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
     try {
         const result = options.parallel
-            ? await runInParallel(terminal, normalized, context)
-            : await runSerially(terminal, normalized, context);
+            ? await runInParallel(normalized, context)
+            : await runSerially(normalized, context);
         return result;
     }
     catch (e) {
@@ -62,8 +61,8 @@ async function default_1(options, context) {
     }
 }
 exports.default = default_1;
-async function runInParallel(pseudoTerminal, options, context) {
-    const procs = options.commands.map((c) => createProcess(pseudoTerminal, c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
+async function runInParallel(options, context) {
+    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
         result,
         command: c.command,
     })));
@@ -135,7 +134,10 @@ function normalizeOptions(options) {
     });
     return options;
 }
-async function runSerially(pseudoTerminal, options, context) {
+async function runSerially(options, context) {
+    const 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, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput);
@@ -155,8 +157,8 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
     env = processEnv(color, cwd, env);
     // 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 (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-        process.stdout.isTTY &&
+    if (pseudoTerminal &&
+        process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
         !commandConfig.prefix &&
         !isParallel &&
         usePty) {
@@ -265,7 +267,11 @@ function processEnv(color, cwd, env) {
         ...localEnv,
         ...env,
     };
-    res.PATH = localEnv.PATH; // need to override PATH to make sure we are using the local node_modules
+    // 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}`;
     }

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

@@ -17,7 +17,7 @@ async function default_1(options, context) {
             .filter((p) => !p.startsWith(path.join(context.root, 'node_modules')))
             .join(path.delimiter) ?? '';
         env.PATH = filteredPath;
-        if (process.stdout.isTTY) {
+        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
             await ptyProcess(command, cwd, env);
         }
         else {

package/src/plugins/js/index.js

@@ -39,7 +39,7 @@ exports.createNodes = [
                 externalNodes: nodes,
             };
         }
-        const externalNodes = (0, lock_file_1.getLockFileNodes)(packageManager, lockFileContents, lockFileHash);
+        const externalNodes = (0, lock_file_1.getLockFileNodes)(packageManager, lockFileContents, lockFileHash, context);
         parsedLockFile.externalNodes = externalNodes;
         return {
             externalNodes,

package/src/plugins/js/lock-file/lock-file.d.ts

@@ -6,12 +6,12 @@ import { PackageManager } from '../../../utils/package-manager';
 import { ProjectGraph, ProjectGraphExternalNode } from '../../../config/project-graph';
 import { RawProjectGraphDependency } from '../../../project-graph/project-graph-builder';
 import { PackageJson } from '../../../utils/package-json';
-import { CreateDependenciesContext } from '../../../utils/nx-plugin';
+import { CreateDependenciesContext, CreateNodesContext } from '../../../utils/nx-plugin';
 export declare const LOCKFILES: string[];
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */
-export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string): Record<string, ProjectGraphExternalNode>;
+export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateNodesContext): Record<string, ProjectGraphExternalNode>;
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */

package/src/plugins/js/lock-file/lock-file.js

@@ -26,10 +26,10 @@ const PNPM_LOCK_PATH = (0, path_1.join)(workspace_root_1.workspaceRoot, PNPM_LOC
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */
-function getLockFileNodes(packageManager, contents, lockFileHash) {
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
     try {
         if (packageManager === 'yarn') {
-            const packageJson = (0, fileutils_1.readJsonFile)('package.json');
+            const packageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, 'package.json'));
             return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
         }
         if (packageManager === 'pnpm') {

package/src/tasks-runner/cache.js

@@ -215,18 +215,21 @@ class Cache {
     }
     tryAndRetry(fn) {
         let attempts = 0;
-        const baseTimeout = 100;
+        const baseTimeout = 5;
+        // Generate a random number between 2 and 4 to raise to the power of attempts
+        const baseExponent = Math.random() * 2 + 2;
         const _try = async () => {
             try {
                 attempts++;
                 return await fn();
             }
             catch (e) {
-                if (attempts === 10) {
+                // Max time is 5 * 4^3 = 20480ms
+                if (attempts === 6) {
                     // After enough attempts, throw the error
                     throw e;
                 }
-                await new Promise((res) => setTimeout(res, baseTimeout * attempts));
+                await new Promise((res) => setTimeout(res, baseExponent ** attempts));
                 return await _try();
             }
         };

package/src/tasks-runner/forked-process-task-runner.d.ts

@@ -22,12 +22,13 @@ export declare class ForkedProcessTaskRunner {
         code: number;
         terminalOutput: string;
     }>;
-    forkProcess(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
+    forkProcess(task: Task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
         pipeOutput: boolean;
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
+        disablePseudoTerminal: boolean;
     }): Promise<{
         code: number;
         terminalOutput: string;

package/src/tasks-runner/forked-process-task-runner.js

@@ -21,10 +21,14 @@ class ForkedProcessTaskRunner {
         this.cliPath = (0, utils_1.getCliPath)();
         this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
         this.processes = new Set();
-        this.pseudoTerminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+        this.pseudoTerminal = pseudo_terminal_1.PseudoTerminal.isSupported()
+            ? (0, pseudo_terminal_1.getPseudoTerminal)()
+            : null;
     }
     async init() {
-        await this.pseudoTerminal.init();
+        if (this.pseudoTerminal) {
+            await this.pseudoTerminal.init();
+        }
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
@@ -104,11 +108,14 @@ class ForkedProcessTaskRunner {
                 env,
             });
     }
-    async forkProcess(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
+    async forkProcess(task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }) {
         const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
         // streamOutput would be false if we are running multiple targets
         // there's no point in running the commands in a pty if we are not streaming the output
-        if (!streamOutput || shouldPrefix || !process.stdout.isTTY) {
+        if (!this.pseudoTerminal ||
+            disablePseudoTerminal ||
+            !streamOutput ||
+            shouldPrefix) {
             return this.forkProcessWithPrefixAndNotTTY(task, {
                 temporaryOutputPath,
                 streamOutput,
@@ -303,13 +310,17 @@ class ForkedProcessTaskRunner {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
     setupProcessEventListeners() {
-        this.pseudoTerminal.onMessageFromChildren((message) => {
-            process.send(message);
-        });
+        if (this.pseudoTerminal) {
+            this.pseudoTerminal.onMessageFromChildren((message) => {
+                process.send(message);
+            });
+        }
         // 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());
-            this.pseudoTerminal.sendMessageToChildren(message);
+            if (this.pseudoTerminal) {
+                this.pseudoTerminal.sendMessageToChildren(message);
+            }
             this.processes.forEach((p) => {
                 if ('connected' in p && p.connected) {
                     p.send(message);

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -2,12 +2,13 @@
 import { ChildProcess, RustPseudoTerminal } from '../native';
 import { PseudoIPCServer } from './pseudo-ipc';
 import { Serializable } from 'child_process';
-export declare function getPseudoTerminal(): PseudoTerminal;
+export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
 export declare class PseudoTerminal {
     private rustPseudoTerminal;
     private pseudoIPCPath;
     private pseudoIPC;
     private initialized;
+    static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
     runCommand(command: string, { cwd, jsEnv, quiet, }?: {

package/src/tasks-runner/pseudo-terminal.js

@@ -4,13 +4,20 @@ exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerm
 const native_1 = require("../native");
 const pseudo_ipc_1 = require("./pseudo-ipc");
 const socket_utils_1 = require("../daemon/socket-utils");
+const os = require("os");
 let pseudoTerminal;
-function getPseudoTerminal() {
+function getPseudoTerminal(skipSupportCheck = false) {
+    if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
+        throw new Error('Pseudo terminal is not supported on this platform.');
+    }
     pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
     return pseudoTerminal;
 }
 exports.getPseudoTerminal = getPseudoTerminal;
 class PseudoTerminal {
+    static isSupported() {
+        return process.stdout.isTTY && supportedPtyPlatform();
+    }
     constructor(rustPseudoTerminal) {
         this.rustPseudoTerminal = rustPseudoTerminal;
         this.pseudoIPCPath = (0, socket_utils_1.FORKED_PROCESS_OS_SOCKET_PATH)(process.pid.toString());
@@ -131,3 +138,22 @@ function messageToCode(message) {
         return 1;
     }
 }
+function supportedPtyPlatform() {
+    if (process.platform !== 'win32') {
+        return true;
+    }
+    let windowsVersion = os.release().split('.');
+    let windowsBuild = windowsVersion[2];
+    if (!windowsBuild) {
+        return false;
+    }
+    // Mininum supported Windows version:
+    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
+    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
+    if (+windowsBuild < 17763) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}

package/src/tasks-runner/task-orchestrator.js

@@ -11,7 +11,6 @@ const utils_1 = require("./utils");
 const tasks_schedule_1 = require("./tasks-schedule");
 const hash_task_1 = require("../hasher/hash-task");
 const task_env_1 = require("./task-env");
-const os = require("os");
 const workspace_root_1 = require("../utils/workspace-root");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
@@ -253,8 +252,9 @@ class TaskOrchestrator {
     }
     async runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput) {
         try {
-            let usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-                supportedPtyPlatform();
+            const usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false';
+            // Disable the pseudo terminal if this is a run-many
+            const disablePseudoTerminal = !this.initiatingProject;
             // execution
             const { code, terminalOutput } = usePtyFork
                 ? await this.forkedProcessTaskRunner.forkProcess(task, {
@@ -263,6 +263,7 @@ class TaskOrchestrator {
                     pipeOutput,
                     taskGraph: this.taskGraph,
                     env,
+                    disablePseudoTerminal,
                 })
                 : await this.forkedProcessTaskRunner.forkProcessLegacy(task, {
                     temporaryOutputPath,
@@ -412,22 +413,3 @@ class TaskOrchestrator {
     }
 }
 exports.TaskOrchestrator = TaskOrchestrator;
-function supportedPtyPlatform() {
-    if (process.platform !== 'win32') {
-        return true;
-    }
-    let windowsVersion = os.release().split('.');
-    let windowsBuild = windowsVersion[2];
-    if (!windowsBuild) {
-        return false;
-    }
-    // Mininum supported Windows version:
-    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
-    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
-    if (+windowsBuild < 17763) {
-        return false;
-    }
-    else {
-        return true;
-    }
-}