@yarnpkg/plugin-pnpm 1.0.0 → 1.1.0-rc.10

package/lib/PnpmLinker.d.ts

@@ -0,0 +1,42 @@
+import { Descriptor, FetchResult, Installer, InstallPackageExtraApi, Linker, LinkOptions, Locator, LocatorHash, MinimalLinkOptions, Package } from '@yarnpkg/core';
+import { PortablePath } from '@yarnpkg/fslib';
+export declare type PnpmCustomData = {
+    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 readonly asyncActions;
+    constructor(opts: LinkOptions);
+    getCustomDataKey(): string;
+    private customData;
+    attachCustomData(customData: any): void;
+    installPackage(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
+        packageLocation: PortablePath;
+        buildDirective: null;
+    } | {
+        packageLocation: PortablePath;
+        buildDirective: import("@yarnpkg/core").BuildDirective[];
+    }>;
+    installPackageSoft(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
+        packageLocation: PortablePath;
+        buildDirective: null;
+    }>;
+    installPackageHard(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
+        packageLocation: PortablePath;
+        buildDirective: import("@yarnpkg/core").BuildDirective[];
+    }>;
+    attachInternalDependencies(locator: Locator, dependencies: Array<[Descriptor, Locator]>): Promise<void>;
+    attachExternalDependents(locator: Locator, dependentPaths: Array<PortablePath>): Promise<void>;
+    finalizeInstall(): Promise<{
+        customData: PnpmCustomData;
+    }>;
+}
+export {};

