nx 19.2.0-canary.20240530-316dcb9 → 19.2.0-canary.20240531-2cb7ecb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.2.0-canary.20240530-316dcb9",
+  "version": "19.2.0-canary.20240531-2cb7ecb",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -69,7 +69,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.2.0-canary.20240530-316dcb9"
+    "@nrwl/tao": "19.2.0-canary.20240531-2cb7ecb"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -84,16 +84,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-darwin-arm64": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-linux-x64-gnu": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-linux-x64-musl": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-win32-x64-msvc": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-linux-arm64-gnu": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-linux-arm64-musl": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-linux-arm-gnueabihf": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-win32-arm64-msvc": "19.2.0-canary.20240530-316dcb9",
-    "@nx/nx-freebsd-x64": "19.2.0-canary.20240530-316dcb9"
+    "@nx/nx-darwin-x64": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-darwin-arm64": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-linux-x64-gnu": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-linux-x64-musl": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-win32-x64-msvc": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-linux-arm64-gnu": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-linux-arm64-musl": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-linux-arm-gnueabihf": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-win32-arm64-msvc": "19.2.0-canary.20240531-2cb7ecb",
+    "@nx/nx-freebsd-x64": "19.2.0-canary.20240531-2cb7ecb"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/devkit-exports.d.ts

@@ -15,7 +15,9 @@ export type { WorkspaceJsonConfiguration, ProjectsConfigurations, TargetDependen
  */
 export type { Generator, GeneratorCallback, Executor, ExecutorContext, TaskGraphExecutor, GeneratorsJson, ExecutorsJson, MigrationsJson, CustomHasher, HasherContext, } from './config/misc-interfaces';
 export { workspaceLayout } from './config/configuration';
-export type { NxPlugin, NxPluginV2, CreateNodes, CreateNodesFunction, CreateNodesResult, CreateNodesContext, CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, ProjectsMetadata, } from './project-graph/plugins';
+export type { NxPlugin, NxPluginV2, CreateNodes, CreateNodesFunction, CreateNodesResult, CreateNodesContext, CreateNodesContextV2, CreateNodesFunctionV2, CreateNodesResultV2, CreateNodesV2, CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, ProjectsMetadata, } from './project-graph/plugins';
+export { AggregateCreateNodesError } from './project-graph/error-types';
+export { createNodesFromFiles } from './project-graph/plugins';
 export type { NxPluginV1, ProjectTargetConfigurator, } from './utils/nx-plugin.deprecated';
 /**
  * @category Workspace

package/src/devkit-exports.js

@@ -4,9 +4,13 @@
  * Try hard to not add to this API to reduce the surface area we need to maintain.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProjectFileMapUsingProjectGraph = exports.cacheDir = exports.hashArray = exports.defaultTasksRunner = exports.getOutputsForTargetAndConfiguration = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectGraph = exports.createProjectGraphAsync = exports.reverse = exports.appRootPath = exports.workspaceRoot = exports.normalizePath = exports.joinPathFragments = exports.stripIndents = exports.writeJsonFile = exports.readJsonFile = exports.stripJsonComments = exports.serializeJson = exports.parseJson = exports.updateJson = exports.writeJson = exports.readJson = exports.validateDependency = exports.ProjectGraphBuilder = exports.DependencyType = exports.updateNxJson = exports.readNxJson = exports.glob = exports.getProjects = exports.updateProjectConfiguration = exports.removeProjectConfiguration = exports.readProjectConfiguration = exports.addProjectConfiguration = exports.runExecutor = exports.isWorkspacesEnabled = exports.getPackageManagerVersion = exports.detectPackageManager = exports.getPackageManagerCommand = exports.output = exports.logger = exports.workspaceLayout = void 0;
+exports.createProjectFileMapUsingProjectGraph = exports.cacheDir = exports.hashArray = exports.defaultTasksRunner = exports.getOutputsForTargetAndConfiguration = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectGraph = exports.createProjectGraphAsync = exports.reverse = exports.appRootPath = exports.workspaceRoot = exports.normalizePath = exports.joinPathFragments = exports.stripIndents = exports.writeJsonFile = exports.readJsonFile = exports.stripJsonComments = exports.serializeJson = exports.parseJson = exports.updateJson = exports.writeJson = exports.readJson = exports.validateDependency = exports.ProjectGraphBuilder = exports.DependencyType = exports.updateNxJson = exports.readNxJson = exports.glob = exports.getProjects = exports.updateProjectConfiguration = exports.removeProjectConfiguration = exports.readProjectConfiguration = exports.addProjectConfiguration = exports.runExecutor = exports.isWorkspacesEnabled = exports.getPackageManagerVersion = exports.detectPackageManager = exports.getPackageManagerCommand = exports.output = exports.logger = exports.createNodesFromFiles = exports.AggregateCreateNodesError = exports.workspaceLayout = void 0;
 var configuration_1 = require("./config/configuration");
 Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: function () { return configuration_1.workspaceLayout; } });
+var error_types_1 = require("./project-graph/error-types");
+Object.defineProperty(exports, "AggregateCreateNodesError", { enumerable: true, get: function () { return error_types_1.AggregateCreateNodesError; } });
+var plugins_1 = require("./project-graph/plugins");
+Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return plugins_1.createNodesFromFiles; } });
 /**
  * @category Logger
  */

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

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildExplicitDependencies = void 0;
-const explicit_project_dependencies_1 = require("./explicit-project-dependencies");
 const explicit_package_json_dependencies_1 = require("./explicit-package-json-dependencies");
+const explicit_project_dependencies_1 = require("./explicit-project-dependencies");
+const target_project_locator_1 = require("./target-project-locator");
 function buildExplicitDependencies(jsPluginConfig, ctx) {
     if (totalNumberOfFilesToProcess(ctx) === 0)
         return [];
     let dependencies = [];
+    // TODO: TargetProjectLocator is a public API, so we can't change the shape of it
+    // We should eventually let it accept Record<string, ProjectConfiguration> s.t. we
+    // don't have to reshape the CreateDependenciesContext here.
+    const nodes = Object.fromEntries(Object.entries(ctx.projects).map(([key, config]) => [
+        key,
+        {
+            name: key,
+            type: null,
+            data: config,
+        },
+    ]));
+    const targetProjectLocator = new target_project_locator_1.TargetProjectLocator(nodes, ctx.externalNodes);
     if (jsPluginConfig.analyzeSourceFiles === undefined ||
         jsPluginConfig.analyzeSourceFiles === true) {
         let tsExists = false;
@@ -16,12 +29,12 @@ function buildExplicitDependencies(jsPluginConfig, ctx) {
         }
         catch { }
         if (tsExists) {
-            dependencies = dependencies.concat((0, explicit_project_dependencies_1.buildExplicitTypeScriptDependencies)(ctx));
+            dependencies = dependencies.concat((0, explicit_project_dependencies_1.buildExplicitTypeScriptDependencies)(ctx, targetProjectLocator));
         }
     }
     if (jsPluginConfig.analyzePackageJson === undefined ||
         jsPluginConfig.analyzePackageJson === true) {
-        dependencies = dependencies.concat((0, explicit_package_json_dependencies_1.buildExplicitPackageJsonDependencies)(ctx));
+        dependencies = dependencies.concat((0, explicit_package_json_dependencies_1.buildExplicitPackageJsonDependencies)(ctx, targetProjectLocator));
     }
     return dependencies;
 }

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.d.ts

@@ -1,3 +1,4 @@
 import { CreateDependenciesContext } from '../../../../project-graph/plugins';
 import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
-export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+import { TargetProjectLocator } from './target-project-locator';
+export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildExplicitPackageJsonDependencies = void 0;
-const file_utils_1 = require("../../../../project-graph/file-utils");
-const path_1 = require("path");
+const node_path_1 = require("node:path");
 const project_graph_1 = require("../../../../config/project-graph");
-const json_1 = require("../../../../utils/json");
-const path_2 = require("../../../../utils/path");
+const file_utils_1 = require("../../../../project-graph/file-utils");
 const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
-function buildExplicitPackageJsonDependencies(ctx) {
+const json_1 = require("../../../../utils/json");
+const path_1 = require("../../../../utils/path");
+function buildExplicitPackageJsonDependencies(ctx, targetProjectLocator) {
     const res = [];
     let packageNameMap = undefined;
     const nodes = Object.values(ctx.projects);
@@ -16,7 +16,7 @@ function buildExplicitPackageJsonDependencies(ctx) {
             if (isPackageJsonAtProjectRoot(nodes, f.file)) {
                 // we only create the package name map once and only if a package.json file changes
                 packageNameMap = packageNameMap || createPackageNameMap(ctx.projects);
-                processPackageJson(source, f.file, ctx, res, packageNameMap);
+                processPackageJson(source, f.file, ctx, targetProjectLocator, res, packageNameMap);
             }
         });
     });
