nx 20.8.4 → 22.7.7

package/dist/src/daemon/server/latest-nx.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestNxTmpPath = getLatestNxTmpPath;
+exports.cleanupLatestNx = cleanupLatestNx;
+const devkit_internals_1 = require("../../devkit-internals");
+const provenance_1 = require("../../utils/provenance");
+const logger_1 = require("../logger");
+// Module-level state - persists across invocations within daemon lifecycle
+let latestNxTmpPath = null;
+let cleanupFn = null;
+let installPromise = null;
+/**
+ * Returns the path to a temp directory containing `nx@latest`.
+ * The installation is cached for the lifetime of the daemon process.
+ * Guards against concurrent callers by reusing the in-flight promise.
+ */
+async function getLatestNxTmpPath() {
+    if (latestNxTmpPath !== null) {
+        logger_1.serverLogger.log('[LATEST-NX]: Reusing cached Nx installation from', latestNxTmpPath);
+        return latestNxTmpPath;
+    }
+    if (installPromise) {
+        return installPromise;
+    }
+    installPromise = (async () => {
+        try {
+            logger_1.serverLogger.log('[LATEST-NX]: Pulling latest Nx...');
+            await (0, provenance_1.ensurePackageHasProvenance)('nx', 'latest');
+            const result = await (0, devkit_internals_1.installPackageToTmpAsync)('nx', 'latest');
+            latestNxTmpPath = result.tempDir;
+            cleanupFn = result.cleanup;
+            logger_1.serverLogger.log('[LATEST-NX]: Successfully pulled latest Nx to', latestNxTmpPath);
+            return latestNxTmpPath;
+        }
+        finally {
+            installPromise = null;
+        }
+    })();
+    return installPromise;
+}
+/**
+ * Clean up the latest Nx installation on daemon shutdown.
+ */
+function cleanupLatestNx() {
+    if (cleanupFn) {
+        logger_1.serverLogger.log('[LATEST-NX]: Cleaning up latest Nx installation from', latestNxTmpPath);
+        cleanupFn();
+    }
+    latestNxTmpPath = null;
+    cleanupFn = null;
+}

package/dist/src/daemon/server/nx-console-operations.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gets the Nx Console status (whether we should prompt the user to install).
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @returns boolean indicating whether we should prompt the user
+ */
+export declare function getNxConsoleStatus({ inner, }?: {
+    inner?: boolean;
+}): Promise<boolean>;
+/**
+ * Handles user preference submission and installs Nx Console if requested.
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @param preference - whether the user wants to install Nx Console
+ * @returns object indicating whether installation succeeded
+ */
+export declare function handleNxConsolePreferenceAndInstall({ preference, inner, }: {
+    preference: boolean;
+    inner?: boolean;
+}): Promise<{
+    installed: boolean;
+}>;
+export declare function getNxConsoleStatusImpl(): Promise<boolean>;
+export declare function handleNxConsolePreferenceAndInstallImpl(preference: boolean): Promise<{
+    installed: boolean;
+}>;

