feat: detect Typescript typings for NPM modules and reference them from barrel files

node/npm_dependencies.ts

@@ -1,11 +1,12 @@
 import { promises as fs } from 'fs'
 import { builtinModules } from 'module'
-import path from 'path'
+import path, { join } from 'path'
 import { fileURLToPath, pathToFileURL } from 'url'
 
 import { resolve, ParsedImportMap } from '@import-maps/resolve'
 import { nodeFileTrace, resolve as nftResolve } from '@vercel/nft'
 import { build } from 'esbuild'
+import { findUp } from 'find-up'
 import getPackageName from 'get-package-name'
 import tmp from 'tmp-promise'
 
@@ -14,6 +15,39 @@ import { Logger } from './logger.js'
 
 const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.cts', '.mts'])
 
+/**
+ * Turns @netlify/functions into @types/netlify__functions.
+ */
+const inferDefinitelyTypedPackage = (specifier: string) => {
+  if (!specifier.startsWith('@')) return `@types/${specifier}`
+  const [scope, pkg] = specifier.split('/')
+  return `@types/${scope.replace('@', '')}__${pkg}`
+}
+
+const detectTypes = async (filePath: string): Promise<string | undefined> => {
+  try {
+    const packageJson = await findUp('package.json', { cwd: filePath })
+    if (!packageJson) return
+    const packageJsonContents = JSON.parse(await fs.readFile(packageJson, 'utf8'))
+    // this only looks at `.types` and `.typings` fields. there might also be data in `exports -> . -> types -> import/default`.
+    // we're ignoring that for now.
+    const packageJsonTypes = packageJsonContents.types ?? packageJsonContents.typings
+    if (packageJsonTypes) return join(packageJson, '..', packageJsonTypes)
+
+    const nodeModulesFolder = await findUp('node_modules', { cwd: packageJson, type: 'directory' })
+    if (!nodeModulesFolder) return
+
+    const typesPackageJson = join(
+      nodeModulesFolder,
+      inferDefinitelyTypedPackage(packageJsonContents.name),
+      'package.json',
+    )
+    const typesPackageContents = JSON.parse(await fs.readFile(typesPackageJson, 'utf8'))
+    const typesPackageTypes = typesPackageContents.types ?? typesPackageContents.typings
+    if (typesPackageContents) return join(typesPackageJson, '..', typesPackageTypes)
+  } catch {}
+}
+
 // Workaround for https://github.com/evanw/esbuild/issues/1921.
 const banner = {
   js: `
@@ -72,14 +106,14 @@ const getNPMSpecifiers = async (basePath: string, functions: string[], importMap
       return nftResolve(specifier, ...args)
     },
   })
-  const npmSpecifiers = new Set<string>()
+  const npmSpecifiers: Record<string, { types?: string }> = {}
   const npmSpecifiersWithExtraneousFiles = new Set<string>()
 
-  reasons.forEach((reason, filePath) => {
+  for (const [filePath, reason] of reasons.entries()) {
     const packageName = getPackageName(filePath)
 
     if (packageName === undefined) {
-      return
+      continue
     }
 
     const parents = [...reason.parents]
@@ -91,7 +125,9 @@ const getNPMSpecifiers = async (basePath: string, functions: string[], importMap
     if (isDirectDependency) {
       const specifier = getPackageName(filePath)
 
-      npmSpecifiers.add(specifier)
+      npmSpecifiers[specifier] = {
+        types: await detectTypes(join(basePath, filePath)),
+      }
     }
 
     const isExtraneousFile = reason.type.every((type) => type === 'asset')
@@ -109,14 +145,19 @@ const getNPMSpecifiers = async (basePath: string, functions: string[], importMap
         }
       })
     }
-  })
+  }
 
   return {
-    npmSpecifiers: [...npmSpecifiers],
+    npmSpecifiers,
     npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
   }
 }
 
+const prependFile = async (path: string, prefix: string) => {
+  const existingContent = await fs.readFile(path, 'utf8')
+  await fs.writeFile(path, prefix + existingContent)
+}
+
 interface VendorNPMSpecifiersOptions {
   basePath: string
   directory?: string
@@ -149,21 +190,22 @@ export const vendorNPMSpecifiers = async ({
   )
 
   // If we found no specifiers, there's nothing left to do here.
-  if (npmSpecifiers.length === 0) {
+  if (Object.keys(npmSpecifiers).length === 0) {
     return
   }
 
   // To bundle an entire module and all its dependencies, create a barrel file
   // where we re-export everything from that specifier. We do this for every
   // specifier, and each of these files will become entry points to esbuild.
   const ops = await Promise.all(
-    npmSpecifiers.map(async (specifier, index) => {
+    Object.entries(npmSpecifiers).map(async ([specifier, { types }], index) => {
       const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`
-      const filePath = path.join(temporaryDirectory.path, `barrel-${index}.js`)
+      const barrelName = `barrel-${index}.js`
+      const filePath = path.join(temporaryDirectory.path, barrelName)
 
       await fs.writeFile(filePath, code)
 
-      return { filePath, specifier }
+      return { filePath, specifier, barrelName, types }
     }),
   )
   const entryPoints = ops.map(({ filePath }) => filePath)
