@yarnpkg/plugin-pnpm 1.0.2-rc.1 → 1.1.0-rc.12

package/lib/PnpmLinker.d.ts

@@ -1,18 +1,19 @@
-import { Descriptor, FetchResult, Installer, InstallPackageExtraApi, Linker, LinkOptions, Locator, MinimalLinkOptions, Package } from '@yarnpkg/core';
+import { Descriptor, FetchResult, Installer, InstallPackageExtraApi, Linker, LinkOptions, Locator, LocatorHash, MinimalLinkOptions, Package } from '@yarnpkg/core';
 import { PortablePath } from '@yarnpkg/fslib';
 export declare type PnpmCustomData = {
-    locatorByPath: Map<string, string>;
+    pathByLocator: Map<LocatorHash, PortablePath>;
+    locatorByPath: Map<PortablePath, string>;
 };
 export declare class PnpmLinker implements Linker {
     supportsPackage(pkg: Package, opts: MinimalLinkOptions): boolean;
     findPackageLocation(locator: Locator, opts: LinkOptions): Promise<PortablePath>;
     findPackageLocator(location: PortablePath, opts: LinkOptions): Promise<Locator | null>;
     makeInstaller(opts: LinkOptions): PnpmInstaller;
+    private isEnabled;
 }
 declare class PnpmInstaller implements Installer {
     private opts;
-    private asyncActions;
-    private packageLocations;
+    private readonly asyncActions;
     constructor(opts: LinkOptions);
     getCustomDataKey(): string;
     private customData;
@@ -34,6 +35,8 @@ declare class PnpmInstaller implements Installer {
     }>;
     attachInternalDependencies(locator: Locator, dependencies: Array<[Descriptor, Locator]>): Promise<void>;
     attachExternalDependents(locator: Locator, dependentPaths: Array<PortablePath>): Promise<void>;
-    finalizeInstall(): Promise<void>;
+    finalizeInstall(): Promise<{
+        customData: PnpmCustomData;
+    }>;
 }
 export {};

package/lib/PnpmLinker.js

