nx 18.1.1 → 18.2.0-beta.0

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

@@ -1,6 +1,8 @@
 "use strict";
+var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+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");
@@ -13,6 +15,7 @@ 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 nx_plugin_1 = require("../utils/nx-plugin");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -70,29 +73,127 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     global.NX_GRAPH_CREATION = true;
     const nxJson = (0, nx_json_1.readNxJson)();
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
-    const { projects, externalNodes, sourceMaps, projectRootMap } = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+    let configurationResult;
+    let projectConfigurationsError;
+    try {
+        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+    }
+    catch (e) {
+        if (e instanceof project_configuration_utils_1.ProjectConfigurationsError) {
+            projectConfigurationsError = e;
+            configurationResult = e.partialProjectConfigurationsResult;
+        }
+        else {
+            throw e;
+        }
+    }
+    const { projects, externalNodes, sourceMaps, projectRootMap } = configurationResult;
     perf_hooks_1.performance.mark('retrieve-project-configurations:end');
     perf_hooks_1.performance.mark('retrieve-workspace-files:start');
     const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
     perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
-    const projectGraph = (await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, cacheEnabled)).projectGraph;
+    let createDependenciesError;
+    let projectGraphResult;
+    try {
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null);
+    }
+    catch (e) {
+        if (e instanceof build_project_graph_1.CreateDependenciesError) {
+            projectGraphResult = {
+                projectGraph: e.partialProjectGraph,
+                projectFileMapCache: null,
+            };
+            createDependenciesError = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    const { projectGraph, projectFileMapCache } = projectGraphResult;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
     (0, nx_plugin_1.unregisterPluginTSTranspiler)();
     delete global.NX_GRAPH_CREATION;
-    return { projectGraph, sourceMaps };
+    const errors = [
+        ...(projectConfigurationsError?.errors ?? []),
+        ...(createDependenciesError?.errors ?? []),
+    ];
+    if (errors.length > 0) {
+        throw new ProjectGraphError(errors, projectGraph, sourceMaps);
+    }
+    else {
+        if (cacheEnabled) {
+            (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
+        }
+        return { projectGraph, sourceMaps };
+    }
 }
 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 lines = e.message.split('\n');
-        output_1.output.error({
-            title: lines[0],
-            bodyLines: lines.slice(1),
-        });
-        if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            console.error(e);
+        const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+        if (e instanceof ProjectGraphError) {
+            let title = e.message;
+            if (isVerbose) {
+                title += ' See errors below.';
+            }
+            const bodyLines = isVerbose
+                ? [e.stack]
+                : ['Pass --verbose to see the stacktraces.'];
+            output_1.output.error({
+                title,
+                bodyLines: bodyLines,
+            });
+        }
+        else {
+            const lines = e.message.split('\n');
+            output_1.output.error({
+                title: lines[0],
+                bodyLines: lines.slice(1),
+            });
+            if (isVerbose) {
+                console.error(e);
+            }
         }
         process.exit(1);
     }
@@ -151,9 +252,6 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
     else {
         try {
             const projectGraphAndSourceMaps = await client_1.daemonClient.getProjectGraphAndSourceMaps();
-            if (opts.resetDaemonClient) {
-                client_1.daemonClient.reset();
-            }
             perf_hooks_1.performance.mark('create-project-graph-async:end');
             perf_hooks_1.performance.measure('create-project-graph-async', 'create-project-graph-async:start', 'create-project-graph-async:end');
             return projectGraphAndSourceMaps;
@@ -186,6 +284,11 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
             }
             handleProjectGraphError(opts, e);
         }
+        finally {
+            if (opts.resetDaemonClient) {
+                client_1.daemonClient.reset();
+            }
+        }
     }
 }
 exports.createProjectGraphAndSourceMapsAsync = createProjectGraphAndSourceMapsAsync;

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

@@ -13,20 +13,43 @@ export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map
 export type ConfigurationResult = {
     projects: Record<string, ProjectConfiguration>;
     externalNodes: Record<string, ProjectGraphExternalNode>;
-    rootMap: Record<string, string>;
+    projectRootMap: Record<string, string>;
     sourceMaps: ConfigurationSourceMaps;
 };
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
+ * @param root The workspace root
  * @param nxJson The NxJson configuration
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
- * @param root The workspace root
  */
