feat: add support for TypeScript to NFT (#1515)

* feat: add support for TypeScript to NFT

* feat: add rewrites

* refactor: stop using esbuild for v2 functions

src/runtimes/node/bundlers/index.ts

@@ -67,10 +67,6 @@ const getDefaultBundler = async ({
   runtimeAPIVersion: number
 }): Promise<NodeBundlerName> => {
   if (runtimeAPIVersion === 2) {
-    if (ESBUILD_EXTENSIONS.has(extension)) {
-      return NODE_BUNDLER.ESBUILD
-    }
-
     return NODE_BUNDLER.NFT
   }
 

src/runtimes/node/bundlers/nft/es_modules.ts

@@ -209,7 +209,12 @@ const transpileESM = async ({
   await Promise.all(
     pathsToTranspile.map(async (path) => {
       const absolutePath = resolvePath(path, basePath)
-      const transpiled = await transpile(absolutePath, config, name)
+      const transpiled = await transpile({
+        config,
+        format: MODULE_FORMAT.COMMONJS,
+        name,
+        path: absolutePath,
+      })
 
       rewrites.set(absolutePath, transpiled)
     }),

src/runtimes/node/bundlers/nft/index.ts

@@ -1,19 +1,21 @@
-import { basename, dirname, join, normalize, resolve } from 'path'
+import { basename, dirname, join, normalize, resolve, extname } from 'path'
 
 import { nodeFileTrace } from '@vercel/nft'
 import resolveDependency from '@vercel/nft/out/resolve-dependency.js'
 
 import type { FunctionConfig } from '../../../../config.js'
 import { FeatureFlags } from '../../../../feature_flags.js'
 import type { RuntimeCache } from '../../../../utils/cache.js'
-import { cachedReadFile } from '../../../../utils/fs.js'
+import { cachedReadFile, getPathWithExtension } from '../../../../utils/fs.js'
 import { minimatch } from '../../../../utils/matching.js'
 import { getBasePath } from '../../utils/base_path.js'
 import { filterExcludedPaths, getPathsOfIncludedFiles } from '../../utils/included_files.js'
+import { MODULE_FORMAT } from '../../utils/module_format.js'
 import { getNodeSupportMatrix } from '../../utils/node_version.js'
 import type { GetSrcFilesFunction, BundleFunction } from '../types.js'
 
 import { processESM } from './es_modules.js'
+import { transpile } from './transpile.js'
 
 const appearsToBeModuleName = (name: string) => !name.startsWith('.')
 
@@ -34,6 +36,8 @@ const bundle: BundleFunction = async ({
     includedFilesBasePath || basePath,
   )
   const {
+    aliases,
+    mainFile: normalizedMainFile,
     moduleFormat,
     paths: dependencyPaths,
     rewrites,
@@ -55,10 +59,11 @@ const bundle: BundleFunction = async ({
   const srcFiles = [...filteredIncludedPaths].sort()
 
   return {
+    aliases,
     basePath: getBasePath(dirnames),
     includedFiles: includedPaths,
     inputs: dependencyPaths,
-    mainFile,
+    mainFile: normalizedMainFile,
     moduleFormat,
     rewrites,
     srcFiles,
@@ -97,6 +102,10 @@ const traceFilesAndTranspile = async function ({
   name: string
   runtimeAPIVersion: number
 }) {
+  const isTypeScript = extname(mainFile) === '.ts'
+  const tsAliases = new Map<string, string>()
+  const tsRewrites = new Map<string, string>()
+
   const {
     fileList: dependencyPaths,
     esmFileList,
@@ -109,6 +118,19 @@ const traceFilesAndTranspile = async function ({
     ignore: getIgnoreFunction(config),
     readFile: async (path: string) => {
       try {
+        if (extname(path) === '.ts') {
+          const transpiledSource = await transpile({ config, name, path })
+          const newPath = getPathWithExtension(path, '.js')
+
+          // Overriding the contents of the `.ts` file.
+          tsRewrites.set(path, transpiledSource)
+
+          // Rewriting the `.ts` path to `.js` in the bundle.
+          tsAliases.set(path, newPath)
+
+          return transpiledSource
+        }
+
         const source = await cachedReadFile(cache.fileCache, path)
 
         return source
@@ -140,6 +162,17 @@ const traceFilesAndTranspile = async function ({
   const normalizedDependencyPaths = [...dependencyPaths].map((path) =>
     basePath ? resolve(basePath, path) : resolve(path),
   )
+
+  if (isTypeScript) {
+    return {
+      aliases: tsAliases,
+      mainFile: getPathWithExtension(mainFile, '.js'),
+      moduleFormat: MODULE_FORMAT.ESM,
+      paths: normalizedDependencyPaths,
+      rewrites: tsRewrites,
+    }
+  }
+
   const { moduleFormat, rewrites } = await processESM({
     basePath,
     cache,
@@ -153,6 +186,7 @@ const traceFilesAndTranspile = async function ({
   })
 
   return {
+    mainFile,
     moduleFormat,
     paths: normalizedDependencyPaths,
     rewrites,

src/runtimes/node/bundlers/nft/transpile.ts

@@ -3,11 +3,18 @@ import { build } from '@netlify/esbuild'
 import type { FunctionConfig } from '../../../../config.js'
 import { FunctionBundlingUserError } from '../../../../utils/error.js'
 import { RUNTIME } from '../../../runtime.js'
-import { MODULE_FORMAT } from '../../utils/module_format.js'
+import { ModuleFormat } from '../../utils/module_format.js'
 import { getBundlerTarget } from '../esbuild/bundler_target.js'
 import { NODE_BUNDLER } from '../types.js'
 
-export const transpile = async (path: string, config: FunctionConfig, functionName: string) => {
+interface TranspileOptions {
+  config: FunctionConfig
+  format?: ModuleFormat
+  name: string
+  path: string
+}
+
+export const transpile = async ({ config, format, name, path }: TranspileOptions) => {
   // The version of ECMAScript to use as the build target. This will determine
   // whether certain features are transpiled down or left untransformed.
   const nodeTarget = getBundlerTarget(config.nodeVersion)
@@ -16,7 +23,7 @@ export const transpile = async (path: string, config: FunctionConfig, functionNa
     const transpiled = await build({
       bundle: false,
       entryPoints: [path],
-      format: MODULE_FORMAT.COMMONJS,
+      format,
       logLevel: 'error',
       platform: 'node',
       sourcemap: Boolean(config.nodeSourcemap),
@@ -27,7 +34,7 @@ export const transpile = async (path: string, config: FunctionConfig, functionNa
     return transpiled.outputFiles[0].text
   } catch (error) {
     throw FunctionBundlingUserError.addCustomErrorInfo(error, {
-      functionName,
+      functionName: name,
       runtime: RUNTIME.JAVASCRIPT,
       bundler: NODE_BUNDLER.NFT,
     })

tests/fixtures/node-typescript-directory-1/function/function.ts

@@ -1,3 +1,5 @@
 type MyType = string
 
-export const type: MyType = '❤️ TypeScript'
+const type: MyType = '❤️ TypeScript'
+
+export const handler = () => type

tests/fixtures/node-typescript-directory-2/function/index.ts

@@ -1,3 +1,5 @@
 type MyType = string
 
-export const type: MyType = '❤️ TypeScript'
+const type: MyType = '❤️ TypeScript'
+
+export const handler = () => type

tests/fixtures/node-typescript-with-imports/function.ts

@@ -1,4 +1,3 @@
-// We do not rename to `./util.js` because `@vercel/nft` does not manage to
-// find the dependency `util.ts` then, even though using `.js` file extensions
-// is the recommended way to use pure ES modules with Typescript.
-export { type } from './lib/util'
+import { type } from './lib/util.js'
+
+export const handler = () => type

tests/fixtures/node-typescript/function.ts

@@ -1,3 +1,5 @@
 type MyType = string
 
-export const type: MyType = '❤️ TypeScript'
+const type: MyType = '❤️ TypeScript'
+
+export const handler = () => type

tests/main.test.ts

@@ -929,53 +929,54 @@ describe('zip-it-and-ship-it', () => {
 
   testMany(
     'Handles a TypeScript function ({name}.ts)',
-    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'todo:bundler_nft'],
+    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'bundler_nft'],
     async (options) => {
       const { files } = await zipFixture('node-typescript', {
         opts: options,
       })
       const unzippedFunctions = await unzipFiles(files)
-      const { type } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
-      expect(type).toBeTypeOf('string')
+      const { handler } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
+      expect(handler()).toBe('❤️ TypeScript')
     },
   )
 
   testMany(
     'Handles a TypeScript function ({name}/{name}.ts)',
-    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'todo:bundler_nft'],
+    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'bundler_nft'],
     async (options) => {
       const { files } = await zipFixture('node-typescript-directory-1', {
         opts: options,
       })
       const unzippedFunctions = await unzipFiles(files)
-      const { type } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
-      expect(type).toBeTypeOf('string')
+      const { handler } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
+      expect(handler()).toBe('❤️ TypeScript')
     },
   )
 
   testMany(
     'Handles a TypeScript function ({name}/index.ts)',
-    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'todo:bundler_nft'],
+    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'bundler_nft'],
     async (options) => {
       const { files } = await zipFixture('node-typescript-directory-2', {
         opts: options,
       })
       const unzippedFunctions = await unzipFiles(files)
-      const { type } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
-      expect(type).toBeTypeOf('string')
+      const { handler } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
+      expect(handler()).toBe('❤️ TypeScript')
     },
   )
 
   testMany(
     'Handles a TypeScript function with imports',
-    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'todo:bundler_nft'],
+    ['bundler_default', 'bundler_esbuild', 'bundler_esbuild_zisi', 'bundler_default_nft', 'bundler_nft'],
     async (options) => {
       const { files } = await zipFixture('node-typescript-with-imports', {
         opts: options,
       })
       const unzippedFunctions = await unzipFiles(files)
-      const { type } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
-      expect(type).toBeTypeOf('string')
+      const { handler } = await importFunctionFile(`${unzippedFunctions[0].unzipPath}/function.js`)
+
+      expect(handler()).toBe('❤️ TypeScript')
     },
   )