package/dist/src/daemon/server/nx-console-operations.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxConsoleStatus = getNxConsoleStatus;
+exports.handleNxConsolePreferenceAndInstall = handleNxConsolePreferenceAndInstall;
+exports.getNxConsoleStatusImpl = getNxConsoleStatusImpl;
+exports.handleNxConsolePreferenceAndInstallImpl = handleNxConsolePreferenceAndInstallImpl;
+const os_1 = require("os");
+const native_1 = require("../../native");
+const logger_1 = require("../logger");
+const latest_nx_1 = require("./latest-nx");
+const handle_import_1 = require("../../utils/handle-import");
+const log = (...messageParts) => {
+    logger_1.serverLogger.log('[NX-CONSOLE]:', ...messageParts);
+};
+/**
+ * Gets the Nx Console status (whether we should prompt the user to install).
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @returns boolean indicating whether we should prompt the user
+ */
+async function getNxConsoleStatus({ inner, } = {}) {
+    // Use local implementation if explicitly requested
+    if (process.env.NX_USE_LOCAL === 'true' || inner === true) {
+        log('Using local implementation (NX_USE_LOCAL=true or inner call)');
+        return await getNxConsoleStatusImpl();
+    }
+    try {
+        const tmpPath = await (0, latest_nx_1.getLatestNxTmpPath)();
+        const modulePath = require.resolve('nx/src/daemon/server/nx-console-operations.js', { paths: [tmpPath] });
+        const module = await (0, handle_import_1.handleImport)(modulePath);
+        const result = await module.getNxConsoleStatus({ inner: true });
+        log('Console status check completed, shouldPrompt:', result);
+        return result;
+    }
+    catch (error) {
+        log('Failed to use latest Nx for console status. Error:', error.message);
+        return await getNxConsoleStatusImpl();
+    }
+}
+/**
+ * Handles user preference submission and installs Nx Console if requested.
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @param preference - whether the user wants to install Nx Console
+ * @returns object indicating whether installation succeeded
+ */
+async function handleNxConsolePreferenceAndInstall({ preference, inner, }) {
+    log('Handling user preference:', preference);
+    // Use local implementation if explicitly requested
+    if (process.env.NX_USE_LOCAL === 'true' || inner === true) {
+        log('Using local implementation (NX_USE_LOCAL=true or inner call)');
+        return await handleNxConsolePreferenceAndInstallImpl(preference);
+    }
+    try {
+        const tmpPath = await (0, latest_nx_1.getLatestNxTmpPath)();
+        const modulePath = require.resolve('nx/src/daemon/server/nx-console-operations.js', { paths: [tmpPath] });
+        const module = await (0, handle_import_1.handleImport)(modulePath);
+        const result = await module.handleNxConsolePreferenceAndInstall({
+            preference,
+            inner: true,
+        });
+        log('Preference saved and installation', result.installed ? 'succeeded' : 'skipped/failed');
+        return result;
+    }
+    catch (error) {
+        log('Failed to use latest Nx for preference install. Error:', error.message);
+        return await handleNxConsolePreferenceAndInstallImpl(preference);
+    }
+}
+async function getNxConsoleStatusImpl() {
+    // If no cached preference, read from disk
+    const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+    const preference = preferences.getAutoInstallPreference();
+    const canInstallConsole = await (0, native_1.canInstallNxConsole)();
+    // If user previously opted in but extension is not installed,
+    // they must have manually uninstalled it - respect that choice
+    if (preference === true && canInstallConsole) {
+        const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+        preferences.setAutoInstallPreference(false);
+        return false; // Don't prompt
+    }
+    // Noop if can't install
+    if (!canInstallConsole) {
+        return false;
+    }
+    // Prompt if we can install and user hasn't answered yet
+    return typeof preference !== 'boolean';
+}
+async function handleNxConsolePreferenceAndInstallImpl(preference) {
+    const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+    preferences.setAutoInstallPreference(preference);
+    let installed = false;
+    if (preference) {
+        installed = await (0, native_1.installNxConsole)();
+    }
+    return { installed };
+}

package/dist/src/daemon/server/outputs-tracking.d.ts

@@ -0,0 +1,23 @@
+import { WatchEvent } from '../../native';
+export declare function _recordOutputsHash(outputs: string[], hash: string): void;
+export declare function _outputsHashesMatch(outputs: string[], hash: string): boolean;
+export declare function processFileChangesInOutputs(changeEvents: WatchEvent[], now?: number): void;
+/**
+ * Check whether the on-disk outputs of each entry still match the hash
+ * the daemon recorded for them. Uses Rayon-parallel filesystem scanning
+ * for uncached entries.
+ */
+export declare function outputsHashesMatchBatch(entries: {
+    outputs: string[];
+    hash: string;
+}[]): boolean[];
+/**
+ * Record the hash of each entry's on-disk outputs so future
+ * outputsHashesMatchBatch calls can skip redundant cache copies.
+ * Uses Rayon-parallel filesystem scanning.
+ */
+export declare function recordOutputsHashBatch(entries: {
+    outputs: string[];
+    hash: string;
+}[]): void;
+export declare function disableOutputsTracking(): void;

