nx 18.3.1 → 18.3.3

package/src/project-graph/error-types.js

@@ -1,6 +1,47 @@
 "use strict";
+var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isProjectsWithConflictingNamesError = exports.ProjectsWithConflictingNamesError = void 0;
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isProjectsWithConflictingNamesError = exports.ProjectsWithConflictingNamesError = exports.ProjectGraphError = void 0;
+const tslib_1 = require("tslib");
+class ProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph, partialSourceMaps) {
+        super(`Failed to process project graph.`);
+        _ProjectGraphError_errors.set(this, void 0);
+        _ProjectGraphError_partialProjectGraph.set(this, void 0);
+        _ProjectGraphError_partialSourceMaps.set(this, void 0);
+        this.name = this.constructor.name;
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_errors, errors, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
+        this.stack = `${this.message}\n  ${errors
+            .map((error) => error.stack.split('\n').join('\n  '))
+            .join('\n')}`;
+    }
+    /**
+     * The daemon cannot throw errors which contain methods as they are not serializable.
+     *
+     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
+     */
+    static fromDaemonProjectGraphError(e) {
+        return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
+    }
+    /**
+     * This gets the partial project graph despite the errors which occured.
+     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
+     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
+     */
+    getPartialProjectGraph() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialProjectGraph, "f");
+    }
+    getPartialSourcemaps() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
+    }
+    getErrors() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_errors, "f");
+    }
+}
+exports.ProjectGraphError = ProjectGraphError;
+_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 class ProjectsWithConflictingNamesError extends Error {
     constructor(conflicts, projects) {
         super([
@@ -94,3 +135,23 @@ function isMergeNodesError(e) {
         (typeof e === 'object' && 'name' in e && e?.name === MergeNodesError.name));
 }
 exports.isMergeNodesError = isMergeNodesError;
+class DaemonProjectGraphError extends Error {
+    constructor(errors, projectGraph, sourceMaps) {
+        super(`The Daemon Process threw an error while calculating the project graph. Convert this error to a ProjectGraphError to get more information.`);
+        this.errors = errors;
+        this.projectGraph = projectGraph;
+        this.sourceMaps = sourceMaps;
+        this.name = this.constructor.name;
+    }
+}
+exports.DaemonProjectGraphError = DaemonProjectGraphError;
+class LoadPluginError extends Error {
+    constructor(plugin, cause) {
+        super(`Could not load plugin ${plugin}`, {
+            cause,
+        });
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.LoadPluginError = LoadPluginError;

package/src/project-graph/plugins/isolation/index.js

@@ -3,14 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadNxPluginInIsolation = void 0;
 const workspace_root_1 = require("../../../utils/workspace-root");
 const plugin_pool_1 = require("./plugin-pool");
+/**
+ * Used to ensure 1 plugin : 1 worker
+ */
 const remotePluginCache = new Map();
 function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
     const cacheKey = JSON.stringify(plugin);
     if (remotePluginCache.has(cacheKey)) {
-        return remotePluginCache.get(cacheKey);
+        return [remotePluginCache.get(cacheKey), () => { }];
     }
-    const [loadingPlugin, cleanup] = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-    remotePluginCache.set(cacheKey, [loadingPlugin, cleanup]);
-    return [loadingPlugin, cleanup];
+    const loadingPlugin = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
+    remotePluginCache.set(cacheKey, loadingPlugin);
+    // We clean up plugin workers when Nx process completes.
+    return [loadingPlugin, () => { }];
 }
 exports.loadNxPluginInIsolation = loadNxPluginInIsolation;

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="node" />
 import { ProjectGraph, ProjectGraphProcessorContext } from '../../../config/project-graph';
 import { PluginConfiguration } from '../../../config/nx-json';
 import { CreateDependenciesContext, CreateNodesContext } from '../public-api';
 import { LoadedNxPlugin } from '../internal-api';
+import { Serializable } from 'child_process';
 export interface PluginWorkerLoadMessage {
     type: 'load';
     payload: {
@@ -19,7 +21,7 @@ export interface PluginWorkerLoadResult {
         success: true;
     } | {
         success: false;
-        error: string;
+        error: Error;
     };
 }
 export interface PluginWorkerCreateNodesMessage {
@@ -38,7 +40,7 @@ export interface PluginWorkerCreateNodesResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }
@@ -57,7 +59,7 @@ export interface PluginCreateDependenciesResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }
@@ -77,18 +79,19 @@ export interface PluginWorkerProcessProjectGraphResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }
 export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage;
 export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult;
+export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
+export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
 type MaybePromise<T> = T | Promise<T>;
 type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;
-export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: string | T, handlers: {
+export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: T, handlers: {
     [K in T['type']]: (payload: Extract<T, {
         type: K;
     }>['payload']) => MessageHandlerReturn<T>;
 }): Promise<void>;
-export declare function createMessage(message: PluginWorkerMessage | PluginWorkerResult): string;
 export {};

package/src/project-graph/plugins/isolation/messaging.js

@@ -1,23 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMessage = exports.consumeMessage = void 0;
+exports.consumeMessage = exports.isPluginWorkerResult = exports.isPluginWorkerMessage = void 0;
+function isPluginWorkerMessage(message) {
+    return (typeof message === 'object' &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        [
+            'load',
+            'createNodes',
+            'createDependencies',
+            'processProjectGraph',
+        ].includes(message.type));
+}
+exports.isPluginWorkerMessage = isPluginWorkerMessage;
+function isPluginWorkerResult(message) {
+    return (typeof message === 'object' &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        [
+            'load-result',
+            'createNodesResult',
+            'createDependenciesResult',
+            'processProjectGraphResult',
+        ].includes(message.type));
+}
+exports.isPluginWorkerResult = isPluginWorkerResult;
 // Takes a message and a map of handlers and calls the appropriate handler
 // type safe and requires all handlers to be handled
 async function consumeMessage(raw, handlers) {
-    const message = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    const message = raw;
     const handler = handlers[message.type];
     if (handler) {
         const response = await handler(message.payload);
         if (response) {
-            process.send(createMessage(response));
+            process.send(response);
         }
     }
-    else {
-        throw new Error(`Unhandled message type: ${message.type}`);
-    }
 }
 exports.consumeMessage = consumeMessage;
-function createMessage(message) {
-    return JSON.stringify(message);
-}
-exports.createMessage = createMessage;

package/src/project-graph/plugins/isolation/plugin-pool.d.ts

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import { LoadedNxPlugin } from '../internal-api';
-export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): [Promise<LoadedNxPlugin>, () => void];
+export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -32,7 +32,7 @@ function loadRemoteNxPlugin(plugin, root) {
             ...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
         ],
     });