@@ -1,21 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PnpmLinker = void 0;
-const tslib_1 = require("tslib");
 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 p_limit_1 = (0, tslib_1.__importDefault)(require("p-limit"));
 class PnpmLinker {
     supportsPackage(pkg, opts) {
-        return opts.project.configuration.get(`nodeLinker`) === `pnpm`;
+        return this.isEnabled(opts);
     }
     async findPackageLocation(locator, opts) {
-        // TODO: Support soft linked packages
-        return getPackageLocation(locator, { project: opts.project });
+        if (!this.isEnabled(opts))
+            throw new Error(`Assertion failed: Expected the pnpm linker to be enabled`);
+        const customDataKey = getCustomDataKey();
+        const customData = opts.project.installersCustomData.get(customDataKey);
+        if (!customData)
+            throw new clipanion_1.UsageError(`The project in ${core_1.formatUtils.pretty(opts.project.configuration, `${opts.project.cwd}/package.json`, core_1.formatUtils.Type.PATH)} doesn't seem to have been installed - running an install there might help`);
+        const packageLocation = customData.pathByLocator.get(locator.locatorHash);
+        if (typeof packageLocation === `undefined`)
+            throw new clipanion_1.UsageError(`Couldn't find ${core_1.structUtils.prettyLocator(opts.project.configuration, locator)} in the currently installed pnpm map - running an install might help`);
+        return packageLocation;
     }
     async findPackageLocator(location, opts) {
+        if (!this.isEnabled(opts))
+            return null;
         const customDataKey = getCustomDataKey();
         const customData = opts.project.installersCustomData.get(customDataKey);
         if (!customData)
@@ -42,14 +50,17 @@ class PnpmLinker {
     makeInstaller(opts) {
         return new PnpmInstaller(opts);
     }
+    isEnabled(opts) {
+        return opts.project.configuration.get(`nodeLinker`) === `pnpm`;
+    }
 }
 exports.PnpmLinker = PnpmLinker;
 class PnpmInstaller {
     constructor(opts) {
         this.opts = opts;
-        this.asyncActions = new AsyncActions();
-        this.packageLocations = new Map();
+        this.asyncActions = new core_1.miscUtils.AsyncActions(10);
         this.customData = {
+            pathByLocator: new Map(),
             locatorByPath: new Map(),
         };
         // Nothing to do
@@ -58,7 +69,8 @@ class PnpmInstaller {
         return getCustomDataKey();
     }
     attachCustomData(customData) {
-        this.customData = customData;
+        // 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.
     }
     async installPackage(pkg, fetchResult, api) {
         switch (pkg.linkType) {
@@ -69,7 +81,7 @@ class PnpmInstaller {
     }
     async installPackageSoft(pkg, fetchResult, api) {
         const pkgPath = fslib_1.ppath.resolve(fetchResult.packageFs.getRealPath(), fetchResult.prefixPath);
-        this.packageLocations.set(pkg.locatorHash, pkgPath);
+        this.customData.pathByLocator.set(pkg.locatorHash, pkgPath);
         return {
             packageLocation: pkgPath,
             buildDirective: null,
@@ -79,7 +91,7 @@ class PnpmInstaller {
         var _a;
         const pkgPath = getPackageLocation(pkg, { project: this.opts.project });
         this.customData.locatorByPath.set(pkgPath, core_1.structUtils.stringifyLocator(pkg));
-        this.packageLocations.set(pkg.locatorHash, pkgPath);
+        this.customData.pathByLocator.set(pkg.locatorHash, pkgPath);
         api.holdFetchResult(this.asyncActions.set(pkg.locatorHash, async () => {
             await fslib_1.xfs.mkdirPromise(pkgPath, { recursive: true });
             // Copy the package source into the <root>/n_m/.store/<hash> directory, so
@@ -113,17 +125,15 @@ class PnpmInstaller {
         this.asyncActions.reduce(locator.locatorHash, async (action) => {
             // Wait that the package is properly installed before starting to copy things into it
             await action;
-            const pkgPath = this.packageLocations.get(locator.locatorHash);
+            const pkgPath = this.customData.pathByLocator.get(locator.locatorHash);
             if (typeof pkgPath === `undefined`)
                 throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(locator)})`);
             const nmPath = fslib_1.ppath.join(pkgPath, fslib_1.Filename.nodeModules);
-            if (dependencies.length > 0)
-                await fslib_1.xfs.mkdirpPromise(nmPath);
+            const concurrentPromises = [];
             // Retrieve what's currently inside the package's true nm folder. We
             // will use that to figure out what are the extraneous entries we'll
             // need to remove.
             const extraneous = await getNodeModulesListing(nmPath);
-            const concurrentPromises = [];
             for (const [descriptor, dependency] of dependencies) {
                 // Downgrade virtual workspaces (cf isPnpmVirtualCompatible's documentation)
                 let targetDependency = dependency;
@@ -131,7 +141,7 @@ class PnpmInstaller {
                     this.opts.report.reportWarning(core_1.MessageName.UNNAMED, `The pnpm linker doesn't support providing different versions to workspaces' peer dependencies`);
                     targetDependency = core_1.structUtils.devirtualizeLocator(dependency);
                 }
-                const depSrcPath = this.packageLocations.get(targetDependency.locatorHash);
+                const depSrcPath = this.customData.pathByLocator.get(targetDependency.locatorHash);
                 if (typeof depSrcPath === `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);
@@ -158,8 +168,7 @@ class PnpmInstaller {
                     }
                 }));
             }
-            for (const name of extraneous.keys())
-                concurrentPromises.push(fslib_1.xfs.removePromise(fslib_1.ppath.join(nmPath, name)));
+            concurrentPromises.push(cleanNodeModules(nmPath, extraneous));
             await Promise.all(concurrentPromises);
         });
     }
@@ -172,9 +181,35 @@ class PnpmInstaller {
             await fslib_1.xfs.removePromise(storeLocation);
         }
         else {
+            const removals = [];
             const expectedEntries = new Set();
-            for (const packageLocation of this.packageLocations.values())
-                expectedEntries.add(fslib_1.ppath.basename(packageLocation));
+            for (const packageLocation of this.customData.pathByLocator.values()) {
+                const subpath = fslib_1.ppath.contains(storeLocation, packageLocation);
+                if (subpath !== null) {
+                    const [storeEntry, /* Filename.nodeModules */ , ...identComponents] = subpath.split(fslib_1.ppath.sep);
+                    expectedEntries.add(storeEntry);
+                    const storeEntryPath = fslib_1.ppath.join(storeLocation, storeEntry);
+                    removals.push(fslib_1.xfs.readdirPromise(storeEntryPath)
+                        .then(entries => {
+                        return Promise.all(entries.map(async (entry) => {
+                            const p = fslib_1.ppath.join(storeEntryPath, entry);
+                            if (entry === fslib_1.Filename.nodeModules) {
+                                const extraneous = await getNodeModulesListing(p);
+                                extraneous.delete(identComponents.join(fslib_1.ppath.sep));
+                                return cleanNodeModules(p, extraneous);
+                            }
+                            else {
+                                return fslib_1.xfs.removePromise(p);
+                            }
+                        }));
+                    })
+                        .catch(error => {
+                        if (error.code !== `ENOENT`) {
+                            throw error;
+                        }
+                    }));
+                }
+            }
             let storeRecords;
             try {
                 storeRecords = await fslib_1.xfs.readdirPromise(storeLocation);
@@ -182,22 +217,24 @@ class PnpmInstaller {
             catch {
                 storeRecords = [];
             }
-            const removals = [];
             for (const record of storeRecords)
                 if (!expectedEntries.has(record))
                     removals.push(fslib_1.xfs.removePromise(fslib_1.ppath.join(storeLocation, record)));
             await Promise.all(removals);
-            await removeIfEmpty(storeLocation);
         }
         // Wait for the package installs to catch up
         await this.asyncActions.wait(),
-            await removeIfEmpty(getNodeModulesLocation(this.opts.project));
+            await removeIfEmpty(storeLocation);
+        await removeIfEmpty(getNodeModulesLocation(this.opts.project));
+        return {
+            customData: this.customData,
+        };
     }
 }
 function getCustomDataKey() {
     return JSON.stringify({
         name: `PnpmInstaller`,
-        version: 1,
+        version: 2,
     });
 }
 function getNodeModulesLocation(project) {
@@ -208,7 +245,8 @@ function getStoreLocation(project) {
 }
 function getPackageLocation(locator, { project }) {
     const pkgKey = core_1.structUtils.slugifyLocator(locator);
-    const pkgPath = fslib_1.ppath.join(getStoreLocation(project), pkgKey);
+    const prefixPath = core_1.structUtils.getIdentVendorPath(locator);
+    const pkgPath = fslib_1.ppath.join(getStoreLocation(project), pkgKey, prefixPath);
     return pkgPath;
 }
 function isPnpmVirtualCompatible(locator, { project }) {
@@ -241,8 +279,14 @@ async function getNodeModulesListing(nmPath) {
             if (entry.name.startsWith(`.`))
                 continue;
             if (entry.name.startsWith(`@`)) {
-                for (const subEntry of await fslib_1.xfs.readdirPromise(fslib_1.ppath.join(nmPath, entry.name), { withFileTypes: true })) {
-                    listing.set(`${entry.name}/${subEntry.name}`, subEntry);
+                const scopeListing = await fslib_1.xfs.readdirPromise(fslib_1.ppath.join(nmPath, entry.name), { withFileTypes: true });
+                if (scopeListing.length === 0) {
+                    listing.set(entry.name, entry);
+                }
+                else {
+                    for (const subEntry of scopeListing) {
+                        listing.set(`${entry.name}/${subEntry.name}`, subEntry);
+                    }
                 }
             }
             else {
@@ -257,6 +301,19 @@ async function getNodeModulesListing(nmPath) {
     }
     return listing;
 }
+async function cleanNodeModules(nmPath, extraneous) {
+    var _a;
+    const removeNamePromises = [];
+    const scopesToRemove = new Set();
+    for (const name of extraneous.keys()) {
+        removeNamePromises.push(fslib_1.xfs.removePromise(fslib_1.ppath.join(nmPath, name)));
+        const scope = (_a = core_1.structUtils.tryParseIdent(name)) === null || _a === void 0 ? void 0 : _a.scope;
+        if (scope) {
+            scopesToRemove.add(`@${scope}`);
+        }
+    }
+    return Promise.all(removeNamePromises).then(() => Promise.all([...scopesToRemove].map(scope => removeIfEmpty(fslib_1.ppath.join(nmPath, scope)))));
+}
 async function removeIfEmpty(dir) {
     try {
         await fslib_1.xfs.rmdirPromise(dir);
@@ -267,44 +324,3 @@ async function removeIfEmpty(dir) {
         }
     }
 }
-function makeDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((resolveFn, rejectFn) => {
-        resolve = resolveFn;
-        reject = rejectFn;
-    });
-    return { promise, resolve: resolve, reject: reject };
-}
-class AsyncActions {
-    constructor() {
-        this.deferred = new Map();
-        this.promises = new Map();
-        this.limit = (0, p_limit_1.default)(10);
-    }
-    set(key, factory) {
-        let deferred = this.deferred.get(key);
-        if (typeof deferred === `undefined`)
-            this.deferred.set(key, deferred = makeDeferred());
-        const promise = this.limit(() => factory());
-        this.promises.set(key, promise);
-        promise.then(() => {
-            if (this.promises.get(key) === promise) {
-                deferred.resolve();
-            }
-        }, err => {
-            if (this.promises.get(key) === promise) {
-                deferred.reject(err);
-            }
-        });
-        return deferred.promise;
-    }
-    reduce(key, factory) {
-        var _a;
-        const promise = (_a = this.promises.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
-        this.set(key, () => factory(promise));
-    }
-    async wait() {
-        await Promise.all(this.promises.values());
-    }
-}

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "@yarnpkg/plugin-pnpm",
-  "version": "1.0.2-rc.1",
+  "version": "1.1.0-rc.12",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "dependencies": {
-    "@yarnpkg/fslib": "^2.6.0",
-    "@yarnpkg/plugin-pnp": "^3.1.2-rc.2",
+    "@yarnpkg/fslib": "^2.6.1-rc.9",
+    "@yarnpkg/plugin-pnp": "^3.2.0-rc.4",
     "@yarnpkg/plugin-stage": "^3.1.1",
-    "clipanion": "^3.0.1",
+    "clipanion": "^3.2.0-rc.4",
     "p-limit": "^2.2.0",
     "tslib": "^1.13.0"
   },
   "peerDependencies": {
-    "@yarnpkg/cli": "^3.2.0-rc.2",
-    "@yarnpkg/core": "^3.2.0-rc.2"
+    "@yarnpkg/cli": "^3.2.0-rc.14",
+    "@yarnpkg/core": "^3.2.0-rc.14"
   },
   "devDependencies": {
-    "@yarnpkg/cli": "^3.2.0-rc.2",
-    "@yarnpkg/core": "^3.2.0-rc.2"
+    "@yarnpkg/cli": "^3.2.0-rc.14",
+    "@yarnpkg/core": "^3.2.0-rc.14"
   },
   "repository": {
     "type": "git",