nx 20.8.4 → 22.7.7

package/dist/src/utils/path.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.joinPathFragments = joinPathFragments;
+exports.getCwd = getCwd;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const workspace_root_1 = require("./workspace-root");
+function removeWindowsDriveLetter(osSpecificPath) {
+    return osSpecificPath.replace(/^[a-zA-Z]:/, '');
+}
+/**
+ * Coverts an os specific path to a unix style path. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+function normalizePath(osSpecificPath) {
+    return removeWindowsDriveLetter(osSpecificPath).split('\\').join('/');
+}
+/**
+ * Normalized path fragments and joins them. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+function joinPathFragments(...fragments) {
+    return normalizePath(path.join(...fragments));
+}
+/**
+ * When running a script with the package manager (e.g. `npm run`), the package manager will
+ * traverse the directory tree upwards until it finds a `package.json` and will set `process.cwd()`
+ * to the folder where it found it. The actual working directory is stored in the INIT_CWD
+ * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
+ *
+ * @returns The path to the current working directory.
+ */
+function getCwd() {
+    return process.env.INIT_CWD?.startsWith(workspace_root_1.workspaceRoot)
+        ? process.env.INIT_CWD
+        : process.cwd();
+}

package/dist/src/utils/perf-hooks.d.ts

@@ -0,0 +1,19 @@
+import type { EventParameters } from '../analytics/analytics';
+
+export interface TrackedDetail extends EventParameters {
+  track: true;
+  [key: string]: string | number | boolean;
+}
+
+interface TrackedMeasureOptions {
+  start?: string | number;
+  end?: string | number;
+  duration?: number;
+  detail: TrackedDetail;
+}
+
+declare module 'perf_hooks' {
+  interface Performance {
+    measure(name: string, options: TrackedMeasureOptions): PerformanceMeasure;
+  }
+}

package/dist/src/utils/perf-logging.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const perf_hooks_1 = require("perf_hooks");
+function isTrackedDetail(detail) {
+    return (typeof detail === 'object' &&
+        detail !== null &&
+        detail.track === true);
+}
+new perf_hooks_1.PerformanceObserver((list) => {
+    // observer is configured for 'measure' entries only (see .observe call below)
+    const entries = list.getEntries();
+    const logEnabled = process.env.NX_PERF_LOGGING === 'true';
+    const tracked = entries.filter((e) => isTrackedDetail(e.detail));
+    // Short-circuit before loading analytics / daemon logger (~60ms of native
+    // binding + module init) when there's nothing to do.
+    if (!logEnabled && tracked.length === 0)
+        return;
+    if (logEnabled) {
+        const { isOnDaemon } = require('../daemon/is-on-daemon');
+        const { serverLogger } = require('../daemon/logger');
+        const { logger } = require('./logger');
+        const log = isOnDaemon()
+            ? (msg) => serverLogger.log(msg)
+            : (msg) => logger.warn(msg);
+        for (const entry of entries) {
+            log(`Time taken for '${entry.name}' ${entry.duration}ms`);
+        }
+    }
+    if (tracked.length === 0)
+        return;
+    const { customDimensions, reportEvent } = require('../analytics');
+    if (!customDimensions)
+        return;
+    const dimensionValues = new Set(Object.values(customDimensions));
+    for (const entry of tracked) {
+        const { track, ...rest } = entry.detail;
+        const params = {
+            [customDimensions.duration]: entry.duration,
+        };
+        for (const [key, value] of Object.entries(rest)) {
+            if (dimensionValues.has(key))
+                params[key] = value;
+        }
+        reportEvent(entry.name, params);
+    }
+}).observe({ entryTypes: ['measure'] });

package/dist/src/utils/plugin-cache-utils.d.ts

