nx 18.2.0-canary.20240316-b69047e → 18.2.0-canary.20240320-64b2396

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/versions.d.ts

@@ -1 +1 @@
-export declare const typescriptVersion = "~5.3.2";
+export declare const typescriptVersion = "~5.4.2";

package/src/plugins/js/versions.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptVersion = void 0;
-exports.typescriptVersion = '~5.3.2';
+exports.typescriptVersion = '~5.4.2';

package/src/project-graph/utils/project-configuration-utils.js

@@ -32,17 +32,27 @@ skipCommandNormalization) {
     // a project.json in which case it was already updated above.
     const updatedProjectConfiguration = {
         ...matchingProject,
-        ...project,
     };
-    if (sourceMap) {
-        for (const property in project) {
-            sourceMap[`${property}`] = sourceInformation;
+    for (const k in project) {
+        if (![
+            'tags',
+            'implicitDependencies',
+            'generators',
+            'targets',
+            'metadata',
+            'namedInputs',
+        ].includes(k)) {
+            updatedProjectConfiguration[k] = project[k];
+            if (sourceMap) {
+                sourceMap[`${k}`] = sourceInformation;
+            }
         }
     }
     // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
     if (project.tags) {
         updatedProjectConfiguration.tags = Array.from(new Set((matchingProject.tags ?? []).concat(project.tags)));
         if (sourceMap) {
+            sourceMap['tags'] ??= sourceInformation;
             project.tags.forEach((tag) => {
                 sourceMap[`tags.${tag}`] = sourceInformation;
             });
@@ -51,6 +61,7 @@ skipCommandNormalization) {
     if (project.implicitDependencies) {
         updatedProjectConfiguration.implicitDependencies = (matchingProject.implicitDependencies ?? []).concat(project.implicitDependencies);
         if (sourceMap) {
+            sourceMap['implicitDependencies'] ??= sourceInformation;
             project.implicitDependencies.forEach((implicitDependency) => {
                 sourceMap[`implicitDependencies.${implicitDependency}`] =
                     sourceInformation;
@@ -61,6 +72,7 @@ skipCommandNormalization) {
         // Start with generators config in new project.
         updatedProjectConfiguration.generators = { ...project.generators };
         if (sourceMap) {
+            sourceMap['generators'] ??= sourceInformation;
             for (const generator in project.generators) {
                 sourceMap[`generators.${generator}`] = sourceInformation;
                 for (const property in project.generators[generator]) {
@@ -85,6 +97,7 @@ skipCommandNormalization) {
             ...project.namedInputs,
         };
         if (sourceMap) {
+            sourceMap['namedInputs'] ??= sourceInformation;
             for (const namedInput in project.namedInputs) {
                 sourceMap[`namedInputs.${namedInput}`] = sourceInformation;
             }
@@ -94,6 +107,9 @@ skipCommandNormalization) {
         // We merge the targets with special handling, so clear this back to the
         // targets as defined originally before merging.
         updatedProjectConfiguration.targets = matchingProject?.targets ?? {};
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
         // For each target defined in the new config
         for (const targetName in project.targets) {
             // Always set source map info for the target, but don't overwrite info already there
@@ -117,6 +133,75 @@ skipCommandNormalization) {
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
+    if (project.metadata) {
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
+        for (const [metadataKey, value] of Object.entries({
+            ...project.metadata,
+        })) {
+            const existingValue = matchingProject.metadata?.[metadataKey];
+            if (Array.isArray(value) && Array.isArray(existingValue)) {
+                for (const item of [...value]) {
+                    const newLength = updatedProjectConfiguration.metadata[metadataKey].push(item);
+                    if (sourceMap) {
+                        sourceMap[`metadata.${metadataKey}.${newLength - 1}`] =
+                            sourceInformation;
+                    }
+                }
+            }
+            else if (Array.isArray(value) && existingValue === undefined) {
+                updatedProjectConfiguration.metadata ??= {};
+                updatedProjectConfiguration.metadata[metadataKey] ??= value;
+                if (sourceMap) {
+                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                }
+                for (let i = 0; i < value.length; i++) {
+                    if (sourceMap) {
+                        sourceMap[`metadata.${metadataKey}.${i}`] = sourceInformation;
+                    }
+                }
+            }
+            else if (typeof value === 'object' &&
+                typeof existingValue === 'object') {
+                for (const key in value) {
+                    const existingValue = matchingProject.metadata?.[metadataKey]?.[key];
+                    if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
+                        for (const item of value[key]) {
+                            const i = updatedProjectConfiguration.metadata[metadataKey][key].push(item);
+                            if (sourceMap) {
+                                sourceMap[`metadata.${metadataKey}.${key}.${i - 1}`] =
+                                    sourceInformation;
+                            }
+                        }
+                    }
+                    else {
+                        updatedProjectConfiguration.metadata[metadataKey] = value;
+                        if (sourceMap) {
+                            sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                        }
+                    }
+                }
+            }
+            else {
+                updatedProjectConfiguration.metadata[metadataKey] = value;
+                if (sourceMap) {
+                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                    if (typeof value === 'object') {
+                        for (const k in value) {
+                            sourceMap[`metadata.${metadataKey}.${k}`] = sourceInformation;
+                            if (Array.isArray(value[k])) {
+                                for (let i = 0; i < value[k].length; i++) {
+                                    sourceMap[`metadata.${metadataKey}.${k}.${i}`] =
+                                        sourceInformation;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
 }
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;

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;
-    }
-}