fixup! module: add clearCache for CJS and ESM

Author: anonrig

doc/api/module.md

@@ -89,6 +89,7 @@ Clears the CommonJS `require` cache and/or the ESM module cache for a module. Th
 reload patterns similar to deleting from `require.cache` in CommonJS, and is useful for HMR.
 When `mode` is `'all'`, resolution failures for one module system do not throw; check the
 returned flags to see what was cleared.
+This also clears internal resolution caches for the resolved module.
 
 ```mjs
 import { clearCache } from 'node:module';

lib/internal/modules/cjs/loader.js

@@ -2162,6 +2162,43 @@ function resolveClearCacheURL(specifier, parentURL, importAttributes) {
   return cascadedLoader.resolveSync(parentURL, request).url;
 }
 
+/**
+ * Remove path cache entries that resolve to a filename.
+ * @param {string} filename
+ * @returns {boolean} true if any entries were deleted.
+ */
+function deletePathCacheEntries(filename) {
+  const cache = Module._pathCache;
+  const keys = ObjectKeys(cache);
+  let deleted = false;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (cache[key] === filename) {
+      delete cache[key];
+      deleted = true;
+    }
+  }
+  return deleted;
+}
+
+/**
+ * Remove relative resolve cache entries that resolve to a filename.
+ * @param {string} filename
+ * @returns {boolean} true if any entries were deleted.
+ */
+function deleteRelativeResolveCacheEntries(filename) {
+  const keys = ObjectKeys(relativeResolveCache);
+  let deleted = false;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (relativeResolveCache[key] === filename) {
+      delete relativeResolveCache[key];
+      deleted = true;
+    }
+  }
+  return deleted;
+}
+
 /**
  * Clear CommonJS and/or ESM module cache entries.
  * @param {string|URL} specifier
@@ -2201,9 +2238,19 @@ function clearCache(specifier, options = kEmptyObject) {
   if (mode !== 'esm') {
     try {
       const filename = resolveClearCacheFilename(specifier, parentPath);
-      if (filename && Module._cache[filename] !== undefined) {
-        delete Module._cache[filename];
-        result.cjs = true;
+      if (filename) {
+        let deleted = false;
+        if (Module._cache[filename] !== undefined) {
+          delete Module._cache[filename];
+          deleted = true;
+        }
+        if (deletePathCacheEntries(filename)) {
+          deleted = true;
+        }
+        if (deleteRelativeResolveCacheEntries(filename)) {
+          deleted = true;
+        }
+        result.cjs = deleted;
       }
     } catch (err) {
       if (mode === 'cjs') {
@@ -2217,7 +2264,9 @@ function clearCache(specifier, options = kEmptyObject) {
       const url = resolveClearCacheURL(specifier, parentURL, importAttributes);
       const cascadedLoader =
         require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
-      result.esm = cascadedLoader.loadCache.deleteAll(url);
+      const loadDeleted = cascadedLoader.loadCache.deleteAll(url);
+      const resolveDeleted = cascadedLoader.deleteResolveCache(url);
+      result.esm = loadDeleted || resolveDeleted;
     } catch (err) {
       if (mode === 'esm') {
         throw err;

lib/internal/modules/esm/loader.js

@@ -169,6 +169,15 @@ class ModuleLoader {
    */
   loadCache = newLoadCache();
 
+  /**
+   * Delete cached resolutions that resolve to a URL.
+   * @param {string} url
+   * @returns {boolean} true if any entries were deleted.
+   */
+  deleteResolveCache(url) {
+    return this.#resolveCache.deleteByResolvedURL(url);
+  }
+
   /**
    * @see {AsyncLoaderHooks.isForAsyncLoaderHookWorker}
    * Shortcut to this.#asyncLoaderHooks.isForAsyncLoaderHookWorker.

lib/internal/modules/esm/module_map.js

@@ -85,6 +85,31 @@ class ResolveCache extends SafeMap {
   has(serializedKey, parentURL) {
     return serializedKey in this.#getModuleCachedImports(parentURL);
   }
+
+  /**
+   * Delete cached resolutions that resolve to a URL.
+   * @param {string} url
+   * @returns {boolean} true if any entries were deleted.
+   */
+  deleteByResolvedURL(url) {
+    validateString(url, 'url');
+    let deleted = false;
+    for (const [parentURL, entries] of this) {
+      const keys = ObjectKeys(entries);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (entries[key]?.url === url) {
+          delete entries[key];
+          deleted = true;
+        }
+      }
+
+      if (ObjectKeys(entries).length === 0) {
+        super.delete(parentURL);
+      }
+    }
+    return deleted;
+  }
 }
 
 /**

test/es-module/test-module-clear-cache.mjs

@@ -19,4 +19,16 @@ assert.strictEqual(result.esm, true);
 const third = await import(specifier);
 assert.strictEqual(third.count, 2);
 
+const nested = new URL('../fixtures/module-cache/esm-nested-a.mjs', import.meta.url);
+const nestedFirst = await import(`${nested.href}?v=1`);
+assert.strictEqual(nestedFirst.value, 1);
+
+const nestedResult = clearCache(new URL('../fixtures/module-cache/esm-nested-b.mjs', import.meta.url));
+assert.strictEqual(nestedResult.cjs, false);
+assert.strictEqual(nestedResult.esm, true);
+
+const nestedSecond = await import(`${nested.href}?v=2`);
+assert.strictEqual(nestedSecond.value, 2);
+
 delete globalThis.__module_cache_esm_counter;
+delete globalThis.__module_cache_esm_nested_c_counter;

test/fixtures/module-cache/esm-nested-a.mjs

@@ -0,0 +1,3 @@
+import { value } from './esm-nested-b.mjs';
+
+export { value };

test/fixtures/module-cache/esm-nested-b.mjs

@@ -0,0 +1,3 @@
+import { count } from './esm-nested-c.mjs';
+
+export const value = count;

test/fixtures/module-cache/esm-nested-c.mjs

@@ -0,0 +1,4 @@
+globalThis.__module_cache_esm_nested_c_counter =
+  (globalThis.__module_cache_esm_nested_c_counter ?? 0) + 1;
+
+export const count = globalThis.__module_cache_esm_nested_c_counter;