feat: split up API Routes + use .nft.json files to make builds fast

.gitignore

@@ -152,4 +152,6 @@ packages/*/lib
 cypress/screenshots
 
 # Test cases have node module fixtures
-!test/**/node_modules
+!test/**/node_modules
+
+/tmp

cypress/e2e/default/revalidate.cy.ts

@@ -33,7 +33,7 @@ describe('On-demand revalidation', () => {
     cy.request({ url: '/api/revalidate/?select=5', failOnStatusCode: false }).then((res) => {
       expect(res.status).to.eq(500)
       expect(res.body).to.have.property('message')
-      expect(res.body.message).to.include('Invalid response 404')
+      expect(res.body.message).to.include('could not refresh content for path /getStaticProps/withRevalidate/3/, path is not handled by an odb')
     })
   })
   it('revalidates dynamic non-prerendered ISR route with fallback blocking', () => {

packages/runtime/src/helpers/config.ts

@@ -8,6 +8,8 @@ import slash from 'slash'
 
 import { HANDLER_FUNCTION_NAME, IMAGE_FUNCTION_NAME, ODB_FUNCTION_NAME } from '../constants'
 
+import { splitApiRoutes } from './flags'
+import type { APILambda } from './functions'
 import type { RoutesManifest } from './types'
 import { escapeStringRegexp } from './utils'
 
@@ -98,10 +100,14 @@ export const configureHandlerFunctions = async ({
   netlifyConfig,
   publish,
   ignore = [],
+  apiLambdas,
+  featureFlags,
 }: {
   netlifyConfig: NetlifyConfig
   publish: string
   ignore: Array<string>
+  apiLambdas: APILambda[]
+  featureFlags: Record<string, unknown>
 }) => {
   const config = await getRequiredServerFiles(publish)
   const files = config.files || []
@@ -117,7 +123,7 @@ export const configureHandlerFunctions = async ({
     (moduleName) => !hasManuallyAddedModule({ netlifyConfig, moduleName }),
   )
 
-  ;[HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME, '_api_*'].forEach((functionName) => {
+  const configureFunction = (functionName: string) => {
     netlifyConfig.functions[functionName] ||= { included_files: [], external_node_modules: [] }
     netlifyConfig.functions[functionName].node_bundler = 'nft'
     netlifyConfig.functions[functionName].included_files ||= []
@@ -156,7 +162,22 @@ export const configureHandlerFunctions = async ({
         netlifyConfig.functions[functionName].included_files.push(`!${moduleRoot}/**/*`)
       }
     })
-  })
+  }
+
+  configureFunction(HANDLER_FUNCTION_NAME)
+  configureFunction(ODB_FUNCTION_NAME)
+
+  if (splitApiRoutes(featureFlags)) {
+    for (const apiLambda of apiLambdas) {
+      const { functionName, includedFiles } = apiLambda
+      netlifyConfig.functions[functionName] ||= { included_files: [] }
+      netlifyConfig.functions[functionName].node_bundler = 'none'
+      netlifyConfig.functions[functionName].included_files ||= []
+      netlifyConfig.functions[functionName].included_files.push(...includedFiles)
+    }
+  } else {
+    configureFunction('_api_*')
+  }
 }
 
 interface BuildHeaderParams {

packages/runtime/src/helpers/files.ts

@@ -366,7 +366,7 @@ export const getDependenciesOfFile = async (file: string) => {
   if (!existsSync(nft)) {
     return []
   }
-  const dependencies = await readJson(nft, 'utf8')
+  const dependencies = (await readJson(nft, 'utf8')) as { files: string[] }
   return dependencies.files.map((dep) => resolve(dirname(file), dep))
 }
 

packages/runtime/src/helpers/flags.ts

@@ -0,0 +1,21 @@
+/**
+ * If this flag is enabled, we generate individual Lambda functions for API Routes.
+ * They're packed together in 50mb chunks to avoid hitting the Lambda size limit.
+ *
+ * To prevent bundling times from rising,
+ * we use the "none" bundling strategy where we fully rely on Next.js' `.nft.json` files.
+ * This should to a significant speedup, but is still experimental.
+ *
+ * If disabled, we bundle all API Routes into a single function.
+ * This is can lead to large bundle sizes.
+ *
+ * Enabled by default. Can be disabled by passing NEXT_SPLIT_API_ROUTES=false.
+ */
+
+export const splitApiRoutes = (featureFlags: Record<string, unknown>): boolean => {
+  if (process.env.NEXT_SPLIT_API_ROUTES) {
+    return process.env.NEXT_SPLIT_API_ROUTES === 'true'
+  }
+  // default to true during testing, swap to false before merging
+  return typeof featureFlags.next_split_api_routes === 'boolean' ? featureFlags.next_split_api_routes : true
+}

packages/runtime/src/helpers/functions.ts

@@ -2,10 +2,11 @@ import type { NetlifyConfig, NetlifyPluginConstants } from '@netlify/build'
 import bridgeFile from '@vercel/node-bridge'
 import chalk from 'chalk'
 import destr from 'destr'
-import { copyFile, ensureDir, existsSync, readJSON, writeFile, writeJSON } from 'fs-extra'
+import { copyFile, ensureDir, existsSync, readJSON, writeFile, writeJSON, stat } from 'fs-extra'
 import type { ImageConfigComplete, RemotePattern } from 'next/dist/shared/lib/image-config'
 import { outdent } from 'outdent'
-import { join, relative, resolve } from 'pathe'
+import { join, relative, resolve, dirname } from 'pathe'
+import glob from 'tiny-glob'
 
 import {
   HANDLER_FUNCTION_NAME,
@@ -21,21 +22,31 @@ import { getHandler } from '../templates/getHandler'
 import { getResolverForPages, getResolverForSourceFiles } from '../templates/getPageResolver'
 
 import { ApiConfig, extractConfigFromFile, isEdgeConfig } from './analysis'
-import { getServerFile, getSourceFileForPage } from './files'
+import { getDependenciesOfFile, getServerFile, getSourceFileForPage } from './files'
 import { writeFunctionConfiguration } from './functionsMetaData'
+import { pack } from './pack'
 import { ApiRouteType } from './types'
 import { getFunctionNameForPage } from './utils'
 
 export interface ApiRouteConfig {
+  functionName: string
   route: string
   config: ApiConfig
   compiled: string
+  includedFiles: string[]
+}
+
+export interface APILambda {
+  functionName: string
+  routes: ApiRouteConfig[]
+  includedFiles: string[]
+  type?: ApiRouteType
 }
 
 export const generateFunctions = async (
   { FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }: NetlifyPluginConstants,
   appDir: string,
-  apiRoutes: Array<ApiRouteConfig>,
+  apiLambdas: APILambda[],
 ): Promise<void> => {
   const publish = resolve(PUBLISH_DIR)
   const functionsDir = resolve(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC)
@@ -47,19 +58,16 @@ export const generateFunctions = async (
     ? relative(functionDir, nextServerModuleAbsoluteLocation)
     : undefined
 
-  for (const { route, config, compiled } of apiRoutes) {
-    // Don't write a lambda if the runtime is edge
-    if (isEdgeConfig(config.runtime)) {
-      continue
-    }
-    const apiHandlerSource = await getApiHandler({
-      page: route,
-      config,
+  for (const apiLambda of apiLambdas) {
+    const { functionName, routes, type, includedFiles } = apiLambda
+
+    const apiHandlerSource = getApiHandler({
+      schedule: type === ApiRouteType.SCHEDULED ? routes[0].config.schedule : undefined,
       publishDir,
       appDir: relative(functionDir, appDir),
       nextServerModuleRelativeLocation,
     })
-    const functionName = getFunctionNameForPage(route, config.type === ApiRouteType.BACKGROUND)
+
     await ensureDir(join(functionsDir, functionName))
 
     // write main API handler file
@@ -78,16 +86,25 @@ export const generateFunctions = async (
 
     const resolveSourceFile = (file: string) => join(publish, 'server', file)
 
+    // TODO: this should be unneeded once we use the `none` bundler everywhere
     const resolverSource = await getResolverForSourceFiles({
       functionsDir,
       // These extra pages are always included by Next.js
-      sourceFiles: [compiled, 'pages/_app.js', 'pages/_document.js', 'pages/_error.js'].map(resolveSourceFile),
+      sourceFiles: [
+        ...routes.map((route) => route.compiled),
+        'pages/_app.js',
+        'pages/_document.js',
+        'pages/_error.js',
+      ].map(resolveSourceFile),
     })
     await writeFile(join(functionsDir, functionName, 'pages.js'), resolverSource)
+
+    const nfInternalFiles = await glob(join(functionsDir, functionName, '**'))
+    includedFiles.push(...nfInternalFiles)
   }
 
   const writeHandler = async (functionName: string, functionTitle: string, isODB: boolean) => {
-    const handlerSource = await getHandler({
+    const handlerSource = getHandler({
       isODB,
       publishDir,
       appDir: relative(functionDir, appDir),
@@ -208,6 +225,143 @@ export const setupImageFunction = async ({
   }
 }
 
+const traceRequiredServerFiles = async (publish: string): Promise<string[]> => {
+  const requiredServerFilesPath = join(publish, 'required-server-files.json')
+  const {
+    files,
+    relativeAppDir,
+    config: {
+      experimental: { outputFileTracingRoot },
+    },
+  } = (await readJSON(requiredServerFilesPath)) as {
+    files: string[]
+    relativeAppDir: string
+    config: { experimental: { outputFileTracingRoot: string } }
+  }
+  const appDirRoot = join(outputFileTracingRoot, relativeAppDir)
+  const absoluteFiles = files.map((file) => join(appDirRoot, file))
+
+  absoluteFiles.push(requiredServerFilesPath)
+
+  return absoluteFiles
+}
+
+const traceNextServer = async (publish: string): Promise<string[]> => {
+  const nextServerDeps = await getDependenciesOfFile(join(publish, 'next-server.js'))
+
+  // during testing, i've seen `next-server` contain only one line.
+  // this is a sanity check to make sure we're getting all the deps.
+  if (nextServerDeps.length < 10) {
+    console.error(nextServerDeps)
+    throw new Error("next-server.js.nft.json didn't contain all dependencies.")
+  }
+
+  const filtered = nextServerDeps.filter((f) => {
+    // NFT detects a bunch of large development files that we don't need.
+    if (f.endsWith('.development.js')) return false
+
+    // not needed for API Routes!
+    if (f.endsWith('node_modules/sass/sass.dart.js')) return false
+
+    return true
+  })
+
+  return filtered
+}
+
+export const traceNPMPackage = async (packageName: string, publish: string) => {
+  try {
+    return await glob(join(dirname(require.resolve(packageName, { paths: [publish] })), '**', '*'), {
+      absolute: true,
+    })
+  } catch (error) {
+    if (process.env.NODE_ENV === 'test') {
+      return []
+    }
+    throw error
+  }
+}
+
+export const getAPIPRouteCommonDependencies = async (publish: string) => {
+  const deps = await Promise.all([
+    traceRequiredServerFiles(publish),
+    traceNextServer(publish),
+
+    // used by our own bridge.js
+    traceNPMPackage('follow-redirects', publish),
+  ])
+
+  return deps.flat(1)
+}
+
+const sum = (arr: number[]) => arr.reduce((v, current) => v + current, 0)
+
+// TODO: cache results
+const getBundleWeight = async (patterns: string[]) => {
+  const sizes = await Promise.all(
+    patterns.flatMap(async (pattern) => {
+      const files = await glob(pattern)
+      return Promise.all(
+        files.map(async (file) => {
+          const fStat = await stat(file)
+          if (fStat.isFile()) {
+            return fStat.size
+          }
+          return 0
+        }),
+      )
+    }),
+  )
+
+  return sum(sizes.flat(1))
+}
+
+const MB = 1024 * 1024
+
+export const getAPILambdas = async (
+  publish: string,
+  baseDir: string,
+  pageExtensions: string[],
+): Promise<APILambda[]> => {
+  const commonDependencies = await getAPIPRouteCommonDependencies(publish)
+
+  const threshold = 50 * MB - (await getBundleWeight(commonDependencies))
+
+  const apiRoutes = await getApiRouteConfigs(publish, baseDir, pageExtensions)
+
+  const packFunctions = async (routes: ApiRouteConfig[], type?: ApiRouteType): Promise<APILambda[]> => {
+    const weighedRoutes = await Promise.all(
+      routes.map(async (route) => ({ value: route, weight: await getBundleWeight(route.includedFiles) })),
+    )
+
+    const bins = pack(weighedRoutes, threshold)
+
+    return bins.map((bin, index) => ({
+      functionName: bin.length === 1 ? bin[0].functionName : `api-${index}`,
+      routes: bin,
+      includedFiles: [...commonDependencies, ...routes.flatMap((route) => route.includedFiles)],
+      type,
+    }))
+  }
+
+  const standardFunctions = apiRoutes.filter(
+    (route) =>
+      !isEdgeConfig(route.config.runtime) &&
+      route.config.type !== ApiRouteType.BACKGROUND &&
+      route.config.type !== ApiRouteType.SCHEDULED,
+  )
+  const scheduledFunctions = apiRoutes.filter((route) => route.config.type === ApiRouteType.SCHEDULED)
+  const backgroundFunctions = apiRoutes.filter((route) => route.config.type === ApiRouteType.BACKGROUND)
+
+  const scheduledLambdas: APILambda[] = scheduledFunctions.map(packSingleFunction)
+
+  const [standardLambdas, backgroundLambdas] = await Promise.all([
+    packFunctions(standardFunctions),
+    packFunctions(backgroundFunctions, ApiRouteType.BACKGROUND),
+  ])
+  return [...standardLambdas, ...backgroundLambdas, ...scheduledLambdas]
+}
+
 /**
  * Look for API routes, and extract the config from the source file.
  */
@@ -226,7 +380,23 @@ export const getApiRouteConfigs = async (
   return await Promise.all(
     apiRoutes.map(async (apiRoute) => {
       const filePath = getSourceFileForPage(apiRoute, [pagesDir, srcPagesDir], pageExtensions)
-      return { route: apiRoute, config: await extractConfigFromFile(filePath, appDir), compiled: pages[apiRoute] }
+      const config = await extractConfigFromFile(filePath, appDir)
+
+      const functionName = getFunctionNameForPage(apiRoute, config.type === ApiRouteType.BACKGROUND)
+
+      const compiled = pages[apiRoute]
+      const compiledPath = join(publish, 'server', compiled)
+
+      const routeDependencies = await getDependenciesOfFile(compiledPath)
+      const includedFiles = [compiledPath, ...routeDependencies]
+
+      return {
+        functionName,
+        route: apiRoute,
+        config,
+        compiled,
+        includedFiles,
+      }
     }),
   )
 }
@@ -245,6 +415,13 @@ export const getExtendedApiRouteConfigs = async (
   return settledApiRoutes.filter((apiRoute) => apiRoute.config.type !== undefined)
 }
 
+export const packSingleFunction = (func: ApiRouteConfig): APILambda => ({
+  functionName: func.functionName,
+  includedFiles: func.includedFiles,
+  routes: [func],
+  type: func.config.type,
+})
+
 interface FunctionsManifest {
   functions: Array<{ name: string; schedule?: string }>
 }