nx 19.2.0-beta.1 → 19.2.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.2.0-beta.1",
+  "version": "19.2.0-beta.2",
   "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-beta.1"
+    "@nrwl/tao": "19.2.0-beta.2"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -84,16 +84,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.2.0-beta.1",
-    "@nx/nx-darwin-arm64": "19.2.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "19.2.0-beta.1",
-    "@nx/nx-linux-x64-musl": "19.2.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "19.2.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "19.2.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "19.2.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "19.2.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "19.2.0-beta.1",
-    "@nx/nx-freebsd-x64": "19.2.0-beta.1"
+    "@nx/nx-darwin-x64": "19.2.0-beta.2",
+    "@nx/nx-darwin-arm64": "19.2.0-beta.2",
+    "@nx/nx-linux-x64-gnu": "19.2.0-beta.2",
+    "@nx/nx-linux-x64-musl": "19.2.0-beta.2",
+    "@nx/nx-win32-x64-msvc": "19.2.0-beta.2",
+    "@nx/nx-linux-arm64-gnu": "19.2.0-beta.2",
+    "@nx/nx-linux-arm64-musl": "19.2.0-beta.2",
+    "@nx/nx-linux-arm-gnueabihf": "19.2.0-beta.2",
+    "@nx/nx-win32-arm64-msvc": "19.2.0-beta.2",
+    "@nx/nx-freebsd-x64": "19.2.0-beta.2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/devkit-internals.d.ts

@@ -23,3 +23,4 @@ export { retrieveProjectConfigurations } from './project-graph/utils/retrieve-wo
 export { LoadedNxPlugin } from './project-graph/plugins/internal-api';
 export * from './project-graph/error-types';
 export { registerTsProject } from './plugins/js/utils/register';
