@depup/nx 22.5.4-depup.0

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts

@@ -0,0 +1,29 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle, TaskResult } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
+    private readonly initiatingProject;
+    private readonly projectNames;
+    private readonly tasks;
+    private readonly args;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    constructor(initiatingProject: string, projectNames: string[], tasks: Task[], args: {
+        targets?: string[];
+        configuration?: string;
+        verbose?: boolean;
+    });
+    startCommand(): void;
+    endCommand(): void;
+    endTasks(taskResults: TaskResult[]): void;
+    printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
+}
+//# sourceMappingURL=static-run-one-terminal-output-life-cycle.d.ts.map

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-run-one-terminal-output-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAG/C;;;;;;;GAOG;AACH,qBAAa,mCAAoC,YAAW,SAAS;IAKjE,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAPvB,WAAW,EAAS,IAAI,EAAE,CAAC;IAC3B,WAAW,EAAS,IAAI,EAAE,CAAC;gBAGR,iBAAiB,EAAE,MAAM,EACzB,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE;QACrB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;IAGH,YAAY,IAAI,IAAI;IAgBpB,UAAU,IAAI,IAAI;IA8ClB,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI;IAczC,uBAAuB,CACrB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,UAAU,EAClB,cAAc,EAAE,MAAM;CAkBzB"}

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunOneTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+const formatting_utils_1 = require("./formatting-utils");
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+class StaticRunOneTerminalOutputLifeCycle {
+    constructor(initiatingProject, projectNames, tasks, args) {
+        this.initiatingProject = initiatingProject;
+        this.projectNames = projectNames;
+        this.tasks = tasks;
+        this.args = args;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+    }
+    startCommand() {
+        const numberOfDeps = this.tasks.length - 1;
+        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
+        if (numberOfDeps > 0) {
+            output_1.output.log({
+                color: 'cyan',
+                title,
+            });
+            output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+        }
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            const bodyLines = this.cachedTasks.length > 0
+                ? [
+                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
+                ]
+                : [];
+            output_1.output.success({
+                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
+                bodyLines,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            const bodyLines = [
+                output_1.output.dim('Failed tasks:'),
+                '',
+                ...this.failedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`),
+                '',
+                `${output_1.output.dim('Hint: run the command with')} --verbose ${output_1.output.dim('for more details.')}`,
+            ];
+            output_1.output.error({
+                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                bodyLines,
+            });
+        }
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, status, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        if (this.args.verbose ||
+            status === 'success' ||
+            status === 'failure' ||
+            task.target.project === this.initiatingProject) {
+            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
+        }
+        else {
+            /**
+             * Do not show the terminal output in the case where it is not the initiating project and verbose is not set,
+             * but still print the command that was run and its status (so that cache hits can still be traced).
+             */
+            output_1.output.logCommandOutput(args.join(' '), status, '');
+        }
+    }
+}
+exports.StaticRunOneTerminalOutputLifeCycle = StaticRunOneTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.d.ts

@@ -0,0 +1,18 @@
+import { LifeCycle, TaskResult } from '../../tasks-runner/life-cycle';
+import { Task } from '../../config/task-graph';
+export declare class StoreRunInformationLifeCycle implements LifeCycle {
+    private readonly command;
+    private readonly storeFile;
+    private readonly now;
+    private startTime;
+    private timings;
+    private taskResults;
+    constructor(command?: string, storeFile?: typeof storeFileFunction, now?: () => string);
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): void;
+    startCommand(): void;
+    endCommand(): any;
+}
+declare function storeFileFunction(runDetails: any): void;
+export {};
+//# sourceMappingURL=store-run-information-life-cycle.d.ts.map

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-run-information-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/store-run-information-life-cycle.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAI/C,qBAAa,4BAA6B,YAAW,SAAS;IAiB1D,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAlBtB,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,OAAO,CAKR;IAEP,OAAO,CAAC,WAAW,CAIhB;gBAGgB,OAAO,GAAE,MAAuB,EAChC,SAAS,2BAAoB,EAC7B,GAAG,eAAiC;IAGvD,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAS/B,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI;IAgBzC,YAAY;IAIZ,UAAU,IAAI,GAAG;CAsClB;AAQD,iBAAS,iBAAiB,CAAC,UAAU,EAAE,GAAG,QAKzC"}

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreRunInformationLifeCycle = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cache_directory_1 = require("../../utils/cache-directory");
+class StoreRunInformationLifeCycle {
+    constructor(command = parseCommand(), storeFile = storeFileFunction, now = () => new Date().toISOString()) {
+        this.command = command;
+        this.storeFile = storeFile;
+        this.now = now;
+        this.timings = {};
+        this.taskResults = [];
+    }
+    startTasks(tasks) {
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                start: this.now(),
+                end: undefined,
+            };
+        }
+    }
+    endTasks(taskResults) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].start = new Date(tr.task.startTime).toISOString();
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].end = new Date(tr.task.endTime).toISOString();
+            }
+            else {
+                this.timings[tr.task.id].end = this.now();
+            }
+        }
+        this.taskResults.push(...taskResults);
+    }
+    startCommand() {
+        this.startTime = this.now();
+    }
+    endCommand() {
+        try {
+            const endTime = this.now();
+            const runDetails = {
+                run: {
+                    command: this.command,
+                    startTime: this.startTime,
+                    endTime: endTime,
+                    inner: false,
+                },
+                tasks: this.taskResults.map((tr) => {
+                    const cacheStatus = tr.status === 'remote-cache'
+                        ? 'remote-cache-hit'
+                        : tr.status === 'local-cache' ||
+                            tr.status === 'local-cache-kept-existing'
+                            ? 'local-cache-hit'
+                            : 'cache-miss';
+                    return {
+                        taskId: tr.task.id,
+                        target: tr.task.target.target,
+                        projectName: tr.task.target.project,
+                        hash: tr.task.hash,
+                        startTime: this.timings[tr.task.id].start,
+                        endTime: this.timings[tr.task.id].end,
+                        params: '',
+                        cacheStatus,
+                        status: tr.code,
+                    };
+                }),
+            };
+            this.storeFile(runDetails);
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
+        }
+    }
+}
+exports.StoreRunInformationLifeCycle = StoreRunInformationLifeCycle;
+function parseCommand() {
+    const cmdBase = (0, path_1.parse)(process.argv[1]).name;
+    const args = `${process.argv.slice(2).join(' ')}`;
+    return `${cmdBase} ${args}`;
+}
+function storeFileFunction(runDetails) {
+    (0, fs_1.writeFileSync)((0, path_1.join)(cache_directory_1.cacheDir, 'run.json'), JSON.stringify(runDetails, null, 2));
+}

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts

@@ -0,0 +1,13 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    private flakyTasks;
+    private cacheableHashes;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
+}
+//# sourceMappingURL=task-history-life-cycle-old.d.ts.map

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-history-life-cycle-old.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle-old.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAU/C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEtD,qBAAa,0BAA2B,YAAW,SAAS;IAC1D,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,UAAU,CAAW;IAK7B,OAAO,CAAC,eAAe,CAA0B;IAEjD,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAMzB,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE;IAqBlC,UAAU;IAiChB,sBAAsB;CAmBvB"}

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyTaskHistoryLifeCycle = void 0;
+const nx_json_1 = require("../../config/nx-json");
+const legacy_task_history_1 = require("../../utils/legacy-task-history");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const serialize_target_1 = require("../../utils/serialize-target");
+const is_tui_enabled_1 = require("../is-tui-enabled");
+class LegacyTaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = [];
+        // hashes which could trigger flaky task detection.
+        // set here rather than on the TaskRun to avoid storing data on
+        // the fs
+        this.cacheableHashes = new Set();
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        for (const taskResult of taskResults) {
+            // Track cacheable tasks for flaky detection
+            if (taskResult.task.cache === true) {
+                this.cacheableHashes.add(taskResult.task.hash);
+            }
+            this.taskRuns.push({
+                project: taskResult.task.target.project,
+                target: taskResult.task.target.target,
+                configuration: taskResult.task.target.configuration,
+                hash: taskResult.task.hash,
+                code: taskResult.code.toString(),
+                status: taskResult.status,
+                start: (taskResult.task.startTime ?? this.startTimings[taskResult.task.id]).toString(),
+                end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
+            });
+        }
+    }
+    async endCommand() {
+        await (0, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
+        // Only check for flaky tasks among cacheable tasks
+        const cacheableTaskRuns = this.taskRuns.filter((t) => this.cacheableHashes.has(t.hash));
+        const history = await (0, legacy_task_history_1.getHistoryForHashes)(cacheableTaskRuns.map((t) => t.hash));
+        this.flakyTasks = [];
+        // check if any hash has different exit codes => flaky
+        for (let hash in history) {
+            if (history[hash].length > 1 &&
+                history[hash].some((run) => run.code !== history[hash][0].code)) {
+                this.flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+            }
+        }
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks?.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...this.flakyTasks.map((t) => `  ${t}`),
+                    ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
+                        ? []
+                        : [
+                            '',
+                            `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                        ]),
+                ],
+            });
+        }
+    }
+}
+exports.LegacyTaskHistoryLifeCycle = LegacyTaskHistoryLifeCycle;

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -0,0 +1,16 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+import { LegacyTaskHistoryLifeCycle } from './task-history-life-cycle-old';
+export declare function getTasksHistoryLifeCycle(): TaskHistoryLifeCycle | LegacyTaskHistoryLifeCycle;
+export declare class TaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    private taskHistory;
+    private flakyTasks;
+    constructor();
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
+}
+//# sourceMappingURL=task-history-life-cycle.d.ts.map

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-history-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAO/C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAS3E,wBAAgB,wBAAwB,IACpC,oBAAoB,GACpB,0BAA0B,CAQ7B;AAED,qBAAa,oBAAqB,YAAW,SAAS;IACpD,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,UAAU,CAAW;;IAW7B,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAMzB,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE;IAelC,UAAU;IA4BhB,sBAAsB;CA0BvB"}

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistoryLifeCycle = void 0;
+exports.getTasksHistoryLifeCycle = getTasksHistoryLifeCycle;
+const nx_json_1 = require("../../config/nx-json");
+const native_1 = require("../../native");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const serialize_target_1 = require("../../utils/serialize-target");
+const task_history_1 = require("../../utils/task-history");
+const is_tui_enabled_1 = require("../is-tui-enabled");
+const task_history_life_cycle_old_1 = require("./task-history-life-cycle-old");
+let tasksHistoryLifeCycle;
+function getTasksHistoryLifeCycle() {
+    if (!tasksHistoryLifeCycle) {
+        tasksHistoryLifeCycle = !native_1.IS_WASM
+            ? new TaskHistoryLifeCycle()
+            : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle();
+    }
+    return tasksHistoryLifeCycle;
+}
+class TaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = new Map();
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
+        if (tasksHistoryLifeCycle) {
+            throw new Error('TaskHistoryLifeCycle is a singleton and should not be instantiated multiple times');
+        }
+        tasksHistoryLifeCycle = this;
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        for (const taskResult of taskResults) {
+            this.taskRuns.set(taskResult.task.hash, {
+                hash: taskResult.task.hash,
+                target: taskResult.task.target,
+                code: taskResult.code,
+                status: taskResult.status,
+                start: taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
+                end: taskResult.task.endTime ?? Date.now(),
+                cacheable: taskResult.task.cache === true,
+            });
+        }
+    }
+    async endCommand() {
+        if (!this.taskHistory) {
+            return;
+        }
+        const runs = [];
+        // Only check for flaky tasks among cacheable tasks
+        const cacheableHashes = [];
+        const iterator = this.taskRuns.entries();
+        for (const [hash, run] of iterator) {
+            runs.push(run);
+            if (run.cacheable) {
+                cacheableHashes.push(hash);
+            }
+        }
+        await this.taskHistory.recordTaskRuns(runs);
+        this.flakyTasks =
+            cacheableHashes.length > 0
+                ? await this.taskHistory.getFlakyTasks(cacheableHashes)
+                : [];
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks?.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...this.flakyTasks.map((hash) => {
+                        const taskRun = this.taskRuns.get(hash);
+                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+                    }),
+                    ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
+                        ? []
+                        : [
+                            '',
+                            `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                        ]),
+                ],
+            });
+        }
+    }
+}
+exports.TaskHistoryLifeCycle = TaskHistoryLifeCycle;

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.d.ts

@@ -0,0 +1,15 @@
+import { LifeCycle, TaskMetadata, TaskResult } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+export declare class TaskProfilingLifeCycle implements LifeCycle {
+    private timings;
+    private profile;
+    private readonly profileFile;
+    private registeredGroups;
+    constructor(_profileFile: string);
+    startTasks(tasks: Task[], { groupId }: TaskMetadata): void;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    endCommand(): void;
+    private recordTaskCompletions;
+    private registerGroup;
+}
+//# sourceMappingURL=task-profiling-life-cycle.d.ts.map

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-profiling-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/task-profiling-life-cycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKpE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAG/C,qBAAa,sBAAuB,YAAW,SAAS;IACtD,OAAO,CAAC,OAAO,CAKR;IACP,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,gBAAgB,CAAa;gBAEzB,YAAY,EAAE,MAAM;IAIhC,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,YAAY,GAAG,IAAI;IAW1D,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAcjE,UAAU,IAAI,IAAI;IAKlB,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,aAAa;CAatB"}

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProfilingLifeCycle = void 0;
+const path_1 = require("path");
+const fileutils_1 = require("../../utils/fileutils");
+class TaskProfilingLifeCycle {
+    constructor(_profileFile) {
+        this.timings = {};
+        this.profile = [];
+        this.registeredGroups = new Set();
+        this.profileFile = (0, path_1.join)(process.cwd(), _profileFile);
+    }
+    startTasks(tasks, { groupId }) {
+        if (this.profileFile && !this.registeredGroups.has(groupId)) {
+            this.registerGroup(groupId);
+        }
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                perfStart: Date.now(),
+            };
+        }
+    }
+    endTasks(taskResults, metadata) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].perfStart = tr.task.startTime;
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].perfEnd = tr.task.endTime;
+            }
+            else {
+                this.timings[tr.task.id].perfEnd = Date.now();
+            }
+        }
+        this.recordTaskCompletions(taskResults, metadata);
+    }
+    endCommand() {
+        (0, fileutils_1.writeJsonFile)(this.profileFile, this.profile);
+        console.log(`Performance Profile: ${this.profileFile}`);
+    }
+    recordTaskCompletions(tasks, { groupId }) {
+        for (const { task, status } of tasks) {
+            const { perfStart, perfEnd } = this.timings[task.id];
+            this.profile.push({
+                name: task.id,
+                cat: Object.values(task.target).join(','),
+                ph: 'X',
+                ts: perfStart * 1000,
+                dur: (perfEnd - perfStart) * 1000,
+                pid: process.pid,
+                tid: groupId,
+                args: {
+                    target: task.target,
+                    status,
+                },
+            });
+        }
+    }
+    registerGroup(groupId) {
+        this.profile.push({
+            name: 'thread_name',
+            ph: 'M',
+            pid: process.pid,
+            tid: groupId,
+            ts: 0,
+            args: {
+                name: 'Group #' + (groupId + 1),
+            },
+        });
+        this.registeredGroups.add(groupId);
+    }
+}
+exports.TaskProfilingLifeCycle = TaskProfilingLifeCycle;

package/src/tasks-runner/life-cycles/task-results-life-cycle.d.ts

@@ -0,0 +1,7 @@
+import type { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskResultsLifeCycle implements LifeCycle {
+    private taskResults;
+    endTasks(taskResults: TaskResult[]): void;
+    getTaskResults(): Record<string, TaskResult>;
+}
+//# sourceMappingURL=task-results-life-cycle.d.ts.map

package/src/tasks-runner/life-cycles/task-results-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-results-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/task-results-life-cycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3D,qBAAa,oBAAqB,YAAW,SAAS;IACpD,OAAO,CAAC,WAAW,CAAoC;IAEvD,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI;IAMzC,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;CAG7C"}

package/src/tasks-runner/life-cycles/task-results-life-cycle.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskResultsLifeCycle = void 0;
+class TaskResultsLifeCycle {
+    constructor() {
+        this.taskResults = {};
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.taskResults[t.task.id] = t;
+        }
+    }
+    getTaskResults() {
+        return this.taskResults;
+    }
+}
+exports.TaskResultsLifeCycle = TaskResultsLifeCycle;

package/src/tasks-runner/life-cycles/task-timings-life-cycle.d.ts

@@ -0,0 +1,9 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskTimingsLifeCycle implements LifeCycle {
+    private timings;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): void;
+    endCommand(): void;
+}
+//# sourceMappingURL=task-timings-life-cycle.d.ts.map

package/src/tasks-runner/life-cycles/task-timings-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-timings-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/task-timings-life-cycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGtD,qBAAa,oBAAqB,YAAW,SAAS;IACpD,OAAO,CAAC,OAAO,CAKR;IAEP,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAS/B,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI;IAazC,UAAU,IAAI,IAAI;CASnB"}

package/src/tasks-runner/life-cycles/task-timings-life-cycle.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTimingsLifeCycle = void 0;
+class TaskTimingsLifeCycle {
+    constructor() {
+        this.timings = {};
+    }
+    startTasks(tasks) {
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                start: new Date().getTime(),
+                end: undefined,
+            };
+        }
+    }
+    endTasks(taskResults) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].start = tr.task.startTime;
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].end = tr.task.endTime;
+            }
+            else {
+                this.timings[tr.task.id].end = new Date().getTime();
+            }
+        }
+    }
+    endCommand() {
+        console.log('Task Execution Timings:');
+        const timings = {};
+        Object.keys(this.timings).forEach((p) => {
+            const t = this.timings[p];
+            timings[p] = t.end ? t.end - t.start : null;
+        });
+        console.log(JSON.stringify(timings, null, 2));
+    }
+}
+exports.TaskTimingsLifeCycle = TaskTimingsLifeCycle;

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

@@ -0,0 +1,20 @@
+import { Task, TaskGraph } from '../../config/task-graph';
+import type { LifeCycle } from '../life-cycle';
+export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }: {
+    projectNames: string[];
+    tasks: Task[];
+    taskGraph: TaskGraph;
+    args: {
+        targets?: string[];
+        configuration?: string;
+        parallel?: number;
+    };
+    overrides: Record<string, unknown>;
+    initiatingProject: string;
+    initiatingTasks: Task[];
+    resolveRenderIsDonePromise: (value: void) => void;
+}): {
+    lifeCycle: LifeCycle;
+    printSummary: () => void;
+};
+//# sourceMappingURL=tui-summary-life-cycle.d.ts.map