nx 19.2.0-canary.20240525-af463c4 → 19.2.0-canary.20240530-316dcb9

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

@@ -23,14 +23,20 @@ function parsePnpmLockFile(lockFileContent, lockFileHash) {
 }
 function getPnpmLockfileNodes(lockFileContent, lockFileHash) {
     const data = parsePnpmLockFile(lockFileContent, lockFileHash);
-    const isV6 = (0, pnpm_normalizer_1.isV6Lockfile)(data);
-    return getNodes(data, keyMap, isV6);
+    if (+data.lockfileVersion.toString() >= 10) {
+        console.warn('Nx was tested only with pnpm lockfile version 5-9. If you encounter any issues, please report them and downgrade to older version of pnpm.');
+    }
+    const isV5 = (0, pnpm_normalizer_1.isV5Syntax)(data);
+    return getNodes(data, keyMap, isV5);
 }
 exports.getPnpmLockfileNodes = getPnpmLockfileNodes;
 function getPnpmLockfileDependencies(lockFileContent, lockFileHash, ctx) {
     const data = parsePnpmLockFile(lockFileContent, lockFileHash);
-    const isV6 = (0, pnpm_normalizer_1.isV6Lockfile)(data);
-    return getDependencies(data, keyMap, isV6, ctx);
+    if (+data.lockfileVersion.toString() >= 10) {
+        console.warn('Nx was tested only with pnpm lockfile version 5-9. If you encounter any issues, please report them and downgrade to older version of pnpm.');
+    }
+    const isV5 = (0, pnpm_normalizer_1.isV5Syntax)(data);
+    return getDependencies(data, keyMap, isV5, ctx);
 }
 exports.getPnpmLockfileDependencies = getPnpmLockfileDependencies;
 function matchPropValue(record, key, originalPackageName) {
@@ -58,79 +64,116 @@ function createHashFromSnapshot(snapshot) {
             ? (0, file_hasher_1.hashArray)([snapshot.resolution['tarball']])
             : undefined));
 }