@@ -185,6 +227,13 @@ export const vendorNPMSpecifiers = async ({
     target: 'es2020',
   })
 
+  for (const { barrelName, types } of ops) {
+    if (!types) continue
+    // we're updating the output instead of adding this to the input,
+    // because esbuild will erase the directive while bundling
+    await prependFile(path.join(temporaryDirectory.path, barrelName), `/// <reference types="${types}" />`)
+  }
+
   // Add all Node.js built-ins to the import map, so any unprefixed specifiers
   // (e.g. `process`) resolve to the prefixed versions (e.g. `node:prefix`),
   // which Deno can process.

node/server/server.test.ts

@@ -1,3 +1,4 @@
+import { readFile } from 'fs/promises'
 import { join } from 'path'
 
 import getPort from 'get-port'
@@ -24,6 +25,9 @@ test('Starts a server and serves requests for edge functions', async () => {
     importMapPaths,
     port,
     servePath,
+    featureFlags: {
+      edge_functions_npm_modules: true,
+    },
   })
 
   const functions = [
@@ -51,7 +55,7 @@ test('Starts a server and serves requests for edge functions', async () => {
     },
     options,
   )
-  expect(features).toEqual({})
+  expect(features).toEqual({ npmModules: true })
   expect(success).toBe(true)
   expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }])
 
@@ -95,4 +99,12 @@ test('Starts a server and serves requests for edge functions', async () => {
     global: 'i love netlify',
     local: 'i love netlify',
   })
+
+  const idBarrelFile = await readFile(join(servePath, 'barrel-0.js'), 'utf-8')
+  expect(idBarrelFile).toContain(`/// <reference types="${join(basePath, 'node_modules', 'id', 'types.d.ts')}" />`)
+
+  const identidadeBarrelFile = await readFile(join(servePath, 'barrel-1.js'), 'utf-8')
+  expect(identidadeBarrelFile).toContain(
+    `/// <reference types="${join(basePath, 'node_modules', '@types', 'pt-committee__identidade', 'index.d.ts')}" />`,
+  )
 })

test/fixtures/serve_test/netlify/edge-functions/echo_env.ts

@@ -1,8 +1,12 @@
 import { Config } from 'https://edge.netlify.com'
 
 import { yell } from 'helper'
+import id from 'id'
+import identidade from '@pt-committee/identidade'
 
-export default () => new Response(yell(Deno.env.get('very_secret_secret') ?? ''))
+export default () => {
+  return new Response(yell(identidade(id(Deno.env.get('very_secret_secret'))) ?? ''))
+}
 
 export const config: Config = {
   path: '/my-function',