-    worker.send((0, messaging_1.createMessage)({ type: 'load', payload: { plugin, root } }));
+    worker.send({ type: 'load', payload: { plugin, root } });
     // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
     const pendingPromises = new Map();
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
@@ -41,16 +41,10 @@ function loadRemoteNxPlugin(plugin, root) {
         shutdownPluginWorker(worker, pendingPromises);
     };
     cleanupFunctions.add(cleanupFunction);
-    return [
-        new Promise((res, rej) => {
-            worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
-            worker.on('exit', exitHandler);
-        }),
-        () => {
-            cleanupFunction();
-            cleanupFunctions.delete(cleanupFunction);
-        },
-    ];
+    return new Promise((res, rej) => {
+        worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
+        worker.on('exit', exitHandler);
+    });
 }
 exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
 async function shutdownPluginWorker(worker, pendingPromises) {
@@ -73,13 +67,10 @@ async function shutdownPluginWorker(worker, pendingPromises) {
 function createWorkerHandler(worker, pending, onload, onloadError) {
     let pluginName;
     return function (message) {
-        const parsed = JSON.parse(message);
-        // logger.verbose(
-        //   `[plugin-pool] received message: ${parsed.type} from ${
-        //     pluginName ?? worker.pid
-        //   }`
-        // );
-        (0, messaging_1.consumeMessage)(parsed, {
+        if (!(0, messaging_1.isPluginWorkerResult)(message)) {
+            return;
+        }
+        return (0, messaging_1.consumeMessage)(message, {
             'load-result': (result) => {
                 if (result.success) {
                     const { name, createNodesPattern } = result;
@@ -93,10 +84,10 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                                 (configFiles, ctx) => {
                                     const tx = pluginName + ':createNodes:' + performance.now();
                                     return registerPendingPromise(tx, pending, () => {
-                                        worker.send((0, messaging_1.createMessage)({
+                                        worker.send({
                                             type: 'createNodes',
                                             payload: { configFiles, context: ctx, tx },
-                                        }));
+                                        });
                                     });
                                 },
                             ]
@@ -105,10 +96,10 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             ? (ctx) => {
                                 const tx = pluginName + ':createDependencies:' + performance.now();
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send((0, messaging_1.createMessage)({
+                                    worker.send({
                                         type: 'createDependencies',
                                         payload: { context: ctx, tx },
-                                    }));
+                                    });
                                 });
                             }
                             : undefined,
@@ -116,10 +107,10 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             ? (graph, ctx) => {
                                 const tx = pluginName + ':processProjectGraph:' + performance.now();
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send((0, messaging_1.createMessage)({
+                                    worker.send({
                                         type: 'processProjectGraph',
                                         payload: { graph, ctx, tx },
-                                    }));
+                                    });
                                 });
                             }
                             : undefined,

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
 const loader_1 = require("../loader");
+const serializable_error_1 = require("../../../utils/serializable-error");
 global.NX_GRAPH_CREATION = true;
 let plugin;
 process.on('message', async (message) => {
-    (0, messaging_1.consumeMessage)(message, {
+    if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
+        return;
+    }
+    return (0, messaging_1.consumeMessage)(message, {
         load: async ({ plugin: pluginConfiguration, root }) => {
             process.chdir(root);
             try {
@@ -27,7 +31,7 @@ process.on('message', async (message) => {
                     type: 'load-result',
                     payload: {
                         success: false,
-                        error: `Could not load plugin ${plugin} \n ${e instanceof Error ? e.stack : ''}`,
+                        error: (0, serializable_error_1.createSerializableError)(e),
                     },
                 };
             }
@@ -43,7 +47,11 @@ process.on('message', async (message) => {
             catch (e) {
                 return {
                     type: 'createNodesResult',
-                    payload: { success: false, error: e.stack, tx },
+                    payload: {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                        tx,
+                    },
                 };
             }
         },
@@ -58,7 +66,11 @@ process.on('message', async (message) => {
             catch (e) {
                 return {
                     type: 'createDependenciesResult',
-                    payload: { success: false, error: e.stack, tx },
+                    payload: {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                        tx,
+                    },
                 };
             }
         },
@@ -73,7 +85,11 @@ process.on('message', async (message) => {
             catch (e) {
                 return {
                     type: 'processProjectGraphResult',
-                    payload: { success: false, error: e.stack, tx },
+                    payload: {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                        tx,
+                    },
                 };
             }
         },

package/src/project-graph/plugins/loader.js

@@ -14,10 +14,11 @@ const find_project_for_path_1 = require("../utils/find-project-for-path");
 const path_1 = require("../../utils/path");
 const logger_1 = require("../../utils/logger");
 const node_path_1 = require("node:path");
-const path = require("node:path/posix");
 const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
 const utils_1 = require("./utils");
 const internal_api_1 = require("./internal-api");
+const error_types_1 = require("../error-types");
+const path = require("node:path/posix");
 function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
@@ -174,26 +175,29 @@ function loadNxPlugin(plugin, root) {
 }
 exports.loadNxPlugin = loadNxPlugin;
 async function loadNxPluginAsync(pluginConfiguration, paths, root) {
-    try {
-        require.resolve(typeof pluginConfiguration === 'string'
-            ? pluginConfiguration
-            : pluginConfiguration.plugin);
-    }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInference ??=
-            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-    }
     const moduleName = typeof pluginConfiguration === 'string'
         ? pluginConfiguration
         : pluginConfiguration.plugin;
-    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
-    const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
-    plugin.name ??= name;
-    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
-    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
-    return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+    try {
+        try {
+            require.resolve(moduleName);
+        }
+        catch {
+            // If a plugin cannot be resolved, we will need projects to resolve it
+            projectsWithoutInference ??=
+                await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+        }
+        performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+        let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+        const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
+        plugin.name ??= name;
+        performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+        performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+        return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+    }
+    catch (e) {
+        throw new error_types_1.LoadPluginError(moduleName, e);
+    }
 }
 exports.loadNxPluginAsync = loadNxPluginAsync;
 async function importPluginModule(pluginPath) {

package/src/project-graph/project-graph.d.ts

@@ -1,9 +1,5 @@
-import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
-import { ConfigurationSourceMaps } from './utils/project-configuration-utils';
-import { CreateNodesError, MergeNodesError, ProjectsWithNoNameError, ProjectsWithConflictingNamesError } from './error-types';
-import { DaemonProjectGraphError } from '../daemon/daemon-project-graph-error';
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -16,26 +12,8 @@ export declare function readCachedProjectConfiguration(projectName: string): Pro
 export declare function readProjectsConfigurationFromProjectGraph(projectGraph: ProjectGraph): ProjectsConfigurations;
 export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
     projectGraph: ProjectGraph;
-    sourceMaps: ConfigurationSourceMaps;
+    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
 }>;
-export declare class ProjectGraphError extends Error {
-    #private;
-    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
-    /**
-     * The daemon cannot throw errors which contain methods as they are not serializable.
-     *
-     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
-     */
-    static fromDaemonProjectGraphError(e: DaemonProjectGraphError): ProjectGraphError;
-    /**
-     * This gets the partial project graph despite the errors which occured.
-     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
-     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
-     */
-    getPartialProjectGraph(): ProjectGraph;
-    getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (ProjectsWithConflictingNamesError | ProjectsWithNoNameError | MergeNodesError | CreateNodesError | ProcessDependenciesError | ProcessProjectGraphError)[];
-}
 /**
  * Computes and returns a ProjectGraph.
  *
@@ -66,5 +44,5 @@ export declare function createProjectGraphAndSourceMapsAsync(opts?: {
     resetDaemonClient?: boolean;
 }): Promise<{
     projectGraph: ProjectGraph;
-    sourceMaps: ConfigurationSourceMaps;
+    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
 }>;

package/src/project-graph/project-graph.js

@@ -1,21 +1,19 @@
 "use strict";
-var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.ProjectGraphError = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
-const tslib_1 = require("tslib");
-const nx_deps_cache_1 = require("./nx-deps-cache");
-const build_project_graph_1 = require("./build-project-graph");
-const output_1 = require("../utils/output");
-const tmp_dir_1 = require("../daemon/tmp-dir");
-const strip_indents_1 = require("../utils/strip-indents");
+exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
+const tmp_dir_1 = require("../daemon/tmp-dir");
 const fileutils_1 = require("../utils/fileutils");
+const output_1 = require("../utils/output");
+const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
-const perf_hooks_1 = require("perf_hooks");
-const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
-const nx_json_1 = require("../config/nx-json");
+const build_project_graph_1 = require("./build-project-graph");
+const nx_deps_cache_1 = require("./nx-deps-cache");
 const error_types_1 = require("./error-types");
 const internal_api_1 = require("./plugins/internal-api");
+const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -122,7 +120,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         ...(createDependenciesError?.errors ?? []),
     ];
     if (errors.length > 0) {
-        throw new ProjectGraphError(errors, projectGraph, sourceMaps);
+        throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
     }
     else {
         if (cacheEnabled) {
@@ -132,49 +130,10 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     }
 }
 exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;
-class ProjectGraphError extends Error {
-    constructor(errors, partialProjectGraph, partialSourceMaps) {
-        super(`Failed to process project graph.`);
-        _ProjectGraphError_errors.set(this, void 0);
-        _ProjectGraphError_partialProjectGraph.set(this, void 0);
-        _ProjectGraphError_partialSourceMaps.set(this, void 0);
-        this.name = this.constructor.name;
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_errors, errors, "f");
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
-        this.stack = `${this.message}\n  ${errors
-            .map((error) => error.stack.split('\n').join('\n  '))
-            .join('\n')}`;
-    }
-    /**
-     * The daemon cannot throw errors which contain methods as they are not serializable.
-     *
-     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
-     */
-    static fromDaemonProjectGraphError(e) {
-        return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
-    }
-    /**
-     * This gets the partial project graph despite the errors which occured.
-     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
-     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
-     */
-    getPartialProjectGraph() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialProjectGraph, "f");
-    }
-    getPartialSourcemaps() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
-    }
-    getErrors() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_errors, "f");
-    }
-}
-exports.ProjectGraphError = ProjectGraphError;
-_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 function handleProjectGraphError(opts, e) {
     if (opts.exitOnError) {
         const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
-        if (e instanceof ProjectGraphError) {
+        if (e instanceof error_types_1.ProjectGraphError) {
             let title = e.message;
             if (isVerbose) {
                 title += ' See errors below.';

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../plugins/internal-api';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.

package/src/tasks-runner/init-tasks-runner.js

@@ -8,8 +8,10 @@ const run_command_1 = require("./run-command");
 const invoke_runner_terminal_output_life_cycle_1 = require("./life-cycles/invoke-runner-terminal-output-life-cycle");
 const perf_hooks_1 = require("perf_hooks");
 const utils_1 = require("./utils");
+const dotenv_1 = require("../utils/dotenv");
 async function initTasksRunner(nxArgs) {
     perf_hooks_1.performance.mark('init-local');
+    (0, dotenv_1.loadRootEnvFiles)();
     (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
     const nxJson = (0, configuration_1.readNxJson)();
     if (nxArgs.verbose) {

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.js

@@ -24,6 +24,10 @@ const EXTENDED_LEFT_PAD = `      `;
  */
 async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, overrides, }) {
     cliCursor.hide();
+    // Show the cursor again after the process exits
+    process.on('exit', () => {
+        cliCursor.show();
+    });
     let resolveRenderIsDonePromise;
     const renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve)).then(() => {
         clearRenderInterval();

package/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.js

@@ -24,6 +24,10 @@ const EXTENDED_LEFT_PAD = `      `;
  */
 async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, args, overrides, }) {
     cliCursor.hide();
+    // Show the cursor again after the process exits
+    process.on('exit', () => {
+        cliCursor.show();
+    });
     let resolveRenderIsDonePromise;
     const renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve)).then(() => {
         clearRenderInterval();

package/src/tasks-runner/pseudo-terminal.js

@@ -142,6 +142,12 @@ function supportedPtyPlatform() {
     if (process.platform !== 'win32') {
         return true;
     }
+    // TODO: Re-enable Windows support when it's stable
+    // Currently, there's an issue with control chars.
+    // See: https://github.com/nrwl/nx/issues/22358
+    if (process.env.NX_WINDOWS_PTY_SUPPORT !== 'true') {
+        return false;
+    }
     let windowsVersion = os.release().split('.');
     let windowsBuild = windowsVersion[2];
     if (!windowsBuild) {