fix: find the pnpapi the issuer belongs to

Author: alexander-akait

lib/PnpPlugin.js

@@ -10,19 +10,21 @@
 /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
 /**
  * @typedef {Object} PnpApiImpl
- * @property {function(string, string, object): string} resolveToUnqualified
+ * @property {function(string, string, object): string | null} resolveToUnqualified
  */
 
 module.exports = class PnpPlugin {
 	/**
 	 * @param {string | ResolveStepHook} source source
 	 * @param {PnpApiImpl} pnpApi pnpApi
 	 * @param {string | ResolveStepHook} target target
+	 * @param {string | ResolveStepHook} alternateTarget alternateTarget
 	 */
-	constructor(source, pnpApi, target) {
+	constructor(source, pnpApi, target, alternateTarget) {
 		this.source = source;
 		this.pnpApi = pnpApi;
 		this.target = target;
+		this.alternateTarget = alternateTarget;
 	}
 
 	/**
@@ -32,6 +34,7 @@ module.exports = class PnpPlugin {
 	apply(resolver) {
 		/** @type {ResolveStepHook} */
 		const target = resolver.ensureHook(this.target);
+		const alternateTarget = resolver.ensureHook(this.alternateTarget);
 		resolver
 			.getHook(this.source)
 			.tapAsync("PnpPlugin", (request, resolveContext, callback) => {
@@ -47,14 +50,33 @@ module.exports = class PnpPlugin {
 				const packageName = packageMatch[0];
 				const innerRequest = `.${req.slice(packageName.length)}`;
 
-				/** @type {string|undefined} */
+				/** @type {string|undefined|null} */
 				let resolution;
-				/** @type {string|undefined} */
+				/** @type {string|undefined|null} */
 				let apiResolution;
 				try {
 					resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, {
 						considerBuiltins: false
 					});
+
+					if (resolution === null) {
+						// This is either not a PnP managed issuer or it's a Node builtin
+						// Try to continue resolving with our alternatives
+						resolver.doResolve(
+							alternateTarget,
+							request,
+							"issuer is not managed by a pnpapi",
+							resolveContext,
+							(err, result) => {
+								if (err) return callback(err);
+								if (result) return callback(null, result);
+								// Skip alternatives
+								return callback(null, null);
+							}
+						);
+						return;
+					}
+
 					if (resolveContext.fileDependencies) {
 						apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, {
 							considerBuiltins: false

lib/ResolverFactory.js

@@ -125,8 +125,27 @@ function processPnpApiOption(option) {
 		option === undefined &&
 		/** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp
 	) {
-		// @ts-ignore
-		return require("pnpapi"); // eslint-disable-line node/no-missing-require
+		const _findPnpApi =
+			/** @type {function(string): PnpApi | null}} */
+			(
+				// @ts-ignore
+				require("module").findPnpApi
+			);
+
+		if (_findPnpApi) {
+			return {
+				resolveToUnqualified(request, issuer, opts) {
+					const pnpapi = _findPnpApi(issuer);
+
+					if (!pnpapi) {
+						// Issuer isn't managed by PnP
+						return null;
+					}
+
+					return pnpapi.resolveToUnqualified(request, issuer, opts);
+				}
+			};
+		}
 	}
 
 	return option || null;
@@ -305,6 +324,7 @@ exports.createResolver = function (options) {
 	resolver.ensureHook("normalResolve");
 	resolver.ensureHook("internal");
 	resolver.ensureHook("rawModule");
+	resolver.ensureHook("alternateRawModule");
 	resolver.ensureHook("module");
 	resolver.ensureHook("resolveAsModule");
 	resolver.ensureHook("undescribedResolveInPackage");
@@ -446,7 +466,20 @@ exports.createResolver = function (options) {
 					)
 				);
 				plugins.push(
-					new PnpPlugin("raw-module", pnpApi, "undescribed-resolve-in-package")
+					new PnpPlugin(
+						"raw-module",
+						pnpApi,
+						"undescribed-resolve-in-package",
+						"alternate-raw-module"
+					)
+				);
+
+				plugins.push(
+					new ModulesInHierarchicalDirectoriesPlugin(
+						"alternate-raw-module",
+						["node_modules"],
+						"module"
+					)
 				);
 			} else {
 				plugins.push(

lib/util/module-browser.js

@@ -0,0 +1,8 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+module.exports = {};

package.json

@@ -9,8 +9,8 @@
     "LICENSE"
   ],
   "browser": {
-    "pnpapi": false,
-    "process": "./lib/util/process-browser.js"
+    "process": "./lib/util/process-browser.js",
+    "module": "./lib/util/module-browser.js"
   },
   "dependencies": {
     "graceful-fs": "^4.2.4",

test/pnp.test.js

@@ -35,8 +35,11 @@ describe("pnp", () => {
 	beforeEach(() => {
 		pnpApi = /** @type {any} */ ({
 			mocks: new Map(),
+			ignoredIssuers: new Set(),
 			resolveToUnqualified(request, issuer) {
-				if (pnpApi.mocks.has(request)) {
+				if (pnpApi.ignoredIssuers.has(issuer)) {
+					return null;
+				} else if (pnpApi.mocks.has(request)) {
 					return pnpApi.mocks.get(request);
 				} else {
 					const err = /** @type {any} */ (new Error(`No way`));
@@ -250,6 +253,24 @@ describe("pnp", () => {
 			}
 		);
 	});
+	it("should fallback to alternatives when pnp doesn't manage the issuer", done => {
+		pnpApi.ignoredIssuers.add(path.resolve(__dirname, "fixtures") + "/");
+		// Add the wrong path on purpose to make sure the issuer is ignored
+		pnpApi.mocks.set("m2", path.resolve(fixture, "pkg"));
+		resolver.resolve(
+			{},
+			path.resolve(__dirname, "fixtures"),
+			"m2/b.js",
+			{},
+			(err, result) => {
+				if (err) return done(err);
+				expect(result).toEqual(
+					path.resolve(__dirname, "fixtures/node_modules/m2/b.js")
+				);
+				done();
+			}
+		);
+	});
 	it("should handle the exports field when using PnP", done => {
 		pnpApi.mocks.set("m1", path.resolve(fixture, "pkg3"));
 		resolver.resolve(

types.d.ts

@@ -289,7 +289,11 @@ type Plugin =
 	| { apply: (arg0: Resolver) => void }
 	| ((this: Resolver, arg1: Resolver) => void);
 declare interface PnpApiImpl {
-	resolveToUnqualified: (arg0: string, arg1: string, arg2: object) => string;
+	resolveToUnqualified: (
+		arg0: string,
+		arg1: string,
+		arg2: object
+	) => null | string;
 }
 declare interface PossibleFileSystemError {
 	code?: string;