package/lib/PnpmLinker.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmLinker = void 0;
+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");
+class PnpmLinker {
+    supportsPackage(pkg, opts) {
+        return this.isEnabled(opts);
+    }
+    async findPackageLocation(locator, opts) {
+        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)
+            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 nmRootLocation = location.match(/(^.*\/node_modules\/(@[^/]*\/)?[^/]+)(\/.*$)/);
+        if (nmRootLocation) {
+            const nmLocator = customData.locatorByPath.get(nmRootLocation[1]);
+            if (nmLocator) {
+                return nmLocator;
+            }
+        }
+        let nextPath = location;
+        let currentPath = location;
+        do {
+            currentPath = nextPath;
+            nextPath = fslib_1.ppath.dirname(currentPath);
+            const locator = customData.locatorByPath.get(currentPath);
+            if (locator) {
+                return locator;
+            }
+        } while (nextPath !== currentPath);
+        return null;
+    }
+    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 core_1.miscUtils.AsyncActions(10);
+        this.customData = {
+            pathByLocator: new Map(),
+            locatorByPath: new Map(),
+        };
+        // Nothing to do
+    }
+    getCustomDataKey() {
+        return getCustomDataKey();
+    }
+    attachCustomData(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) {
+            case core_1.LinkType.SOFT: return this.installPackageSoft(pkg, fetchResult, api);
+            case core_1.LinkType.HARD: return this.installPackageHard(pkg, fetchResult, api);
+        }
+        throw new Error(`Assertion failed: Unsupported package link type`);
+    }
+    async installPackageSoft(pkg, fetchResult, api) {
+        const pkgPath = fslib_1.ppath.resolve(fetchResult.packageFs.getRealPath(), fetchResult.prefixPath);
+        this.customData.pathByLocator.set(pkg.locatorHash, pkgPath);
+        return {
+            packageLocation: pkgPath,
+            buildDirective: null,
+        };
+    }
+    async installPackageHard(pkg, fetchResult, api) {
+        var _a;
+        const pkgPath = getPackageLocation(pkg, { project: this.opts.project });
+        this.customData.locatorByPath.set(pkgPath, core_1.structUtils.stringifyLocator(pkg));
+        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
+            // that we can then create symbolic links to it later.
+            await fslib_1.xfs.copyPromise(pkgPath, fetchResult.prefixPath, {
+                baseFs: fetchResult.packageFs,
+                overwrite: false,
+            });
+        }));
+        const isVirtual = core_1.structUtils.isVirtualLocator(pkg);
+        const devirtualizedLocator = isVirtual ? core_1.structUtils.devirtualizeLocator(pkg) : pkg;
+        const buildConfig = {
+            manifest: (_a = await core_1.Manifest.tryFind(fetchResult.prefixPath, { baseFs: fetchResult.packageFs })) !== null && _a !== void 0 ? _a : new core_1.Manifest(),
+            misc: {
+                hasBindingGyp: plugin_pnp_1.jsInstallUtils.hasBindingGyp(fetchResult),
+            },
+        };
+        const dependencyMeta = this.opts.project.getDependencyMeta(devirtualizedLocator, pkg.version);
+        const buildScripts = plugin_pnp_1.jsInstallUtils.extractBuildScripts(pkg, buildConfig, dependencyMeta, { configuration: this.opts.project.configuration, report: this.opts.report });
+        return {
+            packageLocation: pkgPath,
+            buildDirective: buildScripts,
+        };
+    }
+    async attachInternalDependencies(locator, dependencies) {
+        if (this.opts.project.configuration.get(`nodeLinker`) !== `pnpm`)
+            return;
+        // We don't install those packages at all, because they can't be used anyway
+        if (!isPnpmVirtualCompatible(locator, { project: this.opts.project }))
+            return;
+        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.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);
+            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);
+            for (const [descriptor, dependency] of dependencies) {
+                // Downgrade virtual workspaces (cf isPnpmVirtualCompatible's documentation)
+                let targetDependency = dependency;
+                if (!isPnpmVirtualCompatible(dependency, { project: this.opts.project })) {
+                    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.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);
+                const depDstPath = fslib_1.ppath.join(nmPath, name);
+                const depLinkPath = fslib_1.ppath.relative(fslib_1.ppath.dirname(depDstPath), depSrcPath);
+                const existing = extraneous.get(name);
+                extraneous.delete(name);
+                concurrentPromises.push(Promise.resolve().then(async () => {
+                    // No need to update the symlink if it's already the correct one
+                    if (existing) {
+                        if (existing.isSymbolicLink() && await fslib_1.xfs.readlinkPromise(depDstPath) === depLinkPath) {
+                            return;
+                        }
+                        else {
+                            await fslib_1.xfs.removePromise(depDstPath);
+                        }
+                    }
+                    await fslib_1.xfs.mkdirpPromise(fslib_1.ppath.dirname(depDstPath));
+                    if (process.platform == `win32`) {
+                        await fslib_1.xfs.symlinkPromise(depSrcPath, depDstPath, `junction`);
+                    }
+                    else {
+                        await fslib_1.xfs.symlinkPromise(depLinkPath, depDstPath);
+                    }
+                }));
+            }
+            concurrentPromises.push(cleanNodeModules(nmPath, extraneous));
+            await Promise.all(concurrentPromises);
+        });
+    }
+    async attachExternalDependents(locator, dependentPaths) {
+        throw new Error(`External dependencies haven't been implemented for the pnpm linker`);
+    }
+    async finalizeInstall() {
+        const storeLocation = getStoreLocation(this.opts.project);
+        if (this.opts.project.configuration.get(`nodeLinker`) !== `pnpm`) {
+            await fslib_1.xfs.removePromise(storeLocation);
+        }
+        else {
+            const removals = [];
+            const expectedEntries = new Set();
+            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);
+            }
+            catch {
+                storeRecords = [];
+            }
+            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);
+        }
+        // Wait for the package installs to catch up
+        await this.asyncActions.wait(),
+            await removeIfEmpty(storeLocation);
+        await removeIfEmpty(getNodeModulesLocation(this.opts.project));
+        return {
+            customData: this.customData,
+        };
+    }
+}
+function getCustomDataKey() {
+    return JSON.stringify({
+        name: `PnpmInstaller`,
+        version: 2,
+    });
+}
+function getNodeModulesLocation(project) {
+    return fslib_1.ppath.join(project.cwd, fslib_1.Filename.nodeModules);
+}
+function getStoreLocation(project) {
+    return fslib_1.ppath.join(getNodeModulesLocation(project), `.store`);
+}
+function getPackageLocation(locator, { project }) {
+    const pkgKey = core_1.structUtils.slugifyLocator(locator);
+    const prefixPath = core_1.structUtils.getIdentVendorPath(locator);
+    const pkgPath = fslib_1.ppath.join(getStoreLocation(project), pkgKey, prefixPath);
+    return pkgPath;
+}
+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
+    // copy-paste workspaces like we do with normal dependencies, we can't give
+    // multiple dependency sets to the same workspace based on how its peer
+    // dependencies are satisfied by its dependents (like PnP can).
+    //
+    // For this reason, we ignore all virtual instances of workspaces, and
+    // instead have to rely on the user being aware of this caveat.
+    //
+    // TODO: Perhaps we could implement an error message when we detect multiple
+    // sets in a way that can't be reproduced on disk?
+    return !core_1.structUtils.isVirtualLocator(locator) || !project.tryWorkspaceByLocator(locator);
+}
+async function getNodeModulesListing(nmPath) {
+    const listing = new Map();
+    let fsListing = [];
+    try {
+        fsListing = await fslib_1.xfs.readdirPromise(nmPath, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code !== `ENOENT`) {
+            throw err;
+        }
+    }
+    try {
+        for (const entry of fsListing) {
+            if (entry.name.startsWith(`.`))
+                continue;
+            if (entry.name.startsWith(`@`)) {
+                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 {
+                listing.set(entry.name, entry);
+            }
+        }
+    }
+    catch (err) {
+        if (err.code !== `ENOENT`) {
+            throw err;
+        }
+    }
+    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);
+    }
+    catch (error) {
+        if (error.code !== `ENOENT` && error.code !== `ENOTEMPTY`) {
+            throw error;
+        }
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@yarnpkg/core';
+declare const plugin: Plugin;
+export default plugin;

package/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PnpmLinker_1 = require("./PnpmLinker");
+const plugin = {
+    linkers: [
+        PnpmLinker_1.PnpmLinker,
+    ],
+};
+// eslint-disable-next-line arca/no-default-export
+exports.default = plugin;

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "@yarnpkg/plugin-pnpm",
-  "version": "1.0.0",
+  "version": "1.1.0-rc.10",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "dependencies": {
-    "@yarnpkg/fslib": "^2.6.0",
-    "@yarnpkg/plugin-pnp": "^3.1.0",
-    "@yarnpkg/plugin-stage": "^3.1.0",
-    "clipanion": "^3.0.1",
+    "@yarnpkg/fslib": "^2.6.1-rc.7",
+    "@yarnpkg/plugin-pnp": "^3.2.0-rc.2",
+    "@yarnpkg/plugin-stage": "^3.1.1",
+    "clipanion": "^3.2.0-rc.4",
     "p-limit": "^2.2.0",
     "tslib": "^1.13.0"
   },
   "peerDependencies": {
-    "@yarnpkg/cli": "^3.1.0",
-    "@yarnpkg/core": "^3.1.0"
+    "@yarnpkg/cli": "^3.2.0-rc.12",
+    "@yarnpkg/core": "^3.2.0-rc.12"
   },
   "devDependencies": {
-    "@yarnpkg/cli": "^3.1.0",
-    "@yarnpkg/core": "^3.1.0"
+    "@yarnpkg/cli": "^3.2.0-rc.12",
+    "@yarnpkg/core": "^3.2.0-rc.12"
   },
   "repository": {
     "type": "git",
@@ -38,5 +38,6 @@
   "engines": {
     "node": ">=12 <14 || 14.2 - 14.9 || >14.10.0"
   },
+  "stableVersion": "1.0.1",
   "typings": "./lib/index.d.ts"
 }