nx 19.0.0-beta.1 → 19.0.0-beta.11

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateDependenciesError = exports.ProcessProjectGraphError = exports.ProcessDependenciesError = exports.buildProjectGraphUsingProjectFileMap = exports.getFileMap = void 0;
+exports.applyProjectMetadata = 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");
@@ -15,6 +15,8 @@ const project_graph_builder_1 = require("./project-graph-builder");
 const configuration_1 = require("../config/configuration");
 const fs_1 = require("fs");
 const output_1 = require("../utils/output");
+const error_types_1 = require("./error-types");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
 let storedFileMap = null;
 let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
@@ -38,13 +40,26 @@ function getFileMap() {
     }
 }
 exports.getFileMap = getFileMap;
-async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins) {
+async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
     storedFileMap = fileMap;
     storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
+    const projects = {};
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        projects[project.name] = project;
+    }
+    const errors = [];
     const nxJson = (0, configuration_1.readNxJson)();
     const projectGraphVersion = '6.0';
-    (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
+    try {
+        (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
+    }
+    catch (e) {
+        if ((0, error_types_1.isWorkspaceValidityError)(e)) {
+            errors.push(e);
+        }
+    }
     const packageJsonDeps = readCombinedDeps();
     const rootTsConfig = readRootTsConfig();
     let filesToProcess;
@@ -63,9 +78,26 @@ async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fil
             projectFileMap: {},
         };
     }
-    const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
-    let projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion, plugins);
-    const projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig);
+    let projectGraph;
+    let projectFileMapCache;
+    try {
+        const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
+        projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion, plugins, sourceMap);
+        projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig);
+    }
+    catch (e) {
+        // we need to include the workspace validity errors in the final error
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            errors.push(...e.errors);
+            throw new error_types_1.AggregateProjectGraphError(errors, e.partialProjectGraph);
+        }
+        else {
+            throw e;
+        }
+    }
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateProjectGraphError(errors, projectGraph);
+    }
     return {
         projectGraph,
         projectFileMapCache,
@@ -88,7 +120,7 @@ function readCombinedDeps() {
         ...installationPackageJson.devDependencies,
     };
 }
-async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion, plugins) {
+async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion, plugins, sourceMap) {
     perf_hooks_1.performance.mark('build project graph:start');
     const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
     builder.setVersion(projectGraphVersion);
@@ -100,10 +132,10 @@ async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFile
     let updatedGraph;
     let error;
     try {
-        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph, plugins);
+        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph, plugins, sourceMap);
     }
     catch (e) {
-        if (e instanceof CreateDependenciesError) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
             updatedGraph = e.partialProjectGraph;
             error = e;
         }
@@ -134,26 +166,20 @@ async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFile
         return finalGraph;
     }
     else {
-        throw new CreateDependenciesError(error.errors, finalGraph);
+        throw new error_types_1.AggregateProjectGraphError(error.errors, finalGraph);
     }
 }
 function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess) {
-    const clonedProjects = Object.keys(projects).reduce((map, projectName) => {
-        map[projectName] = {
-            ...projects[projectName],
-        };
-        return map;
-    }, {});
     return {
         nxJsonConfiguration: nxJson,
-        projects: clonedProjects,
+        projects,
         externalNodes,
         workspaceRoot: workspace_root_1.workspaceRoot,
         fileMap,
         filesToProcess,
     };
 }
