nx 20.8.4 → 22.7.7

package/dist/src/utils/consume-messages-from-socket.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_END_SEQ = void 0;
+exports.consumeMessagesFromSocket = consumeMessagesFromSocket;
+exports.isJsonMessage = isJsonMessage;
+exports.parseMessage = parseMessage;
+const string_decoder_1 = require("string_decoder");
+const v8_1 = require("v8");
+const VERY_END_CODE = 4;
+exports.MESSAGE_END_SEQ = 'NX_MSG_END' + String.fromCharCode(VERY_END_CODE);
+function consumeMessagesFromSocket(callback) {
+    let message = '';
+    const decoder = new string_decoder_1.StringDecoder('utf8');
+    return (data) => {
+        const chunk = decoder.write(data);
+        message += chunk;
+        // Check if accumulated message ends with MESSAGE_END_SEQ (not just the chunk)
+        // This handles TCP packet fragmentation where MESSAGE_END_SEQ may be split across packets
+        if (chunk.codePointAt(chunk.length - 1) === VERY_END_CODE &&
+            message.endsWith(exports.MESSAGE_END_SEQ)) {
+            // Remove the trailing MESSAGE_END_SEQ
+            const fullMessage = message.substring(0, message.length - exports.MESSAGE_END_SEQ.length);
+            // Server may send multiple messages in one chunk, so splitting by MESSAGE_END_SEQ
+            const messages = fullMessage.split(exports.MESSAGE_END_SEQ);
+            for (const splitMessage of messages) {
+                if (splitMessage) {
+                    callback(splitMessage);
+                }
+            }
+            message = '';
+        }
+        // If message doesn't end with MESSAGE_END_SEQ, keep accumulating chunks
+    };
+}
+function isJsonMessage(message) {
+    return (
+    // json objects
+    ['[', '{'].some((prefix) => message.startsWith(prefix)) ||
+        // booleans
+        message === 'true' ||
+        message === 'false' ||
+        // strings
+        (message.startsWith('"') && message.endsWith('"')) ||
+        // numbers
+        /^[0-9]+(\.?[0-9]+)?$/.test(message));
+}
+/**
+ * Parse a message that was produced by `serialize()` in
+ * `daemon/socket-utils.ts`. Auto-detects JSON vs. v8-serialized payloads using
+ * `isJsonMessage()` and decodes the binary path via `v8.deserialize`.
+ */
+function parseMessage(message) {
+    return isJsonMessage(message)
+        ? JSON.parse(message)
+        : (0, v8_1.deserialize)(Buffer.from(message, 'binary'));
+}

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

@@ -0,0 +1,14 @@
+import { ExternalObject } from '../native';
+export declare function getDbConnection(opts?: {
+    directory?: string;
+    dbName?: string;
+}): ExternalObject<any>;
+/**
+ * Returns a DB connection scoped to the local worktree (not shared).
+ * Use this for data that is inherently local to a worktree, such as
+ * running task tracking, where sharing across worktrees would cause
+ * false conflicts.
+ */
+export declare function getLocalDbConnection(opts?: {
+    dbName?: string;
+}): ExternalObject<any>;

package/dist/src/utils/db-connection.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbConnection = getDbConnection;
+exports.getLocalDbConnection = getLocalDbConnection;
+const native_1 = require("../native");
+const cache_directory_1 = require("./cache-directory");
+const workspace_root_1 = require("./workspace-root");
+const dbConnectionMap = new Map();
+/**
+ * Shared workspace-data directory, resolved once per process.
+ * In a git worktree this points to the main repo's workspace-data dir
+ * so all worktrees share the same DB.
+ */
+let _sharedDir;
+function sharedWorkspaceDataDirectory(root) {
+    if (_sharedDir)
+        return _sharedDir;
+    try {
+        const mainRoot = (0, native_1.getMainWorktreeRoot)(root);
+        if (mainRoot) {
+            _sharedDir = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(mainRoot);
+            return _sharedDir;
+        }
+    }
+    catch {
+        // Fall back to local workspace data if worktree detection fails
+    }
+    _sharedDir = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(root);
+    return _sharedDir;
+}
+function getDbConnection(opts = {}) {
+    opts.directory ??= sharedWorkspaceDataDirectory(workspace_root_1.workspaceRoot);
+    const key = `${opts.directory}:${opts.dbName ?? 'default'}`;
+    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, opts.dbName));
+    return connection;
+}
+/**
+ * Returns a DB connection scoped to the local worktree (not shared).
+ * Use this for data that is inherently local to a worktree, such as
+ * running task tracking, where sharing across worktrees would cause
+ * false conflicts.
+ */
+function getLocalDbConnection(opts = {}) {
+    const directory = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspace_root_1.workspaceRoot);
+    const key = `${directory}:${opts.dbName ?? 'default'}`;
+    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(directory, opts.dbName));
+    return connection;
+}
+function removeDbConnections() {
+    for (const connection of dbConnectionMap.values()) {
+        (0, native_1.closeDbConnection)(connection);
+    }
+    dbConnectionMap.clear();
+}
+process.on('exit', removeDbConnections);
+function getEntryOrSet(map, key, defaultValue) {
+    const existing = map.get(key);
+    if (existing) {
+        return existing;
+    }
+    const val = defaultValue();
+    map.set(key, val);
+    return val;
+}

