Add path mapping support to ESM and CJS loaders

dist-raw/node-errors.js

@@ -0,0 +1,29 @@
+exports.codes = {};
+
+function defineError(code, buildMessage) {
+  if (!buildMessage) {
+    buildMessage = (...args) => args.join(' ');
+  }
+
+  exports.codes[code] = class CustomError extends Error {
+    constructor(...args) {
+      super(`${code}: ${buildMessage(...args)}`);
+      this.code = code;
+    }
+  }
+}
+
+defineError("ERR_INPUT_TYPE_NOT_ALLOWED");
+defineError("ERR_INVALID_ARG_VALUE");
+defineError("ERR_INVALID_MODULE_SPECIFIER");
+defineError("ERR_INVALID_PACKAGE_CONFIG");
+defineError("ERR_INVALID_PACKAGE_TARGET");
+defineError("ERR_MANIFEST_DEPENDENCY_MISSING");
+defineError("ERR_MODULE_NOT_FOUND", (path, base, type = 'package') => {
+  return `Cannot find ${type} '${path}' imported from ${base}`;
+});
+defineError("ERR_PACKAGE_IMPORT_NOT_DEFINED");
+defineError("ERR_PACKAGE_PATH_NOT_EXPORTED");
+defineError("ERR_UNSUPPORTED_DIR_IMPORT");
+defineError("ERR_UNSUPPORTED_ESM_URL_SCHEME");
+defineError("ERR_UNKNOWN_FILE_EXTENSION");

dist-raw/node-internal-errors.js

@@ -2,36 +2,46 @@
 
 const path = require('path');
 
