@wular/pnext 0.0.3 → 0.0.6

package/src/compat/cache/resume-data-cache.ts

@@ -12,132 +12,134 @@
 // render computes. Values are plain data only; anything else was skipped at capture and is recomputed
 // at request time.
 
-import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
-import path from 'node:path';
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
+import path from 'node:path'
 import {
   getRequestExtensions,
   type PrerenderSidecarContext,
   type PrerenderSidecarExtension,
-} from '../../extensions';
-import { pathRevalidatedSince, tagsRevalidatedSince, tagsStaleSince } from './revalidate';
+} from '../../extensions'
+import { pathRevalidatedSince, tagsRevalidatedSince, tagsStaleSince } from './revalidate'
 import {
   beginUseCacheRdcCapture,
   collectUseCacheRdcRecords,
   collectUseCacheRdcTags,
   seedUseCacheRdcRecords,
   type UseCacheRdcRecord,
-} from './use-cache';
+} from './use-cache'
 import {
   beginFetchRdcCapture,
   collectFetchRdcRecords,
   seedFetchRdcRecords,
   type FetchRdcRecord,
-} from './fetch-patch';
+} from './fetch-patch'
 
 export interface ResumeDataArtifact {
-  v: 1;
-  useCache: UseCacheRdcRecord[];
-  fetch: FetchRdcRecord[];
+  v: 1
+  useCache: UseCacheRdcRecord[]
+  fetch: FetchRdcRecord[]
   /**
    * Union of every captured cache tag - including tags of entries too complex to serialize as records
    * (page-level `use cache` trees). isStale() must see them or updateTag()/revalidateTag() can never
    * stale the prebuilt shell.
    */
-  tags?: string[];
+  tags?: string[]
 }
 
 function isArtifact(value: unknown): value is ResumeDataArtifact {
-  const artifact = value as Partial<ResumeDataArtifact> | null;
+  const artifact = value as Partial<ResumeDataArtifact> | null
   return (
     typeof value === 'object' &&
     value !== null &&
     artifact?.v === 1 &&
     Array.isArray(artifact.useCache) &&
     Array.isArray(artifact.fetch)
-  );
+  )
 }
 
 function artifactPath(context: PrerenderSidecarContext): string {
-  return path.join(context.outPath, 'ppr', `${context.routeId}.rdc`);
+  return path.join(context.outPath, 'ppr', `${context.routeId}.rdc`)
 }
 
 function shellPath(context: PrerenderSidecarContext): string {
-  return path.join(context.outPath, 'ppr', `${context.routeId}.html`);
+  return path.join(context.outPath, 'ppr', `${context.routeId}.html`)
 }
 
 async function sidecarFreshnessAt(context: PrerenderSidecarContext): Promise<number | undefined> {
   for (const file of [shellPath(context), artifactPath(context)]) {
     try {
-      return (await stat(file)).mtimeMs;
+      return (await stat(file)).mtimeMs
     } catch {
       // Try the fallback artifact when unit-testing the extension directly.
     }
   }
-  return undefined;
+  return undefined
 }
 
-async function readArtifact(context: PrerenderSidecarContext): Promise<ResumeDataArtifact | undefined> {
+async function readArtifact(
+  context: PrerenderSidecarContext,
+): Promise<ResumeDataArtifact | undefined> {
   try {
-    const artifact = JSON.parse(await readFile(artifactPath(context), 'utf8')) as unknown;
-    return isArtifact(artifact) ? artifact : undefined;
+    const artifact = JSON.parse(await readFile(artifactPath(context), 'utf8')) as unknown
+    return isArtifact(artifact) ? artifact : undefined
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 export const resumeDataCacheExtension: PrerenderSidecarExtension = {
   begin() {
-    beginUseCacheRdcCapture();
-    beginFetchRdcCapture();
+    beginUseCacheRdcCapture()
+    beginFetchRdcCapture()
   },
   async collect() {
-    const useCache = await collectUseCacheRdcRecords();
-    const fetch = await collectFetchRdcRecords();
-    const tags = await collectUseCacheRdcTags();
-    if (useCache.length === 0 && fetch.length === 0 && tags.length === 0) return undefined;
+    const useCache = await collectUseCacheRdcRecords()
+    const fetch = await collectFetchRdcRecords()
+    const tags = await collectUseCacheRdcTags()
+    if (useCache.length === 0 && fetch.length === 0 && tags.length === 0) return undefined
     return {
       v: 1,
       useCache,
       fetch,
       ...(tags.length > 0 ? { tags } : {}),
-    } satisfies ResumeDataArtifact;
+    } satisfies ResumeDataArtifact
   },
   async persist(context, artifact) {
-    if (!isArtifact(artifact)) return;
-    const file = artifactPath(context);
-    await mkdir(path.dirname(file), { recursive: true });
-    await writeFile(file, JSON.stringify(artifact));
+    if (!isArtifact(artifact)) return
+    const file = artifactPath(context)
+    await mkdir(path.dirname(file), { recursive: true })
+    await writeFile(file, JSON.stringify(artifact))
   },
   async seed(context) {
-    const artifact = await readArtifact(context);
-    if (!artifact) return;
-    seedUseCacheRdcRecords(artifact.useCache, context.routePath);
-    seedFetchRdcRecords(artifact.fetch, context.routePath, artifact.tags ?? []);
+    const artifact = await readArtifact(context)
+    if (!artifact) return
+    seedUseCacheRdcRecords(artifact.useCache, context.routePath)
+    seedFetchRdcRecords(artifact.fetch, context.routePath, artifact.tags ?? [])
   },
   async isStale(context) {
-    const freshnessAt = await sidecarFreshnessAt(context);
+    const freshnessAt = await sidecarFreshnessAt(context)
     if (freshnessAt !== undefined && pathRevalidatedSince(context.routePath, freshnessAt)) {
-      return true;
+      return true
     }
-    const artifact = await readArtifact(context);
-    if (!artifact) return false;
+    const artifact = await readArtifact(context)
+    if (!artifact) return false
     const tags = [
       ...(artifact.tags ?? []),
       ...artifact.useCache.flatMap(record => record.tags),
       ...artifact.fetch.flatMap(record => record.tags),
-    ];
+    ]
     if (
       freshnessAt !== undefined &&
       getRequestExtensions().staticStaleness(context.routePath, freshnessAt, tags)
     ) {
-      return true;
+      return true
     }
     // Soft revalidations (revalidateTag with a nonzero-expiry profile) mark tags stale rather than
     // hard-revalidated. A PPR shell whose data carries a stale tag must regenerate on the next request -
     // the shell IS the data, since the values are baked into the prerendered HTML, so unlike ISR there
     // is no softer way to refresh it.
-    if (freshnessAt === undefined) return false;
-    if (tagsRevalidatedSince(tags, freshnessAt)) return true;
-    return tagsStaleSince(tags, freshnessAt) ? 'soft' : false;
+    if (freshnessAt === undefined) return false
+    if (tagsRevalidatedSince(tags, freshnessAt)) return true
+    return tagsStaleSince(tags, freshnessAt) ? 'soft' : false
   },
-};
+}