@yarnpkg/plugin-pnpm 2.1.2 → 2.3.0

package/lib/PnpmLinker.d.ts

@@ -2,10 +2,11 @@ import { Descriptor, FetchResult, Installer, InstallPackageExtraApi, Linker, Lin
 import { PortablePath } from '@yarnpkg/fslib';
 export type PnpmCustomData = {
     locatorByPath: Map<PortablePath, string>;
-    pathsByLocator: Map<LocatorHash, {
-        packageLocation: PortablePath;
-        dependenciesLocation: PortablePath | null;
-    }>;
+    pathsByLocator: Map<LocatorHash, PnpmPackagePaths>;
+};
+export type PnpmPackagePaths = {
+    packageLocation: PortablePath;
+    dependenciesLocation: PortablePath | null;
 };
 export declare class PnpmLinker implements Linker {
     getCustomDataKey(): string;
@@ -21,7 +22,10 @@ declare class PnpmInstaller implements Installer {
     private readonly indexFolderPromise;
     constructor(opts: LinkOptions);
     private customData;
+    private packageMapNodesByLocator;
     attachCustomData(customData: any): void;
+    private registerPackageMapNode;
+    private registerPackageMapDependency;
     installPackage(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
         packageLocation: PortablePath;
         buildRequest: import("@yarnpkg/core").BuildRequest | null;

package/lib/PnpmLinker.js

@@ -5,6 +5,7 @@ const core_1 = require("@yarnpkg/core");
 const fslib_1 = require("@yarnpkg/fslib");
 const plugin_pnp_1 = require("@yarnpkg/plugin-pnp");
 const clipanion_1 = require("clipanion");
+const PACKAGE_MAP_FILE = `.package-map.json`;
 class PnpmLinker {
     getCustomDataKey() {
         return JSON.stringify({
@@ -64,11 +65,12 @@ exports.PnpmLinker = PnpmLinker;
 class PnpmInstaller {
     constructor(opts) {
         this.opts = opts;
-        this.asyncActions = new core_1.miscUtils.AsyncActions(10);
         this.customData = {
             pathsByLocator: new Map(),
             locatorByPath: new Map(),
         };
+        this.packageMapNodesByLocator = new Map();
+        this.asyncActions = new core_1.miscUtils.AsyncActions(opts.project.configuration.get(`pnpmInstallConcurrency`));
         this.indexFolderPromise = (0, fslib_1.setupCopyIndex)(fslib_1.xfs, {
             indexPath: fslib_1.ppath.join(opts.project.configuration.get(`globalFolder`), `index`),
         });
@@ -77,6 +79,20 @@ class PnpmInstaller {
         // We don't want to attach the data because it's only used in the Linker and we'll recompute it anyways in the Installer,
         // it needs to be invalidated because otherwise we'll never prune the store or we might run into various issues.
     }
+    registerPackageMapNode(locatorHash, { packageLocation }) {
+        const normalizedPackageLocation = stripTrailingSeparators(packageLocation);
+        if (!this.packageMapNodesByLocator.has(locatorHash)) {
+            this.packageMapNodesByLocator.set(locatorHash, {
+                packageLocation: normalizedPackageLocation,
+                dependencies: new Map(),
+            });
+        }
+    }
+    registerPackageMapDependency(packageMapNode, dependencyName, dependency) {
+        if (!this.packageMapNodesByLocator.has(dependency.locatorHash))
+            throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(dependency)})`);
+        packageMapNode.dependencies.set(dependencyName, dependency.locatorHash);
+    }
     async installPackage(pkg, fetchResult, api) {
         switch (pkg.linkType) {
             case core_1.LinkType.SOFT: return this.installPackageSoft(pkg, fetchResult, api);
@@ -89,10 +105,12 @@ class PnpmInstaller {
         const dependenciesLocation = this.opts.project.tryWorkspaceByLocator(pkg)
             ? fslib_1.ppath.join(packageLocation, fslib_1.Filename.nodeModules)
             : null;
-        this.customData.pathsByLocator.set(pkg.locatorHash, {
+        const packagePaths = {
             packageLocation,
             dependenciesLocation,
-        });
+        };
+        this.customData.pathsByLocator.set(pkg.locatorHash, packagePaths);
+        this.registerPackageMapNode(pkg.locatorHash, packagePaths);
         return {
             packageLocation,
             buildRequest: null,
@@ -103,6 +121,7 @@ class PnpmInstaller {
         const packageLocation = packagePaths.packageLocation;
         this.customData.locatorByPath.set(packageLocation, core_1.structUtils.stringifyLocator(pkg));
         this.customData.pathsByLocator.set(pkg.locatorHash, packagePaths);
+        this.registerPackageMapNode(pkg.locatorHash, packagePaths);
         api.holdFetchResult(this.asyncActions.set(pkg.locatorHash, async () => {
             await fslib_1.xfs.mkdirPromise(packageLocation, { recursive: true });
             // Copy the package source into the <root>/n_m/.store/<hash> directory, so
@@ -144,6 +163,9 @@ class PnpmInstaller {
         const { dependenciesLocation, } = packagePaths;
         if (!dependenciesLocation)
             return;
+        const packageMapNode = this.packageMapNodesByLocator.get(locator.locatorHash);
+        if (typeof packageMapNode === `undefined`)
+            throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(locator)})`);
         this.asyncActions.reduce(locator.locatorHash, async (action) => {
             await fslib_1.xfs.mkdirPromise(dependenciesLocation, { recursive: true });
             // Retrieve what's currently inside the package's true nm folder. We
@@ -163,6 +185,7 @@ class PnpmInstaller {
                 if (typeof depSrcPaths === `undefined`)
                     throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(dependency)})`);
                 const name = core_1.structUtils.stringifyIdent(descriptor);
+                this.registerPackageMapDependency(packageMapNode, name, targetDependency);
                 const depDstPath = fslib_1.ppath.join(dependenciesLocation, name);
                 const depLinkPath = fslib_1.ppath.relative(fslib_1.ppath.dirname(depDstPath), depSrcPaths.packageLocation);
                 const existing = extraneous.get(name);
@@ -227,8 +250,23 @@ class PnpmInstaller {
                 await fslib_1.xfs.removePromise(fslib_1.ppath.join(storeLocation, extraneousEntry));
             }));
         }
-        // Wait for the package installs to catch up
         await this.asyncActions.wait();
+        const nodeLinker = this.opts.project.configuration.get(`nodeLinker`);
+        if (nodeLinker === `pnpm`) {
+            const packageMap = buildPackageMap({
+                basePath: getNodeModulesLocation(this.opts.project),
+                packageMapNodesByLocator: this.packageMapNodesByLocator,
+                topLevelLocatorHash: this.opts.project.topLevelWorkspace.anchoredLocator.locatorHash,
+                type: this.opts.project.configuration.get(`nodePackageMapType`),
+            });
+            await fslib_1.xfs.mkdirPromise(getNodeModulesLocation(this.opts.project), { recursive: true });
+            await fslib_1.xfs.changeFilePromise(fslib_1.ppath.join(getNodeModulesLocation(this.opts.project), PACKAGE_MAP_FILE), JSON.stringify(packageMap, null, 2), {
+                automaticNewlines: true,
+            });
+        }
+        else if (nodeLinker !== `node-modules`) {
+            await fslib_1.xfs.removePromise(fslib_1.ppath.join(getNodeModulesLocation(this.opts.project), PACKAGE_MAP_FILE));
+        }
         await removeIfEmpty(storeLocation);
         if (this.opts.project.configuration.get(`nodeLinker`) !== `node-modules`)
             await removeIfEmpty(getNodeModulesLocation(this.opts.project));
@@ -250,6 +288,55 @@ function getPackagePaths(locator, { project }) {
     const dependenciesLocation = fslib_1.ppath.join(storeLocation, pkgKey, fslib_1.Filename.nodeModules);
     return { packageLocation, dependenciesLocation };
 }
+function stripTrailingSeparators(path) {
+    while (path !== fslib_1.PortablePath.root && path.endsWith(fslib_1.ppath.sep))
+        path = path.slice(0, -1);
+    return path;
+}
+function getRelativeUrl(from, to) {
+    let relativePath = fslib_1.ppath.relative(from, to) || fslib_1.PortablePath.dot;
+    if (!relativePath.startsWith(`.`))
+        relativePath = `./${relativePath}`;
+    return relativePath;
+}
+function getPackageId(basePath, location) {
+    const relativePath = fslib_1.ppath.relative(basePath, location) || fslib_1.PortablePath.dot;
+    return relativePath === `..` ? fslib_1.PortablePath.dot : relativePath;
+}
+function compareStrings(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function buildPackageMap({ basePath, packageMapNodesByLocator, topLevelLocatorHash, type }) {
+    basePath = stripTrailingSeparators(basePath);
+    const topLevelPackageMapNode = packageMapNodesByLocator.get(topLevelLocatorHash);
+    if (typeof topLevelPackageMapNode === `undefined`)
+        throw new Error(`Assertion failed: Expected the top-level package to have been registered`);
+    const packageIdsByLocator = new Map();
+    for (const [locatorHash, packageMapNode] of packageMapNodesByLocator)
+        packageIdsByLocator.set(locatorHash, getPackageId(basePath, packageMapNode.packageLocation));
+    const serializeDependencies = (dependencies) => {
+        return Object.fromEntries(Array.from(dependencies).sort(([a], [b]) => compareStrings(a, b)).map(([dependencyName, dependencyLocatorHash]) => {
+            const dependencyPackageId = packageIdsByLocator.get(dependencyLocatorHash);
+            if (typeof dependencyPackageId === `undefined`)
+                throw new Error(`Assertion failed: Expected the package to have been registered (${dependencyLocatorHash})`);
+            return [dependencyName, dependencyPackageId];
+        }));
+    };
+    const packages = {};
+    for (const packageMapNode of Array.from(packageMapNodesByLocator.values()).sort((a, b) => compareStrings(getPackageId(basePath, a.packageLocation), getPackageId(basePath, b.packageLocation)))) {
+        const packageDependencies = type === plugin_pnp_1.NodePackageMapType.LOOSE
+            ? new Map([
+                ...topLevelPackageMapNode.dependencies,
+                ...packageMapNode.dependencies,
+            ])
+            : packageMapNode.dependencies;
+        packages[getPackageId(basePath, packageMapNode.packageLocation)] = {
+            url: getRelativeUrl(basePath, packageMapNode.packageLocation),
+            dependencies: serializeDependencies(packageDependencies),
+        };
+    }
+    return { packages };
+}
 function isPnpmVirtualCompatible(locator, { project }) {
     // The pnpm install strategy has a limitation: because Node would always
     // resolve symbolic path to their true location, and because we can't just

package/lib/index.d.ts

@@ -5,6 +5,7 @@ export { PnpmLinker };
 declare module '@yarnpkg/core' {
     interface ConfigurationValueMap {
         pnpmStoreFolder: PortablePath;
+        pnpmInstallConcurrency: number;
     }
 }
 declare const plugin: Plugin;

package/lib/index.js

@@ -11,6 +11,11 @@ const plugin = {
             type: core_1.SettingsType.ABSOLUTE_PATH,
             default: `./node_modules/.store`,
         },
+        pnpmInstallConcurrency: {
+            description: `Maximum number of packages the pnpm linker will install in parallel. Lower this on monorepos with very large caches if you hit "Couldn't allocate enough memory" from the bundled libzip WASM heap.`,
+            type: core_1.SettingsType.NUMBER,
+            default: 10,
+        },
     },
     linkers: [
         PnpmLinker_1.PnpmLinker,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarnpkg/plugin-pnpm",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "exports": {
@@ -8,20 +8,21 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@yarnpkg/fslib": "^3.1.2",
-    "@yarnpkg/plugin-pnp": "^4.1.1",
+    "@yarnpkg/fslib": "^3.1.5",
+    "@yarnpkg/plugin-pnp": "^4.2.0",
     "@yarnpkg/plugin-stage": "^4.0.2",
     "clipanion": "^4.0.0-rc.2",
     "p-limit": "^2.2.0",
     "tslib": "^2.4.0"
   },
   "peerDependencies": {
-    "@yarnpkg/cli": "^4.9.3",
-    "@yarnpkg/core": "^4.4.3"
+    "@yarnpkg/cli": "^4.17.0",
+    "@yarnpkg/core": "^4.9.0"
   },
   "devDependencies": {
-    "@yarnpkg/cli": "^4.9.3",
-    "@yarnpkg/core": "^4.4.3"
+    "@yarnpkg/cli": "^4.17.0",
+    "@yarnpkg/core": "^4.9.0",
+    "@yarnpkg/nm": "^4.1.0"
   },
   "repository": {
     "type": "git",