Merge pull request #22 from netlify/rs/modify-headers

fix: modify response headers before `res.send`

Author: orinokai

package-lock.json

@@ -34,7 +34,7 @@
   },
   "homepage": "https://github.com/netlify/next-runtime-minimal#readme",
   "dependencies": {
-    "@fastly/http-compute-js": "github:orinokai/http-compute-js",
+    "@fastly/http-compute-js": "1.1.1",
     "@netlify/blobs": "^1.6.0",
     "@netlify/build": "^29.20.6",
     "@netlify/functions": "^2.0.1",

package.json

@@ -1,4 +1,5 @@
 import { toComputeResponse, toReqRes } from '@fastly/http-compute-js'
+import type { HeadersSentEvent } from '@fastly/http-compute-js/dist/http-compute-js/http-outgoing.js'
 import type { NextConfigComplete } from 'next/dist/server/config-shared.js'
 import type { WorkerRequestHandler } from 'next/dist/server/lib/types.js'
 
@@ -26,6 +27,14 @@ export default async (request: Request) => {
 
   const { req, res } = toReqRes(request)
 
+  res.prependListener('_headersSent', (event: HeadersSentEvent) => {
+    const headers = new Headers(event.headers)
+    setCacheControlHeaders(headers)
+    setVaryHeaders(headers, request, nextConfig)
+    event.headers = Object.fromEntries(headers.entries())
+    console.log('Modified response headers:', JSON.stringify(event.headers, null, 2))
+  })
+
   try {
     console.log('Next server request:', req.url)
     await nextHandler(req, res)
@@ -39,8 +48,5 @@ export default async (request: Request) => {
   const response = { headers: res.getHeaders(), statusCode: res.statusCode }
   console.log('Next server response:', JSON.stringify(response, null, 2))
 
-  setCacheControlHeaders(res)
-  setVaryHeaders(res, req, nextConfig)
-
   return toComputeResponse(res)
 }

src/handlers/server.ts

@@ -8,10 +8,10 @@ export const WORKING_DIR = process.cwd()
 export const BUILD_DIR = `${WORKING_DIR}/.netlify`
 export const RUN_DIR = WORKING_DIR
 
-export const SERVER_FUNCTIONS_DIR = `${WORKING_DIR}/.netlify/functions-internal`
+export const SERVER_FUNCTIONS_DIR = `${BUILD_DIR}/functions-internal`
 export const SERVER_HANDLER_NAME = '___netlify-server-handler'
 export const SERVER_HANDLER_DIR = `${SERVER_FUNCTIONS_DIR}/${SERVER_HANDLER_NAME}`
 
-export const EDGE_FUNCTIONS_DIR = `${WORKING_DIR}/.netlify/edge-functions`
+export const EDGE_FUNCTIONS_DIR = `${BUILD_DIR}/edge-functions`
 export const EDGE_HANDLER_NAME = '___netlify-edge-handler'
 export const EDGE_HANDLER_DIR = `${EDGE_FUNCTIONS_DIR}/${EDGE_HANDLER_NAME}`

src/helpers/constants.ts

@@ -1,94 +1,87 @@
-import type { IncomingMessage, ServerResponse } from 'http'
-
 import type { NextConfigComplete } from 'next/dist/server/config-shared.js'
 
-type HeaderValue = number | string | string[]
-
-interface NetlifyVaryDirectives {
+interface NetlifyVaryValues {
   headers: string[]
   languages: string[]
   cookies: string[]
 }
 
-const generateNetlifyVaryDirectives = ({
-  headers,
-  languages,
-  cookies,
-}: NetlifyVaryDirectives): string[] => {
-  const directives = []
+const generateNetlifyVaryValues = ({ headers, languages, cookies }: NetlifyVaryValues): string => {
+  const values = []
   if (headers.length !== 0) {
-    directives.push(`header=${headers.join(`|`)}`)
+    values.push(`header=${headers.join(`|`)}`)
   }
   if (languages.length !== 0) {
-    directives.push(`language=${languages.join(`|`)}`)
+    values.push(`language=${languages.join(`|`)}`)
   }
   if (cookies.length !== 0) {
-    directives.push(`cookie=${cookies.join(`|`)}`)
+    values.push(`cookie=${cookies.join(`|`)}`)
   }
-  return directives
+  return values.join(',')
 }
 
-/**
- * Parse a header value into an array of directives
- */
-const getDirectives = (headerValue: HeaderValue): string[] => {
-  const directives = Array.isArray(headerValue) ? headerValue : String(headerValue).split(',')
-  return directives.map((directive) => directive.trim())
+const getHeaderValueArray = (header: string): string[] => {
+  return header.split(',').map((value) => value.trim())
 }
+
+const removeHeaderValues = (header: string, values: string[]): string => {
+  const headerValues = getHeaderValueArray(header)
+  const filteredValues = headerValues.filter(
+    (value) => !values.some((val) => value.startsWith(val)),
+  )
+  return filteredValues.join(', ')
+}
+
 /**
  * Ensure the Netlify CDN varies on things that Next.js varies on,
  * e.g. i18n, preview mode, etc.
  */
 export const setVaryHeaders = (
-  res: ServerResponse,
-  req: IncomingMessage,
+  headers: Headers,
+  request: Request,
   { basePath, i18n }: NextConfigComplete,
 ) => {
-  const netlifyVaryDirectives: NetlifyVaryDirectives = {
+  const netlifyVaryValues: NetlifyVaryValues = {
     headers: [],
     languages: [],
     cookies: ['__prerender_bypass', '__next_preview_data'],
   }
 
-  const vary = res.getHeader('vary')
-  if (vary !== undefined) {
-    netlifyVaryDirectives.headers.push(...getDirectives(vary))
+  const vary = headers.get('vary')
+  if (vary !== null) {
+    netlifyVaryValues.headers.push(...getHeaderValueArray(vary))
   }
 
-  const path = new URL(req.url ?? '/', `http://${req.headers.host}`).pathname
+  const path = new URL(request.url).pathname
   const locales = i18n && i18n.localeDetection !== false ? i18n.locales : []
 
   if (locales.length > 1) {
     const logicalPath = basePath && path.startsWith(basePath) ? path.slice(basePath.length) : path
     if (logicalPath === `/`) {
-      netlifyVaryDirectives.languages.push(...locales)
-      netlifyVaryDirectives.cookies.push(`NEXT_LOCALE`)
+      netlifyVaryValues.languages.push(...locales)
+      netlifyVaryValues.cookies.push(`NEXT_LOCALE`)
     }
   }
 
-  res.setHeader(`netlify-vary`, generateNetlifyVaryDirectives(netlifyVaryDirectives))
+  headers.set(`netlify-vary`, generateNetlifyVaryValues(netlifyVaryValues))
 }
 
 /**
  * Ensure stale-while-revalidate and s-maxage don't leak to the client, but
  * assume the user knows what they are doing if CDN cache controls are set
  */
-export const setCacheControlHeaders = (res: ServerResponse) => {
-  const cacheControl = res.getHeader('cache-control')
+export const setCacheControlHeaders = (headers: Headers) => {
+  const cacheControl = headers.get('cache-control')
   if (
-    cacheControl !== undefined &&
-    !res.hasHeader('cdn-cache-control') &&
-    !res.hasHeader('netlify-cdn-cache-control')
+    cacheControl !== null &&
+    !headers.has('cdn-cache-control') &&
+    !headers.has('netlify-cdn-cache-control')
   ) {
-    const directives = getDirectives(cacheControl).filter(
-      (directive) =>
-        !directive.startsWith('s-maxage') && !directive.startsWith('stale-while-revalidate'),
-    )
-
-    res.setHeader('netlify-cdn-cache-control', cacheControl)
-    res.setHeader(
-      'cache-control',
-      directives.length === 0 ? 'public, max-age=0, must-revalidate' : directives,
-    )
+    const clientCacheControl = removeHeaderValues(cacheControl, [
+      's-maxage',
+      'stale-while-revalidate',
+    ])
+    headers.set('cache-control', clientCacheControl || 'public, max-age=0, must-revalidate')
+    headers.set('netlify-cdn-cache-control', cacheControl)
   }
 }