nx 18.3.3 → 18.3.5

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

@@ -142,22 +142,22 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
         logger_1.serverLogger.requestLog([...deletedFiles]);
         const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
         global.NX_GRAPH_CREATION = true;
-        let graphNodes;
+        let projectConfigurationsResult;
         let projectConfigurationsError;
         try {
-            graphNodes = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
+            projectConfigurationsResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
         }
         catch (e) {
             if (e instanceof error_types_1.ProjectConfigurationsError) {
-                graphNodes = e.partialProjectConfigurationsResult;
+                projectConfigurationsResult = e.partialProjectConfigurationsResult;
                 projectConfigurationsError = e;
             }
             else {
                 throw e;
             }
         }
-        await processCollectedUpdatedAndDeletedFiles(graphNodes, updatedFileHashes, deletedFiles);
-        const g = await createAndSerializeProjectGraph(graphNodes);
+        await processCollectedUpdatedAndDeletedFiles(projectConfigurationsResult, updatedFileHashes, deletedFiles);
+        const g = await createAndSerializeProjectGraph(projectConfigurationsResult);
         delete global.NX_GRAPH_CREATION;
         const errors = [...(projectConfigurationsError?.errors ?? [])];
         if (g.error) {
@@ -179,7 +179,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
         }
         if (errors.length > 0) {
             return {
-                error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, graphNodes.sourceMaps),
+                error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps),
                 projectGraph: null,
                 projectFileMapCache: null,
                 fileMap: null,

package/src/devkit-internals.d.ts

@@ -8,6 +8,7 @@ export { getExecutorInformation } from './command-line/run/executor-utils';
 export { readNxJson as readNxJsonFromDisk } from './config/nx-json';
 export { calculateDefaultProjectName } from './config/calculate-default-project-name';
 export { retrieveProjectConfigurationsWithAngularProjects } from './project-graph/utils/retrieve-workspace-files';
+export { readProjectConfigurationsFromRootMap } from './project-graph/utils/project-configuration-utils';
 export { splitTarget } from './utils/split-target';
 export { combineOptionsForExecutor } from './utils/params';
 export { sortObjectByKeys } from './utils/object-sort';