-exports.codes = {
-  ERR_INPUT_TYPE_NOT_ALLOWED: createErrorCtor(joinArgs('ERR_INPUT_TYPE_NOT_ALLOWED')),
-  ERR_INVALID_ARG_VALUE: createErrorCtor(joinArgs('ERR_INVALID_ARG_VALUE')),
-  ERR_INVALID_MODULE_SPECIFIER: createErrorCtor(joinArgs('ERR_INVALID_MODULE_SPECIFIER')),
-  ERR_INVALID_PACKAGE_CONFIG: createErrorCtor(joinArgs('ERR_INVALID_PACKAGE_CONFIG')),
-  ERR_INVALID_PACKAGE_TARGET: createErrorCtor(joinArgs('ERR_INVALID_PACKAGE_TARGET')),
-  ERR_MANIFEST_DEPENDENCY_MISSING: createErrorCtor(joinArgs('ERR_MANIFEST_DEPENDENCY_MISSING')),
-  ERR_MODULE_NOT_FOUND: createErrorCtor((path, base, type = 'package') => {
-    return `Cannot find ${type} '${path}' imported from ${base}`
-  }),
-  ERR_PACKAGE_IMPORT_NOT_DEFINED: createErrorCtor(joinArgs('ERR_PACKAGE_IMPORT_NOT_DEFINED')),
-  ERR_PACKAGE_PATH_NOT_EXPORTED: createErrorCtor(joinArgs('ERR_PACKAGE_PATH_NOT_EXPORTED')),
-  ERR_UNSUPPORTED_DIR_IMPORT: createErrorCtor(joinArgs('ERR_UNSUPPORTED_DIR_IMPORT')),
-  ERR_UNSUPPORTED_ESM_URL_SCHEME: createErrorCtor(joinArgs('ERR_UNSUPPORTED_ESM_URL_SCHEME')),
-  ERR_UNKNOWN_FILE_EXTENSION: createErrorCtor(joinArgs('ERR_UNKNOWN_FILE_EXTENSION')),
+// TODO will be useful when implementing https://github.com/TypeStrong/ts-node/issues/1754
+// Try to pluck this symbol off of an intentionally-created node error
+let kIsNodeError;
+try {
+  path.join(0);
+} catch(nodeError) {
+  const symbols = Object.getOwnPropertySymbols(nodeError);
+  kIsNodeError = symbols.find(s => s.toString().includes('kIsNodeError'));
 }
 
-function joinArgs(name) {
-  return (...args) => {
-    return [name, ...args].join(' ')
+exports.codes = {};
+
+function defineError(code, buildMessage) {
+  if (!buildMessage) {
+    buildMessage = (...args) => args.join(' ');
   }
-}
 
-function createErrorCtor(errorMessageCreator) {
-  return class CustomError extends Error {
+  exports.codes[code] = class CustomError extends Error {
     constructor(...args) {
-      super(errorMessageCreator(...args))
+      super(`${code}: ${buildMessage(...args)}`);
+      this.code = code;
     }
   }
 }
+
+defineError("ERR_INPUT_TYPE_NOT_ALLOWED");
+defineError("ERR_INVALID_ARG_VALUE");
+defineError("ERR_INVALID_MODULE_SPECIFIER");
+defineError("ERR_INVALID_PACKAGE_CONFIG");
+defineError("ERR_INVALID_PACKAGE_TARGET");
+defineError("ERR_MANIFEST_DEPENDENCY_MISSING");
+defineError("ERR_MODULE_NOT_FOUND", (path, base, type = 'package') => {
+  return `Cannot find ${type} '${path}' imported from ${base}`;
+});
+defineError("ERR_PACKAGE_IMPORT_NOT_DEFINED");
+defineError("ERR_PACKAGE_PATH_NOT_EXPORTED");
+defineError("ERR_UNSUPPORTED_DIR_IMPORT");
+defineError("ERR_UNSUPPORTED_ESM_URL_SCHEME");
+defineError("ERR_UNKNOWN_FILE_EXTENSION");
+
 exports.createErrRequireEsm = createErrRequireEsm;
 
 // Native ERR_REQUIRE_ESM Error is declared here:

src/cjs-resolve-hooks.ts

@@ -49,19 +49,98 @@ export function installCommonjsResolveHooksIfNecessary(tsNodeService: Service) {
           ...rest
         );
 
-      return Module_resolveFilename.call(
-        this,
-        request,
-        parent,
-        isMain,
-        options,
-        ...rest
-      );
+      // #region path-mapping
+      // Note: [SYNC-PATH-MAPPING] keep this logic synced with the corresponding ESM implementation.
+      let candidateSpecifiers: string[] = [request];
+      const attemptPathMapping =
+        tsNodeService.commonjsPathMapping &&
+        parent?.filename &&
+        !tsNodeService.ignored(parent.filename);
+      if (attemptPathMapping) {
+        const mappedSpecifiers = tsNodeService.mapPath(request);
+        if (mappedSpecifiers) {
+          candidateSpecifiers = [...mappedSpecifiers, request];
+        }
+      }
+      // Attempt all resolutions.  Collect resolution failures and throw an
+      // aggregated error if they all fail.
+      const moduleNotFoundErrors = [];
+      for (let i = 0; i < candidateSpecifiers.length; i++) {
+        try {
+          // TODO does this break if `options.paths` is passed?  Should we bail if
+          // we receive `options.paths`?
+          return Module_resolveFilename.call(
+            this,
+            candidateSpecifiers[i],
+            parent,
+            isMain,
+            options
+          );
+        } catch (err: any) {
+          const isNotFoundError = err.code === 'MODULE_NOT_FOUND';
+          if (!isNotFoundError) {
+            throw err;
+          }
+          moduleNotFoundErrors.push(err);
+        }
+      }
+      // If only one candidate, no need to wrap it.
+      if (candidateSpecifiers.length === 1) {
+        throw moduleNotFoundErrors[0];
+      } else {
+        throw new MappedCommonJSModuleNotFoundError(
+          request,
+          parent!.filename,
+          candidateSpecifiers,
+          moduleNotFoundErrors
+        );
+      }
+      // #endregion
     }
+
     function _findPath(this: any): string {
       if (!tsNodeService.enabled())
         return originalFindPath.apply(this, arguments as any);
       return Module_findPath.apply(this, arguments as any);
     }
   }
 }
+
+interface NodeCommonJSModuleNotFoundError extends Error {
+  requireStack?: string[];
+}
+
+class MappedCommonJSModuleNotFoundError extends Error {
+  // Same code as other module not found errors.
+  readonly code = 'MODULE_NOT_FOUND' as const;
+  readonly errors!: ReadonlyArray<Error>;
+  readonly requireStack?: string[];
+
+  constructor(
+    specifier: string,
+    parentFilename: string,
+    candidates: string[],
+    moduleNotFoundErrors: Error[]
+  ) {
+    super(
+      [
+        `Cannot find '${specifier}' imported from ${parentFilename} using TypeScript path mapping`,
+        'Candidates attempted:',
+        ...candidates.map((candidate) => `- ${candidate}`),
+      ].join('\n')
+    );
+    // TODO this differs slightly from nodejs errors; see if we can match them
+    this.name = `Error [${this.code}]`;
+    // Match shape of `AggregateError`
+    Object.defineProperty(this, 'errors', {
+      value: moduleNotFoundErrors,
+      configurable: true,
+      writable: true,
+    });
+    // Assume every `requireStack` is identical, and maybe downstream code is doing
+    // something with it
+    this.requireStack = (
+      moduleNotFoundErrors[0] as NodeCommonJSModuleNotFoundError | undefined
+    )?.requireStack;
+  }
+}

src/configuration.ts

@@ -381,6 +381,7 @@ function filterRecognizedTsConfigTsNodeOptions(jsonObject: any): {
     experimentalReplAwait,
     swc,
     experimentalResolver,
+    experimentalPathMapping,
     esm,
     experimentalSpecifierResolution,
     ...unrecognized
@@ -407,6 +408,7 @@ function filterRecognizedTsConfigTsNodeOptions(jsonObject: any): {
     moduleTypes,
     swc,
     experimentalResolver,
+    experimentalPathMapping,
     esm,
     experimentalSpecifierResolution,
   };

src/esm.ts

@@ -5,6 +5,7 @@
   UrlWithStringQuery,
   fileURLToPath,
   pathToFileURL,
+  URL,
 } from 'url';
 import { extname } from 'path';
 import * as assert from 'assert';
@@ -212,15 +213,55 @@
         return entrypointFallback(defer);
       }
 