package/dist/src/utils/default-base.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = deduceDefaultBase;
+const child_process_1 = require("child_process");
+function deduceDefaultBase() {
+    const nxDefaultBase = 'main';
+    try {
+        return ((0, child_process_1.execSync)('git config --get init.defaultBranch', {
+            windowsHide: true,
+        })
+            .toString()
+            .trim() || nxDefaultBase);
+    }
+    catch {
+        return nxDefaultBase;
+    }
+}

package/dist/src/utils/delayed-spinner.d.ts

@@ -0,0 +1,51 @@
+import { ProgressTopic } from './progress-topics';
+import { globalSpinner } from './spinner';
+export type DelayedSpinnerOptions = {
+    delay?: number;
+    ciDelay?: number;
+    /**
+     * When set and running inside the Nx daemon, spinner messages are
+     * broadcast to every client currently subscribed to this topic so
+     * their own spinners stay in sync with daemon-side progress.
+     */
+    progressTopic?: ProgressTopic;
+};
+/**
+ * A class that allows to delay the creation of a spinner, as well
+ * as schedule updates to the message of the spinner. Useful for
+ * scenarios where one wants to only show a spinner if an operation
+ * takes longer than a certain amount of time.
+ */
+export declare class DelayedSpinner {
+    spinner: typeof globalSpinner;
+    timeouts: NodeJS.Timeout[];
+    private lastMessage;
+    private ready;
+    private readonly progressTopic;
+    /**
+     * Constructs a new {@link DelayedSpinner} instance.
+     *
+     * @param opts The options for the spinner
+     */
+    constructor(message: string, opts?: DelayedSpinnerOptions);
+    /**
+     * Sets the message to display in the spinner.
+     *
+     * @param message The message to display in the spinner
+     * @returns The {@link DelayedSpinner} instance
+     */
+    setMessage(message: string): this;
+    /**
+     * Schedules an update to the message of the spinner. Useful for
+     * changing the message after a certain amount of time has passed.
+     *
+     * @param opts The options for the update
+     * @returns The {@link DelayedSpinner} instance
+     */
+    scheduleMessageUpdate(message: string, opts?: DelayedSpinnerOptions): this;
+    /**
+     * Stops the spinner and cleans up any scheduled timeouts.
+     */
+    cleanup(): void;
+    private broadcastProgress;
+}

package/dist/src/utils/delayed-spinner.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelayedSpinner = void 0;
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const client_socket_context_1 = require("../daemon/server/client-socket-context");
+const spinner_1 = require("./spinner");
+/**
+ * A class that allows to delay the creation of a spinner, as well
+ * as schedule updates to the message of the spinner. Useful for
+ * scenarios where one wants to only show a spinner if an operation
+ * takes longer than a certain amount of time.
+ */
+class DelayedSpinner {
+    /**
+     * Constructs a new {@link DelayedSpinner} instance.
+     *
+     * @param opts The options for the spinner
+     */
+    constructor(message, opts) {
+        this.timeouts = [];
+        opts = normalizeDelayedSpinnerOpts(opts);
+        this.progressTopic = opts.progressTopic;
+        const delay = spinner_1.SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay;
+        this.lastMessage = message;
+        this.broadcastProgress(message);
+        this.timeouts.push(setTimeout(() => {
+            this.ready = true;
+            if (!spinner_1.SHOULD_SHOW_SPINNERS) {
+                console.warn(this.lastMessage);
+            }
+            else if (!spinner_1.globalSpinner.isSpinning()) {
+                this.spinner = spinner_1.globalSpinner.start(this.lastMessage);
+            }
+        }, delay).unref());
+    }
+    /**
+     * Sets the message to display in the spinner.
+     *
+     * @param message The message to display in the spinner
+     * @returns The {@link DelayedSpinner} instance
+     */
+    setMessage(message) {
+        if (spinner_1.SHOULD_SHOW_SPINNERS) {
+            if (this.spinner && this.ready) {
+                this.spinner.updateText(message);
+            }
+        }
+        else if (this.ready && this.lastMessage && this.lastMessage !== message) {
+            console.warn(message);
+        }
+        this.broadcastProgress(message);
+        this.lastMessage = message;
+        return this;
+    }
+    /**
+     * Schedules an update to the message of the spinner. Useful for
+     * changing the message after a certain amount of time has passed.
+     *
+     * @param opts The options for the update
+     * @returns The {@link DelayedSpinner} instance
+     */
+    scheduleMessageUpdate(message, opts) {
+        opts = normalizeDelayedSpinnerOpts(opts);
+        this.timeouts.push(setTimeout(() => {
+            this.setMessage(message);
+        }, spinner_1.SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay).unref());
+        return this;
+    }
+    /**
+     * Stops the spinner and cleans up any scheduled timeouts.
+     */
+    cleanup() {
+        this.spinner?.stop();
+        this.timeouts.forEach((t) => clearTimeout(t));
+    }
+    broadcastProgress(message) {
+        if (this.progressTopic && (0, is_on_daemon_1.isOnDaemon)()) {
+            (0, client_socket_context_1.sendProgressMessageToTopic)(this.progressTopic, message);
+        }
+    }
+}
+exports.DelayedSpinner = DelayedSpinner;
+function normalizeDelayedSpinnerOpts(opts) {
+    opts ??= {};
+    opts.delay ??= 500;
+    opts.ciDelay ??= 30_000;
+    return opts;
+}