-export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, workspaceFiles: string[], // making this parameter allows devkit to pick up newly created projects
-plugins: LoadedNxPlugin[], root?: string): Promise<ConfigurationResult>;
+export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, workspaceFiles: string[], // making this parameter allows devkit to pick up newly created projects
+plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+export declare class ProjectConfigurationsError extends Error {
+    readonly errors: Array<MergeNodesError | CreateNodesError>;
+    readonly partialProjectConfigurationsResult: ConfigurationResult;
+    constructor(errors: Array<MergeNodesError | CreateNodesError>, partialProjectConfigurationsResult: ConfigurationResult);
+}
+export declare class CreateNodesError extends Error {
+    file: string;
+    pluginName: string;
+    constructor({ file, pluginName, error, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+    });
+}
+export declare class MergeNodesError extends Error {
+    file: string;
+    pluginName: string;
+    constructor({ file, pluginName, error, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+    });
+}
 /**
  * Merges two targets.
  *

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.MergeNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const logger_1 = require("../../utils/logger");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
 const target_defaults_plugin_1 = require("../../plugins/target-defaults/target-defaults-plugin");
 const minimatch_1 = require("minimatch");
 const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -32,17 +33,27 @@ skipCommandNormalization) {
     // a project.json in which case it was already updated above.
     const updatedProjectConfiguration = {
         ...matchingProject,
-        ...project,
     };
-    if (sourceMap) {
-        for (const property in project) {
-            sourceMap[`${property}`] = sourceInformation;
+    for (const k in project) {
+        if (![
+            'tags',
+            'implicitDependencies',
+            'generators',
+            'targets',
+            'metadata',
+            'namedInputs',
+        ].includes(k)) {
+            updatedProjectConfiguration[k] = project[k];
+            if (sourceMap) {
+                sourceMap[`${k}`] = sourceInformation;
+            }
         }
     }
     // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
     if (project.tags) {
         updatedProjectConfiguration.tags = Array.from(new Set((matchingProject.tags ?? []).concat(project.tags)));
         if (sourceMap) {
+            sourceMap['tags'] ??= sourceInformation;
             project.tags.forEach((tag) => {
                 sourceMap[`tags.${tag}`] = sourceInformation;
             });
@@ -51,6 +62,7 @@ skipCommandNormalization) {
     if (project.implicitDependencies) {
         updatedProjectConfiguration.implicitDependencies = (matchingProject.implicitDependencies ?? []).concat(project.implicitDependencies);
         if (sourceMap) {
+            sourceMap['implicitDependencies'] ??= sourceInformation;
             project.implicitDependencies.forEach((implicitDependency) => {
                 sourceMap[`implicitDependencies.${implicitDependency}`] =
                     sourceInformation;
@@ -61,6 +73,7 @@ skipCommandNormalization) {
         // Start with generators config in new project.
         updatedProjectConfiguration.generators = { ...project.generators };
         if (sourceMap) {
+            sourceMap['generators'] ??= sourceInformation;
             for (const generator in project.generators) {
                 sourceMap[`generators.${generator}`] = sourceInformation;
                 for (const property in project.generators[generator]) {
@@ -85,6 +98,7 @@ skipCommandNormalization) {
             ...project.namedInputs,
         };
         if (sourceMap) {
+            sourceMap['namedInputs'] ??= sourceInformation;
             for (const namedInput in project.namedInputs) {
                 sourceMap[`namedInputs.${namedInput}`] = sourceInformation;
             }
@@ -94,6 +108,9 @@ skipCommandNormalization) {
         // We merge the targets with special handling, so clear this back to the
         // targets as defined originally before merging.
         updatedProjectConfiguration.targets = matchingProject?.targets ?? {};
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
         // For each target defined in the new config
         for (const targetName in project.targets) {
             // Always set source map info for the target, but don't overwrite info already there
@@ -117,31 +134,102 @@ skipCommandNormalization) {
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
+    if (project.metadata) {
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
+        for (const [metadataKey, value] of Object.entries({
+            ...project.metadata,
+        })) {
+            const existingValue = matchingProject.metadata?.[metadataKey];
+            if (Array.isArray(value) && Array.isArray(existingValue)) {
+                for (const item of [...value]) {
+                    const newLength = updatedProjectConfiguration.metadata[metadataKey].push(item);
+                    if (sourceMap) {
+                        sourceMap[`metadata.${metadataKey}.${newLength - 1}`] =
+                            sourceInformation;
+                    }
+                }
+            }
+            else if (Array.isArray(value) && existingValue === undefined) {
+                updatedProjectConfiguration.metadata ??= {};
+                updatedProjectConfiguration.metadata[metadataKey] ??= value;
+                if (sourceMap) {
+                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                }
+                for (let i = 0; i < value.length; i++) {
+                    if (sourceMap) {
+                        sourceMap[`metadata.${metadataKey}.${i}`] = sourceInformation;
+                    }
+                }
+            }
+            else if (typeof value === 'object' &&
+                typeof existingValue === 'object') {
+                for (const key in value) {
+                    const existingValue = matchingProject.metadata?.[metadataKey]?.[key];
+                    if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
+                        for (const item of value[key]) {
+                            const i = updatedProjectConfiguration.metadata[metadataKey][key].push(item);
+                            if (sourceMap) {
+                                sourceMap[`metadata.${metadataKey}.${key}.${i - 1}`] =
+                                    sourceInformation;
+                            }
+                        }
+                    }
+                    else {
+                        updatedProjectConfiguration.metadata[metadataKey] = value;
+                        if (sourceMap) {
+                            sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                        }
+                    }
+                }
+            }
+            else {
+                updatedProjectConfiguration.metadata[metadataKey] = value;
+                if (sourceMap) {
+                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                    if (typeof value === 'object') {
+                        for (const k in value) {
+                            sourceMap[`metadata.${metadataKey}.${k}`] = sourceInformation;
+                            if (Array.isArray(value[k])) {
+                                for (let i = 0; i < value[k].length; i++) {
+                                    sourceMap[`metadata.${metadataKey}.${k}.${i}`] =
+                                        sourceInformation;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
 }
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
+ * @param root The workspace root
  * @param nxJson The NxJson configuration
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
- * @param root The workspace root
  */