-      // pathname is the path to be resolved
+      // Note: [SYNC-PATH-MAPPING] keep this logic synced with the corresponding CJS implementation.
+      let candidateSpecifiers: string[] = [specifier];
+
+      if (tsNodeService.esmPathMapping && context.parentURL) {
+        const parentUrl = new URL(context.parentURL);
+        const parentPath =
+          parentUrl.protocol === 'file:' && fileURLToPath(parentUrl);
+        if (parentPath && !tsNodeService.ignored(parentPath)) {
+          const mappedSpecifiers = tsNodeService.mapPath(specifier);
+          if (mappedSpecifiers) {
+            candidateSpecifiers = [
+              ...mappedSpecifiers.map((path) => pathToFileURL(path).toString()),
+              specifier,
+            ];
+          }
+        }
+      }
 
-      return entrypointFallback(() =>
-        nodeResolveImplementation.defaultResolve(
-          specifier,
-          context,
-          defaultResolve
-        )
-      );
+      return entrypointFallback(async () => {
+        // Attempt all resolutions.  Collect resolution failures and throw an
+        // aggregated error if they all fail.
+        const moduleNotFoundErrors = [];
+        for (let i = 0; i < candidateSpecifiers.length; i++) {
+          try {
+            return await nodeResolveImplementation.defaultResolve(
+              candidateSpecifiers[i],
+              context,
+              defaultResolve
+            );
+          } catch (err: any) {
+            const isNotFoundError = err.code === 'ERR_MODULE_NOT_FOUND';
+            if (!isNotFoundError) {
+              throw err;
+            }
+            moduleNotFoundErrors.push(err);
+          }
+        }
+        // If only one candidate, no need to wrap it.
+        if (candidateSpecifiers.length === 1) {
+          throw moduleNotFoundErrors[0];
+        } else {
+          throw new MappedModuleNotFoundError(
+            specifier,
+            context.parentURL,
+            candidateSpecifiers,
+            moduleNotFoundErrors
+          );
+        }
+      });
     });
   }
 
@@ -405,6 +446,35 @@
   return hooksAPI;
 }
 
+class MappedModuleNotFoundError extends Error {
+  // Same code as other module not found errors.
+  readonly code = 'ERR_MODULE_NOT_FOUND' as const;
+  readonly errors!: ReadonlyArray<Error>;
+
+  constructor(
+    specifier: string,
+    base: string,
+    candidates: string[],
+    moduleNotFoundErrors: Error[]
+  ) {
+    super(
+      [
+        `Cannot find '${specifier}' imported from ${base} using TypeScript path mapping`,
+        'Candidates attempted:',
+        ...candidates.map((candidate) => `- ${candidate}`),
+      ].join('\n')
+    );
+    // TODO this differs slightly from nodejs errors; see if we can match them
+    this.name = `Error [${this.code}]`;
+    // Match shape of `AggregateError`
+    Object.defineProperty(this, 'errors', {
+      value: moduleNotFoundErrors,
+      configurable: true,
+      writable: true,
+    });
+  }
+}
+
 async function addShortCircuitFlag<T>(fn: () => Promise<T>) {
   const ret = await fn();
   // Not sure if this is necessary; being lazy.  Can revisit in the future.