nx 19.0.0-beta.0 → 19.0.0-canary.20240419-e617e54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.0.0-beta.0",
+  "version": "19.0.0-canary.20240419-e617e54",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -66,7 +66,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.0.0-beta.0"
+    "@nrwl/tao": "19.0.0-canary.20240419-e617e54"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.0.0-beta.0",
-    "@nx/nx-darwin-arm64": "19.0.0-beta.0",
-    "@nx/nx-linux-x64-gnu": "19.0.0-beta.0",
-    "@nx/nx-linux-x64-musl": "19.0.0-beta.0",
-    "@nx/nx-win32-x64-msvc": "19.0.0-beta.0",
-    "@nx/nx-linux-arm64-gnu": "19.0.0-beta.0",
-    "@nx/nx-linux-arm64-musl": "19.0.0-beta.0",
-    "@nx/nx-linux-arm-gnueabihf": "19.0.0-beta.0",
-    "@nx/nx-win32-arm64-msvc": "19.0.0-beta.0",
-    "@nx/nx-freebsd-x64": "19.0.0-beta.0"
+    "@nx/nx-darwin-x64": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-darwin-arm64": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-linux-x64-gnu": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-linux-x64-musl": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-win32-x64-msvc": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-linux-arm64-gnu": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-linux-arm64-musl": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-linux-arm-gnueabihf": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-win32-arm64-msvc": "19.0.0-canary.20240419-e617e54",
+    "@nx/nx-freebsd-x64": "19.0.0-canary.20240419-e617e54"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/graph/command-object.js

