feat: revert to nft due to output issues with bundling

Author: orinokai

package-lock.json

@@ -34,11 +34,11 @@
   },
   "homepage": "https://github.com/netlify/next-runtime-minimal#readme",
   "dependencies": {
-    "@fastly/http-compute-js": "^1.1.0",
+    "@fastly/http-compute-js": "github:orinokai/http-compute-js",
     "@netlify/blobs": "^1.6.0",
     "@netlify/build": "^29.20.6",
     "@netlify/functions": "^2.0.1",
-    "esbuild": "^0.19.4",
+    "@vercel/nft": "^0.24.3",
     "fs-extra": "^11.1.1"
   },
   "devDependencies": {

package.json

@@ -1,37 +1,23 @@
-import { readFileSync } from 'fs'
+import { readFile } from 'node:fs/promises'
 
-import type { NetlifyConfig } from '@netlify/build'
-import { copySync, moveSync } from 'fs-extra/esm'
-
-import { MODULE_DIR, NETLIFY_PUBLISH_DIR, NETLIFY_TEMP_DIR } from './constants.js'
+import { RUNTIME_DIR } from './constants.js'
 
 /**
- * Modify the user's next.config.js to use standalone mode and cache handler
+ * Enable Next.js standalone mode
  */
-export const modifyNextConfig = () => {
-  // revert any previous changes
-  revertNextConfig()
-
-  // TODO: find a better way to do this because there's a ton of different ways
-  // to configure next.config.js and the user could be using any of them
-  // https://github.com/netlify/next-runtime-minimal/issues/12
-  moveSync('next.config.js', `${NETLIFY_TEMP_DIR}/next.config.js`)
-  copySync(`${MODULE_DIR}/../templates/next-config.cjs`, 'next.config.js')
+export const setBuildtimeConfig = () => {
+  process.env.NEXT_PRIVATE_STANDALONE = 'true'
 }
 
-export const revertNextConfig = () => {
-  // check if modified, then revert
-  if (readFileSync('next.config.js').includes('Netlify generated code')) {
-    moveSync(`${NETLIFY_TEMP_DIR}/next.config.js`, 'next.config.js', { overwrite: true })
+export const setRuntimeConfig = async () => {
+  const runtimeConfig = JSON.parse(await readFile('./.next/required-server-files.json', 'utf-8'))
+
+  // set the path to the cache handler
+  runtimeConfig.config.experimental = {
+    ...runtimeConfig.config.experimental,
+    incrementalCacheHandlerPath: `${RUNTIME_DIR}/dist/templates/cache-handler.cjs`,
   }
-}
 
-/**
- * Modify the user's netlify.toml to use our new publish directory
- * @param config Netlify config
- */
-export const modifyNetlifyConfig = (config: NetlifyConfig) => {
-  // TODO: once onEnd is fixed, we can remove this
-  // https://github.com/netlify/cli/issues/6050
-  config.build.publish = NETLIFY_PUBLISH_DIR
+  // set config from the build output
+  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(runtimeConfig.config)
 }

src/helpers/config.ts

@@ -1,11 +1,18 @@
 import { resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-export const MODULE_DIR = fileURLToPath(new URL('.', import.meta.url))
+let dir
+try {
+  dir = __dirname
+} catch {
+  dir = fileURLToPath(new URL('.', import.meta.url))
+}
+
+export const MODULE_DIR = dir
 export const PLUGIN_DIR = resolve(`${MODULE_DIR}../..`)
+export const RUNTIME_DIR = resolve(`${MODULE_DIR}../..`)
 
-export const NETLIFY_PUBLISH_DIR = '.netlify/publish'
-export const NETLIFY_TEMP_DIR = '.netlify/temp'
+export const NEXT_BUILD_DIR = '.netlify/.next'
 
 export const FUNCTIONS_INTERNAL_DIR = '.netlify/functions-internal'
 export const FUNCTIONS_URL = '/.netlify/functions'

src/helpers/constants.ts

@@ -1,16 +1,23 @@
 import { existsSync } from 'node:fs'
 
-import { copySync } from 'fs-extra/esm'
+import { NetlifyPluginConstants } from '@netlify/build'
+import { copySync, moveSync } from 'fs-extra/esm'
 
-import { NETLIFY_PUBLISH_DIR } from './constants.js'
+import { NEXT_BUILD_DIR } from './constants.js'
 
 /**
- * Ensure static assets get uploaded to the Netlify CDN
- * @param publishDir The publish directory
+ * Stash the Next.js build output in a temporary directory
  */
-export const publishStaticAssets = (publishDir: string) => {
+export const stashBuildOutput = ({ PUBLISH_DIR }: NetlifyPluginConstants) => {
+  moveSync(PUBLISH_DIR, NEXT_BUILD_DIR, { overwrite: true })
+}
+
+/**
+ * Move static assets so they are uploaded to the Netlify CDN
+ */
+export const moveStaticAssets = ({ PUBLISH_DIR }: NetlifyPluginConstants) => {
   if (existsSync('public')) {
-    copySync('public', NETLIFY_PUBLISH_DIR, { overwrite: true })
+    copySync('public', PUBLISH_DIR)
   }
-  copySync(`${publishDir}/static/`, `${NETLIFY_PUBLISH_DIR}/_next/static`, { overwrite: true })
+  copySync(`${NEXT_BUILD_DIR}/static/`, `${PUBLISH_DIR}/_next/static`)
 }

src/helpers/files.ts

@@ -1,86 +1,53 @@
 import { writeFileSync } from 'fs'
 
-import { NetlifyConfig } from '@netlify/build'
-import { build } from 'esbuild'
+import { nodeFileTrace } from '@vercel/nft'
 import { copySync, emptyDirSync, readJsonSync, writeJSONSync } from 'fs-extra/esm'
 
-import {
-  NETLIFY_TEMP_DIR,
-  SERVER_HANDLER_DIR,
-  SERVER_HANDLER_NAME,
-  SERVER_HANDLER_URL,
-  PLUGIN_DIR,
-} from './constants.js'
+import { NEXT_BUILD_DIR, SERVER_HANDLER_DIR, SERVER_HANDLER_NAME, PLUGIN_DIR } from './constants.js'
+import { write } from 'fs-extra'
+
+const pkg = readJsonSync(`${PLUGIN_DIR}/package.json`)
 
 /**
  * Create a Netlify function to run the Next.js server
  * @param publishDir The publish directory
  * @param config Netlify config
  */
-export const createServerHandler = async (publishDir: string, config: NetlifyConfig) => {
+export const createServerHandler = async () => {
   // clear the server handler directory
   emptyDirSync(SERVER_HANDLER_DIR)
 
-  // copy the next.js standalone build output to the server handler directory
-  copySync(`${publishDir}/standalone/.next`, `${SERVER_HANDLER_DIR}/.next`)
-  copySync(`${publishDir}/standalone/node_modules`, `${SERVER_HANDLER_DIR}/node_modules`)
+  // trace the server handler dependencies
+  const { fileList } = await nodeFileTrace(
+    [`${PLUGIN_DIR}/dist/templates/server-handler.js`, `${PLUGIN_DIR}/dist/templates/cache-handler.cjs`],
+    { base: PLUGIN_DIR, ignore: ['package.json', 'node_modules/next/**'] },
+  )
 
-  const pkg = readJsonSync(`${PLUGIN_DIR}/package.json`)
+  // copy the handler dependencies
+  fileList.forEach((path) => {
+    copySync(`${PLUGIN_DIR}/${path}`, `${SERVER_HANDLER_DIR}/${path}`)
+  })
+
+  // copy the next.js standalone build output to the server handler directory
+  copySync(`${NEXT_BUILD_DIR}/standalone/.next`, `${SERVER_HANDLER_DIR}/.next`)
+  copySync(`${NEXT_BUILD_DIR}/standalone/node_modules`, `${SERVER_HANDLER_DIR}/node_modules`)
 
   // create the server handler metadata file
   writeJSONSync(`${SERVER_HANDLER_DIR}/${SERVER_HANDLER_NAME}.json`, {
     config: {
       name: 'Next.js Server Handler',
       generator: `${pkg.name}@${pkg.version}`,
       nodeBundler: 'none',
-      // TODO: remove the final include when Netlify Functions v2 fixes the default exports bug
-      includedFiles: ['.next/**', 'node_modules/**', `${SERVER_HANDLER_NAME}*`],
+      includedFiles: [`${SERVER_HANDLER_NAME}*`, 'package.json', 'dist/**', '.next/**', 'node_modules/**'],
       includedFilesBasePath: SERVER_HANDLER_DIR,
     },
     version: 1,
   })
 
-  // bundle the cache handler
-  await build({
-    entryPoints: [`${PLUGIN_DIR}/dist/templates/cache-handler.js`],
-    bundle: true,
-    platform: 'node',
-    target: ['node18'],
-    format: 'cjs',
-    outfile: `${SERVER_HANDLER_DIR}/${SERVER_HANDLER_NAME}-cache.js`,
-  })
+  writeFileSync(`${SERVER_HANDLER_DIR}/package.json`, JSON.stringify({ type: 'module' }))
 
-  // bundle the server handler
-  await build({
-    entryPoints: [`${PLUGIN_DIR}/dist/templates/server-handler.js`],
-    bundle: true,
-    platform: 'node',
-    target: ['node18'],
-    format: 'esm',
-    external: ['next'],
-    outfile: `${SERVER_HANDLER_DIR}/${SERVER_HANDLER_NAME}-actual.mjs`,
-  })
-
-  // TODO: remove when Netlify Functions v2 fixes the default exports bug
-  // https://github.com/netlify/pod-dev-foundations/issues/599
   writeFileSync(
-    `${SERVER_HANDLER_DIR}/${SERVER_HANDLER_NAME}.mjs`,
-    `import handler from './${SERVER_HANDLER_NAME}-actual.mjs';export default (request) => handler(request);`,
+    `${SERVER_HANDLER_DIR}/${SERVER_HANDLER_NAME}.js`,
+    `import handler from './dist/templates/server-handler.js';export default (request) => handler;export const config = { path: '/*' }`,
   )
-
-  // TODO: remove this when we can use inline config
-  // https://github.com/netlify/next-runtime-minimal/issues/13
-  config.redirects ||= []
-  config.redirects.push({ from: `/*`, to: SERVER_HANDLER_URL, status: 200 })
-}
-
-export const createCacheHandler = async () => {
-  await build({
-    entryPoints: [`${PLUGIN_DIR}/dist/templates/cache-handler.js`],
-    bundle: true,
-    platform: 'node',
-    target: ['node18'],
-    format: 'cjs',
-    outfile: `${NETLIFY_TEMP_DIR}/cache-handler.js`,
-  })
 }

src/helpers/functions.ts

@@ -1,22 +1,17 @@
 import type { NetlifyPluginOptions } from '@netlify/build'
 
-import { modifyNetlifyConfig, modifyNextConfig, revertNextConfig } from './helpers/config.js'
-import { publishStaticAssets } from './helpers/files.js'
-import { createServerHandler, createCacheHandler } from './helpers/functions.js'
+import { setBuildtimeConfig } from './helpers/config.js'
+import { moveStaticAssets, stashBuildOutput } from './helpers/files.js'
+import { createServerHandler } from './helpers/functions.js'
 
 type NetlifyPluginOptionsWithFlags = NetlifyPluginOptions & { featureFlags?: Record<string, unknown> }
 
-export const onPreBuild = async () => {
-  await createCacheHandler()
-  modifyNextConfig()
+export const onPreBuild = () => {
+  setBuildtimeConfig()
 }
 
-export const onBuild = async ({ constants, netlifyConfig }: NetlifyPluginOptionsWithFlags) => {
-  publishStaticAssets(constants.PUBLISH_DIR)
-  await createServerHandler(constants.PUBLISH_DIR, netlifyConfig)
-  modifyNetlifyConfig(netlifyConfig)
-}
-
-export const onEnd = () => {
-  revertNextConfig()
+export const onBuild = async ({ constants }: NetlifyPluginOptionsWithFlags) => {
+  stashBuildOutput(constants)
+  moveStaticAssets(constants)
+  await createServerHandler()
 }

src/index.ts

@@ -1,34 +1,24 @@
-import { readFile } from 'node:fs/promises'
-import { fileURLToPath } from 'node:url'
-
 import { toComputeResponse, toReqRes } from '@fastly/http-compute-js'
 
-import { SERVER_HANDLER_NAME } from '../helpers/constants.js'
-
-const dir = fileURLToPath(new URL('.', import.meta.url))
-
-// json config generated at build time
-const requiredServerFiles = JSON.parse(await readFile('./.next/required-server-files.json', 'utf-8'))
+import { RUNTIME_DIR } from '../helpers/constants.js'
 
-// set the path to the cache handler
-requiredServerFiles.config.experimental = {
-  ...requiredServerFiles.config.experimental,
-  incrementalCacheHandlerPath: `${dir}/${SERVER_HANDLER_NAME}-cache.js`,
-}
-
-// set config from the build output
-process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(requiredServerFiles.config)
+let nextHandler: any
 
 export default async (request: Request) => {
-  const { getRequestHandlers } = await import('next/dist/server/lib/start-server.js')
-
-  // let Next.js initialize and create the request handler
-  const [nextHandler] = await getRequestHandlers({
-    port: 3000,
-    hostname: 'localhost',
-    dir,
-    isDev: false,
-  })
+  if (!nextHandler) {
+    // set the server config
+    const { setRuntimeConfig } = await import('../helpers/config.js')
+    await setRuntimeConfig()
+
+    // let Next.js initialize and create the request handler
+    const { getRequestHandlers } = await import('next/dist/server/lib/start-server.js')
+    ;[nextHandler] = await getRequestHandlers({
+      port: 3000,
+      hostname: 'localhost',
+      dir: RUNTIME_DIR,
+      isDev: false,
+    })
+  }
 
   const { req, res } = toReqRes(request)