@@ -0,0 +1,73 @@
+/**
+ * On-disk format for plugin caches with LRU metadata.
+ */
+interface PluginCacheData<T> {
+    entries: Record<string, T>;
+    accessOrder: string[];
+}
+/**
+ * A plugin cache that tracks access order for LRU eviction.
+ *
+ * Uses explicit `get()` / `set()` / `has()` methods instead of a Proxy
+ * for easier debugging and predictable behavior.
+ *
+ * Access order is tracked via an append-only session log. Deduplication
+ * happens once at serialization time (`toSerializable()`), keeping per-access
+ * cost at O(1).
+ *
+ * Eviction splices the first half of the deduped access-order queue — the
+ * least recently used keys.
+ */
+export declare class PluginCache<T> {
+    private entries;
+    private accessOrder;
+    constructor(cachePath: string);
+    constructor(entries?: Record<string, T>, accessOrder?: string[] | Set<string>);
+    private touch;
+    /**
+     * Returns the value for `key`, or `undefined` if not present.
+     * Tracks the access in the session log for LRU ordering.
+     */
+    get(key: string): T | undefined;
+    /**
+     * Sets `key` to `value` and tracks the access in the session log.
+     */
+    set(key: string, value: T): void;
+    /**
+     * Returns `true` if `key` exists in the cache.
+     * Does NOT track access — use this for existence checks that
+     * should not affect eviction order.
+     */
+    has(key: string): boolean;
+    /**
+     * Returns the serializable cache data (entries + accessOrder).
+     */
+    toSerializable(): PluginCacheData<T>;
+    /**
+     * Safely writes this cache to disk.
+     *
+     * Strategy:
+     * 1. Serialize to JSON
+     *    - RangeError (string too large): evict oldest 50% and retry
+     *    - Other errors (e.g. circular refs): skip straight to empty cache
+     * 2. Write the serialized string to disk — if this fails (fs error),
+     *    wipe the cache file so a corrupted file doesn't persist
+     * 3. On total serialization failure (even after eviction),
+     *    write an empty cache so the file is valid
+     */
+    writeToDisk(cachePath: string): void;
+    /**
+     * Evicts the oldest 50% of entries (front of the access-order queue)
+     * and returns the remaining entries + accessOrder as a plain object.
+     */
+    private evictOldestHalf;
+}
+/**
+ * Safely writes already-stringified content to a cache file on disk.
+ *
+ * Strategy:
+ * 1. Attempt mkdirSync + writeFileSync
+ * 2. On failure: remove existing cache file, log warning, return without throwing
+ */
+export declare function safeWriteFileCache(cachePath: string, content: string): void;
+export {};

