nx 21.3.0-canary.20250621-57e70d0 → 21.3.0-canary.20250625-fe687a0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.3.0-canary.20250621-57e70d0",
+  "version": "21.3.0-canary.20250625-fe687a0",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-darwin-x64": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-freebsd-x64": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-linux-arm-gnueabihf": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-linux-arm64-gnu": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-linux-arm64-musl": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-linux-x64-gnu": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-linux-x64-musl": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-win32-arm64-msvc": "21.3.0-canary.20250621-57e70d0",
-    "@nx/nx-win32-x64-msvc": "21.3.0-canary.20250621-57e70d0"
+    "@nx/nx-darwin-arm64": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-darwin-x64": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-freebsd-x64": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-linux-arm-gnueabihf": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-linux-arm64-gnu": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-linux-arm64-musl": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-linux-x64-gnu": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-linux-x64-musl": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-win32-arm64-msvc": "21.3.0-canary.20250625-fe687a0",
+    "@nx/nx-win32-x64-msvc": "21.3.0-canary.20250625-fe687a0"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/plugins/js/lock-file/lock-file.d.ts

@@ -23,6 +23,7 @@ export declare function lockFileExists(packageManager: PackageManager): boolean;
  * @returns
  */
 export declare function getLockFileName(packageManager: PackageManager): string;
