nx 20.8.0-canary.20250401-b8e4325 → 20.8.0-canary.20250402-2d210b8

package/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{3968:()=>{}},s=>{var e;e=3968,s(s.s=e)}]);
+"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{2341:()=>{}},s=>{var e;e=2341,s(s.s=e)}]);

package/src/native/index.d.ts

@@ -111,7 +111,7 @@ export declare class WorkspaceContext {
 
 export interface CachedResult {
   code: number
-  terminalOutput: string
+  terminalOutput?: string
   outputsPath: string
   size?: number
 }

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

@@ -3,7 +3,7 @@ import { PackageJson } from '../../../../utils/package-json';
  * Get version of hoisted package if available
  */
 export declare function getHoistedPackageVersion(packageName: string): string;
-export type NormalizedPackageJson = Pick<PackageJson, 'name' | 'version' | 'license' | 'dependencies' | 'devDependencies' | 'peerDependencies' | 'peerDependenciesMeta' | 'optionalDependencies' | 'packageManager'>;
+export type NormalizedPackageJson = Pick<PackageJson, 'name' | 'version' | 'license' | 'dependencies' | 'devDependencies' | 'peerDependencies' | 'peerDependenciesMeta' | 'optionalDependencies' | 'packageManager' | 'resolutions'>;
 /**
  * Strip off non-pruning related fields from package.json
  */

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

@@ -19,7 +19,7 @@ function getHoistedPackageVersion(packageName) {
  * Strip off non-pruning related fields from package.json
  */
 function normalizePackageJson(packageJson) {
-    const { name, version, license, dependencies, devDependencies, peerDependencies, peerDependenciesMeta, optionalDependencies, packageManager, } = packageJson;
+    const { name, version, license, dependencies, devDependencies, peerDependencies, peerDependenciesMeta, optionalDependencies, packageManager, resolutions, } = packageJson;
     return {
         name,
         version,
@@ -30,5 +30,6 @@ function normalizePackageJson(packageJson) {
         peerDependenciesMeta,
         optionalDependencies,
         packageManager,
+        resolutions,
     };
 }

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

@@ -203,8 +203,26 @@ function getDependencies(dependencies, ctx) {
                 [snapshot.dependencies, snapshot.optionalDependencies].forEach((section) => {
                     if (section) {
                         Object.entries(section).forEach(([name, versionRange]) => {
-                            const target = keyMap.get(`${name}@npm:${versionRange}`) ||
+                            let target = keyMap.get(`${name}@npm:${versionRange}`) ||
                                 keyMap.get(`${name}@${versionRange}`);
+                            if (!target) {
+                                const shortRange = versionRange.replace(/^npm:/, '');
+                                // for range like 'npm:*' the above will not be a match
+                                if (shortRange === '*') {
+                                    const foundKey = Array.from(keyMap.keys()).find((k) => k.startsWith(`${name}@`));
+                                    if (foundKey) {
+                                        target = keyMap.get(foundKey);
+                                    }
+                                }
+                                else if (shortRange.includes('||')) {
+                                    // when range is a union of ranges, we need to treat it as an array
+                                    const ranges = shortRange.split('||').map((r) => r.trim());
+                                    target = Object.values(keyMap).find((n) => {
+                                        return (n.data.packageName === name &&
+                                            ranges.some((r) => (0, semver_1.satisfies)(n.data.version, r)));
+                                    })?.[1];
+                                }
+                            }
                             if (target) {
                                 const dep = {
                                     source: node.name,
@@ -271,11 +289,11 @@ function addPackageVersion(packageName, version, collection, isBerry) {
         collection.set(packageName, new Set());
     }
     collection.get(packageName).add(`${packageName}@${version}`);
-    if (isBerry && !version.startsWith('npm:')) {
+    if (isBerry && !version.startsWith('npm:') && !version.startsWith('patch:')) {
         collection.get(packageName).add(`${packageName}@npm:${version}`);
     }
 }
-function mapSnapshots(dependencies, nodes, packageJson, isBerry) {
+function mapSnapshots(rootDependencies, nodes, packageJson, 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
@@ -286,8 +304,11 @@ function mapSnapshots(dependencies, nodes, packageJson, isBerry) {
         ...packageJson.optionalDependencies,
         ...packageJson.peerDependencies,
     };
+    const resolutions = {
+        ...packageJson.resolutions,
+    };
     // yarn classic splits keys when parsing so we need to stich them back together
-    const groupedDependencies = groupDependencies(dependencies, isBerry);
+    const groupedDependencies = groupDependencies(rootDependencies, isBerry);
     // collect snapshots and their matching keys
     Object.values(nodes).forEach((node) => {
         const foundOriginalKeys = findOriginalKeys(groupedDependencies, node);
@@ -311,9 +332,19 @@ function mapSnapshots(dependencies, nodes, packageJson, isBerry) {
                 snapshotMap.get(snapshot).add(requestedKey);
             }
         }
+        const requestedResolutionsVersion = getPackageJsonVersion(resolutions, node);
+        if (requestedResolutionsVersion) {
+            addPackageVersion(node.data.packageName, requestedResolutionsVersion, existingKeys, isBerry);
+            const requestedKey = isBerry
+                ? reverseMapBerryKey(node, requestedResolutionsVersion, snapshot)
+                : `${node.data.packageName}@${requestedResolutionsVersion}`;
+            if (!snapshotMap.get(snapshot).has(requestedKey)) {
+                snapshotMap.get(snapshot).add(requestedKey);
+            }
+        }
         if (isBerry) {
             // look for patched versions
-            const patch = findPatchedKeys(groupedDependencies, node);
+            const patch = findPatchedKeys(groupedDependencies, node, resolutions[node.data.packageName]);
             if (patch) {
                 const [matchedKeys, snapshot] = patch;
                 snapshotMap.set(snapshot, new Set(matchedKeys));
@@ -321,7 +352,7 @@ function mapSnapshots(dependencies, nodes, packageJson, isBerry) {
         }
     });
     // remove keys that match version ranges that have been pruned away
-    snapshotMap.forEach((snapshotValue, snapshotKey) => {
+    snapshotMap.forEach((snapshotValue, snapshot) => {
         for (const key of snapshotValue.values()) {
             const packageName = key.slice(0, key.indexOf('@', 1));
             let normalizedKey = key;
@@ -353,8 +384,8 @@ function mapSnapshots(dependencies, nodes, packageJson, isBerry) {
 }
 function reverseMapBerryKey(node, version, snapshot) {
     // alias packages already have version
-    if (version.startsWith('npm:')) {
-        `${node.data.packageName}@${version}`;
+    if (version.startsWith('npm:') || version.startsWith('patch:')) {
+        return `${node.data.packageName}@${version}`;
     }
     // check for berry tarball packages
     if (snapshot.resolution &&
@@ -363,15 +394,28 @@ function reverseMapBerryKey(node, version, snapshot) {
     }
     return `${node.data.packageName}@npm:${version}`;
 }
-function getPackageJsonVersion(combinedDependencies, node) {
+function getPackageJsonVersion(dependencies, node) {
     const { packageName, version } = node.data;
-    if (combinedDependencies[packageName]) {
-        if (combinedDependencies[packageName] === version ||
-            (0, semver_1.satisfies)(version, combinedDependencies[packageName])) {
-            return combinedDependencies[packageName];
+    if (dependencies[packageName]) {
+        const patchRegex = new RegExp(`^patch:${packageName}@(.*)|#.*$`);
+        // extract the version from the patch or use the full version
+        const versionRange = dependencies[packageName].match(patchRegex)?.[1] ||
+            dependencies[packageName];
+        if (versionRange === version || (0, semver_1.satisfies)(version, versionRange)) {
+            return dependencies[packageName];
         }
     }
 }
+function isStandardPackage(snapshot, version) {
+    return snapshot.version === version;
+}
+function isBerryAlias(snapshot, version) {
+    return snapshot.resolution && `npm:${snapshot.resolution}` === version;
+}
+function isClassicAlias(node, keys) {
+    return (node.data.version.startsWith('npm:') &&
+        keys.some((k) => k === `${node.data.packageName}@${node.data.version}`));
+}
 function findOriginalKeys(dependencies, node) {
     for (const keyExpr of Object.keys(dependencies)) {
         const snapshot = dependencies[keyExpr];
@@ -379,18 +423,9 @@ function findOriginalKeys(dependencies, node) {
         if (!keys.some((k) => k.startsWith(`${node.data.packageName}@`))) {
             continue;
         }
-        // standard package
-        if (snapshot.version === node.data.version) {
-            return [keys, snapshot];
-        }
-        // berry alias package
-        if (snapshot.resolution &&
-            `npm:${snapshot.resolution}` === node.data.version) {
-            return [keys, snapshot];
-        }
-        // classic alias
-        if (node.data.version.startsWith('npm:') &&
-            keys.some((k) => k === `${node.data.packageName}@${node.data.version}`)) {
+        if (isStandardPackage(snapshot, node.data.version) ||
+            isBerryAlias(snapshot, node.data.version) ||
+            isClassicAlias(node, keys)) {
             return [keys, snapshot];
         }
         // tarball package
@@ -400,16 +435,27 @@ function findOriginalKeys(dependencies, node) {
         }
     }
 }
-function findPatchedKeys(dependencies, node) {
+function findPatchedKeys(dependencies, node, resolutionVersion) {
     for (const keyExpr of Object.keys(dependencies)) {
         const snapshot = dependencies[keyExpr];
         const keys = keyExpr.split(', ');
         if (!keys[0].startsWith(`${node.data.packageName}@patch:`)) {
             continue;
         }
-        // local patches are currently not supported
-        if (keys[0].includes('.yarn/patches')) {
-            continue;
+        if (keyExpr.includes('.yarn/patches')) {
+            if (!resolutionVersion) {
+                continue;
+            }
+            const key = `${node.data.packageName}@${resolutionVersion}`;
+            // local patches can have different location from than the root lock file
+            // use the one from local package.json as the source of truth as long as the rest of the patch matches
+            // this obviously doesn't cover the case of patch over a patch, but that's a super rare case and one can argue one can just join those two patches
+            if (key.split('::locator')[0] !== keyExpr.split('::locator')[0]) {
+                continue;
+            }
+            else {
+                return [[key], { ...snapshot, resolution: key }];
+            }
         }
         if (snapshot.version === node.data.version) {
             return [keys, snapshot];

package/src/tasks-runner/cache.js

@@ -88,6 +88,7 @@ class DbCache {
         if (res) {
             return {
                 ...res,
+                terminalOutput: res.terminalOutput ?? '',
                 remote: false,
             };
         }
@@ -99,6 +100,7 @@ class DbCache {
                 this.applyRemoteCacheResults(task.hash, res, task.outputs);
                 return {
                     ...res,
+                    terminalOutput: res.terminalOutput ?? '',
                     remote: true,
                 };
             }