typehell

Author: pieh

src/build/content/prerendered.ts

@@ -10,7 +10,7 @@ import { satisfies } from 'semver'
 
 import { encodeBlobKey } from '../../shared/blobkey.js'
 import type {
-  CachedFetchValue,
+  CachedFetchValueForMultipleVersions,
   NetlifyCachedAppPageValue,
   NetlifyCachedPageValue,
   NetlifyCachedRouteValue,
@@ -107,7 +107,9 @@ const buildRouteCacheValue = async (
   revalidate: initialRevalidateSeconds,
 })
 
-const buildFetchCacheValue = async (path: string): Promise<CachedFetchValue> => ({
+const buildFetchCacheValue = async (
+  path: string,
+): Promise<CachedFetchValueForMultipleVersions> => ({
   kind: 'FETCH',
   ...JSON.parse(await readFile(path, 'utf-8')),
 })

src/run/handlers/cache.cts

@@ -11,14 +11,15 @@ import { type Span } from '@opentelemetry/api'
 import type { PrerenderManifest } from 'next/dist/build/index.js'
 import { NEXT_CACHE_TAGS_HEADER } from 'next/dist/lib/constants.js'
 
-import type {
-  CacheHandler,
-  CacheHandlerContext,
-  IncrementalCache,
-  NetlifyCachedPageValue,
-  NetlifyCachedRouteValue,
-  NetlifyCacheHandlerValue,
-  NetlifyIncrementalCacheValue,
+import {
+  type CacheHandlerContext,
+  type CacheHandlerForMultipleVersions,
+  isCachedPageValue,
+  isCachedRouteValue,
+  type NetlifyCachedPageValue,
+  type NetlifyCachedRouteValue,
+  type NetlifyCacheHandlerValue,
+  type NetlifyIncrementalCacheValue,
 } from '../../shared/cache-types.cjs'
 import { getRegionalBlobStore } from '../regional-blob-store.cjs'
 
@@ -29,7 +30,7 @@ type TagManifest = { revalidatedAt: number }
 
 type TagManifestBlobCache = Record<string, Promise<TagManifest>>
 
-export class NetlifyCacheHandler implements CacheHandler {
+export class NetlifyCacheHandler implements CacheHandlerForMultipleVersions {
   options: CacheHandlerContext
   revalidatedTags: string[]
   blobStore: Store
@@ -190,7 +191,9 @@ export class NetlifyCacheHandler implements CacheHandler {
     }
   }
 
-  async get(...args: Parameters<CacheHandler['get']>): ReturnType<CacheHandler['get']> {
+  async get(
+    ...args: Parameters<CacheHandlerForMultipleVersions['get']>
+  ): ReturnType<CacheHandlerForMultipleVersions['get']> {
     return this.tracer.withActiveSpan('get cache key', async (span) => {
       const [key, ctx = {}] = args
       getLogger().debug(`[NetlifyCacheHandler.get]: ${key}`)
@@ -282,18 +285,22 @@ export class NetlifyCacheHandler implements CacheHandler {
   }
 
   private transformToStorableObject(
-    data: Parameters<IncrementalCache['set']>[1],
-    context: Parameters<IncrementalCache['set']>[2],
+    data: Parameters<CacheHandlerForMultipleVersions['set']>[1],
+    context: Parameters<CacheHandlerForMultipleVersions['set']>[2],
   ): NetlifyIncrementalCacheValue | null {
-    if (data?.kind === 'ROUTE' || data?.kind === 'APP_ROUTE') {
+    if (!data) {
+      return null
+    }
+
+    if (isCachedRouteValue(data)) {
       return {
         ...data,
         revalidate: context.revalidate,
         body: data.body.toString('base64'),
       }
     }
 
-    if (data?.kind === 'PAGE' || data?.kind === 'PAGES') {
+    if (isCachedPageValue(data)) {
       return {
         ...data,
         revalidate: context.revalidate,
@@ -311,7 +318,7 @@ export class NetlifyCacheHandler implements CacheHandler {
     return data
   }
 
-  async set(...args: Parameters<IncrementalCache['set']>) {
+  async set(...args: Parameters<CacheHandlerForMultipleVersions['set']>) {
     return this.tracer.withActiveSpan('set cache key', async (span) => {
       const [key, data, context] = args
       const blobKey = await this.encodeBlobKey(key)

src/run/handlers/request-context.cts

@@ -4,7 +4,8 @@ import { LogLevel, systemLogger } from '@netlify/functions/internal'
 
 import type { NetlifyCachedRouteValue } from '../../shared/cache-types.cjs'
 
-// hacks?
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - last remaining bit to fix
 process.env.NODE_ENV = 'production'
 
 type SystemLogger = typeof systemLogger

src/shared/cache-types.cts

@@ -1,58 +1,133 @@
 import type {
+  CacheHandler,
   CacheHandlerValue,
-  IncrementalCache,
 } from 'next/dist/server/lib/incremental-cache/index.js'
 import type {
+  CachedFetchValue,
   CachedRouteValue,
   IncrementalCachedAppPageValue,
+  IncrementalCachedPageValue,
   IncrementalCacheValue,
 } from 'next/dist/server/response-cache/types.js'
 
-export type {
-  CacheHandler,
-  CacheHandlerContext,
-  IncrementalCache,
-} from 'next/dist/server/lib/incremental-cache/index.js'
+export type { CacheHandlerContext } from 'next/dist/server/lib/incremental-cache/index.js'
 
-export type NetlifyCachedRouteValue = Omit<CachedRouteValue, 'body'> & {
+/**
+ * Shape of the cache value that is returned from CacheHandler.get or passed to CacheHandler.set
+ */
+type CachedRouteValueForMultipleVersions = Omit<CachedRouteValue, 'kind'> & {
+  kind: 'ROUTE' | 'APP_ROUTE'
+}
+
+/**
+ * Used for storing in blobs and reading from blobs
+ */
+export type NetlifyCachedRouteValue = Omit<CachedRouteValueForMultipleVersions, 'body'> & {
   // Next.js stores body as buffer, while we store it as base64 encoded string
   body: string
   // Next.js doesn't produce cache-control tag we use to generate cdn cache control
   // so store needed values as part of cached response data
-  revalidate: Parameters<IncrementalCache['set']>[2]['revalidate']
+  revalidate?: Parameters<CacheHandler['set']>[2]['revalidate']
 }
 
-export type NetlifyCachedAppPageValue = Omit<IncrementalCachedAppPageValue, 'rscData'> & {
+/**
+ * Shape of the cache value that is returned from CacheHandler.get or passed to CacheHandler.set
+ */
+type IncrementalCachedAppPageValueForMultipleVersions = Omit<
+  IncrementalCachedAppPageValue,
+  'kind'
+> & {
+  kind: 'APP_PAGE'
+}
+
+/**
+ * Used for storing in blobs and reading from blobs
+ */
+export type NetlifyCachedAppPageValue = Omit<
+  IncrementalCachedAppPageValueForMultipleVersions,
+  'rscData'
+> & {
   // Next.js stores rscData as buffer, while we store it as base64 encoded string
   rscData: string | undefined
-  revalidate?: Parameters<IncrementalCache['set']>[2]['revalidate']
+  revalidate?: Parameters<CacheHandler['set']>[2]['revalidate']
 }
 
-type CachedPageValue = Extract<IncrementalCacheValue, { kind: 'PAGES' }>
-
-export type NetlifyCachedPageValue = CachedPageValue & {
-  revalidate?: Parameters<IncrementalCache['set']>[2]['revalidate']
+/**
+ * Shape of the cache value that is returned from CacheHandler.get or passed to CacheHandler.set
+ */
+type IncrementalCachedPageValueForMultipleVersions = Omit<IncrementalCachedPageValue, 'kind'> & {
+  kind: 'PAGE' | 'PAGES'
 }
 
-export type CachedFetchValue = Extract<IncrementalCacheValue, { kind: 'FETCH' }>
+/**
+ * Used for storing in blobs and reading from blobs
+ */
+export type NetlifyCachedPageValue = IncrementalCachedPageValueForMultipleVersions & {
+  revalidate?: Parameters<CacheHandler['set']>[2]['revalidate']
+}
 
-export type NetlifyIncrementalCacheValue =
-  | Exclude<
-      IncrementalCacheValue,
-      CachedRouteValue | CachedPageValue | IncrementalCachedAppPageValue
-    >
-  | NetlifyCachedRouteValue
-  | NetlifyCachedPageValue
-  | NetlifyCachedAppPageValue
+export type CachedFetchValueForMultipleVersions = Omit<CachedFetchValue, 'kind'> & {
+  kind: 'FETCH'
+}
 
 type CachedRouteValueToNetlify<T> = T extends CachedRouteValue
   ? NetlifyCachedRouteValue
-  : T extends CachedPageValue
+  : T extends IncrementalCachedPageValue
     ? NetlifyCachedPageValue
     : T extends IncrementalCachedAppPageValue
       ? NetlifyCachedAppPageValue
       : T
 
 type MapCachedRouteValueToNetlify<T> = { [K in keyof T]: CachedRouteValueToNetlify<T[K]> }
 
+/**
+ * Used for storing in blobs and reading from blobs
+ */
 export type NetlifyCacheHandlerValue = MapCachedRouteValueToNetlify<CacheHandlerValue>
+
+/**
+ * Used for storing in blobs and reading from blobs
+ */
+export type NetlifyIncrementalCacheValue = NetlifyCacheHandlerValue['value']
+
+// type IncrementalCacheValueToMultipleVersions<T> = T extends CachedRouteValue ?
+type IncrementalCacheValueToMultipleVersions<T> = T extends CachedRouteValue
+  ? CachedRouteValueForMultipleVersions
+  : T extends IncrementalCachedPageValue
+    ? IncrementalCachedPageValueForMultipleVersions
+    : T extends IncrementalCachedAppPageValue
+      ? IncrementalCachedAppPageValueForMultipleVersions
+      : T extends CachedFetchValue
+        ? CachedFetchValueForMultipleVersions
+        : T extends CacheHandlerValue
+          ? {
+              [K in keyof T]: IncrementalCacheValueToMultipleVersions<T[K]>
+            }
+          : T
+
+type IncrementalCacheValueForMultipleVersions =
+  IncrementalCacheValueToMultipleVersions<IncrementalCacheValue>
+
+export const isCachedPageValue = (
+  value: IncrementalCacheValueForMultipleVersions,
+): value is IncrementalCachedPageValueForMultipleVersions =>
+  value.kind === 'PAGE' || value.kind === 'PAGES'
+
+export const isCachedRouteValue = (
+  value: IncrementalCacheValueForMultipleVersions,
+): value is CachedRouteValueForMultipleVersions =>
+  value.kind === 'ROUTE' || value.kind === 'APP_ROUTE'
+
+type MapArgsOrReturn<T> = T extends readonly any[]
+  ? { [K in keyof T]: MapArgsOrReturn<T[K]> }
+  : T extends Promise<infer P>
+    ? Promise<MapArgsOrReturn<P>>
+    : IncrementalCacheValueToMultipleVersions<T>
+
+type MapCacheHandlerClassMethod<T> = T extends (...args: infer Args) => infer Ret
+  ? (...args: MapArgsOrReturn<Args>) => MapArgsOrReturn<Ret>
+  : T
+
+type MapCacheHandlerClass<T> = { [K in keyof T]: MapCacheHandlerClassMethod<T[K]> }
+
+export type CacheHandlerForMultipleVersions = MapCacheHandlerClass<CacheHandler>