nx 18.1.1 → 18.2.0-beta.0

package/src/daemon/client/client.js

@@ -18,6 +18,8 @@ const promised_based_queue_1 = require("../../utils/promised-based-queue");
 const nx_json_1 = require("../../config/nx-json");
 const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
 const cache_1 = require("../cache");
+const daemon_project_graph_error_1 = require("../daemon-project-graph-error");
+const project_graph_1 = require("../../project-graph/project-graph");
 const DAEMON_ENV_SETTINGS = {
     ...process.env,
     NX_PROJECT_GLOB_CACHE: 'false',
@@ -90,13 +92,23 @@ class DaemonClient {
         return this.sendToDaemonViaQueue({ type: 'REQUEST_SHUTDOWN' });
     }
     async getProjectGraphAndSourceMaps() {
-        const response = await this.sendToDaemonViaQueue({
-            type: 'REQUEST_PROJECT_GRAPH',
-        });
-        return {
-            projectGraph: response.projectGraph,
-            sourceMaps: response.sourceMaps,
-        };
+        try {
+            const response = await this.sendToDaemonViaQueue({
+                type: 'REQUEST_PROJECT_GRAPH',
+            });
+            return {
+                projectGraph: response.projectGraph,
+                sourceMaps: response.sourceMaps,
+            };
+        }
+        catch (e) {
+            if (e.name === daemon_project_graph_error_1.DaemonProjectGraphError.name) {
+                throw project_graph_1.ProjectGraphError.fromDaemonProjectGraphError(e);
+            }
+            else {
+                throw e;
+            }
+        }
     }
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });

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