package/dist/src/utils/dotenv.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRootEnvFiles = loadRootEnvFiles;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("./workspace-root");
+const path_1 = require("path");
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+function loadRootEnvFiles(root = workspace_root_1.workspaceRoot) {
+    const myEnv = (0, dotenv_1.config)({
+        path: ['.local.env', '.env.local', '.env'].map((file) => (0, path_1.join)(root, file)),
+    });
+    (0, dotenv_expand_1.expand)(myEnv);
+}

package/dist/src/utils/enable-compile-cache.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Side-effect-only module: import this as the *first* import in any nx
+// process entry point so V8's compile cache is enabled before the rest of
+// the import chain (which is what we actually want to cache) starts loading.
+const compile_cache_1 = require("./compile-cache");
+(0, compile_cache_1.enableCompileCache)();

package/dist/src/utils/exit-codes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Translates NodeJS signals to numeric exit code
+ * @param signal
+ */
+export declare function signalToCode(signal: NodeJS.Signals | null): number;
+/**
+ * Translates numeric exit codes to NodeJS signals
+ */
+export declare function codeToSignal(code: number): NodeJS.Signals;
+export declare const EXPECTED_TERMINATION_SIGNALS: Set<number>;
+/**
+ * Translates a pty exit message (e.g. "Terminated by Interrupt") to a numeric exit code.
+ * Handles both Linux exact-match and macOS strsignal formats (e.g. "Terminated by Hangup: 1").
+ */
+export declare function messageToCode(message: string): number;