+export { interpolate } from './tasks-runner/utils';

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.readProjectConfigurationsFromRootMap = exports.mergeTargetConfigurations = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
+exports.interpolate = 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.mergeTargetConfigurations = 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.
@@ -47,3 +47,5 @@ Object.defineProperty(exports, "LoadedNxPlugin", { enumerable: true, get: functi
 tslib_1.__exportStar(require("./project-graph/error-types"), exports);
 var register_1 = require("./plugins/js/utils/register");
 Object.defineProperty(exports, "registerTsProject", { enumerable: true, get: function () { return register_1.registerTsProject; } });
+var utils_1 = require("./tasks-runner/utils");
+Object.defineProperty(exports, "interpolate", { enumerable: true, get: function () { return utils_1.interpolate; } });

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>;
+export declare function isBuiltinModuleImport(importExpr: string): boolean;
 export declare class TargetProjectLocator {
     private readonly nodes;
-    private readonly externalNodes;
+    readonly externalNodes: Record<string, ProjectGraphExternalNode>;
+    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 | undefined;
     /**
      * Return file paths matching the import relative to the repo root
      * @param normalizedImportExpr
@@ -24,9 +40,9 @@ export declare class TargetProjectLocator {
     findPaths(normalizedImportExpr: string): string[] | undefined;
     private resolveImportWithTypescript;
     private resolveImportWithRequire;
-    private findNpmPackage;
     private findProjectOfResolvedModule;
     private getAbsolutePath;
     private getRootTsConfig;
     private findMatchingProjectFiles;
 }
+export {};

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

@@ -1,36 +1,60 @@
 "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 find_external_package_json_path_1 = require("../../utils/find-external-package-json-path");
+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();
+        this.npmProjects = externalNodes;
+        /**
+         * Only the npm external nodes should be included.
+         *
+         * Unlike the raw externalNodes, ensure that the version is always set in the key
+         * for optimal lookup.
+         */
+        this.npmProjects = Object.values(externalNodes).reduce((acc, node) => {
+            if (node.type === 'npm') {
+                const key = `npm:${node.data.packageName}@${node.data.version}`;
+                acc[key] = 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 +63,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 +71,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 +98,52 @@ 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 externalPackageJsonPath = (0, find_external_package_json_path_1.findExternalPackageJsonPath)(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 (!externalPackageJsonPath) {
+                return undefined;
+            }
+            const externalPackageJson = (0, fileutils_1.readJsonFile)(externalPackageJsonPath);
+            const npmProjectKey = `npm:${externalPackageJson.name}@${externalPackageJson.version}`;
+            if (!this.npmProjects[npmProjectKey]) {
+                return undefined;
+            }
+            const matchingExternalNode = this.npmProjects[npmProjectKey];
+            this.npmResolutionCache.set(npmImportForProject, matchingExternalNode.name);
+            return matchingExternalNode.name;
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
+            return undefined;
+        }
+    }
     /**
      * Return file paths matching the import relative to the repo root
      * @param normalizedImportExpr
@@ -113,23 +183,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 +199,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)();
@@ -166,18 +223,12 @@ class TargetProjectLocator {
     }
 }
 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/find-external-package-json-path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ * NOTE: Unit testing this code is currently impractical as it is not possible to mock
+ * require.resolve in jest https://github.com/jestjs/jest/issues/9543
+ */
+export declare function findExternalPackageJsonPath(packageName: string, relativeToDir: string): string | null;

package/src/plugins/js/utils/find-external-package-json-path.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExternalPackageJsonPath = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * 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.
+ *
+ * NOTE: Unit testing this code is currently impractical as it is not possible to mock
+ * require.resolve in jest https://github.com/jestjs/jest/issues/9543
+ */
+function findExternalPackageJsonPath(packageName, relativeToDir) {
+    try {
+        return require.resolve((0, node_path_1.join)(packageName, 'package.json'), {
+            paths: [relativeToDir],
+        });
+    }
+    catch {
+        try {
+            // Resolve the main entry point of the package
+            const mainPath = require.resolve(packageName, {
+                paths: [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');
+                if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+                    return packageJsonPath;
+                }
+                dir = (0, node_path_1.dirname)(dir);
+            }
+            throw new Error(`Could not find package.json for ${packageName}`);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.findExternalPackageJsonPath = findExternalPackageJsonPath;

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

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../plugins/internal-api';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.

package/src/tasks-runner/utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = void 0;
 const output_1 = require("../utils/output");
 const path_1 = require("path");
+const posix_1 = require("path/posix");
 const workspace_root_1 = require("../utils/workspace-root");
 const path_2 = require("../utils/path");
 const fileutils_1 = require("../utils/fileutils");
@@ -166,18 +167,32 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
     }
 }
 exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguration;
+/**
+ * Matches portions of a string which need to be interpolated.
+ * Matches anything within curly braces, excluding the braces.
+ */
+const replacementRegex = /{([\s\S]+?)}/g;
 function interpolate(template, data) {
+    // Path is absolute or doesn't need interpolation
+    if (template.startsWith('/') || !replacementRegex.test(template)) {
+        return template;
+    }
     if (template.includes('{workspaceRoot}', 1)) {
         throw new Error(`Output '${template}' is invalid. {workspaceRoot} can only be used at the beginning of the expression.`);
     }
     if (data.projectRoot == '.' && template.includes('{projectRoot}', 1)) {
         throw new Error(`Output '${template}' is invalid. When {projectRoot} is '.', it can only be used at the beginning of the expression.`);
     }
-    let res = template.replace('{workspaceRoot}/', '');
+    const parts = template.split('/').map((s) => _interpolate(s, data));
+    return (0, posix_1.join)(...parts).replace('{workspaceRoot}/', '');
+}
+exports.interpolate = interpolate;
+function _interpolate(template, data) {
+    let res = template;
     if (data.projectRoot == '.') {
-        res = res.replace('{projectRoot}/', '');
+        res = res.replace('{projectRoot}', '');
     }
-    return res.replace(/{([\s\S]+?)}/g, (match) => {
+    return res.replace(replacementRegex, (match) => {
         let value = data;
         let path = match.slice(1, -1).trim().split('.');
         for (let idx = 0; idx < path.length; idx++) {
@@ -189,7 +204,6 @@ function interpolate(template, data) {
         return value;
     });
 }
-exports.interpolate = interpolate;
 function getTargetConfigurationForTask(task, projectGraph) {
     const project = projectGraph.nodes[task.target.project].data;
     return project.targets[task.target.target];