module: support module.registerHooks() in ESM

Author: joyeecheung

lib/internal/modules/esm/loader.js

@@ -42,6 +42,12 @@ const { ModuleWrap, kEvaluating, kEvaluated } = internalBinding('module_wrap');
 const {
   urlToFilename,
 } = require('internal/modules/helpers');
+const {
+  resolveHooks,
+  resolveWithHooks,
+  loadHooks,
+  loadWithHooks,
+} = require('internal/modules/sync_hooks');
 let defaultResolve, defaultLoad, defaultLoadSync, importMetaInitializer;
 
 const { tracingChannel } = require('diagnostics_channel');
@@ -137,7 +143,7 @@ class ModuleLoader {
 
   /**
    * Customizations to pass requests to.
-   *
+   * @type {import('./hooks.js').Hooks}
    * Note that this value _MUST_ be set with `setCustomizations`
    * because it needs to copy `customizations.allowImportMetaResolve`
    *  to this property and failure to do so will cause undefined
@@ -580,6 +586,10 @@ class ModuleLoader {
    */
   resolve(specifier, parentURL, importAttributes) {
     specifier = `${specifier}`;
+    if (resolveHooks.length) {
+      // Has module.registerHooks() hooks, use the synchronous variant that can handle both hooks.
+      return this.resolveSync(specifier, parentURL, importAttributes);
+    }
     if (this.#customizations) {  // Only has module.register hooks.
       return this.#customizations.resolve(specifier, parentURL, importAttributes);
     }
@@ -606,7 +616,7 @@ class ModuleLoader {
   }
 
   /**
-   * This is the default resolve step for future synchronous hooks, which incorporates asynchronous hooks
+   * This is the default resolve step for module.registerHooks(), which incorporates asynchronous hooks
    * from module.register() which are run in a blocking fashion for it to be synchronous.
    * @param {string|URL} specifier See {@link resolveSync}.
    * @param {{ parentURL?: string, importAttributes: ImportAttributes}} context See {@link resolveSync}.
@@ -624,7 +634,7 @@ class ModuleLoader {
    * asynchronous resolve hooks from module.register(), it will block until the results are returned
    * from the loader thread for this to be synchornous.
    * This is here to support `import.meta.resolve()`, `require()` in imported CJS, and
-   * future synchronous hooks.
+   * `module.registerHooks()` hooks.
    *
    * TODO(joyeecheung): consolidate the cache behavior and use this in require(esm).
    * @param {string|URL} specifier See {@link resolve}.
@@ -633,7 +643,13 @@ class ModuleLoader {
    * @returns {{ format: string, url: string }}
    */
   resolveSync(specifier, parentURL, importAttributes = { __proto__: null }) {
-    return this.#resolveAndMaybeBlockOnLoaderThread(`${specifier}`, { parentURL, importAttributes });
+    specifier = `${specifier}`;
+    if (resolveHooks.length) {
+      // Has module.registerHooks() hooks, chain the asynchronous hooks in the default step.
+      return resolveWithHooks(specifier, parentURL, importAttributes, this.#defaultConditions,
+                              this.#resolveAndMaybeBlockOnLoaderThread.bind(this));
+    }
+    return this.#resolveAndMaybeBlockOnLoaderThread(specifier, { parentURL, importAttributes });
   }
 
   /**
@@ -662,6 +678,10 @@ class ModuleLoader {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   async load(url, context) {
+    if (loadHooks.length) {
+      // Has module.registerHooks() hooks, use the synchronous variant that can handle both hooks.
+      return this.#loadSync(url, context);
+    }
     if (this.#customizations) {
       return this.#customizations.load(url, context);
     }
@@ -671,7 +691,7 @@ class ModuleLoader {
   }
 
   /**
-   * This is the default load step for future synchronous hooks, which incorporates asynchronous hooks
+   * This is the default load step for module.registerHooks(), which incorporates asynchronous hooks
    * from module.register() which are run in a blocking fashion for it to be synchronous.
    * @param {string} url See {@link load}
    * @param {object} context See {@link load}
@@ -689,14 +709,21 @@ class ModuleLoader {
    * Similar to {@link load} but this is always run synchronously. If there are asynchronous hooks
    * from module.register(), this blocks on the loader thread for it to return synchronously.
    *
-   * This is here to support `require()` in imported CJS and future synchronous hooks.
+   * This is here to support `require()` in imported CJS and `module.registerHooks()` hooks.
    *
    * TODO(joyeecheung): consolidate the cache behavior and use this in require(esm).
    * @param {string} url See {@link load}
    * @param {object} [context] See {@link load}
    * @returns {{ format: ModuleFormat, source: ModuleSource }}
    */
   #loadSync(url, context) {
+    if (loadHooks.length) {
+      // Has module.registerHooks() hooks, chain the asynchronous hooks in the default step.
+      // TODO(joyeecheung): construct the ModuleLoadContext in the loaders directly instead
+      // of converting them from plain objects in the hooks.
+      return loadWithHooks(url, context.format, context.importAttributes, this.#defaultConditions,
+                           this.#loadAndMaybeBlockOnLoaderThread.bind(this));
+    }
     return this.#loadAndMaybeBlockOnLoaderThread(url, context);
   }
 

test/parallel/test-module-hooks-load-esm.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// This tests a pirates-like load hook works.
+
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const { readFileSync } = require('fs');
+
+const loader = require('../fixtures/es-modules/module-hooks/load-from-this-dir');
+const { addHook } = require('../fixtures/es-modules/module-hooks/add-hook');
+
+const matcherArgs = [];
+function matcher(filename) {
+  matcherArgs.push(filename);
+  return true;
+}
+
+const hookArgs = [];
+function hook(code, filename) {
+  hookArgs.push({ code, filename });
+  return code.replace('$key', 'hello');
+}
+
+(async () => {
+  const revert = addHook(hook, { exts: ['.js'], matcher });
+
+  {
+    const foo = await loader.import('foo-esm');
+    const filename = fixtures.path('es-modules', 'module-hooks', 'node_modules', 'foo-esm', 'foo-esm.js');
+    assert.deepStrictEqual(matcherArgs, [filename]);
+    const code = readFileSync(filename, 'utf-8');
+    assert.deepStrictEqual(hookArgs, [{ code, filename }]);
+    assert.deepStrictEqual({ ...foo }, { hello: 'foo-esm' });
+  }
+
+  matcherArgs.splice(0, 1);
+  hookArgs.splice(0, 1);
+
+  revert();
+
+  // Later loads are unaffected.
+
+  {
+    const bar = await loader.import('bar-esm');
+    assert.deepStrictEqual(matcherArgs, []);
+    assert.deepStrictEqual(hookArgs, []);
+    assert.deepStrictEqual({ ...bar }, { $key: 'bar-esm' });
+  }
+
+})().catch(common.mustNotCall());