feat: first draft for no bundler

Author: Skn0tt

packages/runtime/src/helpers/config.ts

@@ -9,7 +9,7 @@ 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 { APILambda, SSRLambda } from './functions'
 import type { RoutesManifest } from './types'
 import { escapeStringRegexp } from './utils'
 
@@ -101,12 +101,14 @@ export const configureHandlerFunctions = async ({
   publish,
   ignore = [],
   apiLambdas,
+  ssrLambdas,
   featureFlags,
 }: {
   netlifyConfig: NetlifyConfig
   publish: string
   ignore: Array<string>
   apiLambdas: APILambda[]
+  ssrLambdas: SSRLambda[]
   featureFlags: Record<string, unknown>
 }) => {
   const config = await getRequiredServerFiles(publish)
@@ -164,8 +166,18 @@ export const configureHandlerFunctions = async ({
     })
   }
 
-  configureFunction(HANDLER_FUNCTION_NAME)
-  configureFunction(ODB_FUNCTION_NAME)
+  if (ssrLambdas.length === 0) {
+    configureFunction(HANDLER_FUNCTION_NAME)
+    configureFunction(ODB_FUNCTION_NAME)
+  } else {
+    for (const ssrLambda of ssrLambdas) {
+      const { functionName, includedFiles } = ssrLambda
+      // TODO: add all the nextRoot/wasm/excludedModules stuff from above
+      netlifyConfig.functions[functionName] ||= { included_files: [] }
+      netlifyConfig.functions[functionName].node_bundler = 'none'
+      netlifyConfig.functions[functionName].included_files = includedFiles
+    }
+  }
 
   if (splitApiRoutes(featureFlags)) {
     for (const apiLambda of apiLambdas) {

packages/runtime/src/helpers/flags.ts

@@ -16,3 +16,16 @@ export const splitApiRoutes = (featureFlags: Record<string, unknown>): boolean =
   // default to true during testing, swap to false before merging
   return typeof featureFlags.next_split_api_routes === 'boolean' ? featureFlags.next_split_api_routes : true
 }
+
+/**
+ * TODO: write comment
+ */
+export const useNFTFilesForBundling = (featureFlags: Record<string, unknown>): boolean => {
+  if (process.env.NEXT_USE_NFT_FILES_FOR_BUNDLING) {
+    return process.env.NEXT_USE_NFT_FILES_FOR_BUNDLING === 'true'
+  }
+  // default to true during testing, swap to false before merging
+  return typeof featureFlags.next_use_nft_files_for_bundling === 'boolean'
+    ? featureFlags.next_use_nft_files_for_bundling
+    : true
+}

packages/runtime/src/helpers/functions.ts

@@ -29,25 +29,36 @@ import { getFunctionNameForPage } from './utils'
 
 // TODO, for reviewer: I added my properties here because that was the easiest way,
 // but is it the right spot for it?
-export interface ApiRouteConfig {
+export interface RouteConfig {
   functionName: string
   route: string
-  config: ApiConfig
   compiled: string
   includedFiles: string[]
 }
 
+export interface ApiRouteConfig extends RouteConfig {
+  config: ApiConfig
+}
+
 export interface APILambda {
   functionName: string
   routes: ApiRouteConfig[]
   includedFiles: string[]
   type?: ApiRouteType
 }
 
+export interface SSRLambda {
+  functionName: string
+  routes: RouteConfig[]
+  includedFiles: string[]
+  type?: ApiRouteType
+}
+
 export const generateFunctions = async (
   { FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }: NetlifyPluginConstants,
   appDir: string,
   apiLambdas: APILambda[],
+  ssrLambdas: SSRLambda[],
 ): Promise<void> => {
   const publish = resolve(PUBLISH_DIR)
   const functionsDir = resolve(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC)
@@ -116,6 +127,12 @@ export const generateFunctions = async (
       join(functionsDir, functionName, 'handlerUtils.js'),
     )
     writeFunctionConfiguration({ functionName, functionTitle, functionsDir })
+
+    const nfInternalFiles = await glob(join(functionsDir, functionName, '**'))
+    const lambda = ssrLambdas.find((l) => l.functionName === functionName)
+    if (lambda) {
+      lambda.includedFiles.push(...nfInternalFiles)
+    }
   }
 
   await writeHandler(HANDLER_FUNCTION_NAME, HANDLER_FUNCTION_TITLE, false)
@@ -245,16 +262,20 @@ const traceNextServer = async (publish: string, baseDir: string): Promise<string
   return filtered.map((file) => relative(baseDir, file))
 }
 
-export const getAPIPRouteCommonDependencies = async (publish: string, baseDir: string) => {
-  const [requiredServerFiles, nextServerFiles, followRedirectsFiles] = await Promise.all([
+export const getCommonDependencies = async (publish: string, baseDir: string) => {
+  const deps = await Promise.all([
     traceRequiredServerFiles(publish),
     traceNextServer(publish, baseDir),
 
-    // used by our own bridge.js
-    glob(join(dirname(require.resolve('follow-redirects', { paths: [publish] })), '**', '*')),
+    ...[
+      'follow-redirects',
+      // using package.json because otherwise, we'd find some /dist/... path
+      '@netlify/functions/package.json',
+      'is-promise',
+    ].map((dep) => glob(join(dirname(require.resolve(dep, { paths: [publish] })), '**', '*'))),
   ])
 
-  return [...requiredServerFiles, ...nextServerFiles, ...followRedirectsFiles]
+  return deps.flat(1)
 }
 
 const sum = (arr: number[]) => arr.reduce((v, current) => v + current, 0)
@@ -279,6 +300,53 @@ const getBundleWeight = async (patterns: string[]) => {
   return sum(sizes.flat(1))
 }
 
+export const getSSRLambdas = async (publish: string, baseDir: string): Promise<SSRLambda[]> => {
+  const commonDependencies = await getCommonDependencies(publish, baseDir)
+  const ssrRoutes = await getSSRRoutes(publish)
+
+  // TODO: for now, they're the same - but we should separate them
+  const nonOdbRoutes = ssrRoutes
+  const odbRoutes = ssrRoutes
+
+  return [
+    {
+      functionName: HANDLER_FUNCTION_NAME,
+      includedFiles: [...commonDependencies, ...nonOdbRoutes.flatMap((route) => route.includedFiles)],
+      routes: nonOdbRoutes,
+    },
+    {
+      functionName: ODB_FUNCTION_NAME,
+      includedFiles: [...commonDependencies, ...odbRoutes.flatMap((route) => route.includedFiles)],
+      routes: odbRoutes,
+    },
+  ]
+}
+
+const getSSRRoutes = async (publish: string): Promise<RouteConfig[]> => {
+  const pages = (await readJSON(join(publish, 'server', 'pages-manifest.json'))) as Record<string, string>
+  const routes = Object.entries(pages).filter(
+    ([page, compiled]) => !page.startsWith('/api/') && !compiled.endsWith('.html'),
+  )
+
+  return await Promise.all(
+    routes.map(async ([route, compiled]) => {
+      const functionName = getFunctionNameForPage(route)
+
+      const compiledPath = join(publish, 'server', compiled)
+
+      const routeDependencies = await getDependenciesOfFile(compiledPath)
+      const includedFiles = [compiledPath, ...routeDependencies]
+
+      return {
+        functionName,
+        route,
+        compiled,
+        includedFiles,
+      }
+    }),
+  )
+}
+
 const MB = 1024 * 1024
 
 export const getAPILambdas = async (
@@ -287,7 +355,7 @@ export const getAPILambdas = async (
   pageExtensions: string[],
 ): Promise<APILambda[]> => {
   console.time('traceCommonDependencies')
-  const commonDependencies = await getAPIPRouteCommonDependencies(publish, baseDir)
+  const commonDependencies = await getCommonDependencies(publish, baseDir)
   console.timeEnd('traceCommonDependencies')
 
   console.time('weighCommonDependencies')

packages/runtime/src/index.ts

@@ -18,7 +18,7 @@ import {
 import { onPreDev } from './helpers/dev'
 import { writeEdgeFunctions, loadMiddlewareManifest, cleanupEdgeFunctions } from './helpers/edge'
 import { moveStaticPages, movePublicFiles, patchNextFiles } from './helpers/files'
-import { splitApiRoutes } from './helpers/flags'
+import { splitApiRoutes, useNFTFilesForBundling } from './helpers/flags'
 import {
   generateFunctions,
   setupImageFunction,
@@ -28,6 +28,7 @@ import {
   packSingleFunction,
   getExtendedApiRouteConfigs,
   APILambda,
+  getSSRLambdas,
 } from './helpers/functions'
 import { generateRedirects, generateStaticRedirects } from './helpers/redirects'
 import { shouldSkip, isNextAuthInstalled, getCustomImageResponseHeaders, getRemotePatterns } from './helpers/utils'
@@ -172,15 +173,19 @@ const plugin: NetlifyPlugin = {
           extendedRoutes.map(packSingleFunction),
         )
 
+    const ssrLambdas = useNFTFilesForBundling(featureFlags) ? await getSSRLambdas(publish, appDir) : []
+
+    await generateFunctions(constants, appDir, apiLambdas, ssrLambdas)
+
     await configureHandlerFunctions({
       netlifyConfig,
       ignore,
       publish: relative(process.cwd(), publish),
       apiLambdas,
+      ssrLambdas,
       featureFlags,
     })
 
-    await generateFunctions(constants, appDir, apiLambdas)
     await generatePagesResolver(constants)
 
     await movePublicFiles({ appDir, outdir, publish, basePath })

packages/runtime/src/templates/getHandler.ts

@@ -172,6 +172,7 @@ const makeHandler = (conf: NextConfig, app, pageRoot, staticManifest: Array<[str
 export const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }): string =>
   // This is a string, but if you have the right editor plugin it should format as js (e.g. bierner.comment-tagged-templates in VS Code)
   javascript/* javascript */ `
+  process.env.NODE_ENV = 'production';
   const { Server } = require("http");
   const { promises } = require("fs");
   // We copy the file here rather than requiring from the node module

test/helpers/functions.spec.ts

@@ -9,57 +9,57 @@ describeCwdTmpDir('api route file analysis', () => {
     expect(new Set(configs.map(({ includedFiles, ...rest }) => rest))).toEqual(
       new Set([
         {
-          functionName: "_api_og-handler",
+          functionName: '_api_og-handler',
           compiled: 'pages/api/og.js',
           config: {
             runtime: 'edge',
           },
           route: '/api/og',
         },
         {
-          functionName: "_api_enterPreview-handler",
+          functionName: '_api_enterPreview-handler',
           compiled: 'pages/api/enterPreview.js',
           config: {},
           route: '/api/enterPreview',
         },
         {
-          functionName: "_api_exitPreview-handler",
+          functionName: '_api_exitPreview-handler',
           compiled: 'pages/api/exitPreview.js',
           config: {},
           route: '/api/exitPreview',
         },
         {
-          functionName: "_api_hello-handler",
+          functionName: '_api_hello-handler',
           compiled: 'pages/api/hello.js',
           config: {},
           route: '/api/hello',
         },
         {
-          functionName: "_api_shows_params-SPLAT-handler",
+          functionName: '_api_shows_params-SPLAT-handler',
           compiled: 'pages/api/shows/[...params].js',
           config: {},
           route: '/api/shows/[...params]',
         },
         {
-          functionName: "_api_shows_id-PARAM-handler",
+          functionName: '_api_shows_id-PARAM-handler',
           compiled: 'pages/api/shows/[id].js',
           config: {},
           route: '/api/shows/[id]',
         },
         {
-          functionName: "_api_hello-background-background",
+          functionName: '_api_hello-background-background',
           compiled: 'pages/api/hello-background.js',
           config: { type: 'experimental-background' },
           route: '/api/hello-background',
         },
         {
-          functionName: "_api_hello-scheduled-handler",
+          functionName: '_api_hello-scheduled-handler',
           compiled: 'pages/api/hello-scheduled.js',
           config: { schedule: '@hourly', type: 'experimental-scheduled' },
           route: '/api/hello-scheduled',
         },
         {
-          functionName: "_api_revalidate-handler",
+          functionName: '_api_revalidate-handler',
           compiled: 'pages/api/revalidate.js',
           config: {},
           route: '/api/revalidate',
@@ -75,13 +75,13 @@ describeCwdTmpDir('api route file analysis', () => {
     expect(new Set(configs.map(({ includedFiles, ...rest }) => rest))).toEqual(
       new Set([
         {
-          functionName: "_api_hello-background-background",
+          functionName: '_api_hello-background-background',
           compiled: 'pages/api/hello-background.js',
           config: { type: 'experimental-background' },
           route: '/api/hello-background',
         },
         {
-          functionName: "_api_hello-scheduled-handler",
+          functionName: '_api_hello-scheduled-handler',
           compiled: 'pages/api/hello-scheduled.js',
           config: { schedule: '@hourly', type: 'experimental-scheduled' },
           route: '/api/hello-scheduled',

test/helpers/pack.spec.ts

@@ -1,6 +1,6 @@
 import { pack } from '../../packages/runtime/src/helpers/pack'
 
-test('pack', () => {
+it('pack', () => {
   expect(pack([], 0)).toEqual([])
   expect(pack([{ value: '10', weight: 10 }], 100)).toEqual([['10']])
   expect(

test/index.spec.ts

@@ -4,7 +4,18 @@ import process from 'process'
 
 import type { NetlifyPluginOptions } from '@netlify/build'
 import Chance from 'chance'
-import { writeJSON, unlink, existsSync, readFileSync, ensureDir, readJson, pathExists, writeFile, move, copy } from 'fs-extra'
+import {
+  writeJSON,
+  unlink,
+  existsSync,
+  readFileSync,
+  ensureDir,
+  readJson,
+  pathExists,
+  writeFile,
+  move,
+  copy,
+} from 'fs-extra'
 import { join, relative } from 'pathe'
 import { dir as getTmpDir } from 'tmp-promise'