package/dist/src/daemon/server/outputs-tracking.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._recordOutputsHash = _recordOutputsHash;
+exports._outputsHashesMatch = _outputsHashesMatch;
+exports.processFileChangesInOutputs = processFileChangesInOutputs;
+exports.outputsHashesMatchBatch = outputsHashesMatchBatch;
+exports.recordOutputsHashBatch = recordOutputsHashBatch;
+exports.disableOutputsTracking = disableOutputsTracking;
+const path_1 = require("path");
+const native_1 = require("../../native");
+const collapse_expanded_outputs_1 = require("../../utils/collapse-expanded-outputs");
+const workspace_root_1 = require("../../utils/workspace-root");
+let disabled = false;
+const dirsContainingOutputs = {};
+const recordedHashes = {};
+const timestamps = {};
+const numberOfExpandedOutputs = {};
+function _recordOutputsHash(outputs, hash) {
+    numberOfExpandedOutputs[hash] = outputs.length;
+    for (const output of outputs) {
+        recordedHashes[output] = hash;
+        timestamps[output] = new Date().getTime();
+        let current = output;
+        while (current != (0, path_1.dirname)(current)) {
+            if (!dirsContainingOutputs[current]) {
+                dirsContainingOutputs[current] = new Set();
+            }
+            dirsContainingOutputs[current].add(output);
+            current = (0, path_1.dirname)(current);
+        }
+    }
+}
+function _outputsHashesMatch(outputs, hash) {
+    if (outputs.length !== numberOfExpandedOutputs[hash]) {
+        return false;
+    }
+    else {
+        for (const output of outputs) {
+            if (recordedHashes[output] !== hash) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function processFileChangesInOutputs(changeEvents, now = undefined) {
+    if (!now) {
+        now = new Date().getTime();
+    }
+    for (let e of changeEvents) {
+        let current = e.path;
+        // the path is either an output itself or a parent
+        if (dirsContainingOutputs[current]) {
+            dirsContainingOutputs[current].forEach((output) => {
+                if (now - timestamps[output] > 2000) {
+                    recordedHashes[output] = undefined;
+                }
+            });
+            continue;
+        }
+        // the path is a child of some output or unrelated
+        while (current != (0, path_1.dirname)(current)) {
+            if (recordedHashes[current] && now - timestamps[current] > 2000) {
+                recordedHashes[current] = undefined;
+                break;
+            }
+            current = (0, path_1.dirname)(current);
+        }
+    }
+}
+/**
+ * Check whether the on-disk outputs of each entry still match the hash
+ * the daemon recorded for them. Uses Rayon-parallel filesystem scanning
+ * for uncached entries.
+ */
+function outputsHashesMatchBatch(entries) {
+    if (disabled)
+        return entries.map(() => false);
+    // Fast path: skip filesystem scan for entries with no recorded hash.
+    // _outputsHashesMatch will return false immediately if the hash isn't
+    // in numberOfExpandedOutputs, so scanning the filesystem is wasted work.
+    const needsScan = [];
+    const results = new Array(entries.length);
+    for (let i = 0; i < entries.length; i++) {
+        if (numberOfExpandedOutputs[entries[i].hash] === undefined) {
+            results[i] = false;
+        }
+        else {
+            needsScan.push(i);
+        }
+    }
+    if (needsScan.length > 0) {
+        // Only scan outputs for entries that have recorded hashes
+        const outputsBatch = needsScan.map((i) => entries[i].outputs);
+        const expandedBatch = (0, native_1.getFilesForOutputsBatch)(workspace_root_1.workspaceRoot, outputsBatch);
+        for (let j = 0; j < needsScan.length; j++) {
+            const expanded = (0, collapse_expanded_outputs_1.collapseExpandedOutputs)(expandedBatch[j]);
+            results[needsScan[j]] = _outputsHashesMatch(expanded, entries[needsScan[j]].hash);
+        }
+    }
+    return results;
+}
+/**
+ * Record the hash of each entry's on-disk outputs so future
+ * outputsHashesMatchBatch calls can skip redundant cache copies.
+ * Uses Rayon-parallel filesystem scanning.
+ */
+function recordOutputsHashBatch(entries) {
+    if (disabled)
+        return;
+    const outputsBatch = entries.map((e) => e.outputs);
+    const expandedBatch = (0, native_1.getFilesForOutputsBatch)(workspace_root_1.workspaceRoot, outputsBatch);
+    for (let i = 0; i < entries.length; i++) {
+        const expanded = (0, collapse_expanded_outputs_1.collapseExpandedOutputs)(expandedBatch[i]);
+        _recordOutputsHash(expanded, entries[i].hash);
+    }
+}
+function disableOutputsTracking() {
+    disabled = true;
+}

package/dist/src/daemon/server/project-graph-incremental-recomputation.d.ts

@@ -0,0 +1,29 @@
+import { Socket } from 'net';
+import { FileData, FileMap, ProjectGraph } from '../../config/project-graph';
+import { NxWorkspaceFilesExternals } from '../../native';
+import { FileMapCache } from '../../project-graph/nx-deps-cache';
+import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
+interface SerializedProjectGraph {
+    error: Error | null;
+    projectGraph: ProjectGraph | null;
+    projectFileMapCache: FileMapCache | null;
+    fileMap: FileMap | null;
+    allWorkspaceFiles: FileData[] | null;
+    serializedProjectGraph: string | null;
+    serializedSourceMaps: string | null;
+    sourceMaps: ConfigurationSourceMaps | null;
+    rustReferences: NxWorkspaceFilesExternals | null;
+}
+export declare let fileMapWithFiles: {
+    fileMap: FileMap;
+    allWorkspaceFiles: FileData[];
+    rustReferences: NxWorkspaceFilesExternals;
+} | undefined;
+export declare let currentProjectFileMapCache: FileMapCache | undefined;
+export declare let currentProjectGraph: ProjectGraph | undefined;
+export declare let currentSourceMaps: ConfigurationSourceMaps | undefined;
+export declare function getCachedSerializedProjectGraphPromise(socket?: Socket): Promise<SerializedProjectGraph>;
+export declare function addUpdatedAndDeletedFiles(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
+export declare function registerProjectGraphRecomputationListener(listener: (projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, error: Error | null) => void): void;
+export declare function invalidateGraphCache(): void;
+export {};