nx 19.4.0-canary.20240621-472459d → 19.4.0-canary.20240626-3a2e8d4

package/src/daemon/client/client.d.ts

@@ -6,6 +6,7 @@ import { Hash } from '../../hasher/task-hasher';
 import { Task, TaskGraph } from '../../config/task-graph';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
 import { NxWorkspaceFiles } from '../../native';
+import { TaskRun } from '../../utils/task-history';
 export type UnregisterCallback = () => void;
 export type ChangedFile = {
     path: string;
@@ -51,6 +52,10 @@ export declare class DaemonClient {
     getWorkspaceFiles(projectRootMap: Record<string, string>): Promise<NxWorkspaceFiles>;
     getFilesInDirectory(dir: string): Promise<string[]>;
     hashGlob(globs: string[], exclude?: string[]): Promise<string>;
+    getTaskHistoryForHashes(hashes: string[]): Promise<{
+        [hash: string]: TaskRun[];
+    }>;
+    writeTaskRunsToHistory(taskRuns: TaskRun[]): Promise<void>;
     isServerAvailable(): Promise<boolean>;
     private sendToDaemonViaQueue;
     private setUpConnection;

package/src/daemon/client/client.js

@@ -221,6 +221,20 @@ class DaemonClient {
         };
         return this.sendToDaemonViaQueue(message);
     }
+    getTaskHistoryForHashes(hashes) {
+        const message = {
+            type: 'GET_TASK_HISTORY_FOR_HASHES',
+            hashes,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    writeTaskRunsToHistory(taskRuns) {
+        const message = {
+            type: 'WRITE_TASK_RUNS_TO_HISTORY',
+            taskRuns,
+        };
+        return this.sendMessageToDaemon(message);
+    }
     async isServerAvailable() {
         return new Promise((resolve) => {
             try {

package/src/daemon/message-types/task-history.d.ts

@@ -0,0 +1,13 @@
+import { TaskRun } from '../../utils/task-history';
+export declare const GET_TASK_HISTORY_FOR_HASHES: "GET_TASK_HISTORY_FOR_HASHES";
+export type HandleGetTaskHistoryForHashesMessage = {
+    type: typeof GET_TASK_HISTORY_FOR_HASHES;
+    hashes: string[];
+};
+export declare function isHandleGetTaskHistoryForHashesMessage(message: unknown): message is HandleGetTaskHistoryForHashesMessage;
+export declare const WRITE_TASK_RUNS_TO_HISTORY: "WRITE_TASK_RUNS_TO_HISTORY";
+export type HandleWriteTaskRunsToHistoryMessage = {
+    type: typeof WRITE_TASK_RUNS_TO_HISTORY;
+    taskRuns: TaskRun[];
+};
+export declare function isHandleWriteTaskRunsToHistoryMessage(message: unknown): message is HandleWriteTaskRunsToHistoryMessage;

package/src/daemon/message-types/task-history.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHandleWriteTaskRunsToHistoryMessage = exports.WRITE_TASK_RUNS_TO_HISTORY = exports.isHandleGetTaskHistoryForHashesMessage = exports.GET_TASK_HISTORY_FOR_HASHES = void 0;
+exports.GET_TASK_HISTORY_FOR_HASHES = 'GET_TASK_HISTORY_FOR_HASHES';
+function isHandleGetTaskHistoryForHashesMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_TASK_HISTORY_FOR_HASHES);
+}
+exports.isHandleGetTaskHistoryForHashesMessage = isHandleGetTaskHistoryForHashesMessage;
+exports.WRITE_TASK_RUNS_TO_HISTORY = 'WRITE_TASK_RUNS_TO_HISTORY';
+function isHandleWriteTaskRunsToHistoryMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.WRITE_TASK_RUNS_TO_HISTORY);
+}
+exports.isHandleWriteTaskRunsToHistoryMessage = isHandleWriteTaskRunsToHistoryMessage;

package/src/daemon/server/handle-get-task-history.d.ts

@@ -0,0 +1,4 @@
+export declare function handleGetTaskHistoryForHashes(hashes: string[]): Promise<{
+    response: string;
+    description: string;
+}>;

package/src/daemon/server/handle-get-task-history.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetTaskHistoryForHashes = void 0;
+const task_history_1 = require("../../utils/task-history");
+async function handleGetTaskHistoryForHashes(hashes) {
+    const history = await (0, task_history_1.getHistoryForHashes)(hashes);
+    return {
+        response: JSON.stringify(history),
+        description: 'handleGetTaskHistoryForHashes',
+    };
+}
+exports.handleGetTaskHistoryForHashes = handleGetTaskHistoryForHashes;

package/src/daemon/server/handle-write-task-runs-to-history.d.ts

@@ -0,0 +1,5 @@
+import { TaskRun } from '../../utils/task-history';
+export declare function handleWriteTaskRunsToHistory(taskRuns: TaskRun[]): Promise<{
+    response: string;
+    description: string;
+}>;

package/src/daemon/server/handle-write-task-runs-to-history.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWriteTaskRunsToHistory = void 0;
+const task_history_1 = require("../../utils/task-history");
+async function handleWriteTaskRunsToHistory(taskRuns) {
+    await (0, task_history_1.writeTaskRunsToHistory)(taskRuns);
+    return {
+        response: 'true',
+        description: 'handleWriteTaskRunsToHistory',
+    };
+}
+exports.handleWriteTaskRunsToHistory = handleWriteTaskRunsToHistory;

package/src/daemon/server/plugins.js

@@ -1,16 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanupPlugins = exports.getPlugins = void 0;
+const file_hasher_1 = require("../../hasher/file-hasher");
 const nx_json_1 = require("../../config/nx-json");
 const internal_api_1 = require("../../project-graph/plugins/internal-api");
 const workspace_root_1 = require("../../utils/workspace-root");
+let currentPluginsConfigurationHash;
 let loadedPlugins;
 let cleanup;
 async function getPlugins() {
-    if (loadedPlugins) {
+    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
+    const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
+    // If the plugins configuration has not changed, reuse the current plugins
+    if (loadedPlugins &&
+        pluginsConfigurationHash === currentPluginsConfigurationHash) {
         return loadedPlugins;
     }
-    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
+    // Cleanup current plugins before loading new ones
+    if (cleanup) {
+        cleanup();
+    }
+    currentPluginsConfigurationHash = pluginsConfigurationHash;
     const [result, cleanupFn] = await (0, internal_api_1.loadNxPlugins)(pluginsConfiguration, workspace_root_1.workspaceRoot);
     cleanup = cleanupFn;
     loadedPlugins = result;

package/src/daemon/server/server.js

@@ -35,6 +35,9 @@ const get_files_in_directory_1 = require("../message-types/get-files-in-director
 const handle_get_files_in_directory_1 = require("./handle-get-files-in-directory");
 const hash_glob_1 = require("../message-types/hash-glob");
 const handle_hash_glob_1 = require("./handle-hash-glob");
+const task_history_1 = require("../message-types/task-history");
+const handle_get_task_history_1 = require("./handle-get-task-history");
+const handle_write_task_runs_to_history_1 = require("./handle-write-task-runs-to-history");
 let performanceObserver;
 let workspaceWatcherError;
 let outputsWatcherError;
@@ -121,6 +124,12 @@ async function handleMessage(socket, data) {
     else if ((0, hash_glob_1.isHandleHashGlobMessage)(payload)) {
         await handleResult(socket, hash_glob_1.HASH_GLOB, () => (0, handle_hash_glob_1.handleHashGlob)(payload.globs, payload.exclude));
     }
+    else if ((0, task_history_1.isHandleGetTaskHistoryForHashesMessage)(payload)) {
+        await handleResult(socket, 'GET_TASK_HISTORY_FOR_HASHES', () => (0, handle_get_task_history_1.handleGetTaskHistoryForHashes)(payload.hashes));
+    }
+    else if ((0, task_history_1.isHandleWriteTaskRunsToHistoryMessage)(payload)) {
+        await handleResult(socket, 'WRITE_TASK_RUNS_TO_HISTORY', () => (0, handle_write_task_runs_to_history_1.handleWriteTaskRunsToHistory)(payload.taskRuns));
+    }
     else {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
     }

package/src/project-graph/plugins/isolation/index.d.ts

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import { LoadedNxPlugin } from '../internal-api';
-export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): [Promise<LoadedNxPlugin>, () => void];
+export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): readonly [Promise<LoadedNxPlugin>, () => void];

package/src/project-graph/plugins/isolation/index.js

@@ -10,11 +10,18 @@ const remotePluginCache = new Map();
 function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
     const cacheKey = JSON.stringify(plugin);
     if (remotePluginCache.has(cacheKey)) {
-        return [remotePluginCache.get(cacheKey), () => { }];
+        return remotePluginCache.get(cacheKey);
     }
-    const loadingPlugin = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-    remotePluginCache.set(cacheKey, loadingPlugin);
+    const [loadingPlugin, cleanup] = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
     // We clean up plugin workers when Nx process completes.
-    return [loadingPlugin, () => { }];
+    const val = [
+        loadingPlugin,
+        () => {
+            cleanup();
+            remotePluginCache.delete(cacheKey);
+        },
+    ];
+    remotePluginCache.set(cacheKey, val);
+    return val;
 }
 exports.loadNxPluginInIsolation = loadNxPluginInIsolation;

package/src/project-graph/plugins/isolation/plugin-pool.d.ts

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import { LoadedNxPlugin } from '../internal-api';
-export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<LoadedNxPlugin>;
+export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): [Promise<LoadedNxPlugin>, () => void];

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -42,10 +42,16 @@ function loadRemoteNxPlugin(plugin, root) {
         shutdownPluginWorker(worker);
     };
     cleanupFunctions.add(cleanupFunction);
-    return new Promise((res, rej) => {
-        worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
-        worker.on('exit', exitHandler);
-    });
+    return [
+        new Promise((res, rej) => {
+            worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
+            worker.on('exit', exitHandler);
+        }),
+        () => {
+            cleanupFunction();
+            cleanupFunctions.delete(cleanupFunction);
+        },
+    ];
 }
 exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
 function shutdownPluginWorker(worker) {

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

@@ -110,7 +110,13 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         }
     }
     finally {
-        cleanup();
+        // When plugins are isolated we don't clean them up during
+        // a single run of the CLI. They are cleaned up when the CLI
+        // process exits. Cleaning them here could cause issues if pending
+        // promises are not resolved.
+        if (process.env.NX_ISOLATE_PLUGINS !== 'true') {
+            cleanup();
+        }
     }
     const { projectGraph, projectFileMapCache } = projectGraphResult;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');

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

@@ -293,7 +293,7 @@ function mergeCreateNodesResults(results, errors) {
     const externalNodes = {};
     const configurationSourceMaps = {};
     for (const result of results.flat()) {
-        const [file, pluginName, nodes] = result;
+        const [pluginName, file, nodes] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
         const sourceInfo = [file, pluginName];
         if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {

package/src/tasks-runner/default-tasks-runner.js

@@ -13,12 +13,12 @@ const defaultTasksRunner = async (tasks, options, context) => {
         options['parallel'] === '') {
         options['parallel'] = Number(options['maxParallel'] || 3);
     }
-    options.lifeCycle.startCommand();
+    await options.lifeCycle.startCommand();
     try {
         return await runAllTasks(tasks, options, context);
     }
     finally {
-        options.lifeCycle.endCommand();
+        await options.lifeCycle.endCommand();
     }
 };
 exports.defaultTasksRunner = defaultTasksRunner;

package/src/tasks-runner/life-cycle.d.ts

@@ -10,9 +10,9 @@ export interface TaskMetadata {
     groupId: number;
 }
 export interface LifeCycle {
-    startCommand?(): void;
-    endCommand?(): void;
-    scheduleTask?(task: Task): void;
+    startCommand?(): void | Promise<void>;
+    endCommand?(): void | Promise<void>;
+    scheduleTask?(task: Task): void | Promise<void>;
     /**
      * @deprecated use startTasks
      *
@@ -25,19 +25,19 @@ export interface LifeCycle {
      * endTask won't be supported after Nx 14 is released.
      */
     endTask?(task: Task, code: number): void;
-    startTasks?(task: Task[], metadata: TaskMetadata): void;
-    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
+    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
 }
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(): void;
-    endCommand(): void;
-    scheduleTask(task: Task): void;
+    startCommand(): Promise<void>;
+    endCommand(): Promise<void>;
+    scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
     endTask(task: Task, code: number): void;
-    startTasks(tasks: Task[], metadata: TaskMetadata): void;
-    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
 }

package/src/tasks-runner/life-cycle.js

@@ -5,24 +5,24 @@ class CompositeLifeCycle {
     constructor(lifeCycles) {
         this.lifeCycles = lifeCycles;
     }
-    startCommand() {
+    async startCommand() {
         for (let l of this.lifeCycles) {
             if (l.startCommand) {
-                l.startCommand();
+                await l.startCommand();
             }
         }
     }
-    endCommand() {
+    async endCommand() {
         for (let l of this.lifeCycles) {
             if (l.endCommand) {
-                l.endCommand();
+                await l.endCommand();
             }
         }
     }
-    scheduleTask(task) {
+    async scheduleTask(task) {
         for (let l of this.lifeCycles) {
             if (l.scheduleTask) {
-                l.scheduleTask(task);
+                await l.scheduleTask(task);
             }
         }
     }
@@ -40,20 +40,20 @@ class CompositeLifeCycle {
             }
         }
     }
-    startTasks(tasks, metadata) {
+    async startTasks(tasks, metadata) {
         for (let l of this.lifeCycles) {
             if (l.startTasks) {
-                l.startTasks(tasks, metadata);
+                await l.startTasks(tasks, metadata);
             }
             else if (l.startTask) {
                 tasks.forEach((t) => l.startTask(t));
             }
         }
     }
-    endTasks(taskResults, metadata) {
+    async endTasks(taskResults, metadata) {
         for (let l of this.lifeCycles) {
             if (l.endTasks) {
-                l.endTasks(taskResults, metadata);
+                await l.endTasks(taskResults, metadata);
             }
             else if (l.endTask) {
                 taskResults.forEach((t) => l.endTask(t.task, t.code));

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

@@ -0,0 +1,9 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistoryLifeCycle = void 0;
+const serialize_target_1 = require("../../utils/serialize-target");
+const output_1 = require("../../utils/output");
+const task_history_1 = require("../../utils/task-history");
+class TaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = [];
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        const taskRuns = taskResults.map((taskResult) => ({
+            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(),
+        }));
+        this.taskRuns.push(...taskRuns);
+    }
+    async endCommand() {
+        await (0, task_history_1.writeTaskRunsToHistory)(this.taskRuns);
+        const history = await (0, task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
+        const 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)) {
+                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+            }
+        }
+        if (flakyTasks.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...flakyTasks.map((t) => `  ${t}`),
+                    '',
+                    `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/run-command.js

@@ -14,6 +14,7 @@ const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dyn
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const is_ci_1 = require("../utils/is-ci");
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
+const nx_json_1 = require("../config/nx-json");
 const create_task_graph_1 = require("./create-task-graph");
 const task_graph_utils_1 = require("./task-graph-utils");
 const params_1 = require("../utils/params");
@@ -21,6 +22,8 @@ const hash_task_1 = require("../hasher/hash-task");
 const client_1 = require("../daemon/client/client");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
+const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -203,6 +206,9 @@ function constructLifeCycles(lifeCycle) {
     if (process.env.NX_PROFILE) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        lifeCycles.push(new task_history_life_cycle_1.TaskHistoryLifeCycle());
+    }
     return lifeCycles;
 }
 function mergeTargetDependencies(defaults, deps) {

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

@@ -88,7 +88,7 @@ class TaskOrchestrator {
         if (!task.hash) {
             await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv);
         }
-        this.options.lifeCycle.scheduleTask(task);
+        await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
     }
     async processScheduledBatch(batch) {
@@ -96,7 +96,7 @@ class TaskOrchestrator {
             if (!task.hash) {
                 await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv);
             }
-            this.options.lifeCycle.scheduleTask(task);
+            await this.options.lifeCycle.scheduleTask(task);
         }));
     }
     processAllScheduledTasks() {
@@ -312,7 +312,7 @@ class TaskOrchestrator {
     // endregion Single Task
     // region Lifecycle
     async preRunSteps(tasks, metadata) {
-        this.options.lifeCycle.startTasks(tasks, metadata);
+        await this.options.lifeCycle.startTasks(tasks, metadata);
     }
     async postRunSteps(tasks, results, doNotSkipCache, { groupId }) {
         for (const task of tasks) {
@@ -342,7 +342,7 @@ class TaskOrchestrator {
             perf_hooks_1.performance.mark('cache-results-end');
             perf_hooks_1.performance.measure('cache-results', 'cache-results-start', 'cache-results-end');
         }
-        this.options.lifeCycle.endTasks(results.map((result) => {
+        await this.options.lifeCycle.endTasks(results.map((result) => {
             const code = result.status === 'success' ||
                 result.status === 'local-cache' ||
                 result.status === 'local-cache-kept-existing' ||

package/src/utils/serialize-target.d.ts

@@ -0,0 +1 @@
+export declare function serializeTarget(project: any, target: any, configuration: any): string;

package/src/utils/serialize-target.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeTarget = void 0;
+function serializeTarget(project, target, configuration) {
+    return [project, target, configuration].filter((part) => !!part).join(':');
+}
+exports.serializeTarget = serializeTarget;

package/src/utils/task-history.d.ts

@@ -0,0 +1,8 @@
+declare const taskRunKeys: readonly ["project", "target", "configuration", "hash", "code", "status", "start", "end"];
+export type TaskRun = Record<(typeof taskRunKeys)[number], string>;
+export declare function getHistoryForHashes(hashes: string[]): Promise<{
+    [hash: string]: TaskRun[];
+}>;
+export declare function writeTaskRunsToHistory(taskRuns: TaskRun[]): Promise<void>;
+export declare const taskHistoryFile: string;
+export {};

package/src/utils/task-history.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskHistoryFile = exports.writeTaskRunsToHistory = exports.getHistoryForHashes = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const client_1 = require("../daemon/client/client");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const cache_directory_1 = require("./cache-directory");
+const taskRunKeys = [
+    'project',
+    'target',
+    'configuration',
+    'hash',
+    'code',
+    'status',
+    'start',
+    'end',
+];
+let taskHistory = undefined;
+let taskHashToIndicesMap = new Map();
+async function getHistoryForHashes(hashes) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        if (taskHistory === undefined) {
+            loadTaskHistoryFromDisk();
+        }
+        const result = {};
+        for (let hash of hashes) {
+            const indices = taskHashToIndicesMap.get(hash);
+            if (!indices) {
+                result[hash] = [];
+            }
+            else {
+                result[hash] = indices.map((index) => taskHistory[index]);
+            }
+        }
+        return result;
+    }
+    return await client_1.daemonClient.getTaskHistoryForHashes(hashes);
+}
+exports.getHistoryForHashes = getHistoryForHashes;
+async function writeTaskRunsToHistory(taskRuns) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        if (taskHistory === undefined) {
+            loadTaskHistoryFromDisk();
+        }
+        const serializedLines = [];
+        for (let taskRun of taskRuns) {
+            const serializedLine = taskRunKeys.map((key) => taskRun[key]).join(',');
+            serializedLines.push(serializedLine);
+            recordTaskRunInMemory(taskRun);
+        }
+        if (!(0, fs_1.existsSync)(exports.taskHistoryFile)) {
+            (0, fs_1.writeFileSync)(exports.taskHistoryFile, `${taskRunKeys.join(',')}\n`);
+        }
+        (0, fs_1.appendFileSync)(exports.taskHistoryFile, serializedLines.join('\n') + '\n');
+    }
+    else {
+        await client_1.daemonClient.writeTaskRunsToHistory(taskRuns);
+    }
+}
+exports.writeTaskRunsToHistory = writeTaskRunsToHistory;
+exports.taskHistoryFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'task-history.csv');
+function loadTaskHistoryFromDisk() {
+    taskHashToIndicesMap.clear();
+    taskHistory = [];
+    if (!(0, fs_1.existsSync)(exports.taskHistoryFile)) {
+        return;
+    }
+    const fileContent = (0, fs_1.readFileSync)(exports.taskHistoryFile, 'utf8');
+    if (!fileContent) {
+        return;
+    }
+    const lines = fileContent.split('\n');
+    // if there are no lines or just the header, return
+    if (lines.length <= 1) {
+        return;
+    }
+    const contentLines = lines.slice(1).filter((l) => l.trim() !== '');
+    // read the values from csv format where each header is a key and the value is the value
+    for (let line of contentLines) {
+        const values = line.trim().split(',');
+        const run = {};
+        taskRunKeys.forEach((header, index) => {
+            run[header] = values[index];
+        });
+        recordTaskRunInMemory(run);
+    }
+}
+function recordTaskRunInMemory(taskRun) {
+    const index = taskHistory.push(taskRun) - 1;
+    if (taskHashToIndicesMap.has(taskRun.hash)) {
+        taskHashToIndicesMap.get(taskRun.hash).push(index);
+    }
+    else {
+        taskHashToIndicesMap.set(taskRun.hash, [index]);
+    }
+}