package/src/devkit-internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
+exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.readProjectConfigurationsFromRootMap = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
 const tslib_1 = require("tslib");
 /**
  * Note to developers: STOP! These exports are available via requireNx in @nx/devkit.
@@ -17,6 +17,8 @@ var calculate_default_project_name_1 = require("./config/calculate-default-proje
 Object.defineProperty(exports, "calculateDefaultProjectName", { enumerable: true, get: function () { return calculate_default_project_name_1.calculateDefaultProjectName; } });
 var retrieve_workspace_files_1 = require("./project-graph/utils/retrieve-workspace-files");
 Object.defineProperty(exports, "retrieveProjectConfigurationsWithAngularProjects", { enumerable: true, get: function () { return retrieve_workspace_files_1.retrieveProjectConfigurationsWithAngularProjects; } });
+var project_configuration_utils_1 = require("./project-graph/utils/project-configuration-utils");
+Object.defineProperty(exports, "readProjectConfigurationsFromRootMap", { enumerable: true, get: function () { return project_configuration_utils_1.readProjectConfigurationsFromRootMap; } });
 var split_target_1 = require("./utils/split-target");
 Object.defineProperty(exports, "splitTarget", { enumerable: true, get: function () { return split_target_1.splitTarget; } });
 var params_1 = require("./utils/params");

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -22,6 +22,7 @@ export interface RunCommandsOptions extends Json {
     readyWhen?: string;
     cwd?: string;
     env?: Record<string, string>;
+    forwardAllArgs?: boolean;
     args?: string | string[];
     envFile?: string;
     __unparsed__: string[];

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

@@ -39,6 +39,7 @@ const propKeys = [
     'usePty',
     'streamOutput',
     'verbose',
+    'forwardAllArgs',
 ];
 async function default_1(options, context) {
     registerProcessListener();
@@ -135,7 +136,7 @@ function normalizeOptions(options) {
     options.parsedArgs = parseArgs(unparsedCommandArgs, options.unknownOptions, options.args);
     options.unparsedCommandArgs = unparsedCommandArgs;
     options.commands.forEach((c) => {
-        c.command = interpolateArgsIntoCommand(c.command, options, c.forwardAllArgs ?? true);
+        c.command = interpolateArgsIntoCommand(c.command, options, c.forwardAllArgs ?? options.forwardAllArgs ?? true);
     });
     return options;
 }

package/src/executors/run-commands/schema.json

@@ -135,6 +135,11 @@
         "$source": "unparsed"
       },
       "x-priority": "internal"
+    },
+    "forwardAllArgs": {
+      "type": "boolean",
+      "description": "Whether arguments should be forwarded when interpolation is not present.",
+      "default": true
     }
   },
   "additionalProperties": true,

package/src/executors/utils/convert-nx-executor.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertNxExecutor = void 0;
 const nx_json_1 = require("../../config/nx-json");
 const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
 const internal_api_1 = require("../../project-graph/plugins/internal-api");
 /**
  * Convert an Nx Executor into an Angular Devkit Builder
@@ -19,7 +20,7 @@ function convertNxExecutor(executor) {
             const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJsonConfiguration.plugins, builderContext.workspaceRoot);
             const projectsConfigurations = {
                 version: 2,
-                projects: (await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects,
+                projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
             };
             cleanup();
             const context = {

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

@@ -143,7 +143,7 @@ function readAndCombineAllProjectConfigurations(tree) {
     const createdFiles = findCreatedProjectFiles(tree, patterns);
     const deletedFiles = findDeletedProjectFiles(tree, patterns);
     const projectFiles = [...globbedFiles, ...createdFiles].filter((r) => deletedFiles.indexOf(r) === -1);
-    const rootMap = new Map();
+    const rootMap = {};
     for (const projectFile of projectFiles) {
         if ((0, path_1.basename)(projectFile) === 'project.json') {
             const json = (0, json_1.readJson)(tree, projectFile);
@@ -153,7 +153,7 @@ function readAndCombineAllProjectConfigurations(tree) {
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, json_1.readJson)(tree, projectFile);
             const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, projectFile, (0, nx_json_1.readNxJson)(tree));
-            if (!rootMap.has(config.root)) {
+            if (!rootMap[config.root]) {
                 (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
                 // Inferred targets, tags, etc don't show up when running generators
                 // This is to help avoid running into issues when trying to update the workspace

package/src/project-graph/affected/locators/workspace-projects.js

@@ -58,7 +58,7 @@ function extractFilesFromInputs(inputs, namedInputs) {
     const globalFiles = [];
     for (const input of inputs) {
         if (typeof input === 'string' && input in namedInputs) {
-            return extractFilesFromInputs(namedInputs[input], namedInputs);
+            globalFiles.push(...extractFilesFromInputs(namedInputs[input], namedInputs));
         }
         else if (typeof input === 'string' &&
             input.startsWith('{workspaceRoot}/')) {

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

@@ -9,7 +9,7 @@ export declare function getFileMap(): {
     allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[]): Promise<{
+export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[]): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;

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

@@ -38,10 +38,15 @@ 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) {
     storedFileMap = fileMap;
     storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
+    const projects = {};
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        projects[project.name] = project;
+    }
     const nxJson = (0, configuration_1.readNxJson)();
     const projectGraphVersion = '6.0';
     (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
@@ -138,15 +143,9 @@ async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFile
     }
 }
 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,

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

@@ -152,7 +152,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/loader.js

@@ -32,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),
@@ -77,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);

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.

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

@@ -43,30 +43,29 @@ async function runCreateNodesInParallel(configFiles, plugin, options, context) {
     performance.mark(`${plugin.name}:createNodes - start`);
     const errors = [];
     const results = [];
-    const promises = configFiles.map((file) => {
+    const promises = configFiles.map(async (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`);
+        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) => {
+        }
+        finally {
             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`);

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

@@ -3,15 +3,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 +20,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 +31,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,

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

@@ -5,16 +5,31 @@ import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/sym
 import { LoadedNxPlugin } from '../plugins/internal-api';
 export type SourceInformation = [file: string, 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;
 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 +41,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.
  *

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

@@ -17,12 +17,12 @@ skipCommandNormalization) {
         configurationSourceMaps[project.root] = {};
     }
     const sourceMap = configurationSourceMaps?.[project.root];
-    let matchingProject = projectRootMap.get(project.root);
+    let matchingProject = projectRootMap[project.root];
     if (!matchingProject) {
-        projectRootMap.set(project.root, {
+        projectRootMap[project.root] = {
             root: project.root,
-        });
-        matchingProject = projectRootMap.get(project.root);
+        };
+        matchingProject = projectRootMap[project.root];
         if (sourceMap) {
             sourceMap[`root`] = sourceInformation;
         }
@@ -138,7 +138,8 @@ skipCommandNormalization) {
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
-    projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
+    projectRootMap[updatedProjectConfiguration.root] =
+        updatedProjectConfiguration;
 }
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata, matchingMetadata) {
@@ -264,7 +265,7 @@ plugins) {
     }
     return Promise.all(results).then((results) => {
         perf_hooks_1.performance.mark('createNodes:merge - start');
-        const projectRootMap = new Map();
+        const projectRootMap = {};
         const externalNodes = {};
         const configurationSourceMaps = {};
         for (const result of results.flat()) {
@@ -291,14 +292,17 @@ plugins) {
             }
             Object.assign(externalNodes, pluginExternalNodes);
         }
-        let projects;
         try {
-            projects = readProjectConfigurationsFromRootMap(projectRootMap);
+            // We still call this just to assert that the root map
+            // only contains valid project names. This is a safety check.
+            //
+            // The signature itself can't be changed as we need it to return
+            // project configurations for use in devkit.
+            readProjectConfigurationsFromRootMap(projectRootMap);
         }
         catch (e) {
             if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
                 (0, error_types_1.isProjectsWithConflictingNamesError)(e)) {
-                projects = e.projects;
                 errors.push(e);
             }
             else {
@@ -312,18 +316,20 @@ plugins) {
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
             return {
-                projects,
+                projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
+                matchingProjectFiles: projectFiles,
             };
         }
         else {
             throw new error_types_1.ProjectConfigurationsError(errors, {
-                projects,
+                projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
+                matchingProjectFiles: projectFiles,
             });
         }
     });
@@ -336,7 +342,8 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     // to provide better error messaging.
     const conflicts = new Map();
     const projectRootsWithNoName = [];
-    for (const [root, configuration] of projectRootMap.entries()) {
+    for (const root in projectRootMap) {
+        const configuration = projectRootMap[root];
         // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
         // Strip it before returning configuration for usage.
         if (configuration['// targets'])
@@ -388,7 +395,7 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     const { configurations: defaultConfigurations, options: defaultOptions, ...baseTargetProperties } = baseTarget ?? {};
     // Target is "compatible", e.g. executor is defined only once or is the same
     // in both places. This means that it is likely safe to merge
-    const isCompatible = isCompatibleTarget(baseTargetProperties, target);
+    const isCompatible = isCompatibleTarget(baseTarget ?? {}, target);
     // If the targets are not compatible, we would normally overwrite the old target
     // with the new one. However, we have a special case for targets that have the
     // ONLY_MODIFIES_EXISTING_TARGET symbol set. This prevents the merged target
@@ -544,7 +551,8 @@ function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
 exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
 function createRootMap(projectRootMap) {
     const map = {};
-    for (const [projectRoot, { name: projectName }] of projectRootMap) {
+    for (const projectRoot in projectRootMap) {
+        const projectName = projectRootMap[projectRoot].name;
         map[projectRoot] = projectName;
     }
     return map;

package/src/utils/perf-logging.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const perf_hooks_1 = require("perf_hooks");
-if (process.env.NX_PERF_LOGGING === 'true') {
+let initialized = false;
+if (process.env.NX_PERF_LOGGING === 'true' && !initialized) {
+    initialized = true;
     const obs = new perf_hooks_1.PerformanceObserver((list) => {
         for (const entry of list.getEntries()) {
             console.log(`Time for '${entry.name}'`, entry.duration);