fixup! module: add clearCache for CJS and ESM

Author: anonrig

lib/internal/modules/cjs/loader.js

@@ -122,7 +122,6 @@ module.exports = {
   initializeCJS,
   Module,
   clearCJSResolutionCaches,
-  relativeResolveCache,
   findLongestRegisteredExtension,
   resolveForCJSWithHooks,
   loadSourceForCJSWithHooks: loadSource,

lib/internal/modules/clear.js

@@ -14,7 +14,6 @@ const {
   Module,
   resolveForCJSWithHooks,
   clearCJSResolutionCaches,
-  relativeResolveCache,
 } = require('internal/modules/cjs/loader');
 const { fileURLToPath, isURL, URLParse, pathToFileURL } = require('internal/url');
 const { emitExperimentalWarning, kEmptyObject, isWindows } = require('internal/util');
@@ -76,20 +75,37 @@ function createParentModuleForClearCache(parentPath) {
 /**
  * Resolve a cache filename for CommonJS.
  * Always goes through resolveForCJSWithHooks so that registered hooks
- * are respected. CJS operates on file paths and bare specifiers; URL
- * objects are not valid require() arguments so they are not supported.
- * @param {string} specifier
+ * are respected. CJS operates on file paths and bare specifiers. file:
+ * URL objects or strings are converted to paths; non-file URLs are not
+ * supported and will return null.
+ * @param {string|URL} specifier
  * @param {string|undefined} parentPath
  * @returns {string|null}
  */
 function resolveClearCacheFilename(specifier, parentPath) {
-  if (!parentPath && typeof specifier === 'string' && isRelative(specifier)) {
+  let request;
+  if (isURL(specifier)) {
+    if (specifier.protocol !== 'file:') {
+      return null;
+    }
+    request = fileURLToPath(specifier);
+  } else if (typeof specifier === 'string' && StringPrototypeStartsWith(specifier, 'file:')) {
+    const parsed = URLParse(specifier);
+    if (!parsed || parsed.protocol !== 'file:') {
+      return null;
+    }
+    request = fileURLToPath(parsed);
+  } else {
+    request = specifier;
+  }
+
+  if (!parentPath && isRelative(request)) {
     return null;
   }
 
   const parent = parentPath ? createParentModuleForClearCache(parentPath) : null;
   try {
-    const { filename, format } = resolveForCJSWithHooks(specifier, parent, false, false);
+    const { filename, format } = resolveForCJSWithHooks(request, parent, false, false);
     if (format === 'builtin') {
       return null;
     }
@@ -284,10 +300,11 @@ function clearCache(specifier, options) {
     }
 
     // CJS has relativeResolveCache and Module._pathCache that map
-    // specifiers to filenames. Only clear the exact entry for this request.
-    if (resolver === 'require') {
-      const request = isSpecifierURL ? specifier.href : specifier;
-      delete relativeResolveCache[`${parentPath}\x00${request}`];
+    // specifiers to filenames. Clear all entries pointing to the resolved
+    // file. Module._pathCache keys are not easily reconstructable so a
+    // value-scan is required.
+    if (resolver === 'require' && resolvedFilename) {
+      clearCJSResolutionCaches(resolvedFilename);
     }
 
     if (resolvedFilename) {