esm: remove CLI flag limitation to programmatic registration

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

@@ -19,7 +19,8 @@ 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;
 });
@@ -138,7 +139,7 @@ class DefaultModuleLoader {
     importAssertions = resolveResult.importAssertions,
   ) {
     const { url, format } = resolveResult;
-debug('getModuleJob', { url, format, parentURL, importAssertions, moduleMap: this.moduleMap });
+debug('getJobFromResolveResult:', { [url]: { format, moduleMap: this.moduleMap } });
     let job = this.moduleMap.get(url, importAssertions.type);
 
     // CommonJS will set functions for lazy job evaluation.
@@ -186,11 +187,12 @@ debug('getModuleJob', { url, format, parentURL, importAssertions, moduleMap: thi
     }
 
     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(
-      url,
+      responseURL,
       moduleWrapper,
       importAssertions,
       isMain,
@@ -258,12 +260,6 @@ debug('getModuleJob', { url, format, parentURL, importAssertions, moduleMap: thi
       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);
 
@@ -316,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());

lib/internal/modules/esm/module_job.js

@@ -19,7 +19,6 @@ const {
 } = primordials;
 
 const { ModuleWrap } = internalBinding('module_wrap');
-const { setCallbackForWrap } = require('internal/modules/esm/utils');
 
 const { decorateErrorStack } = require('internal/util');
 const {
@@ -60,6 +59,14 @@ class ModuleJob {
 
   module;
 
+  /**
+   *
+   * @param {URL['href']} url The resolved url of the module.
+   * @param {ModuleWrap} moduleWrapper
+   * @param {*} importAssertions
+   * @param {boolean} isMain Whether this is the main module.
+   * @param {boolean} inspectBrk Whether to invoke the inspector and break on start.
+   */
   constructor(
     url,
     moduleWrapper,
@@ -74,18 +81,6 @@ class ModuleJob {
 
     debug('ModuleJob::constructor(%o)', { url, importAssertions, isMain, inspectBrk });
 
-    // Expose the promise to the ModuleWrap directly for linking below.
-    // `this.module` is also filled in below.
-
-    setCallbackForWrap(this.modulePromise, {
-      initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
-      importModuleDynamically: (specifier, { url }, importAssertions) => {
-        const moduleLoader = require('internal/process/esm_loader').esmLoader;
-        debug('ModuleJob::importModuleDynamically(%o)', { specifier, url, moduleLoader });
-        return moduleLoader.import(specifier, url, importAssertions);
-      },
-    });
-
     // Wait for the ModuleWrap instance being linked with all dependencies.
     const link = async () => {
       this.module = await this.modulePromise;
@@ -98,11 +93,11 @@ class ModuleJob {
       // these `link` callbacks depending on each other.
       const dependencyJobs = [];
       debug('this.module.link: %o', { [url]: this.module.link.toString() });
-      const promises = this.module.link((specifier, assertions) => {
+      const promises = this.module.link(async (specifier, assertions) => {
         debug('this.module.link(%o)', { specifier, assertions });
         const moduleLoader = require('internal/process/esm_loader').esmLoader;
         debug('this.module.link() moduleLoader: %s', moduleLoader.constructor.name);
-        const job = moduleLoader.getModuleJob(specifier, url, assertions);
+        const job = await moduleLoader.getModuleJob(specifier, url, assertions);
         debug('this.module.link() job: %o', job);
         ArrayPrototypePush(dependencyJobs, job);
         return job.modulePromise;
@@ -152,8 +147,7 @@ class ModuleJob {
       // stack trace originates in module_job, not the file itself. A hidden
       // symbol with filename could be set in node_errors.cc to facilitate this.
       if (!getSourceMapsEnabled() &&
-          StringPrototypeIncludes(e.message,
-                                  ' does not provide an export named')) {
+          StringPrototypeIncludes(e.message, ' does not provide an export named')) {
         const splitStack = StringPrototypeSplit(e.stack, '\n');
         const parentFileUrl = RegExpPrototypeSymbolReplace(
           /:\d+$/,
@@ -162,11 +156,10 @@ class ModuleJob {
         );
         const { 1: childSpecifier, 2: name } = RegExpPrototypeExec(
           /module '(.*)' does not provide an export named '(.+)'/,
-          e.message);
-          const moduleLoader = require('internal/process/esm_loader').esmLoader;
-        const { url: childFileURL } = await moduleLoader.resolve(
-          childSpecifier, parentFileUrl,
+          e.message,
         );
+        const moduleLoader = require('internal/process/esm_loader').esmLoader;
+        const { url: childFileURL } = await moduleLoader.resolve(childSpecifier, parentFileUrl);
         let format;
         try {
           // This might throw for non-CommonJS modules because we aren't passing

lib/internal/modules/esm/translators.js

@@ -103,13 +103,27 @@ function errPath(url) {
   return url;
 }
 
+let importMetaInitializer;
+
 // Strategy for loading a standard JavaScript module.
 translators.set('module', async function moduleStrategy(url, source, isMain) {
   assertBufferSource(source, true, 'load');
   source = stringify(source);
   maybeCacheSourceMap(url, source);
-  debug(`Translating StandardModule ${url}`);
+  debug(`Translating ESModule ${url}`);
   const module = new ModuleWrap(url, undefined, source, 0, 0);
+  const { setCallbackForWrap } = require('internal/modules/esm/utils');
+  setCallbackForWrap(module, {
+    initializeImportMeta(meta, wrap) {
+      importMetaInitializer ??= require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
+      importMetaInitializer(meta, { url });
+    },
+    importModuleDynamically(specifier, { url }, importAssertions) {
+      const moduleLoader = require('internal/process/esm_loader').esmLoader;
+      debug('Translator("module")::importModuleDynamically(%o)', { specifier, url, moduleLoader });
+      return moduleLoader.import(specifier, url, importAssertions);
+    },
+  });
   return module;
 });
 
@@ -133,8 +147,7 @@ function enrichCJSError(err, content, filename) {
 
 // Strategy for loading a node-style CommonJS module
 const isWindows = process.platform === 'win32';
-translators.set('commonjs', async function commonjsStrategy(url, source,
-                                                            isMain) {
+translators.set('commonjs', async function commonjsStrategy(url, source, isMain) {
   debug(`Translating CJSModule ${url}`);
 
   const filename = fileURLToPath(new URL(url));