Merge branch 'main' into tn/blob

Author: taty2010

package-lock.json

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

package.json

@@ -1,14 +1,23 @@
+import { getStore } from '@netlify/blobs'
+import { purgeCache } from '@netlify/functions'
 import type { CacheHandler, CacheHandlerContext } from 'next/dist/server/lib/incremental-cache/index.js'
 
+type TagManifest = { revalidatedAt: number }
+
+const tagsManifestPath = '_netlify-cache/tags'
+const blobStore = getStore('TODO')
+
 /**
  * Netlify Cache Handler
  * (CJS format because Next.js doesn't support ESM yet)
  */
 export default class NetlifyCacheHandler implements CacheHandler {
  options: CacheHandlerContext
+ revalidatedTags: string[]
 
  constructor(options: CacheHandlerContext) {
  this.options = options
+ this.revalidatedTags = options.revalidatedTags
  }
 
  // eslint-disable-next-line require-await, class-methods-use-this
@@ -25,5 +34,30 @@ export default class NetlifyCacheHandler implements CacheHandler {
  // eslint-disable-next-line class-methods-use-this, require-await
  public async revalidateTag(tag: string) {
  console.log('NetlifyCacheHandler.revalidateTag', tag)
+
+ const data: TagManifest = {
+ revalidatedAt: Date.now()
+ }
+
+ try {
+ blobStore.setJSON(this.tagManifestPath(tag), data)
+ } catch (error: any) {
+ console.warn(`Failed to update tag manifest for ${tag}`, error)
+ }
+ 
+ purgeCache({ tags: [tag] })
+ }
+
+ private async loadTagManifest(tag: string) {
+ try {
+ return await blobStore.get(this.tagManifestPath(tag), {type: 'json'})
+ } catch (error: any) {
+ console.warn(`Failed to fetch tag manifest for ${tag}`, error)
+ }
+ }
+
+ // eslint-disable-next-line class-methods-use-this
+ private tagManifestPath(tag: string) {
+ return [tagsManifestPath, tag].join('/')
  }
 }

src/handlers/cache.cts

@@ -1,10 +1,11 @@
 /* eslint-disable n/prefer-global/buffer */
 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'
 
 import { RUN_DIR } from '../helpers/constants.js'
-import { setCacheControlHeaders, setVaryHeaders } from '../helpers/headers.js'
+import { setCacheControlHeaders, setCacheTagsHeaders, setVaryHeaders } from '../helpers/headers.js'
 
 let nextHandler: WorkerRequestHandler, nextConfig: NextConfigComplete
 
@@ -27,6 +28,15 @@ export default async (request: Request) => {
 
  const { req, res } = toReqRes(request)
 
+ res.prependListener('_headersSent', (event: HeadersSentEvent) => {
+ const headers = new Headers(event.headers)
+ setCacheControlHeaders(headers)
+ setCacheTagsHeaders(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)
@@ -40,8 +50,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,91 @@
-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)
  }
 }
+
+export const setCacheTagsHeaders = (headers: Headers) => {
+ // TODO: implement
+}