esm: remove CLI flag limitation to programmatic registration

lib/internal/errors.js

@@ -1036,11 +1036,6 @@ E('ERR_ENCODING_INVALID_ENCODED_DATA', function(encoding, ret) {
 }, TypeError);
 E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported',
   RangeError);
-E('ERR_ESM_LOADER_REGISTRATION_UNAVAILABLE', 'Programmatically registering custom ESM loaders ' +
-  'currently requires at least one custom loader to have been registered via the --experimental-loader ' +
-  'flag. A no-op loader registered via CLI is sufficient (for example: `--experimental-loader ' +
-  '"data:text/javascript,"` with the necessary trailing comma). A future version of Node.js ' +
-  'will remove this requirement.', Error);
 E('ERR_EVAL_ESM_CANNOT_PRINT', '--print cannot be used with ESM input', Error);
 E('ERR_EVENT_RECURSION', 'The event "%s" is already being dispatched', Error);
 E('ERR_FALSY_VALUE_REJECTION', function(reason) {

lib/internal/modules/esm/initialize_import_meta.js

@@ -2,19 +2,26 @@
 
 const { getOptionValue } = require('internal/options');
 const experimentalImportMetaResolve = getOptionValue('--experimental-import-meta-resolve');
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
 
 /**
  * Generate a function to be used as import.meta.resolve for a particular module.
  * @param {string} defaultParentUrl The default base to use for resolution
- * @param {typeof import('./loader.js').ModuleLoader} loader Reference to the current module loader
  * @returns {(specifier: string, parentUrl?: string) => string} Function to assign to import.meta.resolve
  */
-function createImportMetaResolve(defaultParentUrl, loader) {
+function createImportMetaResolve(defaultParentUrl) {
+  debug('createImportMetaResolve(): %o', { defaultParentUrl });
+
   return function resolve(specifier, parentUrl = defaultParentUrl) {
+    const moduleLoader = require('internal/process/esm_loader').esmLoader;
     let url;
 
+    debug('import.meta.resolve(%o) %s', { specifier, parentUrl }, moduleLoader.constructor.name);
+
     try {
-      ({ url } = loader.resolve(specifier, parentUrl));
+      ({ url } = moduleLoader.resolve(specifier, parentUrl));
     } catch (error) {
       if (error?.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
         ({ url } = error);
@@ -31,15 +38,14 @@ function createImportMetaResolve(defaultParentUrl, loader) {
  * Create the `import.meta` object for a module.
  * @param {object} meta
  * @param {{url: string}} context
- * @param {typeof import('./loader.js').ModuleLoader} loader Reference to the current module loader
  * @returns {{url: string, resolve?: Function}}
  */
-function initializeImportMeta(meta, context, loader) {
-  const { url } = context;
+function initializeImportMeta(meta, { url }) {
+  debug('initializeImportMeta for %s', url);
 
   // Alphabetical
-  if (experimentalImportMetaResolve && loader.loaderType !== 'internal') {
-    meta.resolve = createImportMetaResolve(url, loader);
+  if (experimentalImportMetaResolve) {
+    meta.resolve = createImportMetaResolve(url);
   }
 
   meta.url = url;

lib/internal/modules/esm/loader.js

@@ -11,16 +11,19 @@ const {
 } = primordials;
 
 const {
-  ERR_ESM_LOADER_REGISTRATION_UNAVAILABLE,
   ERR_UNKNOWN_MODULE_FORMAT,
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
 const { pathToFileURL } = require('internal/url');
-const { emitExperimentalWarning } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
-let defaultResolve, defaultLoad, importMetaInitializer;
+let defaultResolve;
+let defaultLoad;
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
 
 function newModuleMap() {
   const ModuleMap = require('internal/modules/esm/module_map');
@@ -99,22 +102,10 @@ class DefaultModuleLoader {
     source,
     url = pathToFileURL(`${process.cwd()}/[eval${++this.evalIndex}]`).href,
   ) {
-    const evalInstance = (url) => {
-      const { ModuleWrap } = internalBinding('module_wrap');
-      const { setCallbackForWrap } = require('internal/modules/esm/utils');
-      const module = new ModuleWrap(url, undefined, source, 0, 0);
-      setCallbackForWrap(module, {
-        initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
-        importModuleDynamically: (specifier, { url }, importAssertions) => {
-          return this.import(specifier, url, importAssertions);
-        },
-      });
-
-      return module;
-    };
+    const { ModuleWrap } = internalBinding('module_wrap');
+    const moduleWrapper = new ModuleWrap(url, undefined, source, 0, 0);
     const ModuleJob = require('internal/modules/esm/module_job');
-    const job = new ModuleJob(
-      this, url, undefined, evalInstance, false, false);
+    const job = new ModuleJob(url, moduleWrapper, undefined, false, false);
     this.moduleMap.set(url, undefined, job);
     const { module } = await job.run();
 
@@ -142,55 +133,35 @@ class DefaultModuleLoader {
     return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
   }
 
-  getJobFromResolveResult(resolveResult, parentURL, importAssertions) {
+  getJobFromResolveResult(
+    resolveResult,
+    parentURL,
+    importAssertions = resolveResult.importAssertions,
+  ) {
     const { url, format } = resolveResult;
-    const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
-
-    let job = this.moduleMap.get(url, resolvedImportAssertions.type);
+debug('getJobFromResolveResult:', { [url]: { format, moduleMap: this.moduleMap } });
+    let job = this.moduleMap.get(url, importAssertions.type);
 
     // CommonJS will set functions for lazy job evaluation.
     if (typeof job === 'function') {
       this.moduleMap.set(url, undefined, job = job());
     }
 
-    if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
-    }
+    job ??= this.#createModuleJob(url, parentURL, importAssertions, format);
 
     return job;
   }
 
   /**
    * Create and cache an object representing a loaded module.
    * @param {string} url The absolute URL that was resolved for this module
-   * @param {Record<string, string>} importAssertions Validations for the
-   *                                                  module import.
-   * @param {string} [parentURL] The absolute URL of the module importing this
-   *                             one, unless this is the Node.js entry point
-   * @param {string} [format] The format hint possibly returned by the
-   *                          `resolve` hook
+   * @param {string} [parentURL] The absolute URL of the module importing this one, unless this is
+   *                             the Node.js entry point
+   * @param {Record<string, string>} importAssertions Validations for the module import.
+   * @param {string} [format] The format hint possibly returned by the `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAssertions, parentURL, format) {
-    const moduleProvider = async (url, isMain) => {
-      const {
-        format: finalFormat,
-        responseURL,
-        source,
-      } = await this.load(url, {
-        format,
-        importAssertions,
-      });
-
-      const translator = getTranslators().get(finalFormat);
-
-      if (!translator) {
-        throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
-      }
-
-      return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
-    };
-
+  async #createModuleJob(url, parentURL, importAssertions, format) {
     const inspectBrk = (
       parentURL === undefined &&
       getOptionValue('--inspect-brk')
@@ -200,13 +171,31 @@ class DefaultModuleLoader {
       process.send({ 'watch:import': [url] });
     }
 
+    const {
+      format: finalFormat,
+      responseURL,
+      source,
+    } = await this.load(url, {
+      format,
+      importAssertions,
+    });
+
+    const translator = getTranslators().get(finalFormat);
+
+    if (!translator) {
+      throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
+    }
+
+    const isMain = parentURL === undefined;
+    debug('#createModuleJob', { url, finalFormat, responseURL, source });
+    const moduleWrapper = FunctionPrototypeCall(translator, this, responseURL, source, isMain);
+
     const ModuleJob = require('internal/modules/esm/module_job');
     const job = new ModuleJob(
-      this,
-      url,
+      responseURL,
+      moduleWrapper,
       importAssertions,
-      moduleProvider,
-      parentURL === undefined,
+      isMain,
       inspectBrk,
     );
 
@@ -224,8 +213,8 @@ class DefaultModuleLoader {
    *                                                  module import.
    * @returns {Promise<ModuleExports>}
    */
-  async import(specifier, parentURL, importAssertions) {
-    const moduleJob = this.getModuleJob(specifier, parentURL, importAssertions);
+  async import(specifier, parentURL = undefined, importAssertions = { __proto__: null }) {
+    const moduleJob = await this.getModuleJob(specifier, parentURL, importAssertions);
     const { module } = await moduleJob.run();
     return module.getNamespace();
   }
@@ -271,12 +260,6 @@ class DefaultModuleLoader {
       require('internal/modules/esm/load').throwUnknownModuleFormat(url, format);
     }
   }
-
-  importMetaInitialize(meta, context) {
-    importMetaInitializer ??= require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-    meta = importMetaInitializer(meta, context, this);
-    return meta;
-  }
 }
 ObjectSetPrototypeOf(DefaultModuleLoader.prototype, null);
 
@@ -285,10 +268,21 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
   /**
    * Instantiate a module loader that uses user-provided custom loader hooks.
    */
-  constructor() {
+  constructor({
+    cjsCache,
+    evalIndex,
+    moduleMap,
+  } = kEmptyObject) {
     super();
 
-    getHooksProxy();
+    if (cjsCache != null) { this.cjsCache = cjsCache; }
+    if (evalIndex != null) { this.evalIndex = evalIndex; }
+    if (moduleMap != null) { this.moduleMap = moduleMap; }
+
+    if (!hooksProxy) {
+      const { HooksProxy } = require('internal/modules/esm/hooks');
+      hooksProxy = new HooksProxy();
+    }
   }
 
   /**
@@ -318,12 +312,12 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
 
   async #getModuleJob(specifier, parentURL, importAssertions) {
     const resolveResult = await hooksProxy.makeAsyncRequest('resolve', specifier, parentURL, importAssertions);
-
+debug('#getModuleJob', { [specifier]: resolveResult })
     return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
   }
   getModuleJob(specifier, parentURL, importAssertions) {
     const jobPromise = this.#getModuleJob(specifier, parentURL, importAssertions);
-
+debug('getModuleJob', { [specifier]: jobPromise })
     return {
       run() {
         return PromisePrototypeThen(jobPromise, (job) => job.run());
@@ -357,40 +351,29 @@ let emittedExperimentalWarning = false;
  * A loader instance is used as the main entry point for loading ES modules. Currently, this is a singleton; there is
  * only one used for loading the main module and everything in its dependency graph, though separate instances of this
  * class might be instantiated as part of bootstrap for other purposes.
- * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
+ * @param {boolean} forceCustomizedLoaderInMain Ignore whether custom loader(s) have been provided
+ * via CLI and instantiate a CustomizedModuleLoader instance regardless.
  * @returns {DefaultModuleLoader | CustomizedModuleLoader}
  */
-function createModuleLoader(useCustomLoadersIfPresent = true) {
-  if (useCustomLoadersIfPresent &&
-      // Don't spawn a new worker if we're already in a worker thread created by instantiating CustomizedModuleLoader;
-      // doing so would cause an infinite loop.
-      !require('internal/modules/esm/utils').isLoaderWorker()) {
-    const userLoaderPaths = getOptionValue('--experimental-loader');
-    if (userLoaderPaths.length > 0) {
+function createModuleLoader(customizationSetup) {
+  // Don't spawn a new worker if we're already in a worker thread (doing so would cause an infinite loop).
+  if (!require('internal/modules/esm/utils').isLoaderWorker()) {
+    if (
+      customizationSetup ||
+      getOptionValue('--experimental-loader').length > 0
+    ) {
       if (!emittedExperimentalWarning) {
         emitExperimentalWarning('Custom ESM Loaders');
         emittedExperimentalWarning = true;
       }
-      return new CustomizedModuleLoader();
+      debug('instantiating CustomizedModuleLoader');
+      return new CustomizedModuleLoader(customizationSetup);
     }
   }
 
   return new DefaultModuleLoader();
 }
 
-/**
- * Get the HooksProxy instance. If it is not defined, then create a new one.
- * @returns {HooksProxy}
- */
-function getHooksProxy() {
-  if (!hooksProxy) {
-    const { HooksProxy } = require('internal/modules/esm/hooks');
-    hooksProxy = new HooksProxy();
-  }
-
-  return hooksProxy;
-}
-
 /**
  * Register a single loader programmatically.
  * @param {string} specifier
@@ -405,19 +388,19 @@ function getHooksProxy() {
  * ```
  */
 function register(specifier, parentURL = 'data:') {
-  // TODO: Remove this limitation in a follow-up before `register` is released publicly
-  if (getOptionValue('--experimental-loader').length < 1) {
-    throw new ERR_ESM_LOADER_REGISTRATION_UNAVAILABLE();
-  }
+  let moduleLoader = require('internal/process/esm_loader').esmLoader;
 
-  const moduleLoader = require('internal/process/esm_loader').esmLoader;
+  if (!(moduleLoader instanceof CustomizedModuleLoader)) {
+    debug('register called on DefaultModuleLoader; switching to CustomizedModuleLoader');
+    moduleLoader = createModuleLoader(moduleLoader);
+    require('internal/process/esm_loader').esmLoader = moduleLoader;
+  }
 
   moduleLoader.register(`${specifier}`, parentURL);
 }
 
 module.exports = {
   DefaultModuleLoader,
   createModuleLoader,
-  getHooksProxy,
   register,
 };