nx 19.6.1 → 19.7.0-beta.0

package/src/tasks-runner/cache.d.ts

@@ -1,4 +1,4 @@
-import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { DefaultTasksRunnerOptions, RemoteCache } from './default-tasks-runner';
 import { Task } from '../config/task-graph';
 export type CachedResult = {
     terminalOutput: string;
@@ -10,6 +10,26 @@ export type TaskWithCachedResult = {
     task: Task;
     cachedResult: CachedResult;
 };
+export declare class DbCache {
+    private readonly options;
+    private cache;
+    private remoteCache;
+    private remoteCachePromise;
+    setup(): Promise<void>;
+    constructor(options: {
+        nxCloudRemoteCache: RemoteCache;
+    });
+    get(task: Task): Promise<CachedResult | null>;
+    put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
+    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
+    removeOldCacheRecords(): void;
+    temporaryOutputPath(task: Task): string;
+    private getRemoteCache;
+    private _getRemoteCache;
+}
+/**
+ * @deprecated Use the {@link DbCache} class instead. This will be removed in Nx 21.
+ */
 export declare class Cache {
     private readonly options;
     root: string;
@@ -32,5 +52,4 @@ export declare class Cache {
     private assertLocalCacheValidity;
     private createCacheDir;
     private createTerminalOutputsDir;
-    private tryAndRetry;
 }

package/src/tasks-runner/cache.js

@@ -1,13 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = void 0;
+exports.Cache = exports.DbCache = void 0;
 const workspace_root_1 = require("../utils/workspace-root");
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
+const default_tasks_runner_1 = require("./default-tasks-runner");
 const child_process_1 = require("child_process");
 const cache_directory_1 = require("../utils/cache-directory");
 const node_machine_id_1 = require("node-machine-id");
+const native_1 = require("../native");
+const db_connection_1 = require("../utils/db-connection");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const nx_json_1 = require("../config/nx-json");
+const update_manager_1 = require("../nx-cloud/update-manager");
+const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
+class DbCache {
+    async setup() {
+        this.remoteCache = await this.getRemoteCache();
+    }
+    constructor(options) {
+        this.options = options;
+        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)());
+    }
+    async get(task) {
+        const res = this.cache.get(task.hash);
+        if (res) {
+            return {
+                ...res,
+                remote: false,
+            };
+        }
+        await this.setup();
+        if (this.remoteCache) {
+            // didn't find it locally but we have a remote cache
+            // attempt remote cache
+            const res = await this.remoteCache.retrieve(task.hash, this.cache.cacheDirectory);
+            if (res) {
+                this.cache.applyRemoteCacheResults(task.hash, res);
+                return {
+                    ...res,
+                    remote: true,
+                };
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    async put(task, terminalOutput, outputs, code) {
+        return tryAndRetry(async () => {
+            this.cache.put(task.hash, terminalOutput, outputs, code);
+            await this.setup();
+            if (this.remoteCache) {
+                await this.remoteCache.store(task.hash, this.cache.cacheDirectory, terminalOutput, code);
+            }
+        });
+    }
+    copyFilesFromCache(_, cachedResult, outputs) {
+        return tryAndRetry(async () => this.cache.copyFilesFromCache(cachedResult, outputs));
+    }
+    removeOldCacheRecords() {
+        return this.cache.removeOldCacheRecords();
+    }
+    temporaryOutputPath(task) {
+        return this.cache.getTaskOutputsPath(task.hash);
+    }
+    async getRemoteCache() {
+        if (this.remoteCachePromise) {
+            return this.remoteCachePromise;
+        }
+        this.remoteCachePromise = this._getRemoteCache();
+        return this.remoteCachePromise;
+    }
+    async _getRemoteCache() {
+        const nxJson = (0, nx_json_1.readNxJson)();
+        if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+            const options = (0, get_cloud_options_1.getCloudOptions)();
+            const { nxCloudClient } = await (0, update_manager_1.verifyOrUpdateNxCloudClient)(options);
+            if (nxCloudClient.remoteCache) {
+                return nxCloudClient.remoteCache;
+            }
+            else {
+                // old nx cloud instance
+                return default_tasks_runner_1.RemoteCacheV2.fromCacheV1(this.options.nxCloudRemoteCache);
+            }
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.DbCache = DbCache;
+/**
+ * @deprecated Use the {@link DbCache} class instead. This will be removed in Nx 21.
+ */
 class Cache {
     constructor(options) {
         this.options = options;
@@ -44,7 +134,7 @@ class Cache {
                 this._currentMachineId = await (0, node_machine_id_1.machineId)();
             }
             catch (e) {
-                if (process.env.NX_VERBOSE_LOGGING == 'true') {
+                if (process.env.NX_VERBOSE_LOGGING === 'true') {
                     console.log(`Unable to get machineId. Error: ${e.message}`);
                 }
                 this._currentMachineId = '';
@@ -71,7 +161,10 @@ class Cache {
         }
     }
     async put(task, terminalOutput, outputs, code) {
-        return this.tryAndRetry(async () => {
+        return tryAndRetry(async () => {
+            /**
+             * This is the directory with the cached artifacts
+             */
             const td = (0, path_1.join)(this.cachePath, task.hash);
             const tdCommit = (0, path_1.join)(this.cachePath, `${task.hash}.commit`);
             // might be left overs from partially-completed cache invocations
@@ -105,7 +198,7 @@ class Cache {
         });
     }
     async copyFilesFromCache(hash, cachedResult, outputs) {
-        return this.tryAndRetry(async () => {
+        return tryAndRetry(async () => {
             const expandedOutputs = await this.expandOutputsInCache(outputs, cachedResult);
             await Promise.all(expandedOutputs.map(async (f) => {
                 const cached = (0, path_1.join)(cachedResult.outputsPath, f);
@@ -213,27 +306,26 @@ class Cache {
         (0, fs_extra_1.mkdirSync)(path, { recursive: true });
         return path;
     }
-    tryAndRetry(fn) {
-        let attempts = 0;
-        const baseTimeout = 5;
-        // Generate a random number between 2 and 4 to raise to the power of attempts
-        const baseExponent = Math.random() * 2 + 2;
-        const _try = async () => {
-            try {
-                attempts++;
-                return await fn();
-            }
-            catch (e) {
-                // Max time is 5 * 4^3 = 20480ms
-                if (attempts === 6) {
-                    // After enough attempts, throw the error
-                    throw e;
-                }
-                await new Promise((res) => setTimeout(res, baseExponent ** attempts));
-                return await _try();
-            }
-        };
-        return _try();
-    }
 }
 exports.Cache = Cache;
+function tryAndRetry(fn) {
+    let attempts = 0;
+    // Generate a random number between 2 and 4 to raise to the power of attempts
+    const baseExponent = Math.random() * 2 + 2;
+    const _try = async () => {
+        try {
+            attempts++;
+            return await fn();
+        }
+        catch (e) {
+            // Max time is 5 * 4^3 = 20480ms
+            if (attempts === 6) {
+                // After enough attempts, throw the error
+                throw e;
+            }
+            await new Promise((res) => setTimeout(res, baseExponent ** attempts));
+            return await _try();
+        }
+    };
+    return _try();
+}

package/src/tasks-runner/default-tasks-runner.d.ts

@@ -1,9 +1,15 @@
 import { TasksRunner } from './tasks-runner';
 import { LifeCycle } from './life-cycle';
+import { CachedResult } from '../native';
 export interface RemoteCache {
     retrieve: (hash: string, cacheDirectory: string) => Promise<boolean>;
     store: (hash: string, cacheDirectory: string) => Promise<boolean>;
 }
+export declare abstract class RemoteCacheV2 {
+    static fromCacheV1(cache: RemoteCache): RemoteCacheV2;
+    abstract retrieve(hash: string, cacheDirectory: string): Promise<CachedResult | null>;
+    abstract store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>;
+}
 export interface DefaultTasksRunnerOptions {
     parallel?: number;
     cacheableOperations?: string[];

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

@@ -1,7 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultTasksRunner = void 0;
+exports.defaultTasksRunner = exports.RemoteCacheV2 = void 0;
 const task_orchestrator_1 = require("./task-orchestrator");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+class RemoteCacheV2 {
+    static fromCacheV1(cache) {
+        return {
+            retrieve: async (hash, cacheDirectory) => {
+                const res = cache.retrieve(hash, cacheDirectory);
+                const [terminalOutput, code] = await Promise.all([
+                    (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'terminalOutputs'), 'utf-8'),
+                    (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'code'), 'utf-8').then((s) => +s),
+                ]);
+                if (res) {
+                    return {
+                        outputsPath: cacheDirectory,
+                        terminalOutput,
+                        code,
+                    };
+                }
+                else {
+                    return null;
+                }
+            },
+            store: async (hash, cacheDirectory, __, code) => {
+                await (0, promises_1.writeFile)((0, path_1.join)(cacheDirectory, hash, 'code'), code.toString());
+                return cache.store(hash, cacheDirectory);
+            },
+        };
+    }
+}
+exports.RemoteCacheV2 = RemoteCacheV2;
 const defaultTasksRunner = async (tasks, options, context) => {
     if (options['parallel'] === 'false' ||
         options['parallel'] === false) {

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

@@ -0,0 +1,9 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class LegacyTaskHistoryLifeCycle 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-old.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyTaskHistoryLifeCycle = void 0;
+const serialize_target_1 = require("../../utils/serialize-target");
+const output_1 = require("../../utils/output");
+const legacy_task_history_1 = require("../../utils/legacy-task-history");
+class LegacyTaskHistoryLifeCycle {
+    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, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
+        const history = await (0, legacy_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.LegacyTaskHistoryLifeCycle = LegacyTaskHistoryLifeCycle;

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

@@ -3,6 +3,7 @@ import { LifeCycle, TaskResult } from '../life-cycle';
 export declare class TaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
+    private taskHistory;
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;

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

@@ -7,7 +7,8 @@ const task_history_1 = require("../../utils/task-history");
 class TaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
-        this.taskRuns = [];
+        this.taskRuns = new Map();
+        this.taskHistory = new task_history_1.TaskHistory();
     }
     startTasks(tasks) {
         for (let task of tasks) {
@@ -15,35 +16,32 @@ class TaskHistoryLifeCycle {
         }
     }
     async endTasks(taskResults) {
-        const taskRuns = taskResults.map((taskResult) => ({
-            project: taskResult.task.target.project,
-            target: taskResult.task.target.target,
-            configuration: taskResult.task.target.configuration,
+        taskResults
+            .map((taskResult) => ({
             hash: taskResult.task.hash,
-            code: taskResult.code.toString(),
+            target: taskResult.task.target,
+            code: taskResult.code,
             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);
+            start: taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
+            end: taskResult.task.endTime ?? Date.now(),
+        }))
+            .forEach((taskRun) => {
+            this.taskRuns.set(taskRun.hash, taskRun);
+        });
     }
     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));
-            }
-        }
+        const entries = Array.from(this.taskRuns);
+        await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
+        const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
         if (flakyTasks.length > 0) {
             output_1.output.warn({
                 title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((t) => `  ${t}`),
+                    ...flakyTasks.map((hash) => {
+                        const taskRun = this.taskRuns.get(hash);
+                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+                    }),
                     '',
                     `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
                 ],

package/src/tasks-runner/run-command.js

@@ -27,11 +27,13 @@ const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/stat
 const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-terminal-output-life-cycle");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
+const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
+const native_1 = require("../native");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -333,7 +335,7 @@ function constructLifeCycles(lifeCycle) {
         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());
+        lifeCycles.push(!native_1.IS_WASM ? new task_history_life_cycle_1.TaskHistoryLifeCycle() : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle());
     }
     return lifeCycles;
 }

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

@@ -15,6 +15,8 @@ const task_env_1 = require("./task-env");
 const workspace_root_1 = require("../utils/workspace-root");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const nx_json_1 = require("../config/nx-json");
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon) {
@@ -25,7 +27,14 @@ class TaskOrchestrator {
         this.options = options;
         this.bail = bail;
         this.daemon = daemon;
-        this.cache = new cache_1.Cache(this.options);
+        this.cache = process.env.NX_DB_CACHE === 'true'
+            ? new cache_1.DbCache({
+                // Remove this in Nx 21
+                nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
+                    ? this.options.remoteCache
+                    : null,
+            })
+            : new cache_1.Cache(this.options);
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // region internal state

package/src/utils/cache-directory.d.ts

@@ -4,3 +4,4 @@
 export declare const cacheDir: string;
 export declare function cacheDirectoryForWorkspace(workspaceRoot: string): string;
 export declare const workspaceDataDirectory: string;
+export declare function workspaceDataDirectoryForWorkspace(workspaceRoot: string): string;

package/src/utils/cache-directory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workspaceDataDirectory = exports.cacheDir = void 0;
 exports.cacheDirectoryForWorkspace = cacheDirectoryForWorkspace;
+exports.workspaceDataDirectoryForWorkspace = workspaceDataDirectoryForWorkspace;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const fileutils_1 = require("./fileutils");
@@ -62,6 +63,9 @@ exports.cacheDir = cacheDirectory(workspace_root_1.workspaceRoot, readCacheDirec
 function cacheDirectoryForWorkspace(workspaceRoot) {
     return cacheDirectory(workspaceRoot, readCacheDirectoryProperty(workspaceRoot));
 }
-exports.workspaceDataDirectory = absolutePath(workspace_root_1.workspaceRoot, process.env.NX_WORKSPACE_DATA_DIRECTORY ??
-    process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
-    defaultWorkspaceDataDirectory(workspace_root_1.workspaceRoot));
+exports.workspaceDataDirectory = workspaceDataDirectoryForWorkspace(workspace_root_1.workspaceRoot);
+function workspaceDataDirectoryForWorkspace(workspaceRoot) {
+    return absolutePath(workspaceRoot, process.env.NX_WORKSPACE_DATA_DIRECTORY ??
+        process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
+        defaultWorkspaceDataDirectory(workspaceRoot));
+}

package/src/utils/db-connection.d.ts

@@ -0,0 +1,2 @@
+import { ExternalObject } from '../native';
+export declare function getDbConnection(directory?: string): ExternalObject<any>;

package/src/utils/db-connection.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbConnection = getDbConnection;
+const native_1 = require("../native");
+const cache_directory_1 = require("./cache-directory");
+const package_json_1 = require("../../package.json");
+let dbConnection;
+function getDbConnection(directory = cache_directory_1.workspaceDataDirectory) {
+    dbConnection ??= (0, native_1.connectToNxDb)(directory, package_json_1.version);
+    return dbConnection;
+}

package/src/utils/git-utils.js

@@ -83,7 +83,7 @@ class GitRepository {
         return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
     }
     async move(path, destination) {
-        return this.execAsync(`git mv ${path} ${destination}`);
+        return this.execAsync(`git mv "${path}" "${destination}"`);
     }
     async push(ref, remoteName) {
         return this.execAsync(`git push -u -f ${remoteName} ${ref}`);

package/src/utils/legacy-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/legacy-task-history.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskHistoryFile = void 0;
+exports.getHistoryForHashes = getHistoryForHashes;
+exports.writeTaskRunsToHistory = writeTaskRunsToHistory;
+const fs_1 = require("fs");
+const path_1 = require("path");
+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 (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;
+}
+async function writeTaskRunsToHistory(taskRuns) {
+    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');
+}
+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]);
+    }
+}

package/src/utils/logger.js

@@ -36,7 +36,7 @@ exports.logger = {
         console.error(...s);
     },
     verbose: (...s) => {
-        if (process.env.NX_VERBOSE_LOGGING) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
             console.log(...s);
         }
     },

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

@@ -1,8 +1,6 @@
-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 {};
+import { NxTaskHistory, TaskRun } from '../native';
+export declare class TaskHistory {
+    taskHistory: NxTaskHistory;
+    getFlakyTasks(hashes: string[]): Promise<string[]>;
+    recordTaskRuns(taskRuns: TaskRun[]): Promise<void>;
+}