-function isLockFileKey(depVersion) {
-    return depVersion.startsWith('/');
+function isAliasVersion(depVersion) {
+    return depVersion.startsWith('/') || depVersion.includes('@');
 }
-function getNodes(data, keyMap, isV6) {
+function getNodes(data, keyMap, isV5) {
     const nodes = new Map();
     const maybeAliasedPackageVersions = new Map(); // <version, alias>
+    if (data.importers['.'].optionalDependencies) {
+        for (const [depName, depVersion] of Object.entries(data.importers['.'].optionalDependencies)) {
+            if (isAliasVersion(depVersion)) {
+                maybeAliasedPackageVersions.set(depVersion, depName);
+            }
+        }
+    }
+    if (data.importers['.'].devDependencies) {
+        for (const [depName, depVersion] of Object.entries(data.importers['.'].devDependencies)) {
+            if (isAliasVersion(depVersion)) {
+                maybeAliasedPackageVersions.set(depVersion, depName);
+            }
+        }
+    }
+    if (data.importers['.'].dependencies) {
+        for (const [depName, depVersion] of Object.entries(data.importers['.'].dependencies)) {
+            if (isAliasVersion(depVersion)) {
+                maybeAliasedPackageVersions.set(depVersion, depName);
+            }
+        }
+    }
     const packageNames = new Set();
+    let packageNameObj;
     for (const [key, snapshot] of Object.entries(data.packages)) {
-        const originalPackageName = extractNameFromKey(key);
+        const originalPackageName = extractNameFromKey(key, isV5);
         if (!originalPackageName) {
             continue;
         }
+        const hash = createHashFromSnapshot(snapshot);
         // snapshot already has a name
         if (snapshot.name) {
-            packageNames.add({
+            packageNameObj = {
                 key,
                 packageName: snapshot.name,
-                hash: createHashFromSnapshot(snapshot),
-            });
+                hash,
+            };
         }
         const rootDependencyName = matchedDependencyName(data.importers['.'], key, originalPackageName) ||
+            matchedDependencyName(data.importers['.'], `/${key}`, originalPackageName) ||
             // only root importers have devDependencies
-            matchPropValue(data.importers['.'].devDependencies, key, originalPackageName);
+            matchPropValue(data.importers['.'].devDependencies, key, originalPackageName) ||
+            matchPropValue(data.importers['.'].devDependencies, `/${key}`, originalPackageName);
         if (rootDependencyName) {
-            packageNames.add({
+            packageNameObj = {
                 key,
                 packageName: rootDependencyName,
                 hash: createHashFromSnapshot(snapshot),
-            });
+            };
         }
         if (!snapshot.name && !rootDependencyName) {
-            packageNames.add({
+            packageNameObj = {
                 key,
                 packageName: originalPackageName,
                 hash: createHashFromSnapshot(snapshot),
-            });
+            };
         }
         if (snapshot.peerDependencies) {
             for (const [depName, depVersion] of Object.entries(snapshot.peerDependencies)) {
-                if (isLockFileKey(depVersion)) {
+                if (isAliasVersion(depVersion)) {
                     maybeAliasedPackageVersions.set(depVersion, depName);
                 }
             }
         }
         if (snapshot.optionalDependencies) {
             for (const [depName, depVersion] of Object.entries(snapshot.optionalDependencies)) {
-                if (isLockFileKey(depVersion)) {
+                if (isAliasVersion(depVersion)) {
                     maybeAliasedPackageVersions.set(depVersion, depName);
                 }
             }
         }
         if (snapshot.dependencies) {
             for (const [depName, depVersion] of Object.entries(snapshot.dependencies)) {
-                if (isLockFileKey(depVersion)) {
+                if (isAliasVersion(depVersion)) {
                     maybeAliasedPackageVersions.set(depVersion, depName);
                 }
             }
         }
-        const aliasedDep = maybeAliasedPackageVersions.get(key);
+        const aliasedDep = maybeAliasedPackageVersions.get(`/${key}`);
         if (aliasedDep) {
-            packageNames.add({
+            packageNameObj = {
                 key,
                 packageName: aliasedDep,
-                hash: createHashFromSnapshot(snapshot),
-            });
+                hash,
+                alias: true,
+            };
+        }
+        packageNames.add(packageNameObj);
+        const localAlias = maybeAliasedPackageVersions.get(key);
+        if (localAlias) {
+            packageNameObj = {
+                key,
+                packageName: localAlias,
+                hash,
+                alias: true,
+            };
+            packageNames.add(packageNameObj);
         }
     }
-    for (const { key, packageName, hash } of packageNames) {
-        const rawVersion = findVersion(key, packageName);
+    for (const { key, packageName, hash, alias } of packageNames) {
+        const rawVersion = findVersion(key, packageName, isV5, alias);
         if (!rawVersion) {
             continue;
         }
-        const version = parseBaseVersion(rawVersion, isV6);
+        const version = parseBaseVersion(rawVersion, isV5);
         if (!version) {
             continue;
         }
@@ -140,7 +183,9 @@ function getNodes(data, keyMap, isV6) {
         if (!nodes.get(packageName).has(version)) {
             const node = {
                 type: 'npm',
-                name: version ? `npm:${packageName}@${version}` : `npm:${packageName}`,
+                name: version && !version.startsWith('npm:')
+                    ? `npm:${packageName}@${version}`
+                    : `npm:${packageName}`,
                 data: {
                     version,
                     packageName,
@@ -148,10 +193,21 @@ function getNodes(data, keyMap, isV6) {
                 },
             };
             nodes.get(packageName).set(version, node);
-            keyMap.set(key, node);
+            if (!keyMap.has(key)) {
+                keyMap.set(key, new Set([node]));
+            }
+            else {
+                keyMap.get(key).add(node);
+            }
         }
         else {
-            keyMap.set(key, nodes.get(packageName).get(version));
+            const node = nodes.get(packageName).get(version);
+            if (!keyMap.has(key)) {
+                keyMap.set(key, new Set([node]));
+            }
+            else {
+                keyMap.get(key).add(node);
+            }
         }
     }
     const hoistedDeps = (0, pnpm_normalizer_1.loadPnpmHoistedDepsDefinition)();
@@ -162,7 +218,7 @@ function getNodes(data, keyMap, isV6) {
             hoistedNode = versionMap.values().next().value;
         }
         else {
-            const hoistedVersion = getHoistedVersion(hoistedDeps, packageName, isV6);
+            const hoistedVersion = getHoistedVersion(hoistedDeps, packageName, isV5);
             hoistedNode = versionMap.get(hoistedVersion);
         }
         if (hoistedNode) {
@@ -174,12 +230,12 @@ function getNodes(data, keyMap, isV6) {
     }
     return results;
 }
-function getHoistedVersion(hoistedDependencies, packageName, isV6) {
+function getHoistedVersion(hoistedDependencies, packageName, isV5) {
     let version = (0, package_json_1.getHoistedPackageVersion)(packageName);
     if (!version) {
         const key = Object.keys(hoistedDependencies).find((k) => k.startsWith(`/${packageName}/`));
         if (key) {
-            version = parseBaseVersion(getVersion(key, packageName), isV6);
+            version = parseBaseVersion(getVersion(key.slice(1), packageName), isV5);
         }
         else {
             // pnpm might not hoist every package
@@ -189,96 +245,160 @@ function getHoistedVersion(hoistedDependencies, packageName, isV6) {
     }
     return version;
 }
-function getDependencies(data, keyMap, isV6, ctx) {
+function getDependencies(data, keyMap, isV5, ctx) {
     const results = [];
     Object.entries(data.packages).forEach(([key, snapshot]) => {
-        const node = keyMap.get(key);
-        [snapshot.dependencies, snapshot.optionalDependencies].forEach((section) => {
-            if (section) {
-                Object.entries(section).forEach(([name, versionRange]) => {
-                    const version = parseBaseVersion(findVersion(versionRange, name), isV6);
-                    const target = ctx.externalNodes[`npm:${name}@${version}`] ||
-                        ctx.externalNodes[`npm:${name}`];
-                    if (target) {
-                        const dep = {
-                            source: node.name,
-                            target: target.name,
-                            type: project_graph_1.DependencyType.static,
-                        };
-                        (0, project_graph_builder_1.validateDependency)(dep, ctx);
-                        results.push(dep);
-                    }
-                });
-            }
+        const nodes = keyMap.get(key);
+        nodes.forEach((node) => {
+            [snapshot.dependencies, snapshot.optionalDependencies].forEach((section) => {
+                if (section) {
+                    Object.entries(section).forEach(([name, versionRange]) => {
+                        const version = parseBaseVersion(findVersion(versionRange, name, isV5), isV5);
+                        const target = ctx.externalNodes[`npm:${name}@${version}`] ||
+                            ctx.externalNodes[`npm:${name}`];
+                        if (target) {
+                            const dep = {
+                                source: node.name,
+                                target: target.name,
+                                type: project_graph_1.DependencyType.static,
+                            };
+                            (0, project_graph_builder_1.validateDependency)(dep, ctx);
+                            results.push(dep);
+                        }
+                    });
+                }
+            });
         });
     });
     return results;
 }
-function parseBaseVersion(rawVersion, isV6) {
-    return isV6 ? rawVersion.split('(')[0] : rawVersion.split('_')[0];
+function parseBaseVersion(rawVersion, isV5) {
+    return isV5 ? rawVersion.split('_')[0] : rawVersion.split('(')[0];
 }
 function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson) {
     const data = (0, pnpm_normalizer_1.parseAndNormalizePnpmLockfile)(rootLockFileContent);
     const { lockfileVersion, packages } = data;
+    const rootSnapshot = mapRootSnapshot(packageJson, packages, graph.externalNodes, +lockfileVersion);
+    const snapshots = mapSnapshots(data.packages, graph.externalNodes, +lockfileVersion);
     const output = {
+        ...data,
         lockfileVersion,
         importers: {
-            '.': mapRootSnapshot(packageJson, packages, graph.externalNodes),
+            '.': rootSnapshot,
         },
-        packages: (0, object_sort_1.sortObjectByKeys)(mapSnapshots(data.packages, graph.externalNodes)),
+        packages: (0, object_sort_1.sortObjectByKeys)(snapshots),
     };
     return (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output);
 }
 exports.stringifyPnpmLockfile = stringifyPnpmLockfile;
-function mapSnapshots(packages, nodes) {
+function mapSnapshots(packages, nodes, lockfileVersion) {
     const result = {};
     Object.values(nodes).forEach((node) => {
-        const matchedKeys = findOriginalKeys(packages, node, {
+        const matchedKeys = findOriginalKeys(packages, node, lockfileVersion, {
             returnFullKey: true,
         });
         // the package manager doesn't check for types of dependencies
         // so we can safely set all to prod
         matchedKeys.forEach(([key, snapshot]) => {
-            snapshot.dev = false;
-            result[key] = snapshot;
+            if (lockfileVersion >= 9) {
+                delete snapshot['dev'];
+                result[key] = snapshot;
+            }
+            else {
+                snapshot['dev'] = false; // all dependencies are prod
+                remapDependencies(snapshot);
+                if (snapshot.resolution?.['tarball']) {
+                    // tarballs are not prefixed with /
+                    result[key] = snapshot;
+                }
+                else {
+                    result[`/${key}`] = snapshot;
+                }
+            }
         });
     });
     return result;
 }
-function findOriginalKeys(packages, { data: { packageName, version } }, { returnFullKey } = {}) {
+function remapDependencies(snapshot) {
+    [
+        'dependencies',
+        'optionalDependencies',
+        'devDependencies',
+        'peerDependencies',
+    ].forEach((depType) => {
+        if (snapshot[depType]) {
+            for (const [packageName, version] of Object.entries(snapshot[depType])) {
+                if (version.match(/^[a-zA-Z]+.*/)) {
+                    // remap packageName@version to packageName/version
+                    snapshot[depType][packageName] = `/${version.replace(/([a-zA-Z].+)@/, '$1/')}`;
+                }
+            }
+        }
+    });
+}
+function findOriginalKeys(packages, { data: { packageName, version } }, lockfileVersion, { returnFullKey } = {}) {
     const matchedKeys = [];
     for (const key of Object.keys(packages)) {
         const snapshot = packages[key];
+        // tarball package
+        if (key.startsWith(`${packageName}@${version}`) &&
+            snapshot.resolution?.['tarball']) {
+            matchedKeys.push([getVersion(key, packageName), snapshot]);
+        }
         // standard package
-        if (key.startsWith(`/${packageName}/${version}`)) {
+        if (lockfileVersion < 6 && key.startsWith(`${packageName}/${version}`)) {
             matchedKeys.push([
                 returnFullKey ? key : getVersion(key, packageName),
                 snapshot,
             ]);
         }
-        // tarball package
-        if (key === version) {
-            matchedKeys.push([version, snapshot]);
+        if (lockfileVersion >= 6 &&
+            lockfileVersion < 9 &&
+            key.startsWith(`${packageName}@${version}`)) {
+            matchedKeys.push([
+                // we need to replace the @ with / for v5-7 syntax because the dpParse function expects old format
+                returnFullKey
+                    ? key.replace(`${packageName}@${version}`, `${packageName}/${version}`)
+                    : getVersion(key, packageName),
+                snapshot,
+            ]);
+        }
+        if (lockfileVersion >= 9 && key.startsWith(`${packageName}@${version}`)) {
+            matchedKeys.push([
+                returnFullKey ? key : getVersion(key, packageName),
+                snapshot,
+            ]);
         }
         // alias package
-        if (versionIsAlias(key, version)) {
-            matchedKeys.push([key, snapshot]);
+        if (versionIsAlias(key, version, lockfileVersion)) {
+            if (lockfileVersion >= 9) {
+                // no postprocessing needed for v9
+                matchedKeys.push([key, snapshot]);
+            }
+            else {
+                // for root specifiers we need to ensure alias is prefixed with /
+                const prefixedKey = returnFullKey ? key : `/${key}`;
+                const mappedKey = prefixedKey.replace(/(\/?..+)@/, '$1/');
+                matchedKeys.push([mappedKey, snapshot]);
+            }
         }
     }
     return matchedKeys;
 }
 // check if version has a form of npm:packageName@version and
 // key starts with /packageName/version
-function versionIsAlias(key, versionExpr) {
+function versionIsAlias(key, versionExpr, lockfileVersion) {
     const PREFIX = 'npm:';
     if (!versionExpr.startsWith(PREFIX))
         return false;
     const indexOfVersionSeparator = versionExpr.indexOf('@', PREFIX.length + 1);
     const packageName = versionExpr.slice(PREFIX.length, indexOfVersionSeparator);
     const version = versionExpr.slice(indexOfVersionSeparator + 1);
-    return key.startsWith(`/${packageName}/${version}`);
+    return lockfileVersion < 6
+        ? key.startsWith(`${packageName}/${version}`)
+        : key.startsWith(`${packageName}@${version}`);
 }
-function mapRootSnapshot(packageJson, packages, nodes) {
+function mapRootSnapshot(packageJson, packages, nodes, lockfileVersion) {
     const snapshot = { specifiers: {} };
     [
         'dependencies',
@@ -294,7 +414,7 @@ function mapRootSnapshot(packageJson, packages, nodes) {
                 // peer dependencies are mapped to dependencies
                 let section = depType === 'peerDependencies' ? 'dependencies' : depType;
                 snapshot[section] = snapshot[section] || {};
-                snapshot[section][packageName] = findOriginalKeys(packages, node)[0][0];
+                snapshot[section][packageName] = findOriginalKeys(packages, node, lockfileVersion)[0][0];
             });
         }
     });
@@ -303,13 +423,18 @@ function mapRootSnapshot(packageJson, packages, nodes) {
     });
     return snapshot;
 }
-function findVersion(key, packageName) {
-    if (key.startsWith(`/${packageName}/`)) {
+function findVersion(key, packageName, isV5, alias) {
+    if (isV5 && key.startsWith(`${packageName}/`)) {
+        return getVersion(key, packageName);
+    }
+    // this matches v6 syntax and tarball packages
+    if (key.startsWith(`${packageName}@`)) {
         return getVersion(key, packageName);
     }
-    // for alias packages prepend with "npm:"
-    if (key.startsWith('/')) {
-        const aliasName = key.slice(1, key.lastIndexOf('/'));
+    if (alias) {
+        const aliasName = isV5
+            ? key.slice(0, key.lastIndexOf('/'))
+            : key.slice(0, key.indexOf('@', 2)); // we use 2 to ensure we don't catch the first @
         const version = getVersion(key, aliasName);
         return `npm:${aliasName}@${version}`;
     }
@@ -317,20 +442,26 @@ function findVersion(key, packageName) {
     return key;
 }
 function getVersion(key, packageName) {
-    const KEY_NAME_SEPARATOR_LENGTH = 2; // leading and trailing slash
-    return key.slice(packageName.length + KEY_NAME_SEPARATOR_LENGTH);
+    return key.slice(packageName.length + 1);
 }
-function extractNameFromKey(key) {
-    // if package name contains org e.g. "/@babel/runtime/7.12.5"
-    // we want slice until the third slash
-    if (key.startsWith('/@')) {
-        // find the position of the '/' after org name
-        const startFrom = key.indexOf('/', 1);
-        return key.slice(1, key.indexOf('/', startFrom + 1));
+function extractNameFromKey(key, isV5) {
+    // if package name contains org e.g. "@babel/runtime@7.12.5"
+    if (key.startsWith('@')) {
+        if (isV5) {
+            const startFrom = key.indexOf('/');
+            return key.slice(0, key.indexOf('/', startFrom + 1));
+        }
+        else {
+            // find the position of the '@'
+            return key.slice(0, key.indexOf('@', 1));
+        }
     }
-    if (key.startsWith('/')) {
-        // if package has just a name e.g. "/react/7.12.5..."
-        return key.slice(1, key.indexOf('/', 1));
+    if (isV5) {
+        // if package has just a name e.g. "react/7.12.5..."
+        return key.slice(0, key.indexOf('/', 1));
+    }
+    else {
+        // if package has just a name e.g. "react@7.12.5..."
+        return key.slice(0, key.indexOf('@', 1));
     }
-    return key;
 }

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

@@ -2,37 +2,19 @@
  * This file contains the logic to convert pnpm lockfile to a standard format.
  * It will convert inline specifiers to the separate specifiers format and ensure importers are present.
  */
-import type { Lockfile, ProjectSnapshot } from '@pnpm/lockfile-types';
-export declare function isV6Lockfile(data: InlineSpecifiersLockfile | Lockfile): boolean;
+import type { Lockfile } from '@pnpm/lockfile-types';
+export declare function isV5Syntax(data: {
+    lockfileVersion: number | string;
+}): boolean;
+export declare function usesLeadingDash(data: {
+    lockfileVersion: number | string;
+}): boolean;
 export declare function loadPnpmHoistedDepsDefinition(): any;
-/*************************************************************************
- * THE FOLLOWING CODE IS COPIED & simplified FROM @pnpm/lockfile-file for convenience
- *************************************************************************/
 /**
  * Parsing and mapping logic from pnpm lockfile `read` function
- * https://github.com/pnpm/pnpm/blob/af3e5559d377870d4c3d303429b3ed1a4e64fedc/lockfile/lockfile-file/src/read.ts#L91
  */
 export declare function parseAndNormalizePnpmLockfile(content: string): Lockfile;
 /**
  * Mapping and writing logic from pnpm lockfile `write` function
- * https://github.com/pnpm/pnpm/blob/af3e5559d377870d4c3d303429b3ed1a4e64fedc/lockfile/lockfile-file/src/write.ts#L77
  */
 export declare function stringifyToPnpmYaml(lockfile: Lockfile): string;
-interface InlineSpecifiersLockfile extends Omit<Lockfile, 'lockfileVersion' | 'importers'> {
-    lockfileVersion: string;
-    importers: Record<string, InlineSpecifiersProjectSnapshot>;
-}
-interface InlineSpecifiersProjectSnapshot {
-    dependencies?: InlineSpecifiersResolvedDependencies;
-    devDependencies?: InlineSpecifiersResolvedDependencies;
-    optionalDependencies?: InlineSpecifiersResolvedDependencies;
-    dependenciesMeta?: ProjectSnapshot['dependenciesMeta'];
-}
-interface InlineSpecifiersResolvedDependencies {
-    [depName: string]: SpecifierAndResolution;
-}
-interface SpecifierAndResolution {
-    specifier: string;
-    version: string;
-}
-export {};