nx 21.0.0-beta.1 → 21.0.0-beta.3

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTuiTerminalSummaryLifeCycle = getTuiTerminalSummaryLifeCycle;
+const node_os_1 = require("node:os");
+const output_1 = require("../../utils/output");
+const formatting_utils_1 = require("./formatting-utils");
+const pretty_time_1 = require("./pretty-time");
+const view_logs_utils_1 = require("./view-logs-utils");
+const figures = require("figures");
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, resolveRenderIsDonePromise, }) {
+    const lifeCycle = {};
+    const start = process.hrtime();
+    const targets = args.targets;
+    const totalTasks = tasks.length;
+    let totalCachedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCompletedTasks = 0;
+    let timeTakenText;
+    const failedTasks = new Set();
+    const inProgressTasks = new Set();
+    const tasksToTerminalOutputs = {};
+    const taskIdsInOrderOfCompletion = [];
+    lifeCycle.startTasks = (tasks) => {
+        for (let t of tasks) {
+            inProgressTasks.add(t.id);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, taskStatus, terminalOutput) => {
+        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
+        taskIdsInOrderOfCompletion.push(task.id);
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (let t of taskResults) {
+            totalCompletedTasks++;
+            inProgressTasks.delete(t.task.id);
+            switch (t.status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    failedTasks.add(t.task.id);
+                    break;
+            }
+        }
+    };
+    lifeCycle.endCommand = () => {
+        timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        resolveRenderIsDonePromise();
+    };
+    const printSummary = () => {
+        const isRunOne = initiatingProject && targets?.length === 1;
+        // Handles when the user interrupts the process
+        timeTakenText ??= (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        if (totalTasks === 0) {
+            console.log(`\n${output_1.output.applyNxPrefix('gray', 'No tasks were run')}\n`);
+            return;
+        }
+        if (isRunOne) {
+            printRunOneSummary();
+        }
+        else {
+            printRunManySummary();
+        }
+    };
+    const printRunOneSummary = () => {
+        let lines = [];
+        const failure = totalSuccessfulTasks !== totalTasks;
+        // Prints task outputs in the order they were completed
+        // above the summary, since run-one should print all task results.
+        for (const taskId of taskIdsInOrderOfCompletion) {
+            const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
+            output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+        }
+        lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
+        if (!failure) {
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], targets, tasks)}`;
+            const taskOverridesLines = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.green('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            lines.push(output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim(` (${timeTakenText})`)), ...taskOverridesLines);
+            if (totalCachedTasks > 0) {
+                lines.push(output_1.output.dim(`${node_os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
+        }
+        else if (totalCompletedTasks === totalTasks) {
+            let text = `Ran target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`;
+            if (tasks.length > 1) {
+                text += ` and ${output_1.output.bold(tasks.length - 1)} task(s) they depend on`;
+            }
+            const taskOverridesLines = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.red('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            const viewLogs = (0, view_logs_utils_1.viewLogsFooterRows)(totalFailedTasks);
+            lines = [
+                output_1.output.colors.red([
+                    output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
+                    ...taskOverridesLines,
+                    '',
+                    `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
+                    `${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
+                    ...viewLogs,
+                ]),
+            ];
+        }
+        else {
+            lines = [
+                ...output_1.output.getVerticalSeparatorLines('red'),
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(`Cancelled running target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`) + output_1.output.dim(` (${timeTakenText})`)),
+            ];
+        }
+        // adds some vertical space after the summary to avoid bunching against terminal
+        lines.push('');
+        console.log(lines.join(node_os_1.EOL));
+    };
+    const printRunManySummary = () => {
+        console.log('');
+        const lines = [];
+        const failure = totalSuccessfulTasks !== totalTasks;
+        for (const taskId of taskIdsInOrderOfCompletion) {
+            const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
+            if (taskStatus === 'failure') {
+                output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+                lines.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+            else {
+                lines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+        }
+        lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
+        if (totalSuccessfulTasks === totalTasks) {
+            const successSummaryRows = [];
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.green('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            successSummaryRows.push(...[
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim.white(` (${timeTakenText})`)),
+                ...taskOverridesRows,
+            ]);
+            if (totalCachedTasks > 0) {
+                successSummaryRows.push(output_1.output.dim(`${node_os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            lines.push(successSummaryRows.join(node_os_1.EOL));
+        }
+        else {
+            const text = `${inProgressTasks.size ? 'Cancelled while running' : 'Ran'} ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.red('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            const numFailedToPrint = 5;
+            const failedTasksForPrinting = Array.from(failedTasks).slice(0, numFailedToPrint);
+            const failureSummaryRows = [
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim.white(` (${timeTakenText})`)),
+                ...taskOverridesRows,
+                '',
+            ];
+            if (totalCompletedTasks > 0) {
+                if (totalSuccessfulTasks > 0) {
+                    failureSummaryRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`), '');
+                }
+                if (totalFailedTasks > 0) {
+                    failureSummaryRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`, '', `${failedTasksForPrinting
+                        .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                        .join('\n')}`, '');
+                    if (failedTasks.size > numFailedToPrint) {
+                        failureSummaryRows.push(output_1.output.dim(`${EXTENDED_LEFT_PAD}...and ${failedTasks.size - numFailedToPrint} more...`));
+                    }
+                }
+                if (totalCompletedTasks !== totalTasks) {
+                    const remainingTasks = totalTasks - totalCompletedTasks;
+                    if (inProgressTasks.size) {
+                        failureSummaryRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.ellipsis)}${SPACER}${inProgressTasks.size}${`/${totalTasks}`} targets were in progress, including the following:`, '', `${Array.from(inProgressTasks)
+                            .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                            .join(node_os_1.EOL)}`, '');
+                    }
+                    if (remainingTasks - inProgressTasks.size > 0) {
+                        failureSummaryRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.colors.red(figures.ellipsis)}${SPACER}${remainingTasks - inProgressTasks.size}${`/${totalTasks}`} targets had not started.`), '');
+                    }
+                }
+                failureSummaryRows.push(...(0, view_logs_utils_1.viewLogsFooterRows)(failedTasks.size));
+                lines.push(output_1.output.colors.red(failureSummaryRows.join(node_os_1.EOL)));
+            }
+        }
+        // adds some vertical space after the summary to avoid bunching against terminal
+        lines.push('');
+        console.log(lines.join(node_os_1.EOL));
+    };
+    return { lifeCycle, printSummary };
+}

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