@@ -0,0 +1,8 @@
+import { ProjectGraph } from '../config/project-graph';
+import { ConfigurationSourceMaps } from '../project-graph/utils/project-configuration-utils';
+export declare class DaemonProjectGraphError extends Error {
+    errors: any[];
+    readonly projectGraph: ProjectGraph;
+    readonly sourceMaps: ConfigurationSourceMaps;
+    constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonProjectGraphError = void 0;
+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;

package/src/daemon/server/handle-hash-tasks.js

@@ -4,6 +4,7 @@ exports.handleHashTasks = void 0;
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const configuration_1 = require("../../config/configuration");
+const daemon_project_graph_error_1 = require("../daemon-project-graph-error");
 /**
  * We use this not to recreated hasher for every hash operation
  * TaskHasher has a cache inside, so keeping it around results in faster performance
@@ -11,7 +12,16 @@ const configuration_1 = require("../../config/configuration");
 let storedProjectGraph = null;
 let storedHasher = null;
 async function handleHashTasks(payload) {
-    const { projectGraph, allWorkspaceFiles, fileMap, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const { error, projectGraph: _graph, allWorkspaceFiles, fileMap, rustReferences, } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    let projectGraph = _graph;
+    if (error) {
+        if (error instanceof daemon_project_graph_error_1.DaemonProjectGraphError) {
+            projectGraph = error.projectGraph;
+        }
+        else {
+            throw error;
+        }
+    }
     const nxJson = (0, configuration_1.readNxJson)();
     if (projectGraph !== storedProjectGraph) {
         storedProjectGraph = projectGraph;

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

@@ -4,6 +4,7 @@ import { NxWorkspaceFilesExternals } from '../../native';
 interface SerializedProjectGraph {
     error: Error | null;
     projectGraph: ProjectGraph | null;
+    projectFileMapCache: FileMapCache | null;
     fileMap: FileMap | null;
     allWorkspaceFiles: FileData[] | null;
     serializedProjectGraph: string | null;

package/src/daemon/server/project-graph-incremental-recomputation.js

@@ -13,6 +13,8 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const logger_1 = require("./logger");
+const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
+const daemon_project_graph_error_1 = require("../daemon-project-graph-error");
 let cachedSerializedProjectGraphPromise;
 const collectedUpdatedFiles = new Set();
 const collectedDeletedFiles = new Set();
@@ -48,6 +50,7 @@ async function getCachedSerializedProjectGraphPromise() {
             serializedProjectGraph: null,
             serializedSourceMaps: null,
             projectGraph: null,
+            projectFileMapCache: null,
             fileMap: null,
             allWorkspaceFiles: null,
             rustReferences: null,
@@ -139,22 +142,66 @@ async function processFilesAndCreateAndSerializeProjectGraph() {
         const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
         // Set this globally to allow plugins to know if they are being called from the project graph creation
         global.NX_GRAPH_CREATION = true;
-        const graphNodes = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+        let graphNodes;
+        let projectConfigurationsError;
+        try {
+            graphNodes = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+        }
+        catch (e) {
+            if (e instanceof project_configuration_utils_1.ProjectConfigurationsError) {
+                graphNodes = e.partialProjectConfigurationsResult;
+                projectConfigurationsError = e;
+            }
+        }
         await processCollectedUpdatedAndDeletedFiles(graphNodes, updatedFileHashes, deletedFiles);
-        const g = createAndSerializeProjectGraph(graphNodes);
+        const g = await createAndSerializeProjectGraph(graphNodes);
         delete global.NX_GRAPH_CREATION;
-        return g;
+        const errors = [...(projectConfigurationsError?.errors ?? [])];
+        if (g.error) {
+            if (g.error instanceof build_project_graph_1.CreateDependenciesError) {
+                errors.concat(g.error.errors);
+            }
+            else {
+                return {
+                    error: g.error,
+                    projectGraph: null,
+                    projectFileMapCache: null,
+                    fileMap: null,
+                    rustReferences: null,
+                    allWorkspaceFiles: null,
+                    serializedProjectGraph: null,
+                    serializedSourceMaps: null,
+                };
+            }
+        }
+        if (errors.length > 0) {
+            return {
+                error: new daemon_project_graph_error_1.DaemonProjectGraphError(errors, g.projectGraph, graphNodes.sourceMaps),
+                projectGraph: null,
+                projectFileMapCache: null,
+                fileMap: null,
+                rustReferences: null,
+                allWorkspaceFiles: null,
+                serializedProjectGraph: null,
+                serializedSourceMaps: null,
+            };
+        }
+        else {
+            (0, nx_deps_cache_1.writeCache)(g.projectFileMapCache, g.projectGraph);
+            return g;
+        }
     }
     catch (err) {
-        return Promise.resolve({
+        return {
             error: err,
             projectGraph: null,
+            projectFileMapCache: null,
             fileMap: null,
             rustReferences: null,
             allWorkspaceFiles: null,
             serializedProjectGraph: null,
             serializedSourceMaps: null,
-        });
+        };
     }
 }
 function copyFileData(d) {
@@ -176,7 +223,7 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
         const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
         const allWorkspaceFiles = copyFileData(exports.fileMapWithFiles.allWorkspaceFiles);
         const rustReferences = exports.fileMapWithFiles.rustReferences;
-        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), true);
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)());
         exports.currentProjectFileMapCache = projectFileMapCache;
         exports.currentProjectGraph = projectGraph;
         perf_hooks_1.performance.mark('create-project-graph-end');
@@ -189,6 +236,7 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
         return {
             error: null,
             projectGraph,
+            projectFileMapCache,
             fileMap,
             allWorkspaceFiles,
             serializedProjectGraph,
@@ -201,6 +249,7 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
         return {
             error: e,
             projectGraph: null,
+            projectFileMapCache: null,
             fileMap: null,
             allWorkspaceFiles: null,
             serializedProjectGraph: null,

package/src/daemon/server/shutdown-utils.js

@@ -69,9 +69,7 @@ exports.respondToClient = respondToClient;
 async function respondWithErrorAndExit(socket, description, error) {
     // print some extra stuff in the error message
     logger_1.serverLogger.requestLog(`Responding to the client with an error.`, description, error.message);
-    console.error(error);
-    error.message = `${error.message}\n\nBecause of the error the Nx daemon process has exited. The next Nx command is going to restart the daemon process.\nIf the error persists, please run "nx reset".`;
+    console.error(error.stack);
     await respondToClient(socket, (0, socket_utils_1.serializeResult)(error, null, null), null);
-    process.exit(1);
 }
 exports.respondWithErrorAndExit = respondWithErrorAndExit;

package/src/daemon/socket-utils.js

@@ -5,6 +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 daemon_project_graph_error_1 = require("./daemon-project-graph-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.
@@ -32,7 +33,12 @@ function serializeError(error) {
     if (!error) {
         return null;
     }
-    return JSON.stringify(error, Object.getOwnPropertyNames(error));
+    if (error instanceof daemon_project_graph_error_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) {

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

@@ -47,11 +47,10 @@ async function default_1(options, context) {
         !options.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "color" and "bgColor" can only be set when "parallel=true".');
     }
-    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
     try {
         const result = options.parallel
-            ? await runInParallel(terminal, normalized, context)
-            : await runSerially(terminal, normalized, context);
+            ? await runInParallel(normalized, context)
+            : await runSerially(normalized, context);
         return result;
     }
     catch (e) {
@@ -62,8 +61,8 @@ async function default_1(options, context) {
     }
 }
 exports.default = default_1;
-async function runInParallel(pseudoTerminal, options, context) {
-    const procs = options.commands.map((c) => createProcess(pseudoTerminal, c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
+async function runInParallel(options, context) {
+    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
         result,
         command: c.command,
     })));
@@ -135,7 +134,10 @@ function normalizeOptions(options) {
     });
     return options;
 }
-async function runSerially(pseudoTerminal, options, context) {
+async function runSerially(options, context) {
+    const pseudoTerminal = pseudo_terminal_1.PseudoTerminal.isSupported()
+        ? (0, pseudo_terminal_1.getPseudoTerminal)()
+        : null;
     let terminalOutput = '';
     for (const c of options.commands) {
         const result = await createProcess(pseudoTerminal, c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput);
@@ -155,8 +157,8 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
     env = processEnv(color, cwd, env);
     // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
     // currently does not work properly in windows
-    if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-        process.stdout.isTTY &&
+    if (pseudoTerminal &&
+        process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
         !commandConfig.prefix &&
         !isParallel &&
         usePty) {
@@ -265,7 +267,11 @@ function processEnv(color, cwd, env) {
         ...localEnv,
         ...env,
     };
-    res.PATH = localEnv.PATH; // need to override PATH to make sure we are using the local node_modules
+    // need to override PATH to make sure we are using the local node_modules
+    if (localEnv.PATH)
+        res.PATH = localEnv.PATH; // UNIX-like
+    if (localEnv.Path)
+        res.Path = localEnv.Path; // Windows
     if (color) {
         res.FORCE_COLOR = `${color}`;
     }

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

@@ -17,7 +17,7 @@ async function default_1(options, context) {
             .filter((p) => !p.startsWith(path.join(context.root, 'node_modules')))
             .join(path.delimiter) ?? '';
         env.PATH = filteredPath;
-        if (process.stdout.isTTY) {
+        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
             await ptyProcess(command, cwd, env);
         }
         else {

package/src/plugins/js/index.js

@@ -39,7 +39,7 @@ exports.createNodes = [
                 externalNodes: nodes,
             };
         }
-        const externalNodes = (0, lock_file_1.getLockFileNodes)(packageManager, lockFileContents, lockFileHash);
+        const externalNodes = (0, lock_file_1.getLockFileNodes)(packageManager, lockFileContents, lockFileHash, context);
         parsedLockFile.externalNodes = externalNodes;
         return {
             externalNodes,

package/src/plugins/js/lock-file/lock-file.d.ts

@@ -6,12 +6,12 @@ import { PackageManager } from '../../../utils/package-manager';
 import { ProjectGraph, ProjectGraphExternalNode } from '../../../config/project-graph';
 import { RawProjectGraphDependency } from '../../../project-graph/project-graph-builder';
 import { PackageJson } from '../../../utils/package-json';
-import { CreateDependenciesContext } from '../../../utils/nx-plugin';
+import { CreateDependenciesContext, CreateNodesContext } from '../../../utils/nx-plugin';
 export declare const LOCKFILES: string[];
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */
-export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string): Record<string, ProjectGraphExternalNode>;
+export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateNodesContext): Record<string, ProjectGraphExternalNode>;
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */

package/src/plugins/js/lock-file/lock-file.js

@@ -26,10 +26,10 @@ const PNPM_LOCK_PATH = (0, path_1.join)(workspace_root_1.workspaceRoot, PNPM_LOC
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */
-function getLockFileNodes(packageManager, contents, lockFileHash) {
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
     try {
         if (packageManager === 'yarn') {
-            const packageJson = (0, fileutils_1.readJsonFile)('package.json');
+            const packageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, 'package.json'));
             return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
         }
         if (packageManager === 'pnpm') {

package/src/plugins/js/versions.d.ts

@@ -1 +1 @@
-export declare const typescriptVersion = "~5.3.2";
+export declare const typescriptVersion = "~5.4.2";

package/src/plugins/js/versions.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptVersion = void 0;
-exports.typescriptVersion = '~5.3.2';
+exports.typescriptVersion = '~5.4.2';

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

@@ -8,7 +8,24 @@ export declare function getFileMap(): {
     allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, shouldWriteCache: boolean): Promise<{
+export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;
+export declare class ProcessDependenciesError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class ProcessProjectGraphError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class CreateDependenciesError extends Error {
+    readonly errors: Array<ProcessDependenciesError | ProcessProjectGraphError>;
+    readonly partialProjectGraph: ProjectGraph;
+    constructor(errors: Array<ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph);
+}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildProjectGraphUsingProjectFileMap = exports.getFileMap = void 0;
+exports.CreateDependenciesError = exports.ProcessProjectGraphError = exports.ProcessDependenciesError = exports.buildProjectGraphUsingProjectFileMap = exports.getFileMap = void 0;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -39,7 +39,7 @@ function getFileMap() {
     }
 }
 exports.getFileMap = getFileMap;
-async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, shouldWriteCache) {
+async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache) {
     storedFileMap = fileMap;
     storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
@@ -65,11 +65,8 @@ async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fil
         };
     }
     const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