-async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins) {
+async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins, sourceMap) {
     let graph = initProjectGraph;
     const errors = [];
     for (const plugin of plugins) {
@@ -187,7 +213,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins)
             }
         }
         catch (e) {
-            errors.push(new ProcessProjectGraphError(plugin.name, {
+            errors.push(new error_types_1.ProcessProjectGraphError(plugin.name, {
                 cause: e,
             }));
         }
@@ -205,52 +231,24 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins)
             }
         }
         catch (cause) {
-            errors.push(new ProcessDependenciesError(plugin.name, {
+            errors.push(new error_types_1.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`);
     }));
-    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;
+    const graphWithDeps = builder.getUpdatedProjectGraph();
+    const { errors: metadataErrors, graph: updatedGraph } = await applyProjectMetadata(graphWithDeps, plugins, {
+        nxJsonConfiguration: context.nxJsonConfiguration,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    }, sourceMap);
+    errors.push(...metadataErrors);
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateProjectGraphError(errors, updatedGraph);
     }
+    return updatedGraph;
 }
-exports.CreateDependenciesError = CreateDependenciesError;
 function readRootTsConfig() {
     try {
         const tsConfigPath = (0, typescript_1.getRootTsConfigPath)();
@@ -262,3 +260,34 @@ function readRootTsConfig() {
         return {};
     }
 }
+async function applyProjectMetadata(graph, plugins, context, sourceMap) {
+    const results = [];
+    const errors = [];
+    const promises = plugins.map(async (plugin) => {
+        if ((0, utils_1.isNxPluginV2)(plugin) && plugin.createMetadata) {
+            perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
+            try {
+                const metadata = await plugin.createMetadata(graph, undefined, context);
+                results.push({ metadata, pluginName: plugin.name });
+            }
+            catch (e) {
+                errors.push(new error_types_1.CreateMetadataError(e, plugin.name));
+            }
+            finally {
+                perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - end`);
+                perf_hooks_1.performance.measure(`${plugin.name}:createMetadata`, `${plugin.name}:createMetadata - start`, `${plugin.name}:createMetadata - end`);
+            }
+        }
+    });
+    await Promise.all(promises);
+    for (const { metadata: projectsMetadata, pluginName } of results) {
+        for (const project in projectsMetadata) {
+            const projectConfiguration = graph.nodes[project]?.data;
+            if (projectConfiguration) {
+                projectConfiguration.metadata = (0, project_configuration_utils_1.mergeMetadata)(sourceMap[project], [null, pluginName], 'metadata', projectsMetadata[project].metadata, projectConfiguration.metadata);
+            }
+        }
+    }
+    return { errors, graph };
+}
+exports.applyProjectMetadata = applyProjectMetadata;

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