+export declare function getLockFilePath(packageManager: PackageManager): string;
 /**
  * Create lock file based on the root level lock file and (pruned) package.json
  *

package/src/plugins/js/lock-file/lock-file.js

@@ -9,6 +9,7 @@ exports.getLockFileNodes = getLockFileNodes;
 exports.getLockFileDependencies = getLockFileDependencies;
 exports.lockFileExists = lockFileExists;
 exports.getLockFileName = getLockFileName;
+exports.getLockFilePath = getLockFilePath;
 exports.createLockFile = createLockFile;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");

package/src/plugins/js/lock-file/npm-parser.js

@@ -10,6 +10,7 @@ const operators_1 = require("../../../project-graph/operators");
 const project_graph_builder_1 = require("../../../project-graph/project-graph-builder");
 const project_graph_1 = require("../../../config/project-graph");
 const file_hasher_1 = require("../../../hasher/file-hasher");
+const get_workspace_packages_from_graph_1 = require("../utils/get-workspace-packages-from-graph");
 // we use key => node map to avoid duplicate work when parsing keys
 let keyMap = new Map();
 let currentLockFileHash;
@@ -236,7 +237,9 @@ function addV1NodeDependencies(path, snapshot, dependencies, keyMap, ctx) {
 function stringifyNpmLockfile(graph, rootLockFileContent, packageJson) {
     const rootLockFile = JSON.parse(rootLockFileContent);
     const { lockfileVersion } = JSON.parse(rootLockFileContent);
+    const workspaceModulesFromGraph = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
     const mappedPackages = mapSnapshots(rootLockFile, graph);
+    const workspaceModules = mapWorkspaceModules(packageJson, rootLockFile, workspaceModulesFromGraph);
     const output = {
         name: packageJson.name || rootLockFile.name,
         version: packageJson.version || '0.0.1',
@@ -246,21 +249,57 @@ function stringifyNpmLockfile(graph, rootLockFileContent, packageJson) {
         output.requires = rootLockFile.requires;
     }
     if (lockfileVersion > 1) {
-        output.packages = mapV3Snapshots(mappedPackages, packageJson);
+        const packages = mapV3Snapshots(mappedPackages, packageJson);
+        output.packages = { ...packages, ...workspaceModules };
     }
     if (lockfileVersion < 3) {
-        output.dependencies = mapV1Snapshots(mappedPackages);
+        const dependencies = mapV1Snapshots(mappedPackages);
+        output.dependencies = { ...dependencies, ...workspaceModules };
     }
     return JSON.stringify(output, null, 2);
 }
+function mapWorkspaceModules(packageJson, rootLockFile, workspaceModules) {
+    const output = {};
+    for (const [pkgName, pkgVersion] of Object.entries(packageJson.dependencies)) {
+        if (workspaceModules.has(pkgName)) {
+            let workspaceModuleDefinition;
+            for (const [depName, depSnapshot] of Object.entries(rootLockFile.packages || rootLockFile.dependencies)) {
+                if (depSnapshot.name === pkgName) {
+                    workspaceModuleDefinition = depSnapshot;
+                    break;
+                }
+            }
+            output[`node_modules/${pkgName}`] = {
+                version: `file:./workspace_modules/${pkgName}`,
+                resolved: `workspace_modules/${pkgName}`,
+                link: true,
+            };
+            output[`workspace_modules/${pkgName}`] = {
+                name: pkgName,
+                version: `0.0.1`,
+                dependencies: workspaceModuleDefinition.dependencies,
+            };
+        }
+    }
+    return output;
+}
 function mapV3Snapshots(mappedPackages, packageJson) {
     const output = {};
-    output[''] = packageJson;
+    const mappedPackageJson = mapPackageJsonWithWorkspaceModules(packageJson);
+    output[''] = mappedPackageJson;
     mappedPackages.forEach((p) => {
         output[p.path] = p.valueV3;
     });
     return output;
 }
+function mapPackageJsonWithWorkspaceModules(packageJson) {
+    for (const [pkgName, pkgVersion] of Object.entries(packageJson.dependencies)) {
+        if (pkgVersion.startsWith('workspace:') || pkgVersion.startsWith('file:')) {
+            packageJson.dependencies[pkgName] = `workspace_modules/${pkgName}`;
+        }
+    }
+    return packageJson;
+}
 function mapV1Snapshots(mappedPackages) {
     const output = {};
     mappedPackages.forEach((p) => {

package/src/plugins/js/lock-file/pnpm-parser.js

@@ -10,6 +10,8 @@ const project_graph_builder_1 = require("../../../project-graph/project-graph-bu
 const project_graph_1 = require("../../../config/project-graph");
 const file_hasher_1 = require("../../../hasher/file-hasher");
 const project_graph_pruning_1 = require("./project-graph-pruning");
+const path_1 = require("path");
+const get_workspace_packages_from_graph_1 = require("../utils/get-workspace-packages-from-graph");
 // we use key => node map to avoid duplicate work when parsing keys
 let keyMap = new Map();
 let currentLockFileHash;
@@ -278,14 +280,21 @@ function parseBaseVersion(rawVersion, isV5) {
 }
 function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson) {
     const data = (0, pnpm_normalizer_1.parseAndNormalizePnpmLockfile)(rootLockFileContent);
-    const { lockfileVersion, packages } = data;
-    const rootSnapshot = mapRootSnapshot(packageJson, packages, graph, +lockfileVersion);
+    const { lockfileVersion, packages, importers } = data;
+    const { snapshot: rootSnapshot, importers: requiredImporters } = mapRootSnapshot(packageJson, importers, packages, graph, +lockfileVersion);
     const snapshots = mapSnapshots(data.packages, graph.externalNodes, +lockfileVersion);
+    const workspaceDependencyImporters = {};
+    for (const [packageName, importerPath] of Object.entries(requiredImporters)) {
+        const baseImporter = importers[importerPath];
+        workspaceDependencyImporters[`workspace_modules/${packageName}`] =
+            baseImporter;
+    }
     const output = {
         ...data,
         lockfileVersion,
         importers: {
             '.': rootSnapshot,
+            ...workspaceDependencyImporters,
         },
         packages: (0, object_sort_1.sortObjectByKeys)(snapshots),
     };
@@ -398,8 +407,10 @@ function versionIsAlias(key, versionExpr, lockfileVersion) {
         ? key.startsWith(`${packageName}/${version}`)
         : key.startsWith(`${packageName}@${version}`);
 }
-function mapRootSnapshot(packageJson, packages, graph, lockfileVersion) {
+function mapRootSnapshot(packageJson, rootImporters, packages, graph, lockfileVersion) {
+    const workspaceModules = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
     const snapshot = { specifiers: {} };
+    const importers = {};
     [
         'dependencies',
         'optionalDependencies',
@@ -409,26 +420,42 @@ function mapRootSnapshot(packageJson, packages, graph, lockfileVersion) {
         if (packageJson[depType]) {
             Object.keys(packageJson[depType]).forEach((packageName) => {
                 const version = packageJson[depType][packageName];
-                const node = graph.externalNodes[`npm:${packageName}@${version}`] ||
-                    (graph.externalNodes[`npm:${packageName}`] &&
-                        graph.externalNodes[`npm:${packageName}`].data.version === version
-                        ? graph.externalNodes[`npm:${packageName}`]
-                        : (0, project_graph_pruning_1.findNodeMatchingVersion)(graph, packageName, version));
-                if (!node) {
-                    throw new Error(`Could not find external node for package ${packageName}@${version}.`);
+                if (workspaceModules.has(packageName)) {
+                    for (const [importerPath, importerSnapshot] of Object.entries(rootImporters)) {
+                        const workspaceDep = importerSnapshot.dependencies[packageName];
+                        if (workspaceDep) {
+                            const workspaceDepImporterPath = workspaceDep.replace('link:', '');
+                            const importerKeyForPackage = (0, path_1.join)(importerPath, workspaceDepImporterPath);
+                            importers[packageName] = importerKeyForPackage;
+                            snapshot.specifiers[packageName] = `file:./workspace_modules/${packageName}`;
+                            snapshot.dependencies = snapshot.dependencies || {};
+                            snapshot.dependencies[packageName] = `link:./workspace_modules/${packageName}`;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    const node = graph.externalNodes[`npm:${packageName}@${version}`] ||
+                        (graph.externalNodes[`npm:${packageName}`] &&
+                            graph.externalNodes[`npm:${packageName}`].data.version === version
+                            ? graph.externalNodes[`npm:${packageName}`]
+                            : (0, project_graph_pruning_1.findNodeMatchingVersion)(graph, packageName, version));
+                    if (!node) {
+                        throw new Error(`Could not find external node for package ${packageName}@${version}.`);
+                    }
+                    snapshot.specifiers[packageName] = version;
+                    // peer dependencies are mapped to dependencies
+                    let section = depType === 'peerDependencies' ? 'dependencies' : depType;
+                    snapshot[section] = snapshot[section] || {};
+                    snapshot[section][packageName] = findOriginalKeys(packages, node, lockfileVersion)[0][0];
                 }
-                snapshot.specifiers[packageName] = version;
-                // peer dependencies are mapped to dependencies
-                let section = depType === 'peerDependencies' ? 'dependencies' : depType;
-                snapshot[section] = snapshot[section] || {};
-                snapshot[section][packageName] = findOriginalKeys(packages, node, lockfileVersion)[0][0];
             });
         }
     });
     Object.keys(snapshot).forEach((key) => {
         snapshot[key] = (0, object_sort_1.sortObjectByKeys)(snapshot[key]);
     });
-    return snapshot;
+    return { snapshot, importers };
 }
 function findVersion(key, packageName, isV5, alias) {
     if (isV5 && key.startsWith(`${packageName}/`)) {

package/src/plugins/js/lock-file/project-graph-pruning.d.ts

@@ -1,8 +1,11 @@
-import { ProjectGraph, ProjectGraphExternalNode } from '../../../config/project-graph';
+import { ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../config/project-graph';
 import { PackageJson } from '../../../utils/package-json';
+import { ProjectGraphBuilder } from '../../../project-graph/project-graph-builder';
 /**
  * Prune project graph's external nodes and their dependencies
  * based on the pruned package.json
  */
 export declare function pruneProjectGraph(graph: ProjectGraph, prunedPackageJson: PackageJson): ProjectGraph;
 export declare function findNodeMatchingVersion(graph: ProjectGraph, packageName: string, versionExpr: string): ProjectGraphExternalNode;