@@ -27,7 +27,7 @@ function createPackageNameMap(projects) {
     const res = {};
     for (let projectName of Object.keys(projects)) {
         try {
-            const packageJson = (0, json_1.parseJson)((0, file_utils_1.defaultFileRead)((0, path_1.join)(projects[projectName].root, 'package.json')));
+            const packageJson = (0, json_1.parseJson)((0, file_utils_1.defaultFileRead)((0, node_path_1.join)(projects[projectName].root, 'package.json')));
             res[packageJson.name ?? projectName] = projectName;
         }
         catch (e) { }
@@ -36,13 +36,12 @@ function createPackageNameMap(projects) {
 }
 function isPackageJsonAtProjectRoot(nodes, fileName) {
     return (fileName.endsWith('package.json') &&
-        nodes.find((projectNode) => (0, path_2.joinPathFragments)(projectNode.root, 'package.json') === fileName));
+        nodes.find((projectNode) => (0, path_1.joinPathFragments)(projectNode.root, 'package.json') === fileName));
 }
-function processPackageJson(sourceProject, fileName, ctx, collectedDeps, packageNameMap) {
+function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps, packageNameMap) {
     try {
         const deps = readDeps((0, json_1.parseJson)((0, file_utils_1.defaultFileRead)(fileName)));
-        // the name matches the import path
-        deps.forEach((d) => {
+        for (const d of Object.keys(deps)) {
             // package.json refers to another project in the monorepo
             if (packageNameMap[d]) {
                 const dependency = {
@@ -53,30 +52,44 @@ function processPackageJson(sourceProject, fileName, ctx, collectedDeps, package
                 };
                 (0, project_graph_builder_1.validateDependency)(dependency, ctx);
                 collectedDeps.push(dependency);
+                continue;
             }
-            else if (ctx.externalNodes[`npm:${d}`]) {
-                const dependency = {
-                    source: sourceProject,
-                    target: `npm:${d}`,
-                    sourceFile: fileName,
-                    type: project_graph_1.DependencyType.static,
-                };
-                (0, project_graph_builder_1.validateDependency)(dependency, ctx);
-                collectedDeps.push(dependency);
+            const externalNodeName = targetProjectLocator.findNpmProjectFromImport(d, fileName);
+            if (!externalNodeName) {
+                continue;
             }
-        });
+            const dependency = {
+                source: sourceProject,
+                target: externalNodeName,
+                sourceFile: fileName,
+                type: project_graph_1.DependencyType.static,
+            };
+            (0, project_graph_builder_1.validateDependency)(dependency, ctx);
+            collectedDeps.push(dependency);
+        }
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            console.log(e);
+            console.error(e);
         }
     }
 }
 function readDeps(packageJson) {
-    return [
-        ...Object.keys(packageJson?.dependencies ?? {}),
-        ...Object.keys(packageJson?.devDependencies ?? {}),
-        ...Object.keys(packageJson?.peerDependencies ?? {}),
-        ...Object.keys(packageJson?.optionalDependencies ?? {}),
+    const deps = {};
+    /**
+     * We process dependencies in a rough order of increasing importance such that if a dependency is listed in multiple
+     * sections, the version listed under the "most important" one wins, with production dependencies being the most important.
+     */
+    const depType = [
+        'optionalDependencies',
+        'peerDependencies',
+        'devDependencies',
+        'dependencies',
     ];
+    for (const type of depType) {
+        for (const [depName, depVersion] of Object.entries(packageJson[type] || {})) {
+            deps[depName] = depVersion;
+        }
+    }
+    return deps;
 }

package/src/plugins/js/project-graph/build-dependencies/explicit-project-dependencies.d.ts

@@ -1,3 +1,4 @@
 import { CreateDependenciesContext } from '../../../../project-graph/plugins';
 import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
-export declare function buildExplicitTypeScriptDependencies(ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+import { TargetProjectLocator } from './target-project-locator';
+export declare function buildExplicitTypeScriptDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];

package/src/plugins/js/project-graph/build-dependencies/explicit-project-dependencies.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildExplicitTypeScriptDependencies = void 0;
-const target_project_locator_1 = require("./target-project-locator");
-const project_graph_1 = require("../../../../config/project-graph");
 const path_1 = require("path");
-const workspace_root_1 = require("../../../../utils/workspace-root");
-const path_2 = require("../../../../utils/path");
+const project_graph_1 = require("../../../../config/project-graph");
 const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
+const path_2 = require("../../../../utils/path");
+const workspace_root_1 = require("../../../../utils/workspace-root");
 function isRoot(projects, projectName) {
     return projects[projectName]?.root === '.';
 }
 function convertImportToDependency(importExpr, sourceFile, source, type, targetProjectLocator) {
-    const target = targetProjectLocator.findProjectWithImport(importExpr, sourceFile) ??
-        `npm:${importExpr}`;
+    const target = targetProjectLocator.findProjectFromImport(importExpr, sourceFile);
+    if (!target) {
+        return;
+    }
     return {
         source,
         target,
@@ -20,19 +21,7 @@ function convertImportToDependency(importExpr, sourceFile, source, type, targetP
         type,
     };
 }
-function buildExplicitTypeScriptDependencies(ctx) {
-    // TODO: TargetProjectLocator is a public API, so we can't change the shape of it
-    // We should eventually let it accept Record<string, ProjectConfiguration> s.t. we
-    // don't have to reshape the CreateDependenciesContext here.
-    const nodes = Object.fromEntries(Object.entries(ctx.projects).map(([key, config]) => [
-        key,
-        {
-            name: key,
-            type: null,
-            data: config,
-        },
-    ]));
-    const targetProjectLocator = new target_project_locator_1.TargetProjectLocator(nodes, ctx.externalNodes);
+function buildExplicitTypeScriptDependencies(ctx, targetProjectLocator) {
     const res = [];
     const filesToProcess = {};
     const moduleExtensions = [
@@ -63,6 +52,9 @@ function buildExplicitTypeScriptDependencies(ctx) {
         const normalizedFilePath = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, file));
         for (const importExpr of staticImportExpressions) {
             const dependency = convertImportToDependency(importExpr, normalizedFilePath, sourceProject, project_graph_1.DependencyType.static, targetProjectLocator);
+            if (!dependency) {
+                continue;
+            }
             // TODO: These edges technically should be allowed but we need to figure out how to separate config files out from root
             if (isRoot(ctx.projects, dependency.source) ||
                 !isRoot(ctx.projects, dependency.target)) {
@@ -71,6 +63,9 @@ function buildExplicitTypeScriptDependencies(ctx) {
         }
         for (const importExpr of dynamicImportExpressions) {
             const dependency = convertImportToDependency(importExpr, normalizedFilePath, sourceProject, project_graph_1.DependencyType.dynamic, targetProjectLocator);
+            if (!dependency) {
+                continue;
+            }
             // TODO: These edges technically should be allowed but we need to figure out how to separate config files out from root
             if (isRoot(ctx.projects, dependency.source) ||
                 !isRoot(ctx.projects, dependency.target)) {

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.d.ts

@@ -1,21 +1,37 @@
 import { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
+/**
+ * The key is a combination of the package name and the workspace relative directory
+ * containing the file importing it e.g. `lodash__packages/my-lib`, the value is the
+ * resolved external node name from the project graph.
+ */
+type NpmResolutionCache = Map<string, string | null>;
+export declare function isBuiltinModuleImport(importExpr: string): boolean;
 export declare class TargetProjectLocator {
     private readonly nodes;
     private readonly externalNodes;
+    private readonly npmResolutionCache;
     private projectRootMappings;
     private npmProjects;
     private tsConfig;
     private paths;
     private typescriptResolutionCache;
-    private npmResolutionCache;
-    constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes: Record<string, ProjectGraphExternalNode>);
+    constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes?: Record<string, ProjectGraphExternalNode>, npmResolutionCache?: NpmResolutionCache);
     /**
-     * Find a project based on its import
+     * Resolve any workspace or external project that matches the given import expression,
+     * originating from the given filePath.
      *
      * @param importExpr
      * @param filePath
      */
-    findProjectWithImport(importExpr: string, filePath: string): string;
+    findProjectFromImport(importExpr: string, filePath: string): string;
+    /**
+     * Resolve any external project that matches the given import expression,
+     * relative to the given file path.
+     *
+     * @param importExpr
+     * @param projectRoot
+     */
+    findNpmProjectFromImport(importExpr: string, fromFilePath: string): string | null;
     /**
      * Return file paths matching the import relative to the repo root
      * @param normalizedImportExpr
@@ -24,9 +40,20 @@ export declare class TargetProjectLocator {
     findPaths(normalizedImportExpr: string): string[] | undefined;
     private resolveImportWithTypescript;
     private resolveImportWithRequire;
-    private findNpmPackage;
     private findProjectOfResolvedModule;
     private getAbsolutePath;
     private getRootTsConfig;
     private findMatchingProjectFiles;
+    /**
+     * In many cases the package.json will be directly resolvable, so we try that first.
+     * If, however, package exports are used and the package.json is not defined, we will
+     * need to resolve the main entry point of the package and traverse upwards to find the
+     * package.json.
+     *
+     * In some cases, such as when multiple module formats are published, the resolved package.json
+     * might only contain the "type" field - no "name" or "version", so in such cases we keep traversing
+     * until we find a package.json that contains the "name" and "version" fields.
+     */
+    private readPackageJson;
 }
+export {};

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -1,36 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TargetProjectLocator = void 0;
-const typescript_1 = require("../../utils/typescript");
+exports.TargetProjectLocator = exports.isBuiltinModuleImport = void 0;
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
 const fileutils_1 = require("../../../../utils/fileutils");
-const path_1 = require("path");
 const workspace_root_1 = require("../../../../utils/workspace-root");
-const module_1 = require("module");
-const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
+const resolve_relative_to_dir_1 = require("../../utils/resolve-relative-to-dir");
+const typescript_1 = require("../../utils/typescript");
+/**
+ * Use a shared cache to avoid repeated npm package resolution work within the TargetProjectLocator.
+ */
+const defaultNpmResolutionCache = new Map();
 const builtInModuleSet = new Set([
-    ...module_1.builtinModules,
-    ...module_1.builtinModules.map((x) => `node:${x}`),
+    ...node_module_1.builtinModules,
+    ...node_module_1.builtinModules.map((x) => `node:${x}`),
 ]);
+function isBuiltinModuleImport(importExpr) {
+    const packageName = parsePackageNameFromImportExpression(importExpr);
+    return builtInModuleSet.has(packageName);
+}
+exports.isBuiltinModuleImport = isBuiltinModuleImport;
 class TargetProjectLocator {
-    constructor(nodes, externalNodes) {
+    constructor(nodes, externalNodes = {}, npmResolutionCache = defaultNpmResolutionCache) {
         this.nodes = nodes;
         this.externalNodes = externalNodes;
+        this.npmResolutionCache = npmResolutionCache;
         this.projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(this.nodes);
-        this.npmProjects = filterRootExternalDependencies(this.externalNodes);
         this.tsConfig = this.getRootTsConfig();
         this.paths = this.tsConfig.config?.compilerOptions?.paths;
         this.typescriptResolutionCache = new Map();
-        this.npmResolutionCache = new Map();
+        /**
+         * Only the npm external nodes should be included.
+         *
+         * Unlike the raw externalNodes, ensure that there is always copy of the node where the version
+         * is set in the key for optimal lookup.
+         */
+        this.npmProjects = Object.values(this.externalNodes).reduce((acc, node) => {
+            if (node.type === 'npm') {
+                const keyWithVersion = `npm:${node.data.packageName}@${node.data.version}`;
+                if (!acc[node.name]) {
+                    acc[node.name] = node;
+                }
+                // The node.name may have already contained the version
+                if (!acc[keyWithVersion]) {
+                    acc[keyWithVersion] = node;
+                }
+            }
+            return acc;
+        }, {});
     }
     /**
-     * Find a project based on its import
+     * Resolve any workspace or external project that matches the given import expression,
+     * originating from the given filePath.
      *
      * @param importExpr
      * @param filePath
      */
-    findProjectWithImport(importExpr, filePath) {
+    findProjectFromImport(importExpr, filePath) {
         if ((0, fileutils_1.isRelativePath)(importExpr)) {
-            const resolvedModule = path_1.posix.join((0, path_1.dirname)(filePath), importExpr);
+            const resolvedModule = node_path_1.posix.join((0, node_path_1.dirname)(filePath), importExpr);
             return this.findProjectOfResolvedModule(resolvedModule);
         }
         // find project using tsconfig paths
@@ -39,7 +68,7 @@ class TargetProjectLocator {
             const [path, paths] = results;
             for (let p of paths) {
                 const r = p.endsWith('/*')
-                    ? (0, path_1.join)((0, path_1.dirname)(p), (0, path_1.relative)(path.replace(/\*$/, ''), importExpr))
+                    ? (0, node_path_1.join)((0, node_path_1.dirname)(p), (0, node_path_1.relative)(path.replace(/\*$/, ''), importExpr))
                     : p;
                 const maybeResolvedProject = this.findProjectOfResolvedModule(r);
                 if (maybeResolvedProject) {
@@ -47,14 +76,14 @@ class TargetProjectLocator {
                 }
             }
         }
-        if (builtInModuleSet.has(importExpr)) {
+        if (isBuiltinModuleImport(importExpr)) {
             this.npmResolutionCache.set(importExpr, null);
             return null;
         }
         // try to find npm package before using expensive typescript resolution
-        const npmProject = this.findNpmPackage(importExpr);
-        if (npmProject) {
-            return npmProject;
+        const externalProject = this.findNpmProjectFromImport(importExpr, filePath);
+        if (externalProject) {
+            return externalProject;
         }
         if (this.tsConfig.config) {
             // TODO(meeroslav): this block is probably obsolete
@@ -74,6 +103,55 @@ class TargetProjectLocator {
         this.npmResolutionCache.set(importExpr, null);
         return null;
     }
+    /**
+     * Resolve any external project that matches the given import expression,
+     * relative to the given file path.
+     *
+     * @param importExpr
+     * @param projectRoot
+     */
+    findNpmProjectFromImport(importExpr, fromFilePath) {
+        const packageName = parsePackageNameFromImportExpression(importExpr);
+        let fullFilePath = fromFilePath;
+        let workspaceRelativeFilePath = fromFilePath;
+        if (fromFilePath.startsWith(workspace_root_1.workspaceRoot)) {
+            workspaceRelativeFilePath = fromFilePath.replace(workspace_root_1.workspaceRoot, '');
+        }
+        else {
+            fullFilePath = (0, node_path_1.join)(workspace_root_1.workspaceRoot, fromFilePath);
+        }
+        const fullDirPath = (0, node_path_1.dirname)(fullFilePath);
+        const workspaceRelativeDirPath = (0, node_path_1.dirname)(workspaceRelativeFilePath);
+        const npmImportForProject = `${packageName}__${workspaceRelativeDirPath}`;
+        if (this.npmResolutionCache.has(npmImportForProject)) {
+            return this.npmResolutionCache.get(npmImportForProject);
+        }
+        try {
+            // package.json refers to an external package, we do not match against the version found in there, we instead try and resolve the relevant package how node would
+            const externalPackageJson = this.readPackageJson(packageName, fullDirPath);
+            // The external package.json path might be not be resolvable, e.g. if a reference has been added to a project package.json, but the install command has not been run yet.
+            if (!externalPackageJson) {
+                // Try and fall back to resolving an external node from the graph by name
+                const externalNode = this.npmProjects[`npm:${packageName}`];
+                const externalNodeName = externalNode?.name || null;
+                this.npmResolutionCache.set(npmImportForProject, externalNodeName);
+                return externalNodeName;
+            }
+            const npmProjectKey = `npm:${externalPackageJson.name}@${externalPackageJson.version}`;
+            const matchingExternalNode = this.npmProjects[npmProjectKey];
+            if (!matchingExternalNode) {
+                return null;
+            }
+            this.npmResolutionCache.set(npmImportForProject, matchingExternalNode.name);
+            return matchingExternalNode.name;
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
+            return null;
+        }
+    }
     /**
      * Return file paths matching the import relative to the repo root
      * @param normalizedImportExpr
@@ -113,23 +191,10 @@ class TargetProjectLocator {
         return;
     }
     resolveImportWithRequire(normalizedImportExpr, filePath) {
-        return path_1.posix.relative(workspace_root_1.workspaceRoot, require.resolve(normalizedImportExpr, {
-            paths: [(0, path_1.dirname)(filePath)],
+        return node_path_1.posix.relative(workspace_root_1.workspaceRoot, require.resolve(normalizedImportExpr, {
+            paths: [(0, node_path_1.dirname)(filePath)],
         }));
     }
-    findNpmPackage(npmImport) {
-        if (this.npmResolutionCache.has(npmImport)) {
-            return this.npmResolutionCache.get(npmImport);
-        }
-        else {
-            const pkg = this.npmProjects.find((pkg) => npmImport === pkg.data.packageName ||
-                npmImport.startsWith(`${pkg.data.packageName}/`));
-            if (pkg) {
-                this.npmResolutionCache.set(npmImport, pkg.name);
-                return pkg.name;
-            }
-        }
-    }
     findProjectOfResolvedModule(resolvedModule) {
         if (resolvedModule.startsWith('node_modules/') ||
             resolvedModule.includes('/node_modules/')) {
@@ -142,7 +207,7 @@ class TargetProjectLocator {
         return importedProject ? importedProject.name : void 0;
     }
     getAbsolutePath(path) {
-        return (0, path_1.join)(workspace_root_1.workspaceRoot, path);
+        return (0, node_path_1.join)(workspace_root_1.workspaceRoot, path);
     }
     getRootTsConfig() {
         const path = (0, typescript_1.getRootTsConfigFileName)();
@@ -164,20 +229,54 @@ class TargetProjectLocator {
         const project = (0, find_project_for_path_1.findProjectForPath)(file, this.projectRootMappings);
         return this.nodes[project];
     }
+    /**
+     * In many cases the package.json will be directly resolvable, so we try that first.
+     * If, however, package exports are used and the package.json is not defined, we will
+     * need to resolve the main entry point of the package and traverse upwards to find the
+     * package.json.
+     *
+     * In some cases, such as when multiple module formats are published, the resolved package.json
+     * might only contain the "type" field - no "name" or "version", so in such cases we keep traversing
+     * until we find a package.json that contains the "name" and "version" fields.
+     */
+    readPackageJson(packageName, relativeToDir) {
+        // The package.json is directly resolvable
+        const packageJsonPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)((0, node_path_1.join)(packageName, 'package.json'), relativeToDir);
+        if (packageJsonPath) {
+            return (0, fileutils_1.readJsonFile)(packageJsonPath);
+        }
+        try {
+            // Resolve the main entry point of the package
+            const mainPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)(packageName, relativeToDir);
+            let dir = (0, node_path_1.dirname)(mainPath);
+            while (dir !== (0, node_path_1.parse)(dir).root) {
+                const packageJsonPath = (0, node_path_1.join)(dir, 'package.json');
+                try {
+                    const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+                    // Ensure the package.json contains the "name" and "version" fields
+                    if (parsedPackageJson.name && parsedPackageJson.version) {
+                        return parsedPackageJson;
+                    }
+                }
+                catch {
+                    // Package.json doesn't exist, keep traversing
+                }
+                dir = (0, node_path_1.dirname)(dir);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
 }
 exports.TargetProjectLocator = TargetProjectLocator;
-// matches `npm:@scope/name`, `npm:name` but not `npm:@scope/name@version` and `npm:name@version`
-const ROOT_VERSION_PACKAGE_NAME_REGEX = /^npm:(?!.+@.+)/;
-function filterRootExternalDependencies(externalNodes) {
-    if (!externalNodes) {
-        return [];
-    }
-    const keys = Object.keys(externalNodes);
-    const nodes = [];
-    for (let i = 0; i < keys.length; i++) {
-        if (keys[i].match(ROOT_VERSION_PACKAGE_NAME_REGEX)) {
-            nodes.push(externalNodes[keys[i]]);
-        }
+function parsePackageNameFromImportExpression(importExpression) {
+    // Check if the package is scoped
+    if (importExpression.startsWith('@')) {
+        // For scoped packages, the package name is up to the second '/'
+        return importExpression.split('/').slice(0, 2).join('/');
     }
-    return nodes;
+    // For unscoped packages, the package name is up to the first '/'
+    return importExpression.split('/')[0];
 }

package/src/plugins/js/utils/resolve-relative-to-dir.d.ts

@@ -0,0 +1,5 @@
+/**
+ * NOTE: This function is in its own file because it is not possible to mock
+ * require.resolve directly in jest https://github.com/jestjs/jest/issues/9543
+ */
+export declare function resolveRelativeToDir(path: string, relativeToDir: any): string;

package/src/plugins/js/utils/resolve-relative-to-dir.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelativeToDir = void 0;
+/**
+ * NOTE: This function is in its own file because it is not possible to mock
+ * require.resolve directly in jest https://github.com/jestjs/jest/issues/9543
+ */
+function resolveRelativeToDir(path, relativeToDir) {
+    try {
+        return require.resolve(path, {
+            paths: [relativeToDir],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+exports.resolveRelativeToDir = resolveRelativeToDir;

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

@@ -1,10 +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 { ProjectGraph } from '../config/project-graph';
+import { CreateNodesFunctionV2 } from './plugins';
 export declare class ProjectGraphError extends Error {
     #private;
-    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | ProcessProjectGraphError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
+    constructor(errors: Array<AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | ProcessProjectGraphError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
     /**
      * The daemon cannot throw errors which contain methods as they are not serializable.
      *
@@ -18,7 +18,7 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | CreateMetadataError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError)[];
+    getErrors(): (AggregateCreateNodesError | MergeNodesError | CreateMetadataError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError)[];
 }
 export declare class MultipleProjectsWithSameNameError extends Error {
     conflicts: Map<string, string[]>;
@@ -44,25 +44,44 @@ export declare class ProjectWithNoNameError extends Error {
 }
 export declare function isProjectWithNoNameError(e: unknown): e is ProjectWithNoNameError;
 export declare class ProjectConfigurationsError extends Error {
-    readonly errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>;
+    readonly errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>;
     readonly partialProjectConfigurationsResult: ConfigurationResult;
-    constructor(errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>, partialProjectConfigurationsResult: ConfigurationResult);
+    constructor(errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>, partialProjectConfigurationsResult: ConfigurationResult);
 }
 export declare function isProjectConfigurationsError(e: unknown): e is ProjectConfigurationsError;
-export declare class CreateNodesError extends Error {
-    file: string;
-    pluginName: string;
-    constructor({ file, pluginName, error, }: {
-        file: string;
-        pluginName: string;
-        error: Error;
-    });
-}
+/**
+ * This error should be thrown when a `createNodesV2` function hits a recoverable error.
+ * It allows Nx to recieve partial results and continue processing for better UX.
+ */
 export declare class AggregateCreateNodesError extends Error {
-    readonly pluginName: string;
-    readonly errors: Array<CreateNodesError>;
-    readonly partialResults: Array<CreateNodesResultWithContext>;
-    constructor(pluginName: string, errors: Array<CreateNodesError>, partialResults: Array<CreateNodesResultWithContext>);
+    readonly errors: Array<[file: string | null, error: Error]>;
+    readonly partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>;
+    /**
+     * Throwing this error from a `createNodesV2` function will allow Nx to continue processing and recieve partial results from your plugin.
+     * @example
+     * export async function createNodesV2(
+     *  files: string[],
+     * ) {
+     *   const partialResults = [];
+     *   const errors = [];
+     *   await Promise.all(files.map(async (file) => {
+     *     try {
+     *        const result = await createNodes(file);
+     *        partialResults.push(result);
+     *     } catch (e) {
+     *        errors.push([file, e]);
+     *     }
+     *   }));
+     *  if (errors.length > 0) {
+     *     throw new AggregateCreateNodesError(errors, partialResults);
+     *   }
+     *   return partialResults;
+     * }
+     *
+     * @param errors An array of tuples that represent errors encountered when processing a given file. An example entry might look like ['path/to/project.json', [Error: 'Invalid JSON. Unexpected token 'a' in JSON at position 0]]
+     * @param partialResults The partial results of the `createNodesV2` function. This should be the results for each file that didn't encounter an issue.
+     */
+    constructor(errors: Array<[file: string | null, error: Error]>, partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>);
 }
 export declare class MergeNodesError extends Error {
     file: string;
@@ -102,7 +121,6 @@ export declare class AggregateProjectGraphError extends Error {
 }
 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;
 export declare class DaemonProjectGraphError extends Error {

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

@@ -1,7 +1,7 @@
 "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.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;
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateMetadataError = exports.isAggregateProjectGraphError = exports.AggregateProjectGraphError = exports.ProcessProjectGraphError = exports.isWorkspaceValidityError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = 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) {
@@ -126,21 +126,38 @@ function isProjectConfigurationsError(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}:`;
-        super(msg, { cause: error });
-        this.name = this.constructor.name;
-        this.file = file;
-        this.pluginName = pluginName;
-        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
-    }
-}
-exports.CreateNodesError = CreateNodesError;
+/**
+ * This error should be thrown when a `createNodesV2` function hits a recoverable error.
+ * It allows Nx to recieve partial results and continue processing for better UX.
+ */
 class AggregateCreateNodesError extends Error {
-    constructor(pluginName, errors, partialResults) {
+    /**
+     * Throwing this error from a `createNodesV2` function will allow Nx to continue processing and recieve partial results from your plugin.
+     * @example
+     * export async function createNodesV2(
+     *  files: string[],
+     * ) {
+     *   const partialResults = [];
+     *   const errors = [];
+     *   await Promise.all(files.map(async (file) => {
+     *     try {
+     *        const result = await createNodes(file);
+     *        partialResults.push(result);
+     *     } catch (e) {
+     *        errors.push([file, e]);
+     *     }
+     *   }));
+     *  if (errors.length > 0) {
+     *     throw new AggregateCreateNodesError(errors, partialResults);
+     *   }
+     *   return partialResults;
+     * }
+     *
+     * @param errors An array of tuples that represent errors encountered when processing a given file. An example entry might look like ['path/to/project.json', [Error: 'Invalid JSON. Unexpected token 'a' in JSON at position 0]]
+     * @param partialResults The partial results of the `createNodesV2` function. This should be the results for each file that didn't encounter an issue.
+     */
+    constructor(errors, partialResults) {
         super('Failed to create nodes');
-        this.pluginName = pluginName;
         this.errors = errors;
         this.partialResults = partialResults;
         this.name = this.constructor.name;
@@ -230,11 +247,6 @@ function isCreateMetadataError(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));
-}
-exports.isCreateNodesError = isCreateNodesError;
 function isAggregateCreateNodesError(e) {
     return (e instanceof AggregateCreateNodesError ||
         (typeof e === 'object' &&

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

@@ -1,2 +1,3 @@
 export * from './public-api';
 export { readPluginPackageJson, registerPluginTSTranspiler } from './loader';
+export { createNodesFromFiles } from './utils';

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
+exports.createNodesFromFiles = exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./public-api"), exports);
 var loader_1 = require("./loader");
 Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return loader_1.readPluginPackageJson; } });
 Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return loader_1.registerPluginTSTranspiler; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return utils_1.createNodesFromFiles; } });

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

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

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

@@ -6,9 +6,10 @@ exports.getDefaultPlugins = exports.loadNxPlugins = exports.nxPluginCache = expo
 const path_1 = require("path");
 const workspace_root_1 = require("../../utils/workspace-root");
 const angular_json_1 = require("../../adapter/angular-json");
-const utils_1 = require("./utils");
 const isolation_1 = require("./isolation");
 const loader_1 = require("./loader");
+const utils_1 = require("./utils");
+const error_types_1 = require("../error-types");
 class LoadedNxPlugin {
     constructor(plugin, pluginDefinition) {
         this.name = plugin.name;
@@ -17,12 +18,41 @@ class LoadedNxPlugin {
             this.include = pluginDefinition.include;
             this.exclude = pluginDefinition.exclude;
         }
-        if (plugin.createNodes) {
+        if (plugin.createNodes && !plugin.createNodesV2) {
             this.createNodes = [
                 plugin.createNodes[0],
-                (files, context) => (0, utils_1.runCreateNodesInParallel)(files, plugin, this.options, context),
+                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
+            ];
+        }
+        if (plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodesV2[0],
+                async (configFiles, context) => {
+                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
             ];
         }
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([null, e], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
         if (plugin.createDependencies) {
             this.createDependencies = (context) => plugin.createDependencies(this.options, context);
         }

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

@@ -6,19 +6,23 @@ import { RawProjectGraphDependency } from '../project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
-export interface CreateNodesContext {
-    readonly nxJsonConfiguration: NxJsonConfiguration;
-    readonly workspaceRoot: string;
+export interface CreateNodesContext extends CreateNodesContextV2 {
     /**
      * The subset of configuration files which match the createNodes pattern
      */
     readonly configFiles: readonly string[];
 }
+export interface CreateNodesContextV2 {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+}
 /**
  * A function which parses a configuration file into a set of nodes.
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export type CreateNodesResultV2 = Array<readonly [configFileSource: string, result: CreateNodesResult]>;
+export type CreateNodesFunctionV2<T = unknown> = (projectConfigurationFiles: readonly string[], options: T | undefined, context: CreateNodesContextV2) => CreateNodesResultV2 | Promise<CreateNodesResultV2>;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
@@ -32,11 +36,29 @@ export interface CreateNodesResult {
 }
 /**
  * A pair of file patterns and {@link CreateNodesFunction}
+ *
+ * Nx 19.2+: Both original `CreateNodes` and `CreateNodesV2` are supported. Nx will only invoke `CreateNodesV2` if it is present.
+ * Nx 20.X : The `CreateNodesV2` will be the only supported API. This typing will still exist, but be identical to `CreateNodesV2`.
+             Nx **will not** invoke the original `plugin.createNodes` callback. This should give plugin authors a window to transition.
+             Plugin authors should update their plugin's `createNodes` function to align with `CreateNodesV2` / the updated `CreateNodes`.
+             The plugin should contain something like: `export createNodes = createNodesV2;` during this period. This will allow the plugin
+             to maintain compatibility with Nx 19.2 and up.
+ * Nx 21.X : The `CreateNodesV2` typing will be removed, as it has replaced `CreateNodes`.
+ *
+ * @deprecated Use {@link CreateNodesV2} instead. CreateNodesV2 will replace this API. Read more about the transition above.
  */
 export type CreateNodes<T = unknown> = readonly [
     projectFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
+/**
+ * A pair of file patterns and {@link CreateNodesFunctionV2}
+ * In Nx 20 {@link CreateNodes} will be replaced with this type. In Nx 21, this type will be removed.
+ */
+export type CreateNodesV2<T = unknown> = readonly [
+    projectFilePattern: string,
+    createNodesFunction: CreateNodesFunctionV2<T>
+];
 /**
  * Context for {@link CreateDependencies}
  */
@@ -82,8 +104,17 @@ export type NxPluginV2<TOptions = unknown> = {
     /**
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
+     *
+     * @deprecated Use {@link createNodesV2} instead. In Nx 20 support for calling createNodes with a single file for the first argument will be removed.
      */
     createNodes?: CreateNodes<TOptions>;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFiles }
+     *
+     * In Nx 20 {@link createNodes} will be replaced with this property. In Nx 21, this property will be removed.
+     */
+    createNodesV2?: CreateNodesV2<TOptions>;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */

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

@@ -1,7 +1,8 @@
 import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
-import { type CreateNodesContext, type NxPlugin, type NxPluginV2 } from './public-api';
+import type { LoadedNxPlugin, NormalizedPlugin } from './internal-api';
+import { CreateNodesContextV2, CreateNodesFunction, CreateNodesResult, 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: readonly string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;
+export type AsyncFn<T extends Function> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
+export declare function createNodesFromFiles<T = unknown>(createNodes: CreateNodesFunction, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;

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

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCreateNodesInParallel = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
+exports.createNodesFromFiles = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
 const node_path_1 = require("node:path");
 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;
 }
@@ -40,36 +39,24 @@ function normalizeNxPlugin(plugin) {
     return plugin;
 }
 exports.normalizeNxPlugin = normalizeNxPlugin;
-async function runCreateNodesInParallel(configFiles, plugin, options, context) {
-    perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
-    const errors = [];
+async function createNodesFromFiles(createNodes, configFiles, options, context) {
     const results = [];
-    const promises = configFiles.map(async (file) => {
+    const errors = [];
+    await Promise.all(configFiles.map(async (file) => {
         try {
-            const value = await plugin.createNodes[1](file, options, context);
-            if (value) {
-                results.push({
-                    ...value,
-                    file,
-                    pluginName: plugin.name,
-                });
-            }
+            const value = await createNodes(file, options, {
+                ...context,
+                configFiles,
+            });
+            results.push([file, value]);
         }
         catch (e) {
-            errors.push(new error_types_1.CreateNodesError({
-                error: e,
-                pluginName: plugin.name,
-                file,
-            }));
+            errors.push([file, e]);
         }
-    });
-    await Promise.all(promises).then(() => {
-        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);
+        throw new error_types_1.AggregateCreateNodesError(errors, results);
     }
     return results;
 }
-exports.runCreateNodesInParallel = runCreateNodesInParallel;
+exports.createNodesFromFiles = createNodesFromFiles;

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

@@ -227,92 +227,35 @@ plugins) {
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const { name: pluginName, createNodes: createNodesTuple, include, exclude, } of plugins) {
+    for (const { createNodes: createNodesTuple, include, exclude, name: pluginName, } of plugins) {
         const [pattern, createNodes] = createNodesTuple ?? [];
         if (!pattern) {
             continue;
         }
-        const matchingConfigFiles = [];
-        for (const file of projectFiles) {
-            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                if (include) {
-                    const included = include.some((includedPattern) => (0, minimatch_1.minimatch)(file, includedPattern, { dot: true }));
-                    if (!included) {
-                        continue;
-                    }
-                }
-                if (exclude) {
-                    const excluded = exclude.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
-                    if (excluded) {
-                        continue;
-                    }
-                }
-                matchingConfigFiles.push(file);
-            }
-        }
+        const matchingConfigFiles = findMatchingConfigFiles(projectFiles, pattern, include, exclude);
         let r = createNodes(matchingConfigFiles, {
             nxJsonConfiguration: nxJson,
             workspaceRoot: root,
-            configFiles: matchingConfigFiles,
         }).catch((e) => {
-            if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
-                errors.push(...e.errors);
-                return e.partialResults;
-            }
-            else {
-                throw e;
-            }
+            const errorBodyLines = [
+                `An error occurred while processing files for the ${pluginName} plugin.`,
+            ];
+            const error = (0, error_types_1.isAggregateCreateNodesError)(e)
+                ? // This is an expected error if something goes wrong while processing files.
+                    e
+                : // This represents a single plugin erroring out with a hard error.
+                    new error_types_1.AggregateCreateNodesError([[null, e]], []);
+            errorBodyLines.push(...error.errors.map(([file, e]) => `  - ${file}: ${e.message}`));
+            error.message = errorBodyLines.join('\n');
+            // This represents a single plugin erroring out with a hard error.
+            errors.push(error);
+            // The plugin didn't return partial results, so we return an empty array.
+            return error.partialResults.map((r) => [pluginName, r[0], r[1]]);
         });
         results.push(r);
     }
     return Promise.all(results).then((results) => {
-        perf_hooks_1.performance.mark('createNodes:merge - start');
-        const projectRootMap = {};
-        const externalNodes = {};
-        const configurationSourceMaps = {};
-        for (const result of results.flat()) {
-            const { projects: projectNodes, externalNodes: pluginExternalNodes, file, pluginName, } = result;
-            const sourceInfo = [file, pluginName];
-            if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
-                sourceInfo[0] = result[symbols_1.OVERRIDE_SOURCE_FILE];
-            }
-            for (const node in projectNodes) {
-                // Handles `{projects: {'libs/foo': undefined}}`.
-                if (!projectNodes[node]) {
-                    continue;
-                }
-                const project = {
-                    root: node,
-                    ...projectNodes[node],
-                };
-                try {
-                    mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
-                }
-                catch (error) {
-                    errors.push(new error_types_1.MergeNodesError({
-                        file,
-                        pluginName,
-                        error,
-                    }));
-                }
-            }
-            Object.assign(externalNodes, pluginExternalNodes);
-        }
-        try {
-            validateAndNormalizeProjectRootMap(projectRootMap);
-        }
-        catch (e) {
-            if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
-                (0, error_types_1.isMultipleProjectsWithSameNameError)(e)) {
-                errors.push(e);
-            }
-            else {
-                throw e;
-            }
-        }
-        const rootMap = createRootMap(projectRootMap);
-        perf_hooks_1.performance.mark('createNodes:merge - end');
-        perf_hooks_1.performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
+        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
@@ -336,6 +279,78 @@ plugins) {
     });
 }
 exports.createProjectConfigurations = createProjectConfigurations;
+function mergeCreateNodesResults(results, errors) {
+    perf_hooks_1.performance.mark('createNodes:merge - start');
+    const projectRootMap = {};
+    const externalNodes = {};
+    const configurationSourceMaps = {};
+    for (const result of results.flat()) {
+        const [file, pluginName, nodes] = result;
+        const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
+        const sourceInfo = [file, pluginName];
+        if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
+            sourceInfo[0] = result[symbols_1.OVERRIDE_SOURCE_FILE];
+        }
+        for (const node in projectNodes) {
+            // Handles `{projects: {'libs/foo': undefined}}`.
+            if (!projectNodes[node]) {
+                continue;
+            }
+            const project = {
+                root: node,
+                ...projectNodes[node],
+            };
+            try {
+                mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
+            }
+            catch (error) {
+                errors.push(new error_types_1.MergeNodesError({
+                    file,
+                    pluginName,
+                    error,
+                }));
+            }
+        }
+        Object.assign(externalNodes, pluginExternalNodes);
+    }
+    try {
+        validateAndNormalizeProjectRootMap(projectRootMap);
+    }
+    catch (e) {
+        if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
+            (0, error_types_1.isMultipleProjectsWithSameNameError)(e)) {
+            errors.push(e);
+        }
+        else {
+            throw e;
+        }
+    }
+    const rootMap = createRootMap(projectRootMap);
+    perf_hooks_1.performance.mark('createNodes:merge - end');
+    perf_hooks_1.performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
+    return { projectRootMap, externalNodes, rootMap, configurationSourceMaps };
+}
+function findMatchingConfigFiles(projectFiles, pattern, include, exclude) {
+    const matchingConfigFiles = [];
+    for (const file of projectFiles) {
+        if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
+            if (include) {
+                const included = include.some((includedPattern) => (0, minimatch_1.minimatch)(file, includedPattern, { dot: true }));
+                if (!included) {
+                    continue;
+                }
+            }
+            if (exclude) {
+                const excluded = exclude.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
+                if (excluded) {
+                    continue;
+                }
+            }
+            matchingConfigFiles.push(file);
+        }
+    }
+    return matchingConfigFiles;
+}
 function readProjectConfigurationsFromRootMap(projectRootMap) {
     const projects = {};
     // If there are projects that have the same name, that is an error.