nx 19.0.0-beta.0 → 19.0.0-beta.10

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

@@ -32,7 +32,7 @@ function loadRemoteNxPlugin(plugin, root) {
             ...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
         ],
     });
-    worker.send((0, messaging_1.createMessage)({ type: 'load', payload: { plugin, root } }));
+    worker.send({ type: 'load', payload: { plugin, root } });
     // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
     const pendingPromises = new Map();
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
@@ -67,30 +67,29 @@ async function shutdownPluginWorker(worker, pendingPromises) {
 function createWorkerHandler(worker, pending, onload, onloadError) {
     let pluginName;
     return function (message) {
-        const parsed = JSON.parse(message);
-        // logger.verbose(
-        //   `[plugin-pool] received message: ${parsed.type} from ${
-        //     pluginName ?? worker.pid
-        //   }`
-        // );
-        (0, messaging_1.consumeMessage)(parsed, {
+        if (!(0, messaging_1.isPluginWorkerResult)(message)) {
+            return;
+        }
+        return (0, messaging_1.consumeMessage)(message, {
             'load-result': (result) => {
                 if (result.success) {
-                    const { name, createNodesPattern } = result;
+                    const { name, createNodesPattern, include, exclude } = result;
                     pluginName = name;
                     pluginNames.set(worker, pluginName);
                     onload({
                         name,
+                        include,
+                        exclude,
                         createNodes: createNodesPattern
                             ? [
                                 createNodesPattern,
                                 (configFiles, ctx) => {
                                     const tx = pluginName + ':createNodes:' + performance.now();
                                     return registerPendingPromise(tx, pending, () => {
-                                        worker.send((0, messaging_1.createMessage)({
+                                        worker.send({
                                             type: 'createNodes',
                                             payload: { configFiles, context: ctx, tx },
-                                        }));
+                                        });
                                     });
                                 },
                             ]
@@ -99,10 +98,10 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             ? (ctx) => {
                                 const tx = pluginName + ':createDependencies:' + performance.now();
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send((0, messaging_1.createMessage)({
+                                    worker.send({
                                         type: 'createDependencies',
                                         payload: { context: ctx, tx },
-                                    }));
+                                    });
                                 });
                             }
                             : undefined,
@@ -110,10 +109,21 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             ? (graph, ctx) => {
                                 const tx = pluginName + ':processProjectGraph:' + performance.now();
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send((0, messaging_1.createMessage)({
+                                    worker.send({
                                         type: 'processProjectGraph',
                                         payload: { graph, ctx, tx },
-                                    }));
+                                    });
+                                });
+                            }
+                            : undefined,
+                        createMetadata: result.hasCreateMetadata
+                            ? (graph, ctx) => {
+                                const tx = pluginName + ':createMetadata:' + performance.now();
+                                return registerPendingPromise(tx, pending, () => {
+                                    worker.send({
+                                        type: 'createMetadata',
+                                        payload: { graph, context: ctx, tx },
+                                    });
                                 });
                             }
                             : undefined,
@@ -150,6 +160,15 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                     rejector(result.error);
                 }
             },
+            createMetadataResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver(result.metadata);
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
         });
     };
 }

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

@@ -2,10 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
 const loader_1 = require("../loader");
+const serializable_error_1 = require("../../../utils/serializable-error");
+if (process.env.NX_PERF_LOGGING === 'true') {
+    require('../../../utils/perf-logging');
+}
 global.NX_GRAPH_CREATION = true;
 let plugin;
 process.on('message', async (message) => {
-    (0, messaging_1.consumeMessage)(message, {
+    if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
+        return;
+    }
+    return (0, messaging_1.consumeMessage)(message, {
         load: async ({ plugin: pluginConfiguration, root }) => {
             process.chdir(root);
             try {
@@ -15,9 +22,12 @@ process.on('message', async (message) => {
                     type: 'load-result',
                     payload: {
                         name: plugin.name,
+                        include: plugin.include,
+                        exclude: plugin.exclude,
                         createNodesPattern: plugin.createNodes?.[0],
                         hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
                         hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
+                        hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
                         success: true,
                     },
                 };
@@ -27,7 +37,7 @@ process.on('message', async (message) => {
                     type: 'load-result',
                     payload: {
                         success: false,
-                        error: `Could not load plugin ${plugin} \n ${e instanceof Error ? e.stack : ''}`,
+                        error: (0, serializable_error_1.createSerializableError)(e),
                     },
                 };
             }
@@ -43,7 +53,11 @@ process.on('message', async (message) => {
             catch (e) {
                 return {
                     type: 'createNodesResult',
-                    payload: { success: false, error: e.stack, tx },
+                    payload: {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                        tx,
+                    },
                 };
             }
         },
@@ -58,7 +72,11 @@ process.on('message', async (message) => {
             catch (e) {
                 return {
                     type: 'createDependenciesResult',
-                    payload: { success: false, error: e.stack, tx },
+                    payload: {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                        tx,
+                    },
                 };
             }
         },
@@ -73,6 +91,25 @@ process.on('message', async (message) => {
             catch (e) {
                 return {
                     type: 'processProjectGraphResult',
+                    payload: {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                        tx,
+                    },
+                };
+            }
+        },
+        createMetadata: async ({ graph, context, tx }) => {
+            try {
+                const result = await plugin.createMetadata(graph, context);
+                return {
+                    type: 'createMetadataResult',
+                    payload: { metadata: result, success: true, tx },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'createMetadataResult',
                     payload: { success: false, error: e.stack, tx },
                 };
             }

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

@@ -8,16 +8,17 @@ const package_json_1 = require("../../utils/package-json");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
 const node_fs_1 = require("node:fs");
-const typescript_1 = require("../../utils/typescript");
 const register_1 = require("../../plugins/js/utils/register");
 const find_project_for_path_1 = require("../utils/find-project-for-path");
 const path_1 = require("../../utils/path");
 const logger_1 = require("../../utils/logger");
 const node_path_1 = require("node:path");
-const path = require("node:path/posix");
 const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
 const utils_1 = require("./utils");
 const internal_api_1 = require("./internal-api");
+const error_types_1 = require("../error-types");
+const path = require("node:path/posix");
+const typescript_1 = require("../../plugins/js/utils/typescript");
 function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
@@ -31,6 +32,9 @@ function readPluginPackageJson(pluginName, projects, paths = (0, installation_di
             const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
             if (localPluginPath) {
                 const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                if (!exports.unregisterPluginTSTranspiler) {
+                    registerPluginTSTranspiler();
+                }
                 return {
                     path: localPluginPackageJson,
                     json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
@@ -76,22 +80,27 @@ function registerPluginTSTranspiler() {
 }
 exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
 function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const plugin = findNxProjectForImportPath(importPath, projects, root);
-    if (!plugin) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
         return null;
     }
-    const projectConfig = projects[plugin];
     return { path: path.join(root, projectConfig.root), projectConfig };
 }
 function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
     const tsConfigPaths = readTsConfigPaths(root);
     const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
     if (possiblePaths?.length) {
-        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+        const projectRootMappings = new Map();
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
         for (const tsConfigPath of possiblePaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
-                return nxProject;
+                return projectNameMap.get(nxProject);
             }
         }
         logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
@@ -174,26 +183,29 @@ function loadNxPlugin(plugin, root) {
 }
 exports.loadNxPlugin = loadNxPlugin;
 async function loadNxPluginAsync(pluginConfiguration, paths, root) {
-    try {
-        require.resolve(typeof pluginConfiguration === 'string'
-            ? pluginConfiguration
-            : pluginConfiguration.plugin);
-    }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInference ??=
-            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-    }
     const moduleName = typeof pluginConfiguration === 'string'
         ? pluginConfiguration
         : pluginConfiguration.plugin;
-    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
-    const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
-    plugin.name ??= name;
-    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
-    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
-    return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+    try {
+        try {
+            require.resolve(moduleName);
+        }
+        catch {
+            // If a plugin cannot be resolved, we will need projects to resolve it
+            projectsWithoutInference ??=
+                await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+        }
+        performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+        let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+        const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
+        plugin.name ??= name;
+        performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+        performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+        return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+    }
+    catch (e) {
+        throw new error_types_1.LoadPluginError(moduleName, e);
+    }
 }
 exports.loadNxPluginAsync = loadNxPluginAsync;
 async function importPluginModule(pluginPath) {

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

@@ -12,7 +12,7 @@ export interface CreateNodesContext {
     /**
      * The subset of configuration files which match the createNodes pattern
      */
-    readonly configFiles: string[];
+    readonly configFiles: readonly string[];
 }
 /**
  * A function which parses a configuration file into a set of nodes.
@@ -68,6 +68,12 @@ export interface CreateDependenciesContext {
  * Use {@link validateDependency} to validate dependencies
  */
 export type CreateDependencies<T = unknown> = (options: T | undefined, context: CreateDependenciesContext) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
+export type CreateMetadataContext = {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+};
+export type ProjectsMetadata = Record<string, Pick<ProjectConfiguration, 'metadata'>>;
+export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | undefined, context: CreateMetadataContext) => ProjectsMetadata | Promise<ProjectsMetadata>;
 /**
  * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
  */
@@ -82,6 +88,10 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
     createDependencies?: CreateDependencies<TOptions>;
+    /**
+     * Provides a function to create metadata for the {@link ProjectGraph}
+     */
+    createMetadata?: CreateMetadata<TOptions>;
 };
 /**
  * A plugin for Nx

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

@@ -1,7 +1,7 @@
 import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
 import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
-import type { CreateNodesContext, NxPlugin, NxPluginV2 } from './public-api';
+import { type CreateNodesContext, type NxPlugin, type NxPluginV2 } from './public-api';
 export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
 export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
 export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
-export declare function runCreateNodesInParallel(configFiles: string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;
+export declare function runCreateNodesInParallel(configFiles: readonly string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;

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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCreateNodesInParallel = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
 const node_path_1 = require("node:path");
-const workspaces_1 = require("../../config/workspaces");
+const to_project_name_1 = require("../../config/to-project-name");
 const globs_1 = require("../../utils/globs");
 const error_types_1 = require("../error-types");
+const perf_hooks_1 = require("perf_hooks");
 function isNxPluginV2(plugin) {
     return 'createNodes' in plugin || 'createDependencies' in plugin;
 }
@@ -27,7 +28,7 @@ function normalizeNxPlugin(plugin) {
                     return {
                         projects: {
                             [root]: {
-                                name: (0, workspaces_1.toProjectName)(configFilePath),
+                                name: (0, to_project_name_1.toProjectName)(configFilePath),
                                 targets: plugin.registerProjectTargets?.(configFilePath),
                             },
                         },
@@ -40,37 +41,31 @@ function normalizeNxPlugin(plugin) {
 }
 exports.normalizeNxPlugin = normalizeNxPlugin;
 async function runCreateNodesInParallel(configFiles, plugin, options, context) {
-    performance.mark(`${plugin.name}:createNodes - start`);
+    perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
     const errors = [];
     const results = [];
-    const promises = configFiles.map((file) => {
-        performance.mark(`${plugin.name}:createNodes:${file} - start`);
-        // Result is either static or a promise, using Promise.resolve lets us
-        // handle both cases with same logic
-        const value = Promise.resolve(plugin.createNodes[1](file, options, context));
-        return value
-            .catch((e) => {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
+    const promises = configFiles.map(async (file) => {
+        try {
+            const value = await plugin.createNodes[1](file, options, context);
+            if (value) {
+                results.push({
+                    ...value,
+                    file,
+                    pluginName: plugin.name,
+                });
+            }
+        }
+        catch (e) {
             errors.push(new error_types_1.CreateNodesError({
                 error: e,
                 pluginName: plugin.name,
                 file,
             }));
-            return null;
-        })
-            .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`);
-            // Existing behavior is to ignore null results of
-            // createNodes function.
-            if (r) {
-                results.push({ ...r, file, pluginName: plugin.name });
-            }
-        });
+        }
     });
     await Promise.all(promises).then(() => {
-        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`);
     });
     if (errors.length > 0) {
         throw new error_types_1.AggregateCreateNodesError(plugin.name, errors, results);

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

@@ -14,6 +14,9 @@ export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
     projectGraph: ProjectGraph;
     sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
 }>;
+export declare function handleProjectGraphError(opts: {
+    exitOnError: boolean;
+}, e: any): void;
 /**
  * Computes and returns a ProjectGraph.
  *

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

@@ -1,6 +1,6 @@
 "use strict";
 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.handleProjectGraphError = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
@@ -10,8 +10,8 @@ const output_1 = require("../utils/output");
 const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
 const build_project_graph_1 = require("./build-project-graph");
-const nx_deps_cache_1 = require("./nx-deps-cache");
 const error_types_1 = require("./error-types");
+const nx_deps_cache_1 = require("./nx-deps-cache");
 const internal_api_1 = require("./plugins/internal-api");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 /**
@@ -92,18 +92,18 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     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');
-    let createDependenciesError;
+    let projectGraphError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
     }
     catch (e) {
-        if (e instanceof build_project_graph_1.CreateDependenciesError) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
             projectGraphResult = {
                 projectGraph: e.partialProjectGraph,
                 projectFileMapCache: null,
             };
-            createDependenciesError = e;
+            projectGraphError = e;
         }
         else {
             throw e;
@@ -117,7 +117,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     delete global.NX_GRAPH_CREATION;
     const errors = [
         ...(projectConfigurationsError?.errors ?? []),
-        ...(createDependenciesError?.errors ?? []),
+        ...(projectGraphError?.errors ?? []),
     ];
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
@@ -162,6 +162,7 @@ function handleProjectGraphError(opts, e) {
         throw e;
     }
 }
+exports.handleProjectGraphError = handleProjectGraphError;
 /**
  * Computes and returns a ProjectGraph.
  *

package/src/project-graph/utils/find-project-for-path.js

@@ -9,9 +9,8 @@ const path_2 = require("../../utils/path");
  */
 function createProjectRootMappingsFromProjectConfigurations(projects) {
     const projectRootMappings = new Map();
-    for (const projectName of Object.keys(projects)) {
-        const root = projects[projectName].root;
-        projectRootMappings.set(normalizeProjectRoot(root), projectName);
+    for (const { name, root } of Object.values(projects)) {
+        projectRootMappings.set(normalizeProjectRoot(root), name);
     }
     return projectRootMappings;
 }

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -2,7 +2,7 @@ import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
 import { CreateDependenciesContext } from '../plugins';
-export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
+export declare function normalizeProjectNodes({ projects }: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
 /**
  * Apply target defaults and normalization
  */

package/src/project-graph/utils/normalize-project-nodes.js

@@ -2,16 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
-const project_configuration_utils_1 = require("../utils/project-configuration-utils");
-async function normalizeProjectNodes(ctx, builder) {
-    const toAdd = [];
+async function normalizeProjectNodes({ projects }, builder) {
     // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
     // This is important to ensure that expanded properties referencing projects (e.g. implicit dependencies)
     // are also deterministic, and thus don't cause the calculated project configuration hash to shift.
-    const projects = Object.keys(ctx.projects).sort();
+    const sortedProjectNames = Object.keys(projects).sort();
     // Used for expanding implicit dependencies (e.g. `@proj/*` or `tag:foo`)
-    const partialProjectGraphNodes = projects.reduce((graph, project) => {
-        const projectConfiguration = ctx.projects[project];
+    const partialProjectGraphNodes = sortedProjectNames.reduce((graph, project) => {
+        const projectConfiguration = projects[project];
         graph[project] = {
             name: project,
             type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
@@ -21,8 +19,9 @@ async function normalizeProjectNodes(ctx, builder) {
         };
         return graph;
     }, {});
-    for (const key of projects) {
-        const p = ctx.projects[key];
+    const toAdd = [];
+    for (const key of sortedProjectNames) {
+        const p = projects[key];
         p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
         p.targets = normalizeProjectTargets(p, key);
         // TODO: remove in v16
@@ -31,7 +30,7 @@ async function normalizeProjectNodes(ctx, builder) {
                 ? 'e2e'
                 : 'app'
             : 'lib';
-        const tags = ctx.projects?.[key]?.tags || [];
+        const tags = p.tags || [];
         toAdd.push({
             name: key,
             type: projectType,
@@ -69,11 +68,6 @@ function normalizeProjectTargets(project, projectName) {
             delete targets[target];
             continue;
         }
-        targets[target].options = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].options, project, `${projectName}:${target}`);
-        targets[target].configurations ??= {};
-        for (const configuration in targets[target].configurations) {
-            targets[target].configurations[configuration] = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].configurations[configuration], project, `${projectName}:${target}:${configuration}`);
-        }
     }
     return targets;
 }

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

@@ -1,20 +1,36 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
+import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../config/workspace-json-project-json';
 import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/symbols';
 import { LoadedNxPlugin } from '../plugins/internal-api';
-export type SourceInformation = [file: string, plugin: string];
+export type SourceInformation = [file: string | null, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration & {
     targets?: Record<string, TargetConfiguration & {
         [ONLY_MODIFIES_EXISTING_TARGET]?: boolean;
     }>;
-}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipCommandNormalization?: boolean): void;
+}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): void;
+export declare function mergeMetadata<T = ProjectMetadata | TargetMetadata>(sourceMap: Record<string, [file: string, plugin: string]>, sourceInformation: [file: string, plugin: string], baseSourceMapPath: string, metadata: T, matchingMetadata?: T): T;
 export type ConfigurationResult = {
-    projects: Record<string, ProjectConfiguration>;
+    /**
+     * A map of project configurations, keyed by project root.
+     */
+    projects: {
+        [projectRoot: string]: ProjectConfiguration;
+    };
+    /**
+     * Node Name -> Node info
+     */
     externalNodes: Record<string, ProjectGraphExternalNode>;
+    /**
+     * Project Root -> Project Name
+     */
     projectRootMap: Record<string, string>;
     sourceMaps: ConfigurationSourceMaps;
+    /**
+     * The list of files that were used to create project configurations
+     */
+    matchingProjectFiles: string[];
 };
 /**
  * Transforms a list of project paths into a map of project configurations.
@@ -26,7 +42,7 @@ export type ConfigurationResult = {
  */
 export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, projectFiles: 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 function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 /**
  * Merges two targets.
  *
@@ -51,3 +67,4 @@ export declare function mergeTargetConfigurations(target: TargetConfiguration, b
 export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
 export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
 export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
+export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration): TargetConfiguration<any>;