loader: TSError that survives thread comms channel

When an error is thrown in the loader thread, it must be passed through
the comms channel to be printed in the main thread.

Node has some heuristics to try to reconstitute errors properly, but
they don't function very well if the error has a custom inspect method,
or properties that are not compatible with JSON.stringify, so the
TSErrors raised by the source transforms don't get printed in any sort
of useful way.

This catches those errors, and creates a new error that can go through
the comms channel intact.

Another possible approach would be to update the shape of the errors
raised by source transforms, but that would be a much more extensive
change with further reaching consequences.

Author: isaacs

src/esm.ts

@@ -1,4 +1,4 @@
-import { register, RegisterOptions, Service } from './index';
+import { register, RegisterOptions, Service, type TSError } from './index';
 import { parse as parseUrl, format as formatUrl, UrlWithStringQuery, fileURLToPath, pathToFileURL } from 'url';
 import { extname, resolve as pathResolve } from 'path';
 import * as assert from 'assert';
@@ -223,7 +223,7 @@ export function createEsmHooks(tsNodeService: Service) {
     format: NodeLoaderHooksFormat;
     source: string | Buffer | undefined;
   }> {
-    return addShortCircuitFlag(async () => {
+    return await addShortCircuitFlag(async () => {
       // If we get a format hint from resolve() on the context then use it
       // otherwise call the old getFormat() hook using node's old built-in defaultGetFormat() that ships with ts-node
       const format =
@@ -251,8 +251,23 @@ export function createEsmHooks(tsNodeService: Service) {
         });
 
         // Call the old hook
-        const { source: transformedSource } = await transformSource(rawSource, { url, format }, defaultTransformSource);
-        source = transformedSource;
+        try {
+          const { source: transformedSource } = await transformSource(
+            rawSource,
+            { url, format },
+            defaultTransformSource
+          );
+          source = transformedSource;
+        } catch (er) {
+          // throw an error that can make it through the loader thread
+          // comms channel intact.
+          const tsErr = er as TSError;
+          const err = new Error(tsErr.message.trimEnd());
+          const { diagnosticCodes } = tsErr;
+          Object.assign(err, { diagnosticCodes });
+          Error.captureStackTrace(err, load);
+          throw err;
+        }
       }
 
       return { format, source };
@@ -360,11 +375,12 @@ export function createEsmHooks(tsNodeService: Service) {
 }
 
 async function addShortCircuitFlag<T>(fn: () => Promise<T>) {
-  const ret = await fn();
-  // Not sure if this is necessary; being lazy.  Can revisit in the future.
-  if (ret == null) return ret;
-  return {
-    ...ret,
-    shortCircuit: true,
-  };
+  return fn().then((ret) => {
+    // Not sure if this is necessary; being lazy.  Can revisit in the future.
+    if (ret == null) return ret;
+    return {
+      ...ret,
+      shortCircuit: true,
+    };
+  });
 }

tests/esm-custom-loader/loader.mjs

@@ -11,4 +11,4 @@ const tsNodeInstance = register({
   },
 });
 
-export const { resolve, getFormat, transformSource, load } = createEsmHooks(tsNodeInstance);
+export const { globalPreload, resolve, getFormat, transformSource, load } = createEsmHooks(tsNodeInstance);