-function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson, workspaceFiles, // making this parameter allows devkit to pick up newly created projects
-plugins, root = workspace_root_1.workspaceRoot) {
+function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, workspaceFiles, // making this parameter allows devkit to pick up newly created projects
+plugins) {
+    perf_hooks_1.performance.mark('build-project-configs:start');
     const results = [];
+    const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
     for (const { plugin, options } of plugins) {
         const [pattern, createNodes] = plugin.createNodes ?? [];
         const pluginResults = [];
-        performance.mark(`${plugin.name}:createNodes - start`);
+        perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
         if (!pattern) {
             continue;
         }
         const matchingConfigFiles = workspaceFiles.filter(minimatch_1.minimatch.filter(pattern, { dot: true }));
         for (const file of matchingConfigFiles) {
-            performance.mark(`${plugin.name}:createNodes:${file} - start`);
+            perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - start`);
             try {
                 let r = createNodes(file, options, {
                     nxJsonConfiguration: nxJson,
@@ -150,19 +238,26 @@ plugins, root = workspace_root_1.workspaceRoot) {
                 });
                 if (r instanceof Promise) {
                     pluginResults.push(r
-                        .catch((e) => {
-                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+                        .catch((error) => {
+                        perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                        errors.push(new CreateNodesError({
+                            file,
+                            pluginName: plugin.name,
+                            error,
+                        }));
+                        return {
+                            projects: {},
+                        };
                     })
                         .then((r) => {
-                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+                        perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                        perf_hooks_1.performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
                         return { ...r, file, pluginName: plugin.name };
                     }));
                 }
                 else {
-                    performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                    performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+                    perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                    perf_hooks_1.performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
                     pluginResults.push({
                         ...r,
                         file,
@@ -170,19 +265,22 @@ plugins, root = workspace_root_1.workspaceRoot) {
                     });
                 }
             }
-            catch (e) {
-                throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+            catch (error) {
+                errors.push(new CreateNodesError({
+                    file,
+                    pluginName: plugin.name,
+                    error,
+                }));
             }
         }
-        // If there are no promises (counter undefined) or all promises have resolved (counter === 0)
         results.push(Promise.all(pluginResults).then((results) => {
-            performance.mark(`${plugin.name}:createNodes - end`);
-            performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+            perf_hooks_1.performance.mark(`${plugin.name}:createNodes - end`);
+            perf_hooks_1.performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
             return results;
         }));
     }
     return Promise.all(results).then((results) => {
-        performance.mark('createNodes:merge - start');
+        perf_hooks_1.performance.mark('createNodes:merge - start');
         const projectRootMap = new Map();
         const externalNodes = {};
         const configurationSourceMaps = {};
@@ -200,25 +298,41 @@ plugins, root = workspace_root_1.workspaceRoot) {
                 try {
                     mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
                 }
-                catch (e) {
-                    throw new CreateNodesError(`Unable to merge project information for "${project.root}" from ${result.file} using plugin ${result.pluginName}.`, e);
+                catch (error) {
+                    errors.push(new MergeNodesError({
+                        file,
+                        pluginName,
+                        error,
+                    }));
                 }
             }
             Object.assign(externalNodes, pluginExternalNodes);
         }
         const projects = readProjectConfigurationsFromRootMap(projectRootMap);
         const rootMap = createRootMap(projectRootMap);
-        performance.mark('createNodes:merge - end');
-        performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
-        return {
-            projects,
-            externalNodes,
-            rootMap,
-            sourceMaps: configurationSourceMaps,
-        };
+        perf_hooks_1.performance.mark('createNodes:merge - end');
+        perf_hooks_1.performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
+        perf_hooks_1.performance.mark('build-project-configs:end');
+        perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
+        if (errors.length === 0) {
+            return {
+                projects,
+                externalNodes,
+                projectRootMap: rootMap,
+                sourceMaps: configurationSourceMaps,
+            };
+        }
+        else {
+            throw new ProjectConfigurationsError(errors, {
+                projects,
+                externalNodes,
+                projectRootMap: rootMap,
+                sourceMaps: configurationSourceMaps,
+            });
+        }
     });
 }
-exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = buildProjectsConfigurationsFromProjectPathsAndPlugins;
+exports.createProjectConfigurations = createProjectConfigurations;
 function readProjectConfigurationsFromRootMap(projectRootMap) {
     const projects = {};
     // If there are projects that have the same name, that is an error.
@@ -261,20 +375,37 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+class ProjectConfigurationsError extends Error {
+    constructor(errors, partialProjectConfigurationsResult) {
+        super('Failed to create project configurations');
+        this.errors = errors;
+        this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectConfigurationsError = ProjectConfigurationsError;
 class CreateNodesError extends Error {
-    constructor(msg, cause) {
-        const message = `${msg} ${!cause
-            ? ''
-            : cause instanceof Error
-                ? `\n\n\t Inner Error: ${cause.stack}`
-                : cause}`;
-        // These errors are thrown during a JS callback which is invoked via rust.
-        // The errors messaging gets lost in the rust -> js -> rust transition, but
-        // logging the error here will ensure that it is visible in the console.
-        console.error(message);
-        super(message, { cause });
+    constructor({ file, pluginName, error, }) {
+        const msg = `The "${pluginName}" plugin threw an error while creating nodes from ${file}:`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.CreateNodesError = CreateNodesError;
+class MergeNodesError extends Error {
+    constructor({ file, pluginName, error, }) {
+        const msg = `The nodes created from ${file} by the "${pluginName}" could not be merged into the project graph:`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
     }
 }
+exports.MergeNodesError = MergeNodesError;
 /**
  * Merges two targets.
  *

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

@@ -1,7 +1,6 @@
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
-import { ProjectGraphExternalNode } from '../../config/project-graph';
-import { ConfigurationSourceMaps } from './project-configuration-utils';
+import { ConfigurationResult } from './project-configuration-utils';
 import { LoadedNxPlugin } from '../../utils/nx-plugin';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
@@ -10,12 +9,12 @@ import { LoadedNxPlugin } from '../../utils/nx-plugin';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("../../config/project-graph").FileData[];
+    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("../../native").FileData[];
+        nonProjectFiles: import("nx/src/native").FileData[];
     };
-    rustReferences: import("../../native").NxWorkspaceFilesExternals;
+    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
@@ -23,15 +22,8 @@ export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRoo
  * @param workspaceRoot
  * @param nxJson
  */
-export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<RetrievedGraphNodes>;
-export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<RetrievedGraphNodes>;
-export type RetrievedGraphNodes = {
-    externalNodes: Record<string, ProjectGraphExternalNode>;
-    projects: Record<string, ProjectConfiguration>;
-    sourceMaps: ConfigurationSourceMaps;
-    projectRootMap: Record<string, string>;
-};
+export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
 export declare function retrieveProjectConfigurationPaths(root: string, plugins: LoadedNxPlugin[]): string[];
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: LoadedNxPlugin[]): Promise<RetrievedGraphNodes>;
 export declare function configurationGlobs(plugins: LoadedNxPlugin[]): string[];