@@ -1,11 +1,10 @@
 import { CreateNodesResultWithContext } from './plugins/internal-api';
 import { ConfigurationResult, ConfigurationSourceMaps } from './utils/project-configuration-utils';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
 import { ProjectGraph } from '../config/project-graph';
 export declare class ProjectGraphError extends Error {
     #private;
-    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
+    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | ProcessProjectGraphError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
     /**
      * The daemon cannot throw errors which contain methods as they are not serializable.
      *
@@ -19,23 +18,37 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (ProcessDependenciesError | ProcessProjectGraphError | CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError)[];
+    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | CreateMetadataError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError)[];
 }
-export declare class ProjectsWithConflictingNamesError extends Error {
+export declare class MultipleProjectsWithSameNameError extends Error {
+    conflicts: Map<string, string[]>;
     projects: Record<string, ProjectConfiguration>;
     constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>);
 }
-export declare function isProjectsWithConflictingNamesError(e: unknown): e is ProjectsWithConflictingNamesError;
+export declare class ProjectWithExistingNameError extends Error {
+    projectName: string;
+    projectRoot: string;
+    constructor(projectName: string, projectRoot: string);
+}
+export declare function isProjectWithExistingNameError(e: unknown): e is ProjectWithExistingNameError;
+export declare function isMultipleProjectsWithSameNameError(e: unknown): e is MultipleProjectsWithSameNameError;
 export declare class ProjectsWithNoNameError extends Error {
+    projectRoots: string[];
     projects: Record<string, ProjectConfiguration>;
     constructor(projectRoots: string[], projects: Record<string, ProjectConfiguration>);
 }
 export declare function isProjectsWithNoNameError(e: unknown): e is ProjectsWithNoNameError;
+export declare class ProjectWithNoNameError extends Error {
+    projectRoot: string;
+    constructor(projectRoot: string);
+}
+export declare function isProjectWithNoNameError(e: unknown): e is ProjectWithNoNameError;
 export declare class ProjectConfigurationsError extends Error {
-    readonly errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError>;
+    readonly errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>;
     readonly partialProjectConfigurationsResult: ConfigurationResult;
-    constructor(errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError>, partialProjectConfigurationsResult: ConfigurationResult);
+    constructor(errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>, partialProjectConfigurationsResult: ConfigurationResult);
 }
+export declare function isProjectConfigurationsError(e: unknown): e is ProjectConfigurationsError;
 export declare class CreateNodesError extends Error {
     file: string;
     pluginName: string;
@@ -60,6 +73,35 @@ export declare class MergeNodesError extends Error {
         error: Error;
     });
 }
+export declare class CreateMetadataError extends Error {
+    readonly error: Error;
+    readonly plugin: string;
+    constructor(error: Error, plugin: string);
+}
+export declare class ProcessDependenciesError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class WorkspaceValidityError extends Error {
+    message: string;
+    constructor(message: string);
+}
+export declare function isWorkspaceValidityError(e: unknown): e is WorkspaceValidityError;
+export declare class ProcessProjectGraphError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class AggregateProjectGraphError extends Error {
+    readonly errors: Array<CreateMetadataError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError>;
+    readonly partialProjectGraph: ProjectGraph;
+    constructor(errors: Array<CreateMetadataError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph);
+}
+export declare function isAggregateProjectGraphError(e: unknown): e is AggregateProjectGraphError;
+export declare function isCreateMetadataError(e: unknown): e is CreateMetadataError;
 export declare function isCreateNodesError(e: unknown): e is CreateNodesError;
 export declare function isAggregateCreateNodesError(e: unknown): e is AggregateCreateNodesError;
 export declare function isMergeNodesError(e: unknown): e is MergeNodesError;

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

@@ -1,11 +1,11 @@
 "use strict";
 var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.isCreateMetadataError = exports.isAggregateProjectGraphError = exports.AggregateProjectGraphError = exports.ProcessProjectGraphError = exports.isWorkspaceValidityError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.isProjectConfigurationsError = exports.ProjectConfigurationsError = exports.isProjectWithNoNameError = exports.ProjectWithNoNameError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isMultipleProjectsWithSameNameError = exports.isProjectWithExistingNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = void 0;
 const tslib_1 = require("tslib");
 class ProjectGraphError extends Error {
     constructor(errors, partialProjectGraph, partialSourceMaps) {
-        super(`Failed to process project graph.`);
+        super(`Failed to process project graph. Run "nx reset" to fix this. Please report the issue if you keep seeing it.`);
         _ProjectGraphError_errors.set(this, void 0);
         _ProjectGraphError_partialProjectGraph.set(this, void 0);
         _ProjectGraphError_partialSourceMaps.set(this, void 0);
@@ -42,7 +42,7 @@ class ProjectGraphError extends Error {
 }
 exports.ProjectGraphError = ProjectGraphError;
 _ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
-class ProjectsWithConflictingNamesError extends Error {
+class MultipleProjectsWithSameNameError extends Error {
     constructor(conflicts, projects) {
         super([
             `The following projects are defined in multiple locations:`,
@@ -50,21 +50,39 @@ class ProjectsWithConflictingNamesError extends Error {
             '',
             "To fix this, set a unique name for each project in a project.json inside the project's root. If the project does not currently have a project.json, you can create one that contains only a name.",
         ].join('\n'));
+        this.conflicts = conflicts;
         this.projects = projects;
         this.name = this.constructor.name;
     }
 }
-exports.ProjectsWithConflictingNamesError = ProjectsWithConflictingNamesError;
-function isProjectsWithConflictingNamesError(e) {
-    return (e instanceof ProjectsWithConflictingNamesError ||
+exports.MultipleProjectsWithSameNameError = MultipleProjectsWithSameNameError;
+class ProjectWithExistingNameError extends Error {
+    constructor(projectName, projectRoot) {
+        super(`The project "${projectName}" is defined in multiple locations.`);
+        this.projectName = projectName;
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithExistingNameError = ProjectWithExistingNameError;
+function isProjectWithExistingNameError(e) {
+    return (e instanceof ProjectWithExistingNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithExistingNameError.name));
+}
+exports.isProjectWithExistingNameError = isProjectWithExistingNameError;
+function isMultipleProjectsWithSameNameError(e) {
+    return (e instanceof MultipleProjectsWithSameNameError ||
         (typeof e === 'object' &&
             'name' in e &&
-            e?.name === ProjectsWithConflictingNamesError.prototype.name));
+            e?.name === MultipleProjectsWithSameNameError.name));
 }
-exports.isProjectsWithConflictingNamesError = isProjectsWithConflictingNamesError;
+exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameError;
 class ProjectsWithNoNameError extends Error {
     constructor(projectRoots, projects) {
         super(`The projects in the following directories have no name provided:\n  - ${projectRoots.join('\n  - ')}`);
+        this.projectRoots = projectRoots;
         this.projects = projects;
         this.name = this.constructor.name;
     }
@@ -74,9 +92,24 @@ function isProjectsWithNoNameError(e) {
     return (e instanceof ProjectsWithNoNameError ||
         (typeof e === 'object' &&
             'name' in e &&
-            e?.name === ProjectsWithNoNameError.prototype.name));
+            e?.name === ProjectsWithNoNameError.name));
 }
 exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
+class ProjectWithNoNameError extends Error {
+    constructor(projectRoot) {
+        super(`The project in ${projectRoot} has no name provided.`);
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithNoNameError = ProjectWithNoNameError;
+function isProjectWithNoNameError(e) {
+    return (e instanceof ProjectWithNoNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithNoNameError.name));
+}
+exports.isProjectWithNoNameError = isProjectWithNoNameError;
 class ProjectConfigurationsError extends Error {
     constructor(errors, partialProjectConfigurationsResult) {
         super('Failed to create project configurations');
@@ -86,6 +119,13 @@ class ProjectConfigurationsError extends Error {
     }
 }
 exports.ProjectConfigurationsError = ProjectConfigurationsError;
+function isProjectConfigurationsError(e) {
+    return (e instanceof ProjectConfigurationsError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectConfigurationsError.name));
+}
+exports.isProjectConfigurationsError = isProjectConfigurationsError;
 class CreateNodesError extends Error {
     constructor({ file, pluginName, error, }) {
         const msg = `The "${pluginName}" plugin threw an error while creating nodes from ${file}:`;
@@ -118,6 +158,78 @@ class MergeNodesError extends Error {
     }
 }
 exports.MergeNodesError = MergeNodesError;
+class CreateMetadataError extends Error {
+    constructor(error, plugin) {
+        super(`The "${plugin}" plugin threw an error while creating metadata:`, {
+            cause: error,
+        });
+        this.error = error;
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.CreateMetadataError = CreateMetadataError;
+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 WorkspaceValidityError extends Error {
+    constructor(message) {
+        message = `Configuration Error\n${message}`;
+        super(message);
+        this.message = message;
+        this.name = this.constructor.name;
+    }
+}
+exports.WorkspaceValidityError = WorkspaceValidityError;
+function isWorkspaceValidityError(e) {
+    return (e instanceof WorkspaceValidityError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === WorkspaceValidityError.name));
+}
+exports.isWorkspaceValidityError = isWorkspaceValidityError;
+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 AggregateProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph) {
+        super('Failed to create project graph. See above for errors');
+        this.errors = errors;
+        this.partialProjectGraph = partialProjectGraph;
+        this.name = this.constructor.name;
+    }
+}
+exports.AggregateProjectGraphError = AggregateProjectGraphError;
+function isAggregateProjectGraphError(e) {
+    return (e instanceof AggregateProjectGraphError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === AggregateProjectGraphError.name));
+}
+exports.isAggregateProjectGraphError = isAggregateProjectGraphError;
+function isCreateMetadataError(e) {
+    return (e instanceof CreateMetadataError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === CreateMetadataError.name));
+}
+exports.isCreateMetadataError = isCreateMetadataError;
 function isCreateNodesError(e) {
     return (e instanceof CreateNodesError ||
         (typeof e === 'object' && 'name' in e && e?.name === CreateNodesError.name));

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

@@ -18,8 +18,8 @@ export declare function isDeletedFileChange(change: Change): change is DeletedFi
 export declare function calculateFileChanges(files: string[], allWorkspaceFiles: FileData[], nxArgs?: NxArgs, readFileAtRevision?: (f: string, r: void | string) => string, ignore?: any): FileChange[];
 export declare const TEN_MEGABYTES: number;
 /**
- * TODO(v19): Remove this function
- * @deprecated To get projects use {@link retrieveProjectConfigurations} instead
+ * TODO(v20): Remove this function
+ * @deprecated To get projects use {@link retrieveProjectConfigurations} instead. This will be removed in v20.
  */
 export declare function readWorkspaceConfig(opts: {
     format: 'angularCli' | 'nx';
@@ -28,4 +28,3 @@ export declare function readWorkspaceConfig(opts: {
 export declare function defaultFileRead(filePath: string): string | null;
 export declare function readPackageJson(): any;
 export { FileData };
-export { readNxJson, workspaceLayout } from '../config/configuration';

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workspaceLayout = exports.readNxJson = exports.readPackageJson = exports.defaultFileRead = exports.readWorkspaceConfig = exports.TEN_MEGABYTES = exports.calculateFileChanges = exports.isDeletedFileChange = exports.isWholeFileChange = exports.DeletedFileChange = exports.WholeFileChange = void 0;
+exports.readPackageJson = exports.defaultFileRead = exports.readWorkspaceConfig = exports.TEN_MEGABYTES = exports.calculateFileChanges = exports.isDeletedFileChange = exports.isWholeFileChange = exports.DeletedFileChange = exports.WholeFileChange = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -98,8 +98,8 @@ function defaultReadFileAtRevision(file, revision) {
     }
 }
 /**
- * TODO(v19): Remove this function
- * @deprecated To get projects use {@link retrieveProjectConfigurations} instead
+ * TODO(v20): Remove this function
+ * @deprecated To get projects use {@link retrieveProjectConfigurations} instead. This will be removed in v20.
  */
 function readWorkspaceConfig(opts) {
     let configuration = null;
@@ -139,12 +139,8 @@ function readPackageJson() {
     }
 }
 exports.readPackageJson = readPackageJson;
-// TODO(17): Remove these exports
-var configuration_2 = require("../config/configuration");
-Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return configuration_2.readNxJson; } });
-Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: function () { return configuration_2.workspaceLayout; } });
 /**
- * TODO(v19): Remove this function.
+ * TODO(v20): Remove this function.
  */
 function getProjectsSyncNoInference(root, nxJson) {
     const allConfigFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
@@ -152,7 +148,7 @@ function getProjectsSyncNoInference(root, nxJson) {
         package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin,
         ...(0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root),
     ];
-    const projectRootMap = new Map();
+    const projectRootMap = {};
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
     for (const plugin of plugins) {
         const [pattern, createNodes] = plugin.createNodes ?? [];

package/src/project-graph/plugins/internal-api.d.ts

@@ -1,7 +1,7 @@
 import { PluginConfiguration } from '../../config/nx-json';
 import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import { CreateDependencies, CreateDependenciesContext, CreateNodesContext, CreateNodesResult, NxPluginV2 } from './public-api';
-import { ProjectGraphProcessor } from '../../config/project-graph';
+import { CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, CreateNodesContext, CreateNodesResult, NxPluginV2 } from './public-api';
+import { ProjectGraph, ProjectGraphProcessor } from '../../config/project-graph';
 export declare class LoadedNxPlugin {
     readonly name: string;
     readonly createNodes?: [
@@ -9,6 +9,7 @@ export declare class LoadedNxPlugin {
         fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<CreateNodesResultWithContext[]>
     ];
     readonly createDependencies?: (context: CreateDependenciesContext) => ReturnType<CreateDependencies>;
+    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => ReturnType<CreateMetadata>;
     readonly processProjectGraph?: ProjectGraphProcessor;
     readonly options?: unknown;
     readonly include?: string[];

package/src/project-graph/plugins/internal-api.js

@@ -26,6 +26,9 @@ class LoadedNxPlugin {
         if (plugin.createDependencies) {
             this.createDependencies = (context) => plugin.createDependencies(this.options, context);
         }
+        if (plugin.createMetadata) {
+            this.createMetadata = (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
         this.processProjectGraph = plugin.processProjectGraph;
     }
 }

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { ProjectGraph, ProjectGraphProcessorContext } from '../../../config/project-graph';
 import { PluginConfiguration } from '../../../config/nx-json';
-import { CreateDependenciesContext, CreateNodesContext } from '../public-api';
+import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext } from '../public-api';
 import { LoadedNxPlugin } from '../internal-api';
 import { Serializable } from 'child_process';
 export interface PluginWorkerLoadMessage {
@@ -15,9 +15,12 @@ export interface PluginWorkerLoadResult {
     type: 'load-result';
     payload: {
         name: string;
+        include?: string[];
+        exclude?: string[];
         createNodesPattern: string;
         hasCreateDependencies: boolean;
         hasProcessProjectGraph: boolean;
+        hasCreateMetadata: boolean;
         success: true;
     } | {
         success: false;
@@ -51,6 +54,14 @@ export interface PluginCreateDependenciesMessage {
         tx: string;
     };
 }
+export interface PluginCreateMetadataMessage {
+    type: 'createMetadata';
+    payload: {
+        graph: ProjectGraph;
+        context: CreateMetadataContext;
+        tx: string;
+    };
+}
 export interface PluginCreateDependenciesResult {
     type: 'createDependenciesResult';
     payload: {
@@ -63,6 +74,18 @@ export interface PluginCreateDependenciesResult {
         tx: string;
     };
 }
+export interface PluginCreateMetadataResult {
+    type: 'createMetadataResult';
+    payload: {
+        metadata: ReturnType<LoadedNxPlugin['createMetadata']>;
+        success: true;
+        tx: string;
+    } | {
+        success: false;
+        error: string;
+        tx: string;
+    };
+}
 export interface PluginWorkerProcessProjectGraphMessage {
     type: 'processProjectGraph';
     payload: {
@@ -83,8 +106,8 @@ export interface PluginWorkerProcessProjectGraphResult {
         tx: string;
     };
 }
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage;
-export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult;
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
+export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult | PluginCreateMetadataResult;
 export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
 export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
 type MaybePromise<T> = T | Promise<T>;