@@ -7,7 +7,7 @@ exports.yargsDepGraphCommand = {
     command: 'graph',
     describe: 'Graph dependencies within workspace',
     aliases: ['dep-graph'],
-    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withDepGraphOptions)(yargs)), 'dep-graph')
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withVerbose)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withDepGraphOptions)(yargs))), 'dep-graph')
         .option('affected', {
         type: 'boolean',
         description: 'Highlight affected projects',

package/src/command-line/show/command-object.js

@@ -26,7 +26,7 @@ exports.yargsShowCommand = {
 const showProjectsCommand = {
     command: 'projects',
     describe: 'Show a list of projects in the workspace',
-    builder: (yargs) => (0, shared_options_1.withAffectedOptions)(yargs)
+    builder: (yargs) => (0, shared_options_1.withVerbose)((0, shared_options_1.withAffectedOptions)(yargs))
         .option('affected', {
         type: 'boolean',
         description: 'Show only affected projects',
@@ -47,10 +47,6 @@ const showProjectsCommand = {
         type: 'string',
         description: 'Select only projects of the given type',
         choices: ['app', 'lib', 'e2e'],
-    })
-        .option('verbose', {
-        type: 'boolean',
-        description: 'Prints additional information about the commands (e.g., stack traces)',
     })
         .implies('untracked', 'affected')
         .implies('uncommitted', 'affected')

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -28,6 +28,9 @@ export declare function withTargetAndConfigurationOption(yargs: Argv, demandOpti
 export declare function withConfiguration(yargs: Argv): Argv<{
     configuration: string;
 }>;
+export declare function withVerbose(yargs: Argv): Argv<{
+    verbose: boolean;
+}>;
 export declare function withBatch(yargs: Argv): any;
 export declare function withAffectedOptions(yargs: Argv): Argv<ExcludeOptions & {
     files: string;

package/src/command-line/yargs-utils/shared-options.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCSV = exports.withRunOneOptions = exports.withDepGraphOptions = exports.withOutputStyleOption = exports.withOverrides = exports.withRunManyOptions = exports.withAffectedOptions = exports.withBatch = exports.withConfiguration = exports.withTargetAndConfigurationOption = exports.withRunOptions = exports.withExcludeOption = void 0;
+exports.parseCSV = exports.withRunOneOptions = exports.withDepGraphOptions = exports.withOutputStyleOption = exports.withOverrides = exports.withRunManyOptions = exports.withAffectedOptions = exports.withBatch = exports.withVerbose = exports.withConfiguration = exports.withTargetAndConfigurationOption = exports.withRunOptions = exports.withExcludeOption = void 0;
 function withExcludeOption(yargs) {
     return yargs.option('exclude', {
         describe: 'Exclude certain projects from being processed',
@@ -10,7 +10,7 @@ function withExcludeOption(yargs) {
 }
 exports.withExcludeOption = withExcludeOption;
 function withRunOptions(yargs) {
-    return withExcludeOption(yargs)
+    return withVerbose(withExcludeOption(yargs))
         .option('parallel', {
         describe: 'Max number of parallel processes [default is 3]',
         type: 'string',
@@ -41,10 +41,6 @@ function withRunOptions(yargs) {
             : value === 'false' || value === false
                 ? false
                 : value,
-    })
-        .option('verbose', {
-        type: 'boolean',
-        describe: 'Prints additional information about the commands (e.g., stack traces)',
     })
         .option('nxBail', {
         describe: 'Stop command execution after the first failed task',
@@ -96,6 +92,19 @@ function withConfiguration(yargs) {
     });
 }
 exports.withConfiguration = withConfiguration;
+function withVerbose(yargs) {
+    return yargs
+        .option('verbose', {
+        describe: 'Prints additional information about the commands (e.g., stack traces)',
+        type: 'boolean',
+    })
+        .middleware((args) => {
+        if (args.verbose) {
+            process.env.NX_VERBOSE_LOGGING = 'true';
+        }
+    });
+}
+exports.withVerbose = withVerbose;
 function withBatch(yargs) {
     return yargs.options('batch', {
         type: 'boolean',

package/src/daemon/server/server.js

@@ -60,10 +60,7 @@ async function handleMessage(socket, data) {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `File watcher error in the workspace '${workspace_root_1.workspaceRoot}'.`, workspaceWatcherError);
     }
     if (daemonIsOutdated()) {
-        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Lock files changed`, {
-            name: '',
-            message: 'LOCK-FILES-CHANGED',
-        });
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Lock files changed`, new Error('LOCK-FILES-CHANGED'));
     }
     (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     const unparsedPayload = data;

package/src/daemon/socket-utils.js

@@ -5,7 +5,7 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const tmp_dir_1 = require("./tmp-dir");
-const error_types_1 = require("../project-graph/error-types");
+const serializable_error_1 = require("../utils/serializable-error");
 exports.isWindows = (0, os_1.platform)() === 'win32';
 /**
  * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
@@ -28,21 +28,9 @@ function killSocketOrPath() {
     catch { }
 }
 exports.killSocketOrPath = killSocketOrPath;
-// Include the original stack trace within the serialized error so that the client can show it to the user.
-function serializeError(error) {
-    if (!error) {
-        return null;
-    }
-    if (error instanceof error_types_1.DaemonProjectGraphError) {
-        error.errors = error.errors.map((e) => JSON.parse(serializeError(e)));
-    }
-    return `{${Object.getOwnPropertyNames(error)
-        .map((k) => `"${k}": ${JSON.stringify(error[k])}`)
-        .join(',')}}`;
-}
 // Prepare a serialized project graph result for sending over IPC from the server to the client
 function serializeResult(error, serializedProjectGraph, serializedSourceMaps) {
     // We do not want to repeat work `JSON.stringify`ing an object containing the potentially large project graph so merge as strings
-    return `{ "error": ${serializeError(error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
+    return `{ "error": ${JSON.stringify(error ? (0, serializable_error_1.createSerializableError)(error) : error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
 }
 exports.serializeResult = serializeResult;

package/src/executors/run-commands/run-commands.impl.js

@@ -8,6 +8,16 @@ const npm_run_path_1 = require("npm-run-path");
 const chalk = require("chalk");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 exports.LARGE_BUFFER = 1024 * 1000000;
+const exitListeners = new Set();
+function processExitListener() {
+    for (const listener of exitListeners) {
+        listener();
+    }
+}
+process.on('exit', processExitListener);
+process.on('SIGTERM', processExitListener);
+process.on('SIGINT', processExitListener);
+process.on('SIGQUIT', processExitListener);
 async function loadEnvVars(path) {
     if (path) {
         const result = (await Promise.resolve().then(() => require('dotenv'))).config({ path });
@@ -205,11 +215,8 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
         /**
          * Ensure the child process is killed when the parent exits
          */
-        const processExitListener = (signal) => childProcess.kill(signal);
-        process.on('exit', processExitListener);
-        process.on('SIGTERM', processExitListener);
-        process.on('SIGINT', processExitListener);
-        process.on('SIGQUIT', processExitListener);
+        const childProcessKiller = (signal) => childProcess.kill(signal);
+        exitListeners.add(childProcessKiller);
         childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             terminalOutput += output;
@@ -239,6 +246,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
             res({ success: false, terminalOutput });
         });
         childProcess.on('exit', (code) => {
+            exitListeners.delete(childProcessKiller);
             if (!readyWhen) {
                 res({ success: code === 0, terminalOutput });
             }

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

@@ -19,7 +19,7 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError)[];
+    getErrors(): (ProcessDependenciesError | ProcessProjectGraphError | CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError)[];
 }
 export declare class ProjectsWithConflictingNamesError extends Error {
     projects: Record<string, ProjectConfiguration>;
@@ -69,3 +69,7 @@ export declare class DaemonProjectGraphError extends Error {
     readonly sourceMaps: ConfigurationSourceMaps;
     constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
 }
+export declare class LoadPluginError extends Error {
+    plugin: string;
+    constructor(plugin: string, cause: Error);
+}

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

@@ -1,7 +1,7 @@
 "use strict";
 var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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) {
@@ -145,3 +145,13 @@ class DaemonProjectGraphError extends Error {
     }
 }
 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/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.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);
@@ -67,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;
@@ -87,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 },
-                                        }));
+                                        });
                                     });
                                 },
                             ]
@@ -99,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,
@@ -110,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/utils/serializable-error.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function transforms an error into an object which can be properly serialized and deserialized to be sent between processes.
+ */
+export declare function createSerializableError<T extends Error>(error: T): T;

package/src/utils/serializable-error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSerializableError = void 0;
+/**
+ * This function transforms an error into an object which can be properly serialized and deserialized to be sent between processes.
+ */
+function createSerializableError(error) {
+    const res = {};
+    Object.getOwnPropertyNames(error).forEach((k) => {
+        let value = error[k];
+        // If an error has an error as a property such as cause, it will be transformed into a serializable error
+        if (typeof value === 'object' && value instanceof Error) {
+            value = createSerializableError(value);
+        }
+        // If an error has an array of errors as a property, they will be transformed into serializable errors
+        if (Array.isArray(value)) {
+            value = value.map((v) => {
+                if (typeof v === 'object' && v instanceof Error) {
+                    return createSerializableError(v);
+                }
+                return v;
+            });
+        }
+        res[k] = value;
+    });
+    return res;
+}
+exports.createSerializableError = createSerializableError;