package/dist/src/utils/plugin-cache-utils.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginCache = void 0;
+exports.safeWriteFileCache = safeWriteFileCache;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("./fileutils");
+const logger_1 = require("./logger");
+/**
+ * A plugin cache that tracks access order for LRU eviction.
+ *
+ * Uses explicit `get()` / `set()` / `has()` methods instead of a Proxy
+ * for easier debugging and predictable behavior.
+ *
+ * Access order is tracked via an append-only session log. Deduplication
+ * happens once at serialization time (`toSerializable()`), keeping per-access
+ * cost at O(1).
+ *
+ * Eviction splices the first half of the deduped access-order queue — the
+ * least recently used keys.
+ */
+class PluginCache {
+    constructor(cachePathOrEntries, accessOrder) {
+        if (typeof cachePathOrEntries === 'string') {
+            const loaded = loadFromDisk(cachePathOrEntries);
+            this.entries = loaded.entries;
+            this.accessOrder = loaded.accessOrder;
+        }
+        else {
+            this.entries = cachePathOrEntries ?? {};
+            this.accessOrder =
+                accessOrder instanceof Set ? accessOrder : new Set(accessOrder ?? []);
+        }
+    }
+    touch(key) {
+        // Sets are guaranteed to maintain insertion order, so we can delete and re-add to move it to the end.
+        this.accessOrder.delete(key); // remove from current position in access order
+        this.accessOrder.add(key); // add to end of access order (most recently accessed)
+    }
+    /**
+     * Returns the value for `key`, or `undefined` if not present.
+     * Tracks the access in the session log for LRU ordering.
+     */
+    get(key) {
+        if (key in this.entries) {
+            this.touch(key);
+            return this.entries[key];
+        }
+        return undefined;
+    }
+    /**
+     * Sets `key` to `value` and tracks the access in the session log.
+     */
+    set(key, value) {
+        this.entries[key] = value;
+        this.touch(key);
+    }
+    /**
+     * Returns `true` if `key` exists in the cache.
+     * Does NOT track access — use this for existence checks that
+     * should not affect eviction order.
+     */
+    has(key) {
+        return key in this.entries;
+    }
+    /**
+     * Returns the serializable cache data (entries + accessOrder).
+     */
+    toSerializable() {
+        return {
+            entries: this.entries,
+            accessOrder: [...this.accessOrder],
+        };
+    }
+    /**
+     * Safely writes this cache to disk.
+     *
+     * Strategy:
+     * 1. Serialize to JSON
+     *    - RangeError (string too large): evict oldest 50% and retry
+     *    - Other errors (e.g. circular refs): skip straight to empty cache
+     * 2. Write the serialized string to disk — if this fails (fs error),
+     *    wipe the cache file so a corrupted file doesn't persist
+     * 3. On total serialization failure (even after eviction),
+     *    write an empty cache so the file is valid
+     */
+    writeToDisk(cachePath) {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(cachePath), { recursive: true });
+        let content;
+        try {
+            content = JSON.stringify({
+                entries: this.entries,
+                accessOrder: [...this.accessOrder],
+            });
+        }
+        catch (e) {
+            // RangeError → string too large, recoverable via eviction
+            if (e instanceof RangeError) {
+                const reduced = this.evictOldestHalf();
+                // Update in-memory state
+                this.entries = reduced.entries;
+                this.accessOrder = new Set(reduced.accessOrder);
+                try {
+                    content = JSON.stringify(reduced);
+                }
+                catch {
+                    // Still fails after eviction — fall through to empty cache
+                }
+            }
+            // Other errors (TypeError for circular refs, etc.) fall through to empty cache
+        }
+        // If serialization still fails, fall back to an empty cache
+        if (content === undefined) {
+            content = JSON.stringify({ entries: {}, accessOrder: [] });
+        }
+        // Attempt to write the serialized content to disk
+        try {
+            (0, node_fs_1.writeFileSync)(cachePath, content);
+        }
+        catch {
+            // Filesystem error — wipe cache so a corrupted file doesn't persist
+            tryRemoveFile(cachePath);
+        }
+    }
+    /**
+     * Evicts the oldest 50% of entries (front of the access-order queue)
+     * and returns the remaining entries + accessOrder as a plain object.
+     */
+    evictOldestHalf() {
+        const accessOrderArr = [...this.accessOrder];
+        if (accessOrderArr.length === 0)
+            return { entries: {}, accessOrder: [] };
+        const cutoff = Math.ceil(accessOrderArr.length / 2);
+        const remaining = accessOrderArr.slice(cutoff);
+        const entries = {};
+        for (const key of remaining) {
+            if (key in this.entries) {
+                entries[key] = this.entries[key];
+            }
+        }
+        return { entries, accessOrder: remaining };
+    }
+}
+exports.PluginCache = PluginCache;
+/**
+ * Loads plugin cache data from disk.
+ *
+ * Returns the current format `{ entries, accessOrder }` if it matches,
+ * otherwise returns an empty cache (no backward compat — stale caches
+ * are simply discarded).
+ */
+function loadFromDisk(cachePath) {
+    const empty = {
+        entries: {},
+        accessOrder: new Set(),
+    };
+    try {
+        if (process.env.NX_CACHE_PROJECT_GRAPH === 'false' ||
+            !(0, node_fs_1.existsSync)(cachePath)) {
+            return empty;
+        }
+        const raw = (0, fileutils_1.readJsonFile)(cachePath);
+        // Current format: { entries, accessOrder }
+        if (raw &&
+            typeof raw === 'object' &&
+            'entries' in raw &&
+            'accessOrder' in raw &&
+            Array.isArray(raw.accessOrder)) {
+            return { entries: raw.entries, accessOrder: new Set(raw.accessOrder) };
+        }
+        return empty;
+    }
+    catch {
+        return empty;
+    }
+}
+/**
+ * Safely writes already-stringified content to a cache file on disk.
+ *
+ * Strategy:
+ * 1. Attempt mkdirSync + writeFileSync
+ * 2. On failure: remove existing cache file, log warning, return without throwing
+ */
+function safeWriteFileCache(cachePath, content) {
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(cachePath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(cachePath, content);
+    }
+    catch (e) {
+        logger_1.logger.warn(`Failed to write cache at ${cachePath}: ${e instanceof Error ? e.message : 'unknown error'}. Removing existing cache file.`);
+        tryRemoveFile(cachePath);
+    }
+}
+// --- Internal helpers ---
+function tryRemoveFile(path) {
+    try {
+        (0, node_fs_1.unlinkSync)(path);
+    }
+    catch {
+        // Intentionally ignored — best effort
+    }
+}

package/dist/src/utils/plugin-progress-text.d.ts

@@ -0,0 +1 @@
+export declare function formatPluginProgressText(action: string, inProgressPlugins: ReadonlySet<string>): string;

package/dist/src/utils/plugin-progress-text.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPluginProgressText = formatPluginProgressText;
+function formatPluginProgressText(action, inProgressPlugins) {
+    if (inProgressPlugins.size === 0) {
+        return '';
+    }
+    if (inProgressPlugins.size === 1) {
+        return `${action} with ${inProgressPlugins.values().next().value}`;
+    }
+    return [
+        `${action} with ${inProgressPlugins.size} plugins`,
+        ...Array.from(inProgressPlugins, (p) => `  - ${p}`),
+    ].join('\n');
+}

package/dist/src/utils/plugins/atomizer-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Helper that tries to derive the name of the CI group, based on the related target name.
+ *
+ * This will work well when the CI target name follows the documented naming convention or similar (for e.g `test-ci`, `e2e-ci`, `ny-e2e-ci`, etc).
+ *
+ * For example, `test-ci` => `TEST (CI)`,  `e2e-ci` => `E2E (CI)`,  `my-e2e-ci` => `MY E2E (CI)`
+ *
+ * @param ciTargetName name of the CI target
+ * @returns the derived group name or `${ciTargetName.toUpperCase()} (CI)` if cannot be derived automatically
+ */
+export declare function deriveGroupNameFromTarget(ciTargetName: string | undefined): string;