+export declare function addNodesAndDependencies(graph: ProjectGraph, packageJsonDeps: Record<string, string>, workspacePackages: Map<string, ProjectGraphProjectNode>, builder: ProjectGraphBuilder): void;
+export declare function rehoistNodes(graph: ProjectGraph, packageJsonDeps: Record<string, string>, builder: ProjectGraphBuilder): void;

package/src/plugins/js/lock-file/project-graph-pruning.js

@@ -2,17 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pruneProjectGraph = pruneProjectGraph;
 exports.findNodeMatchingVersion = findNodeMatchingVersion;
+exports.addNodesAndDependencies = addNodesAndDependencies;
+exports.rehoistNodes = rehoistNodes;
 const semver_1 = require("semver");
 const project_graph_builder_1 = require("../../../project-graph/project-graph-builder");
 const operators_1 = require("../../../project-graph/operators");
+const get_workspace_packages_from_graph_1 = require("../utils/get-workspace-packages-from-graph");
 /**
  * Prune project graph's external nodes and their dependencies
  * based on the pruned package.json
  */
 function pruneProjectGraph(graph, prunedPackageJson) {
     const builder = new project_graph_builder_1.ProjectGraphBuilder();
-    const combinedDependencies = normalizeDependencies(prunedPackageJson, graph);
-    addNodesAndDependencies(graph, combinedDependencies, builder);
+    const workspacePackages = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
+    const combinedDependencies = normalizeDependencies(prunedPackageJson, graph, workspacePackages);
+    addNodesAndDependencies(graph, combinedDependencies, workspacePackages, builder);
+    for (const nodeName of workspacePackages.keys()) {
+        const node = graph.nodes[nodeName];
+        builder.addNode(node);
+    }
     // for NPM (as well as the graph consistency)
     // we need to distinguish between hoisted and non-hoisted dependencies
     rehoistNodes(graph, combinedDependencies, builder);
@@ -20,7 +28,7 @@ function pruneProjectGraph(graph, prunedPackageJson) {
 }
 // ensure that dependency ranges from package.json (e.g. ^1.0.0)
 // are replaced with the actual version based on the available nodes (e.g. 1.0.1)
-function normalizeDependencies(packageJson, graph) {
+function normalizeDependencies(packageJson, graph, workspacePackages) {
     const { dependencies, devDependencies, optionalDependencies, peerDependencies, } = packageJson;
     const combinedDependencies = {
         ...dependencies,
@@ -41,6 +49,10 @@ function normalizeDependencies(packageJson, graph) {
         if (node) {
             combinedDependencies[packageName] = node.data.version;
         }
+        else if (workspacePackages.has(packageName)) {
+            // workspace module, leave as is
+            combinedDependencies[packageName] = versionRange;
+        }
         else {
             throw new Error(`Pruned lock file creation failed. The following package was not found in the root lock file: ${packageName}@${versionRange}`);
         }
@@ -63,11 +75,18 @@ function findNodeMatchingVersion(graph, packageName, versionExpr) {
     }
     return nodes.find((n) => (0, semver_1.satisfies)(n.data.version, versionExpr));
 }
-function addNodesAndDependencies(graph, packageJsonDeps, builder) {
+function addNodesAndDependencies(graph, packageJsonDeps, workspacePackages, builder) {
     Object.entries(packageJsonDeps).forEach(([name, version]) => {
         const node = graph.externalNodes[`npm:${name}@${version}`] ||
             graph.externalNodes[`npm:${name}`];
-        traverseNode(graph, builder, node);
+        if (node) {
+            traverseNode(graph, builder, node);
+        }
+        else if (workspacePackages.has(name)) {
+            // Workspace Node
+            const node = graph.nodes[name];
+            traverseWorkspaceNode(graph, builder, node);
+        }
     });
 }
 function traverseNode(graph, builder, node) {
@@ -81,6 +100,14 @@ function traverseNode(graph, builder, node) {
         builder.addStaticDependency(node.name, dep.target);
     });
 }
+function traverseWorkspaceNode(graph, builder, node) {
+    graph.dependencies[node.name]?.forEach((dep) => {
+        const depNode = graph.externalNodes[dep.target];
+        if (depNode) {
+            traverseNode(graph, builder, depNode);
+        }
+    });
+}
 function rehoistNodes(graph, packageJsonDeps, builder) {
     const packagesToRehoist = new Map();
     // find all packages that need to be rehoisted

package/src/plugins/js/lock-file/yarn-parser.js

@@ -9,6 +9,7 @@ const semver_1 = require("semver");
 const project_graph_1 = require("../../../config/project-graph");
 const file_hasher_1 = require("../../../hasher/file-hasher");
 const object_sort_1 = require("../../../utils/object-sort");
+const get_workspace_packages_from_graph_1 = require("../utils/get-workspace-packages-from-graph");
 let currentLockFileHash;
 let cachedParsedLockFile;
 // we use key => node map to avoid duplicate work when parsing keys
@@ -244,7 +245,8 @@ function stringifyYarnLockfile(graph, rootLockFileContent, packageJson) {
     const { parseSyml, stringifySyml } = require('@yarnpkg/parsers');
     const { __metadata, ...dependencies } = parseSyml(rootLockFileContent);
     const isBerry = !!__metadata;
-    const snapshots = mapSnapshots(dependencies, graph.externalNodes, packageJson, isBerry);
+    const workspaceModules = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
+    const snapshots = mapSnapshots(dependencies, graph.externalNodes, packageJson, workspaceModules, isBerry);
     if (isBerry) {
         // add root workspace package
         const workspacePackage = generateRootWorkspacePackage(packageJson);
@@ -293,7 +295,7 @@ function addPackageVersion(packageName, version, collection, isBerry) {
         collection.get(packageName).add(`${packageName}@npm:${version}`);
     }
 }
-function mapSnapshots(rootDependencies, nodes, packageJson, isBerry) {
+function mapSnapshots(rootDependencies, nodes, packageJson, workspaceModules, isBerry) {
     // map snapshot to set of keys (e.g. `eslint@^7.0.0, eslint@npm:^7.0.0`)
     const snapshotMap = new Map();
     // track all existing dependencies's keys
@@ -311,7 +313,7 @@ function mapSnapshots(rootDependencies, nodes, packageJson, isBerry) {
     const groupedDependencies = groupDependencies(rootDependencies, isBerry);
     // collect snapshots and their matching keys
     Object.values(nodes).forEach((node) => {
-        const foundOriginalKeys = findOriginalKeys(groupedDependencies, node);
+        const foundOriginalKeys = findOriginalKeys(groupedDependencies, node, workspaceModules);
         if (!foundOriginalKeys) {
             throw new Error(`Original key(s) not found for "${node.data.packageName}@${node.data.version}" while pruning yarn.lock.`);
         }
@@ -322,7 +324,7 @@ function mapSnapshots(rootDependencies, nodes, packageJson, isBerry) {
             Object.entries(section || {}).forEach(([name, versionSpec]) => addPackageVersion(name, versionSpec, existingKeys, isBerry));
         });
         // add package.json requested version to keys
-        const requestedVersion = getPackageJsonVersion(combinedDependencies, node);
+        const requestedVersion = getPackageJsonVersion(combinedDependencies, node, workspaceModules);
         if (requestedVersion) {
             addPackageVersion(node.data.packageName, requestedVersion, existingKeys, isBerry);
             const requestedKey = isBerry
@@ -332,7 +334,7 @@ function mapSnapshots(rootDependencies, nodes, packageJson, isBerry) {
                 snapshotMap.get(snapshot).add(requestedKey);
             }
         }
-        const requestedResolutionsVersion = getPackageJsonVersion(resolutions, node);
+        const requestedResolutionsVersion = getPackageJsonVersion(resolutions, node, workspaceModules);
         if (requestedResolutionsVersion) {
             addPackageVersion(node.data.packageName, requestedResolutionsVersion, existingKeys, isBerry);
             const requestedKey = isBerry
@@ -394,8 +396,11 @@ function reverseMapBerryKey(node, version, snapshot) {
     }
     return `${node.data.packageName}@npm:${version}`;
 }
-function getPackageJsonVersion(dependencies, node) {
+function getPackageJsonVersion(dependencies, node, workspaceModules) {
     const { packageName, version } = node.data;
+    if (workspaceModules.has(packageName)) {
+        return `file:./workspace_modules/${packageName}`;
+    }
     if (dependencies[packageName]) {
         const patchRegex = new RegExp(`^patch:${packageName}@(.*)|#.*$`);
         // extract the version from the patch or use the full version
@@ -416,13 +421,20 @@ function isClassicAlias(node, keys) {
     return (node.data.version.startsWith('npm:') &&
         keys.some((k) => k === `${node.data.packageName}@${node.data.version}`));
 }
-function findOriginalKeys(dependencies, node) {
+function findOriginalKeys(dependencies, node, workspaceModules) {
     for (const keyExpr of Object.keys(dependencies)) {
         const snapshot = dependencies[keyExpr];
         const keys = keyExpr.split(', ');
         if (!keys.some((k) => k.startsWith(`${node.data.packageName}@`))) {
             continue;
         }
+        if (keys.some((k) => workspaceModules.has(k) || workspaceModules.has(k.split('@file:')[0]))) {
+            const packageName = keys[0].split('@file:')[0];
+            return [
+                [`${packageName}@file:./workspace_modules/${packageName}`],
+                snapshot,
+            ];
+        }
         if (isStandardPackage(snapshot, node.data.version) ||
             isBerryAlias(snapshot, node.data.version) ||
             isClassicAlias(node, keys)) {

package/src/plugins/js/utils/get-workspace-packages-from-graph.d.ts

@@ -0,0 +1,2 @@
+import { type ProjectGraph, ProjectGraphProjectNode } from '../../../config/project-graph';
+export declare function getWorkspacePackagesFromGraph(graph: ProjectGraph): Map<string, ProjectGraphProjectNode>;

package/src/plugins/js/utils/get-workspace-packages-from-graph.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspacePackagesFromGraph = getWorkspacePackagesFromGraph;
+function getWorkspacePackagesFromGraph(graph) {
+    const workspacePackages = new Map();
+    for (const [projectName, project] of Object.entries(graph.nodes)) {
+        const pkgName = project.data?.metadata?.js?.packageName;
+        if (pkgName) {
+            workspacePackages.set(pkgName, project);
+        }
+    }
+    return workspacePackages;
+}