package/dist/src/utils/exit-codes.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPECTED_TERMINATION_SIGNALS = void 0;
+exports.signalToCode = signalToCode;
+exports.codeToSignal = codeToSignal;
+exports.messageToCode = messageToCode;
+/**
+ * Translates NodeJS signals to numeric exit code
+ * @param signal
+ */
+function signalToCode(signal) {
+    switch (signal) {
+        case 'SIGHUP':
+            return 128 + 1;
+        case 'SIGINT':
+            return 128 + 2;
+        case 'SIGTERM':
+            return 128 + 15;
+        case 'SIGQUIT':
+            return 128 + 3;
+        default:
+            return 128;
+    }
+}
+/**
+ * Translates numeric exit codes to NodeJS signals
+ */
+function codeToSignal(code) {
+    switch (code) {
+        case 128 + 1:
+            return 'SIGHUP';
+        case 128 + 2:
+            return 'SIGINT';
+        case 128 + 15:
+            return 'SIGTERM';
+        case 128 + 3:
+            return 'SIGQUIT';
+        default:
+            return 'SIGTERM';
+    }
+}
+// Exit codes from signals that indicate intentional termination (SIGHUP, SIGINT, SIGQUIT, SIGTERM).
+// Excludes SIGKILL (137) and SIGABRT (134) as those indicate abnormal termination.
+exports.EXPECTED_TERMINATION_SIGNALS = new Set([129, 130, 131, 143]);
+/**
+ * Translates a pty exit message (e.g. "Terminated by Interrupt") to a numeric exit code.
+ * Handles both Linux exact-match and macOS strsignal formats (e.g. "Terminated by Hangup: 1").
+ */
+function messageToCode(message) {
+    if (message.startsWith('Terminated by ')) {
+        const signalDescription = message.replace('Terminated by ', '').trim();
+        if (signalDescription.startsWith('Hangup'))
+            return 129;
+        if (signalDescription.startsWith('Interrupt'))
+            return 130;
+        if (signalDescription.startsWith('Quit'))
+            return 131;
+        if (signalDescription.startsWith('Abort'))
+            return 134;
+        if (signalDescription.startsWith('Killed'))
+            return 137;
+        if (signalDescription.startsWith('Terminated'))
+            return 143;
+        return 128;
+    }
+    else if (message.startsWith('Exited with code ')) {
+        return parseInt(message.replace('Exited with code ', '').trim());
+    }
+    else if (message === 'Success') {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}

package/dist/src/utils/fileutils.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFile = readJsonFile;
+exports.readYamlFile = readYamlFile;
+exports.writeJsonFile = writeJsonFile;
+exports.writeJsonFileAsync = writeJsonFileAsync;
+exports.directoryExists = directoryExists;
+exports.fileExists = fileExists;
+exports.createDirectory = createDirectory;
+exports.isRelativePath = isRelativePath;
+exports.extractFileFromTarball = extractFileFromTarball;
+exports.readFileIfExisting = readFileIfExisting;
+const tslib_1 = require("tslib");
+const json_1 = require("./json");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const path_1 = require("path");
+const tar = tslib_1.__importStar(require("tar-stream"));
+const zlib_1 = require("zlib");
+/**
+ * Reads a JSON file and returns the object the JSON content represents.
+ *
+ * @param path A path to a file.
+ * @param options JSON parse options
+ * @returns Object the JSON content of the file represents
+ */
+function readJsonFile(path, options) {
+    const content = (0, node_fs_1.readFileSync)(path, 'utf-8');
+    if (options) {
+        options.endsWithNewline = content.charCodeAt(content.length - 1) === 10;
+    }
+    try {
+        return (0, json_1.parseJson)(content, options);
+    }
+    catch (e) {
+        e.message = e.message.replace('JSON', path);
+        throw e;
+    }
+}
+/**
+ * Reads a YAML file and returns the object the YAML content represents.
+ *
+ * @param path A path to a file.
+ * @returns
+ */
+function readYamlFile(path, options) {
+    const content = (0, node_fs_1.readFileSync)(path, 'utf-8');
+    const { load } = require('@zkochan/js-yaml');
+    return load(content, { ...options, filename: path });
+}
+/**
+ * Serializes the given data to JSON and writes it to a file.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+function writeJsonFile(path, data, options) {
+    (0, node_fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+    const serializedJson = (0, json_1.serializeJson)(data, options);
+    const content = options?.appendNewLine
+        ? `${serializedJson}\n`
+        : serializedJson;
+    (0, node_fs_1.writeFileSync)(path, content, { encoding: 'utf-8' });
+}
+/**
+ * Serializes the given data to JSON and writes it to a file asynchronously.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+async function writeJsonFileAsync(path, data, options) {
+    await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+    const serializedJson = (0, json_1.serializeJson)(data, options);
+    const content = options?.appendNewLine
+        ? `${serializedJson}\n`
+        : serializedJson;
+    await (0, promises_1.writeFile)(path, content, { encoding: 'utf-8' });
+}
+/**
+ * Check if a directory exists
+ * @param path Path to directory
+ */
+function directoryExists(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file exists.
+ * @param path Path to file
+ */
+function fileExists(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function createDirectory(path) {
+    (0, node_fs_1.mkdirSync)(path, { recursive: true });
+}
+function isRelativePath(path) {
+    return (path === '.' ||
+        path === '..' ||
+        path.startsWith('./') ||
+        path.startsWith('../'));
+}
+/**
+ * Extracts a file from a given tarball to the specified destination.
+ * @param tarballPath The path to the tarball from where the file should be extracted.
+ * @param file The path to the file inside the tarball.
+ * @param destinationFilePath The destination file path.
+ * @returns True if the file was extracted successfully, false otherwise.
+ */
+async function extractFileFromTarball(tarballPath, file, destinationFilePath) {
+    return new Promise((resolve, reject) => {
+        (0, node_fs_1.mkdirSync)((0, path_1.dirname)(destinationFilePath), { recursive: true });
+        var tarExtractStream = tar.extract();
+        const destinationFileStream = (0, node_fs_1.createWriteStream)(destinationFilePath);
+        let isFileExtracted = false;
+        tarExtractStream.on('entry', function (header, stream, next) {
+            if (header.name === file) {
+                stream.pipe(destinationFileStream);
+                stream.on('end', () => {
+                    isFileExtracted = true;
+                });
+                destinationFileStream.on('close', () => {
+                    resolve(destinationFilePath);
+                });
+            }
+            stream.on('end', function () {
+                next();
+            });
+            stream.resume();
+        });
+        tarExtractStream.on('finish', function () {
+            if (!isFileExtracted) {
+                reject();
+            }
+        });
+        (0, node_fs_1.createReadStream)(tarballPath).pipe((0, zlib_1.createGunzip)()).pipe(tarExtractStream);
+    });
+}
+function readFileIfExisting(path) {
+    return (0, node_fs_1.existsSync)(path) ? (0, node_fs_1.readFileSync)(path, 'utf-8') : '';
+}