package/dist/src/utils/plugins/atomizer-utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveGroupNameFromTarget = deriveGroupNameFromTarget;
+/**
+ * Helper that tries to derive the name of the CI group, based on the related target name.
+ *
+ * This will work well when the CI target name follows the documented naming convention or similar (for e.g `test-ci`, `e2e-ci`, `ny-e2e-ci`, etc).
+ *
+ * For example, `test-ci` => `TEST (CI)`,  `e2e-ci` => `E2E (CI)`,  `my-e2e-ci` => `MY E2E (CI)`
+ *
+ * @param ciTargetName name of the CI target
+ * @returns the derived group name or `${ciTargetName.toUpperCase()} (CI)` if cannot be derived automatically
+ */
+function deriveGroupNameFromTarget(ciTargetName) {
+    if (!ciTargetName) {
+        return null;
+    }
+    const parts = ciTargetName.split('-').map((v) => v.toUpperCase());
+    if (parts.length > 1) {
+        return `${parts.slice(0, -1).join(' ')} (${parts[parts.length - 1]})`;
+    }
+    return `${parts[0]} (CI)`; // default group name when there is a single segment
+}

package/dist/src/utils/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { getInstalledPluginsAndCapabilities } from './installed-plugins';
+export { getLocalWorkspacePlugins } from './local-plugins';
+export { listPlugins, listAlsoAvailableCorePlugins, listPluginCapabilities, } from './output';
+export { getPluginCapabilities } from './plugin-capabilities';
+export { deriveGroupNameFromTarget } from './atomizer-utils';

package/dist/src/utils/plugins/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveGroupNameFromTarget = exports.getPluginCapabilities = exports.listPluginCapabilities = exports.listAlsoAvailableCorePlugins = exports.listPlugins = exports.getLocalWorkspacePlugins = exports.getInstalledPluginsAndCapabilities = void 0;
+var installed_plugins_1 = require("./installed-plugins");
+Object.defineProperty(exports, "getInstalledPluginsAndCapabilities", { enumerable: true, get: function () { return installed_plugins_1.getInstalledPluginsAndCapabilities; } });
+var local_plugins_1 = require("./local-plugins");
+Object.defineProperty(exports, "getLocalWorkspacePlugins", { enumerable: true, get: function () { return local_plugins_1.getLocalWorkspacePlugins; } });
+var output_1 = require("./output");
+Object.defineProperty(exports, "listPlugins", { enumerable: true, get: function () { return output_1.listPlugins; } });
+Object.defineProperty(exports, "listAlsoAvailableCorePlugins", { enumerable: true, get: function () { return output_1.listAlsoAvailableCorePlugins; } });
+Object.defineProperty(exports, "listPluginCapabilities", { enumerable: true, get: function () { return output_1.listPluginCapabilities; } });
+var plugin_capabilities_1 = require("./plugin-capabilities");
+Object.defineProperty(exports, "getPluginCapabilities", { enumerable: true, get: function () { return plugin_capabilities_1.getPluginCapabilities; } });
+var atomizer_utils_1 = require("./atomizer-utils");
+Object.defineProperty(exports, "deriveGroupNameFromTarget", { enumerable: true, get: function () { return atomizer_utils_1.deriveGroupNameFromTarget; } });

package/dist/src/utils/plugins/output.d.ts

@@ -0,0 +1,34 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { PluginCapabilities } from './plugin-capabilities';
+export declare function listPlugins(plugins: Map<string, PluginCapabilities>, title: string): void;
+export declare function listAlsoAvailableCorePlugins(installedPlugins: Map<string, PluginCapabilities>): void;
+export declare function listPowerpackPlugins(): void;
+export declare function listPluginCapabilities(pluginName: string, projects: Record<string, ProjectConfiguration>, json?: boolean): Promise<void>;
+export declare function formatPluginCapabilitiesAsJson(plugin: PluginCapabilities): {
+    name: string;
+    path: string;
+    generators: Record<string, {
+        description: string;
+        path: string | null;
+        schema: string | null;
+    }>;
+    executors: Record<string, {
+        description: string;
+        path: string | null;
+        schema: string | null;
+    }>;
+    projectGraphExtension: boolean;
+    projectInference: boolean;
+};
+export declare function formatPluginsAsJson(localPlugins: Map<string, PluginCapabilities>, installedPlugins: Map<string, PluginCapabilities>): {
+    localWorkspacePlugins: {
+        name: string;
+        path: string;
+        capabilities: string[];
+    }[];
+    installedPlugins: {
+        name: string;
+        path: string;
+        capabilities: string[];
+    }[];
+};