nx 19.4.0-canary.20240622-963f753 → 19.4.0-canary.20240627-c2c6a13

package/src/utils/git-utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLatestCommitSha = exports.commitChanges = exports.extractUserAndRepoFromGitHubUrl = exports.getGithubSlugOrNull = void 0;
 const child_process_1 = require("child_process");
+const devkit_exports_1 = require("../devkit-exports");
 function getGithubSlugOrNull() {
     try {
         const gitRemote = (0, child_process_1.execSync)('git remote -v').toString();
@@ -38,17 +39,27 @@ function parseGitHubUrl(url) {
     }
     return null;
 }
-function commitChanges(commitMessage) {
+function commitChanges(commitMessage, directory) {
     try {
         (0, child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
         (0, child_process_1.execSync)('git commit --no-verify -F -', {
             encoding: 'utf8',
             stdio: 'pipe',
             input: commitMessage,
+            cwd: directory,
         });
     }
     catch (err) {
-        throw new Error(`Error committing changes:\n${err.stderr}`);
+        if (directory) {
+            // We don't want to throw during create-nx-workspace
+            // because maybe there was an error when setting up git
+            // initially.
+            devkit_exports_1.logger.verbose(`Git may not be set up correctly for this new workspace.
+        ${err}`);
+        }
+        else {
+            throw new Error(`Error committing changes:\n${err.stderr}`);
+        }
     }
     return getLatestCommitSha();
 }

package/src/utils/nx-cloud-utils.d.ts

@@ -1,4 +1,4 @@
 import { NxJsonConfiguration } from '../config/nx-json';
-export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): string | boolean;
+export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
 export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
 export declare function getNxCloudToken(nxJson: NxJsonConfiguration): string;

package/src/utils/nx-cloud-utils.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNxCloudToken = exports.getNxCloudUrl = exports.isNxCloudUsed = void 0;
 function isNxCloudUsed(nxJson) {
-    return (process.env.NX_CLOUD_ACCESS_TOKEN ||
+    return (!!process.env.NX_CLOUD_ACCESS_TOKEN ||
         !!nxJson.nxCloudAccessToken ||
         !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
 }

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]);
+    }
+}