@@ -1,7 +1,8 @@
+import { Serializable } from 'child_process';
 import { ChildProcess, RustPseudoTerminal } from '../native';
 import { PseudoIPCServer } from './pseudo-ipc';
-import { Serializable } from 'child_process';
-export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
+import { RunningTask } from './running-tasks/running-task';
+export declare function createPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
 export declare class PseudoTerminal {
     private rustPseudoTerminal;
     private pseudoIPCPath;
@@ -10,6 +11,7 @@ export declare class PseudoTerminal {
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
+    shutdown(): void;
     runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
         cwd?: string;
         execArgv?: string[];
@@ -25,16 +27,15 @@ export declare class PseudoTerminal {
     }): Promise<PseudoTtyProcessWithSend>;
     sendMessageToChildren(message: Serializable): void;
     onMessageFromChildren(callback: (message: Serializable) => void): void;
-    private setupProcessListeners;
-    private shutdownPseudoIPC;
 }
-export declare class PseudoTtyProcess {
+export declare class PseudoTtyProcess implements RunningTask {
+    rustPseudoTerminal: RustPseudoTerminal;
     private childProcess;
     isAlive: boolean;
     private exitCallbacks;
     private outputCallbacks;
     private terminalOutput;
-    constructor(childProcess: ChildProcess);
+    constructor(rustPseudoTerminal: RustPseudoTerminal, childProcess: ChildProcess);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
@@ -42,10 +43,12 @@ export declare class PseudoTtyProcess {
     onExit(callback: (code: number) => void): void;
     onOutput(callback: (message: string) => void): void;
     kill(): void;
+    getParserAndWriter(): import("../native").ExternalObject<[ParserArc, WriterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    rustPseudoTerminal: RustPseudoTerminal;
     private id;
     private pseudoIpc;
-    constructor(_childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
+    constructor(rustPseudoTerminal: RustPseudoTerminal, _childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
     send(message: Serializable): void;
 }

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

@@ -1,29 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = void 0;
-exports.getPseudoTerminal = getPseudoTerminal;
+exports.createPseudoTerminal = createPseudoTerminal;
+const os = require("os");
+const socket_utils_1 = require("../daemon/socket-utils");
 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(skipSupportCheck = false) {
+// Register single event listeners for all pseudo-terminal instances
+const pseudoTerminalShutdownCallbacks = [];
+process.on('SIGINT', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+process.on('SIGTERM', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+process.on('SIGHUP', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+process.on('exit', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+function createPseudoTerminal(skipSupportCheck = false) {
     if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
         throw new Error('Pseudo terminal is not supported on this platform.');
     }
-    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
+    const pseudoTerminal = new PseudoTerminal(new native_1.RustPseudoTerminal());
+    pseudoTerminalShutdownCallbacks.push(pseudoTerminal.shutdown.bind(pseudoTerminal));
     return pseudoTerminal;
 }
+let id = 0;
 class PseudoTerminal {
     static isSupported() {
         return process.stdout.isTTY && supportedPtyPlatform();
     }
     constructor(rustPseudoTerminal) {
         this.rustPseudoTerminal = rustPseudoTerminal;
-        this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString());
+        this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString() + '-' + id++);
         this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
         this.initialized = false;
-        this.setupProcessListeners();
     }
     async init() {
         if (this.initialized) {
@@ -32,14 +46,19 @@ class PseudoTerminal {
         await this.pseudoIPC.init();
         this.initialized = true;
     }
+    shutdown() {
+        if (this.initialized) {
+            this.pseudoIPC.close();
+        }
+    }
     runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
-        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
+        return new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
     }
     async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
         if (!this.initialized) {
             throw new Error('Call init() before forking processes');
         }
-        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
         await this.pseudoIPC.waitForChildReady(id);
         return cp;
     }
@@ -49,32 +68,11 @@ class PseudoTerminal {
     onMessageFromChildren(callback) {
         this.pseudoIPC.onMessageFromChildren(callback);
     }
-    setupProcessListeners() {
-        const shutdown = () => {
-            this.shutdownPseudoIPC();
-        };
-        process.on('SIGINT', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('SIGTERM', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('SIGHUP', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('exit', () => {
-            this.shutdownPseudoIPC();
-        });
-    }
-    shutdownPseudoIPC() {
-        if (this.initialized) {
-            this.pseudoIPC.close();
-        }
-    }
 }
 exports.PseudoTerminal = PseudoTerminal;
 class PseudoTtyProcess {
-    constructor(childProcess) {
+    constructor(rustPseudoTerminal, childProcess) {
+        this.rustPseudoTerminal = rustPseudoTerminal;
         this.childProcess = childProcess;
         this.isAlive = true;
         this.exitCallbacks = [];
@@ -118,11 +116,15 @@ class PseudoTtyProcess {
             }
         }
     }
+    getParserAndWriter() {
+        return this.childProcess.getParserAndWriter();
+    }
 }
 exports.PseudoTtyProcess = PseudoTtyProcess;
 class PseudoTtyProcessWithSend extends PseudoTtyProcess {
-    constructor(_childProcess, id, pseudoIpc) {
-        super(_childProcess);
+    constructor(rustPseudoTerminal, _childProcess, id, pseudoIpc) {
+        super(rustPseudoTerminal, _childProcess);
+        this.rustPseudoTerminal = rustPseudoTerminal;
         this.id = id;
         this.pseudoIpc = pseudoIpc;
     }

package/src/tasks-runner/run-command.d.ts

@@ -29,6 +29,7 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
 }): Promise<{
     [id: string]: TaskResult;
 }>;
+export declare function constructLifeCycles(lifeCycle: LifeCycle): LifeCycle[];
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;