-    let projectGraph = await buildProjectGraphUsingContext(nxJson, externalNodes, context, cachedFileData, projectGraphVersion);
+    let projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion);
     const projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig);
-    if (shouldWriteCache) {
-        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
-    }
     return {
         projectGraph,
         projectFileMapCache,
@@ -92,7 +89,7 @@ function readCombinedDeps() {
         ...installationPackageJson.devDependencies,
     };
 }
-async function buildProjectGraphUsingContext(nxJson, knownExternalNodes, ctx, cachedFileData, projectGraphVersion) {
+async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion) {
     perf_hooks_1.performance.mark('build project graph:start');
     const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
     builder.setVersion(projectGraphVersion);
@@ -101,8 +98,21 @@ async function buildProjectGraphUsingContext(nxJson, knownExternalNodes, ctx, ca
     }
     await (0, normalize_project_nodes_1.normalizeProjectNodes)(ctx, builder);
     const initProjectGraph = builder.getUpdatedProjectGraph();
-    const r = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
-    const updatedBuilder = new project_graph_builder_1.ProjectGraphBuilder(r, ctx.fileMap.projectFileMap);
+    let updatedGraph;
+    let error;
+    try {
+        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
+    }
+    catch (e) {
+        if (e instanceof CreateDependenciesError) {
+            updatedGraph = e.partialProjectGraph;
+            error = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    const updatedBuilder = new project_graph_builder_1.ProjectGraphBuilder(updatedGraph, ctx.fileMap.projectFileMap);
     for (const proj of Object.keys(cachedFileData.projectFileMap)) {
         for (const f of ctx.fileMap.projectFileMap[proj] || []) {
             const cached = cachedFileData.projectFileMap[proj][f.file];
@@ -121,7 +131,12 @@ async function buildProjectGraphUsingContext(nxJson, knownExternalNodes, ctx, ca
     const finalGraph = updatedBuilder.getUpdatedProjectGraph();
     perf_hooks_1.performance.mark('build project graph:end');
     perf_hooks_1.performance.measure('build project graph', 'build project graph:start', 'build project graph:end');
-    return finalGraph;
+    if (!error) {
+        return finalGraph;
+    }
+    else {
+        throw new CreateDependenciesError(error.errors, finalGraph);
+    }
 }
 function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess) {
     const clonedProjects = Object.keys(projects).reduce((map, projectName) => {
@@ -142,6 +157,7 @@ function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess)
 async function updateProjectGraphWithPlugins(context, initProjectGraph) {
     const plugins = await (0, nx_plugin_1.loadNxPlugins)(context.nxJsonConfiguration?.plugins, (0, installation_directory_1.getNxRequirePaths)(), context.workspaceRoot, context.projects);
     let graph = initProjectGraph;
+    const errors = [];
     for (const { plugin } of plugins) {
         try {
             if ((0, nx_plugin_1.isNxPluginV1)(plugin) &&
@@ -173,12 +189,9 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph) {
             }
         }
         catch (e) {
-            let message = `Failed to process the project graph with "${plugin.name}".`;
-            if (e instanceof Error) {
-                e.message = message + '\n' + e.message;
-                throw e;
-            }
-            throw new Error(message);
+            errors.push(new ProcessProjectGraphError(plugin.name, {
+                cause: e,
+            }));
         }
     }
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
@@ -193,19 +206,53 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph) {
                 builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
             }
         }
-        catch (e) {
-            let message = `Failed to process project dependencies with "${plugin.name}".`;
-            if (e instanceof Error) {
-                e.message = message + '\n' + e.message;
-                throw e;
-            }
-            throw new Error(message);
+        catch (cause) {
+            errors.push(new ProcessDependenciesError(plugin.name, {
+                cause,
+            }));
         }
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - end`);
         perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, `${plugin.name}:createDependencies - start`, `${plugin.name}:createDependencies - end`);
     }));
-    return builder.getUpdatedProjectGraph();
+    const result = builder.getUpdatedProjectGraph();
+    if (errors.length === 0) {
+        return result;
+    }
+    else {
+        throw new CreateDependenciesError(errors, result);
+    }
+}
+class ProcessDependenciesError extends Error {
+    constructor(pluginName, { cause }) {
+        super(`The "${pluginName}" plugin threw an error while creating dependencies:`, {
+            cause,
+        });
+        this.pluginName = pluginName;
+        this.name = this.constructor.name;
+        this.stack = `${this.message}\n  ${cause.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.ProcessDependenciesError = ProcessDependenciesError;
+class ProcessProjectGraphError extends Error {
+    constructor(pluginName, { cause }) {
+        super(`The "${pluginName}" plugin threw an error while processing the project graph:`, {
+            cause,
+        });
+        this.pluginName = pluginName;
+        this.name = this.constructor.name;
+        this.stack = `${this.message}\n  ${cause.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.ProcessProjectGraphError = ProcessProjectGraphError;
+class CreateDependenciesError extends Error {
+    constructor(errors, partialProjectGraph) {
+        super('Failed to create dependencies. See above for errors');
+        this.errors = errors;
+        this.partialProjectGraph = partialProjectGraph;
+        this.name = this.constructor.name;
+    }
 }
+exports.CreateDependenciesError = CreateDependenciesError;
 function readRootTsConfig() {
     try {
         const tsConfigPath = (0, typescript_1.getRootTsConfigPath)();

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

@@ -1,5 +1,8 @@
+import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { ConfigurationSourceMaps, CreateNodesError, MergeNodesError } from './utils/project-configuration-utils';
+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
@@ -12,8 +15,26 @@ export declare function readCachedProjectConfiguration(projectName: string): Pro
 export declare function readProjectsConfigurationFromProjectGraph(projectGraph: ProjectGraph): ProjectsConfigurations;
 export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
     projectGraph: ProjectGraph;
-    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
+    sourceMaps: ConfigurationSourceMaps;
 }>;
+export declare class ProjectGraphError extends Error {
+    #private;
+    constructor(errors: Array<CreateNodesError | MergeNodesError | 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(): (ProcessDependenciesError | ProcessProjectGraphError | CreateNodesError)[];
+}
 /**
  * Computes and returns a ProjectGraph.
  *
@@ -44,5 +65,5 @@ export declare function createProjectGraphAndSourceMapsAsync(opts?: {
     resetDaemonClient?: boolean;
 }): Promise<{
     projectGraph: ProjectGraph;
-    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
+    sourceMaps: ConfigurationSourceMaps;
 }>;