refactor(app-tools): unify esm ts path resolution

Author: zllkjc

packages/server/utils/src/compilers/typescript/tsconfigPathsPlugin.ts

@@ -1,19 +1,26 @@
 import * as os from 'os';
 import path, { dirname, posix } from 'path';
-import { findMatchedSourcePath, toEsmOutputPath } from '@modern-js/utils';
+import { findMatchedSourcePath, findSourceEntry } from '@modern-js/utils';
 import type { MatchPath } from '@modern-js/utils/tsconfig-paths';
 import { createMatchPath } from '@modern-js/utils/tsconfig-paths';
 import * as ts from 'typescript';
 
+// Convert a resolved source path into the specifier that native ESM output
+// should reference at runtime, which is always the emitted `.js` file.
+const toEsmOutputPath = (resolvedPath: string) => {
+  const sourcePath = findSourceEntry(resolvedPath) || resolvedPath;
+  const ext = path.extname(sourcePath);
+
+  return ext ? `${sourcePath.slice(0, -ext.length)}.js` : `${sourcePath}.js`;
+};
+
 const resolveRelativeEsmSpecifier = (sf: ts.SourceFile, text: string) => {
   if (!text.startsWith('./') && !text.startsWith('../')) {
     return;
   }
 
   const importerDir = dirname(sf.fileName);
-  const resolvedPath = path.resolve(importerDir, text);
-
-  return toEsmOutputPath(resolvedPath);
+  return path.resolve(importerDir, text);
 };
 
 const isRegExpKey = (str: string) => {
@@ -196,8 +203,6 @@ export function tsconfigPathsBeforeHookFactory(
   };
 }
 
-// fork from https://github.com/nestjs/nest-cli/blob/HEAD/lib/compiler/hooks/tsconfig-paths.hook.ts
-// license at https://github.com/nestjs/nest/blob/master/LICENSE
 function getNotAliasedPath(
   sf: ts.SourceFile,
   matcher: MatchPath,
@@ -208,15 +213,12 @@ function getNotAliasedPath(
   // rules as the runtime loaders.
   let result = findMatchedSourcePath(matcher, text);
 
-  // For CommonJS we only rewrite known alias matches. For native ESM we also
-  // need to normalize relative imports like `../service/user` into a path that
-  // can be emitted as `../service/user.js`.
+  // For native ESM, unresolved relative imports like `../service/user` must be
+  // resolved to a source path before we convert them to the emitted `.js` specifier.
   if (!result && moduleType === 'module') {
     // This branch is only for relative specifiers. Bare package imports should
     // stay untouched when they are not matched by alias rules.
-    if (!result) {
-      result = resolveRelativeEsmSpecifier(sf, text);
-    }
+    result = resolveRelativeEsmSpecifier(sf, text);
   }
 
   if (!result) {

packages/solutions/app-tools/src/esm/register-esm.mjs

@@ -1,11 +1,15 @@
 import path from 'node:path';
-import { fs } from '@modern-js/utils';
 
 /**
  * Register Node.js module hooks for TypeScript support.
  * Uses node:module register API to enable ts-node loader.
  */
-export const registerModuleHooks = async ({ appDir, distDir, alias }) => {
+export const registerModuleHooks = async ({
+  appDir,
+  distDir,
+  baseUrl,
+  paths,
+}) => {
   const TS_CONFIG_FILENAME = `tsconfig.json`;
   const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
 
@@ -21,10 +25,8 @@ export const registerModuleHooks = async ({ appDir, distDir, alias }) => {
   )}/`;
   register('./ts-node-loader.mjs', import.meta.url, {
     data: {
-      appDir,
-      distDir,
-      alias,
-      tsconfigPath,
+      baseUrl,
+      paths,
     },
   });
 };

packages/solutions/app-tools/src/esm/ts-node-loader.mjs

@@ -1,26 +1,23 @@
 import { pathToFileURL } from 'url';
+import { findMatchedSourcePath, findSourceEntry } from '@modern-js/utils';
+import { createMatchPath } from '@modern-js/utils/tsconfig-paths';
 import { resolve as tsNodeResolve } from 'ts-node/esm';
 import { load as tsNodeLoad } from 'ts-node/esm';
-import {
-  createMatchPath,
-  findMatchedPath,
-  resolvePathWithExtensions,
-} from './utils.mjs';
 
 let matchPath;
-export async function initialize({ appDir, alias, tsconfigPath }) {
-  matchPath = createMatchPath({
-    alias,
-    appDir,
-    tsconfigPath,
-  });
+
+export async function initialize({ baseUrl, paths }) {
+  matchPath = createMatchPath(baseUrl || './', paths || {});
 }
 
 export function resolve(specifier, context, defaultResolve) {
-  const match = findMatchedPath(matchPath, specifier);
+  // Without this rewrite, aliases such as `@service/user` and
+  // `@service/user.js` would never reach ts-node as real source files.
+  const match = findMatchedSourcePath(matchPath, specifier);
+
   return match
     ? tsNodeResolve(
-        pathToFileURL(resolvePathWithExtensions(match)).href,
+        pathToFileURL(findSourceEntry(match) || match).href,
         context,
         defaultResolve,
       )
@@ -38,5 +35,7 @@ export function load(url, context, defaultLoad) {
     return defaultLoad(url, context);
   }
 
+  // Without ts-node here, local `.ts` files would be handed to Node as-is and
+  // fail to execute in environments that do not natively run TypeScript.
   return tsNodeLoad(url, context, defaultLoad);
 }

packages/solutions/app-tools/src/esm/ts-paths-loader.mjs

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { findMatchedSourcePath, findSourceEntry } from '@modern-js/utils';
 import { createMatchPath as oCreateMatchPath } from '@modern-js/utils/tsconfig-paths';
-import { findMatchedPath, resolvePathWithExtensions } from './utils.mjs';
 
 let matchPath;
 let appDir;
@@ -13,6 +13,8 @@ export async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
 }
 
 export function resolve(specifier, context, defaultResolve) {
+  // Without this branch, app-local imports like `../service/user` would fail
+  // under native ESM because Node does not try `.ts` / `.js` extensions here.
   const parentPath = context.parentURL
     ? path.dirname(fileURLToPath(context.parentURL))
     : process.cwd();
@@ -30,9 +32,8 @@ export function resolve(specifier, context, defaultResolve) {
     !path.extname(specifier) &&
     isAppFile
   ) {
-    const resolvedPath = resolvePathWithExtensions(
-      path.resolve(parentPath, specifier),
-    );
+    const matchedPath = path.resolve(parentPath, specifier);
+    const resolvedPath = findSourceEntry(matchedPath) || matchedPath;
 
     if (resolvedPath && fs.existsSync(resolvedPath)) {
       return defaultResolve(
@@ -47,12 +48,15 @@ export function resolve(specifier, context, defaultResolve) {
     return defaultResolve(specifier, context, defaultResolve);
   }
 
-  const match = findMatchedPath(matchPath, specifier);
+  // Without this rewrite, aliases such as `@service/user` and
+  // `@service/user.js` would be left to Node's default resolver, which cannot
+  // map tsconfig paths to the real source files.
+  const match = findMatchedSourcePath(matchPath, specifier);
   if (!match) {
     return defaultResolve(specifier, context, defaultResolve);
   }
 
-  const resolvedPath = resolvePathWithExtensions(match);
+  const resolvedPath = findSourceEntry(match) || match;
   return defaultResolve(
     pathToFileURL(resolvedPath).href,
     context,