WIP: exposed error? (need to remove catches, debugs, etc)

Author: JakobJingleheimer

lib/internal/modules/esm/hooks.js

@@ -66,6 +66,9 @@ const {
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
+const { writeFileSync } = require('fs');
+
+
 let importMetaInitializer;
 
 /**
@@ -125,11 +128,16 @@ class Hooks {
    */
   async register(urlOrSpecifier, parentURL, data) {
     const moduleLoader = require('internal/process/esm_loader').esmLoader;
+// debug('Hooks::register', { urlOrSpecifier, parentURL, data }, moduleLoader.import)
     const keyedExports = await moduleLoader.import(
       urlOrSpecifier,
       parentURL,
       kEmptyObject,
-    );
+    ).catch((err) => {
+      writeFileSync(1, `Hooks::register err ${err.stack}\n`);
+      throw err;
+    });
+debug('Hooks::register imported', urlOrSpecifier, keyedExports)
     return this.addCustomLoader(urlOrSpecifier, keyedExports, data);
   }
 

lib/internal/modules/esm/loader.js

@@ -20,6 +20,10 @@ const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
 let defaultResolve, defaultLoad, defaultLoadSync, importMetaInitializer;
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
+const { writeFileSync } = require('fs');
 
 function newResolveCache() {
   const { ResolveCache } = require('internal/modules/esm/module_map');
@@ -167,6 +171,7 @@ class ModuleLoader {
    */
   setCustomizations(customizations) {
     this.#customizations = customizations;
+    this.isCustomized = customizations != null;
     if (customizations) {
       this.allowImportMetaResolve = customizations.allowImportMetaResolve;
     } else {
@@ -304,9 +309,17 @@ class ModuleLoader {
    * @returns {Promise<ModuleExports>}
    */
   async import(specifier, parentURL, importAssertions) {
+writeFileSync(1, `ESMLoader::import specifier ${specifier}\n`);
     const moduleJob = await this.getModuleJob(specifier, parentURL, importAssertions);
-    const { module } = await moduleJob.run();
-    return module.getNamespace();
+writeFileSync(1, `ESMLoader::import gotModuleJob ${JSON.stringify(moduleJob)}\n`);
+    const { module } = await moduleJob.run().catch((err) => {
+      writeFileSync(1, `ESMLoader::import moduleJob.run caught error ${err.stack}\n`)
+      throw err;
+    });
+writeFileSync(1, `ESMLoader::import gotModuleJob ${JSON.stringify(module)}\n`);
+    const namespace = module.getNamespace();
+writeFileSync(1, `ESMLoader::import gotModuleJob ${JSON.stringify(namespace)}\n`);
+    return namespace;
   }
 
   /**

lib/internal/modules/esm/module_job.js

@@ -27,6 +27,10 @@ const {
 } = require('internal/source_map/source_map_cache');
 const assert = require('internal/assert');
 const resolvedPromise = PromiseResolve();
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
+const { writeFileSync } = require('fs');
 
 const noop = FunctionPrototype;
 
@@ -87,8 +91,7 @@ class ModuleJob {
         return job.modulePromise;
       });
 
-      if (promises !== undefined)
-        await SafePromiseAllReturnVoid(promises);
+      if (promises !== undefined) await SafePromiseAllReturnVoid(promises);
 
       return SafePromiseAllReturnArrayLike(dependencyJobs);
     };
@@ -111,17 +114,21 @@ class ModuleJob {
   }
 
   async _instantiate() {
+    writeFileSync(1, 'ModuleJob::instantiate()\n');
     const jobsInGraph = new SafeSet();
     const addJobsToDependencyGraph = async (moduleJob) => {
       if (jobsInGraph.has(moduleJob)) {
         return;
       }
       jobsInGraph.add(moduleJob);
+      writeFileSync(1, 'ModuleJob::instantiate() getting linked jobs\n');
       const dependencyJobs = await moduleJob.linked;
+      writeFileSync(1, 'ModuleJob::instantiate() got linked jobs\n');
       return SafePromiseAllReturnVoid(dependencyJobs, addJobsToDependencyGraph);
     };
     await addJobsToDependencyGraph(this);
 
+    writeFileSync(1, 'ModuleJob::instantiate() job added to dep graph\n');
     try {
       if (!hasPausedEntry && this.inspectBrk) {
         hasPausedEntry = true;
@@ -131,6 +138,7 @@ class ModuleJob {
         this.module.instantiate();
       }
     } catch (e) {
+      writeFileSync(1, `ModuleJob::instantiate() error: ${e.stack}\n`);
       decorateErrorStack(e);
       // TODO(@bcoe): Add source map support to exception that occurs as result
       // of missing named export. This is currently not possible because
@@ -210,12 +218,16 @@ class ModuleJob {
   }
 
   async run() {
+    writeFileSync(1, `ModuleJob::run() instantiating: ${this.url}\n`);
     await this.instantiate();
+    writeFileSync(1, `ModuleJob::run() instantiated: ${this.url}\n`);
     const timeout = -1;
     const breakOnSigint = false;
     try {
       await this.module.evaluate(timeout, breakOnSigint);
+      writeFileSync(1, `ModuleJob::run() evaluation complete: ${this.module}\n`);
     } catch (e) {
+      writeFileSync(1, `ModuleJob::run() error: ${e.stack}\n`);
       if (e?.name === 'ReferenceError' &&
           isCommonJSGlobalLikeNotDefinedError(e.message)) {
         e.message += ' in ES module scope';
@@ -237,6 +249,7 @@ class ModuleJob {
             'to use the \'.cjs\' file extension.';
         }
       }
+      writeFileSync(1, `ModuleJob::run() throwing error: ${e.stack}\n`);
       throw e;
     }
     return { __proto__: null, module: this.module };

lib/internal/modules/esm/utils.js

@@ -25,6 +25,10 @@ const {
   getModuleFromWrap,
 } = require('internal/vm/module');
 const assert = require('internal/assert');
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
+const { writeFileSync } = require('fs');
 
 const callbackMap = new SafeWeakMap();
 function setCallbackForWrap(wrap, data) {
@@ -120,12 +124,15 @@ async function initializeHooks() {
     cwd = '/';
   }
 
-
   const { Hooks } = require('internal/modules/esm/hooks');
   const esmLoader = require('internal/process/esm_loader').esmLoader;
 
   const hooks = new Hooks();
+// debug('initializeHooks hooks:', hooks);
+// debug('initializeHooks between hooks & esmLoader');
+// debug('initializeHooks esmLoader:', esmLoader);
   esmLoader.setCustomizations(hooks);
+// debug('initializeHooks customization set');
 
   // We need the loader customizations to be set _before_ we start invoking
   // `--require`, otherwise loops can happen because a `--require` script
@@ -135,15 +142,22 @@ async function initializeHooks() {
   // N.B.  This block appears here specifically in order to ensure that
   // `--require` calls occur before `--loader` ones do.
   loadPreloadModules();
+// debug('initializeHooks loaded preload modules');
   initializeFrozenIntrinsics();
+// debug('initializeHooks Frozen Intrinsics initialized');
 
   const parentURL = pathToFileURL(cwd).href;
+// debug('initializeHooks registering hooks relative to', parentURL, customLoaderURLs);
   for (let i = 0; i < customLoaderURLs.length; i++) {
     await hooks.register(
       customLoaderURLs[i],
       parentURL,
-    );
+    ).catch((err) => {
+      writeFileSync(1, `initializeHooks: Error registering hooks: ${err.message}\n${err.stack}\n`);
+      throw err;
+    });
   }
+debug('initializeHooks finished: hooks', hooks);
 
   return hooks;
 }

lib/internal/modules/esm/worker.js

@@ -31,6 +31,8 @@ const {
 } = require('internal/modules/esm/shared_constants');
 const { initializeHooks } = require('internal/modules/esm/utils');
 const { isMarkedAsUntransferable } = require('internal/buffer');
+const { writeFileSync } = require('fs');
+
 
 function transferArrayBuffer(hasError, source) {
   if (hasError || source == null) return;
@@ -99,6 +101,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     // be thrown and printed.
     hasInitializationError = true;
     initializationError = exception;
+    writeFileSync(1, `Error initializing hooks: ${exception.stack}\n`);
   }
 
   syncCommPort.on('message', handleMessage);

test/es-module/test-esm-loader-with-syntax-error.mjs

@@ -7,17 +7,20 @@ import { describe, it } from 'node:test';
 
 describe('ESM: loader with syntax error', { concurrency: true }, () => {
   it('should crash the node process', async () => {
-    const { code, stderr } = await spawnPromisified(execPath, [
+    const { code, stderr, stdout } = await spawnPromisified(execPath, [
       '--no-warnings',
       '--experimental-loader',
       fileURL('es-module-loaders', 'syntax-error.mjs').href,
       path('print-error-message.js'),
     ]);
 
-    console.log(stderr);
+    console.log('\n\nstderr', stderr);
+    console.log('\n\nstdout', stdout);
 
-    match(stderr, /SyntaxError \[Error\]:/);
-    doesNotMatch(stderr, /Bad command or file name/);
-    notStrictEqual(code, 0);
+    match('foo', /bar/);
+
+    // match(stderr, /SyntaxError \[Error\]:/);
+    // doesNotMatch(stderr, /Bad command or file name/); // It should have crashed before this.
+    // notStrictEqual(code, 0);
   });
 });