nx 19.7.0-canary.20240821-2065033 → 19.7.0-canary.20240823-1824267

package/src/plugins/js/package-json/create-package-json.js

@@ -121,6 +121,30 @@ function createPackageJson(projectName, graph, options = {}, fileMap = null) {
         }
         packageJson.packageManager = rootPackageJson.packageManager;
     }
+    // region Overrides/Resolutions
+    // npm
+    if (rootPackageJson.overrides && !options.skipOverrides) {
+        packageJson.overrides = {
+            ...rootPackageJson.overrides,
+            ...packageJson.overrides,
+        };
+    }
+    // pnpm
+    if (rootPackageJson.pnpm?.overrides && !options.skipOverrides) {
+        packageJson.pnpm ??= {};
+        packageJson.pnpm.overrides = {
+            ...rootPackageJson.pnpm.overrides,
+            ...packageJson.pnpm.overrides,
+        };
+    }
+    // yarn
+    if (rootPackageJson.resolutions && !options.skipOverrides) {
+        packageJson.resolutions = {
+            ...rootPackageJson.resolutions,
+            ...packageJson.resolutions,
+        };
+    }
+    // endregion Overrides/Resolutions
     return packageJson;
 }
 function findProjectsNpmDependencies(projectNode, graph, target, rootPackageJson, options, fileMap) {

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -140,15 +140,20 @@ class TargetProjectLocator {
                 return externalNodeName;
             }
             const version = (0, semver_1.clean)(externalPackageJson.version);
-            const npmProjectKey = `npm:${externalPackageJson.name}@${version}`;
-            let matchingExternalNode = this.npmProjects[npmProjectKey];
+            let matchingExternalNode = this.npmProjects[`npm:${externalPackageJson.name}@${version}`];
             if (!matchingExternalNode) {
                 // check if it's a package alias, where the resolved package key is used as the version
-                const aliasNpmProjectKey = `npm:${packageName}@${npmProjectKey}`;
+                const aliasNpmProjectKey = `npm:${packageName}@npm:${externalPackageJson.name}@${version}`;
                 matchingExternalNode = this.npmProjects[aliasNpmProjectKey];
-                if (!matchingExternalNode) {
-                    return null;
-                }
+            }
+            if (!matchingExternalNode) {
+                // Fallback to package name as key. This can happen if the version in project graph is not the same as in the resolved package.json.
+                // e.g. Version in project graph is a git remote, but the resolved version is semver.
+                matchingExternalNode =
+                    this.npmProjects[`npm:${externalPackageJson.name}`];
+            }
+            if (!matchingExternalNode) {
+                return null;
             }
             this.npmResolutionCache.set(npmImportForProject, matchingExternalNode.name);
             return matchingExternalNode.name;

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 await 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): Promise<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,40 @@
 "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 cache_directory_1 = require("../utils/cache-directory");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+class RemoteCacheV2 {
+    static async fromCacheV1(cache) {
+        await (0, promises_1.mkdir)((0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs'), { recursive: true });
+        return {
+            retrieve: async (hash, cacheDirectory) => {
+                const res = await cache.retrieve(hash, cacheDirectory);
+                if (res) {
+                    const [terminalOutput, oldTerminalOutput, code] = await Promise.all([
+                        (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'terminalOutputs'), 'utf-8').catch(() => null),
+                        (0, promises_1.readFile)((0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs', hash), 'utf-8').catch(() => null),
+                        (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'code'), 'utf-8').then((s) => +s),
+                    ]);
+                    return {
+                        outputsPath: cacheDirectory,
+                        terminalOutput: terminalOutput ?? oldTerminalOutput,
+                        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/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 {};