@wular/pnext 0.0.4 → 0.0.6

package/src/compat/cache/handler.ts

@@ -10,24 +10,24 @@
 // installs it via setCacheHandler, so core never imports compat.
 
 export interface CacheHandlerEntry {
-  value: unknown;
-  lastModified: number;
-  tags?: readonly string[];
+  value: unknown
+  lastModified: number
+  tags?: readonly string[]
 }
 
 export interface CacheHandlerGetContext {
-  tags?: readonly string[];
-  softTags?: readonly string[];
-  kind?: string;
+  tags?: readonly string[]
+  softTags?: readonly string[]
+  kind?: string
 }
 
 export interface CacheHandlerSetContext {
-  tags?: readonly string[];
-  revalidate?: number | false;
-  kind?: string;
+  tags?: readonly string[]
+  revalidate?: number | false
+  kind?: string
   /** Set for fetch data-cache writes (Next's incremental-cache fetch ctx). */
-  fetchCache?: boolean;
-  fetchUrl?: string;
+  fetchCache?: boolean
+  fetchUrl?: string
 }
 
 /** The subset of Next's IncrementalCacheHandler contract pnext drives. */
@@ -35,29 +35,25 @@ export interface CacheHandler {
   get(
     key: string,
     ctx?: CacheHandlerGetContext,
-  ): Promise<CacheHandlerEntry | undefined | null> | CacheHandlerEntry | undefined | null;
-  set(
-    key: string,
-    data: unknown,
-    ctx?: CacheHandlerSetContext,
-  ): Promise<void> | void;
-  revalidateTag?(tag: string | string[]): Promise<void> | void;
-  resetRequestCache?(): void;
+  ): Promise<CacheHandlerEntry | undefined | null> | CacheHandlerEntry | undefined | null
+  set(key: string, data: unknown, ctx?: CacheHandlerSetContext): Promise<void> | void
+  revalidateTag?(tag: string | string[]): Promise<void> | void
+  resetRequestCache?(): void
 }
 
-let handler: CacheHandler | undefined;
+let handler: CacheHandler | undefined
 
 /** Install the configured handler (compat calls this from an init hook). */
 export function setCacheHandler(instance: CacheHandler | undefined): void {
-  handler = instance;
+  handler = instance
 }
 
 export function getCacheHandler(): CacheHandler | undefined {
-  return handler;
+  return handler
 }
 
 export function hasCacheHandler(): boolean {
-  return handler !== undefined;
+  return handler !== undefined
 }
 
 /** Read an entry from the configured handler, tolerating sync/async + throws. */
@@ -65,12 +61,12 @@ export async function cacheHandlerGet(
   key: string,
   ctx?: CacheHandlerGetContext,
 ): Promise<CacheHandlerEntry | undefined> {
-  if (!handler) return undefined;
+  if (!handler) return undefined
   try {
-    const entry = await handler.get(key, ctx);
-    return entry ?? undefined;
+    const entry = await handler.get(key, ctx)
+    return entry ?? undefined
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -80,9 +76,9 @@ export async function cacheHandlerSet(
   data: unknown,
   ctx?: CacheHandlerSetContext,
 ): Promise<void> {
-  if (!handler) return;
+  if (!handler) return
   try {
-    await handler.set(key, data, ctx);
+    await handler.set(key, data, ctx)
   } catch {
     // A handler failure must not break the response; the in-memory store is
     // authoritative for correctness, the handler is a persistence layer.
@@ -91,9 +87,9 @@ export async function cacheHandlerSet(
 
 /** Forward on-demand tag invalidation to the handler if it supports it. */
 export async function cacheHandlerRevalidateTag(tag: string): Promise<void> {
-  if (!handler?.revalidateTag) return;
+  if (!handler?.revalidateTag) return
   try {
-    await handler.revalidateTag(tag);
+    await handler.revalidateTag(tag)
   } catch {
     // best-effort
   }

package/src/compat/cache/modern-handler.ts

@@ -1,113 +1,127 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { format } from 'node:util';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { currentRequest } from '../../request/context';
-import { realNow } from '../../ppr';
-import { getNextConfig } from '../next/config-loader';
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { format } from 'node:util'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { currentRequest } from '../../request/context'
+import { realNow } from '../../render/ppr'
+import { getNextConfig } from '../next/config-loader'
 
 interface ModernCacheEntry {
-  value: ReadableStream<Uint8Array>;
-  tags: string[];
-  stale: number;
-  timestamp: number;
-  expire: number;
-  revalidate: number;
+  value: ReadableStream<Uint8Array>
+  tags: string[]
+  stale: number
+  timestamp: number
+  expire: number
+  revalidate: number
 }
 
 interface ModernCacheHandler {
-  get?: (cacheKey: string, softTags: string[]) => Promise<ModernCacheEntry | undefined> | ModernCacheEntry | undefined;
-  set?: (cacheKey: string, pendingEntry: Promise<ModernCacheEntry>) => Promise<void> | void;
-  refreshTags?: () => Promise<void> | void;
-  getExpiration?: (tags: string[]) => Promise<number> | number;
-  updateTags?: (tags: string[], durations?: { expire?: number }) => Promise<void> | void;
+  get?: (
+    cacheKey: string,
+    softTags: string[],
+  ) => Promise<ModernCacheEntry | undefined> | ModernCacheEntry | undefined
+  set?: (cacheKey: string, pendingEntry: Promise<ModernCacheEntry>) => Promise<void> | void
+  refreshTags?: () => Promise<void> | void
+  getExpiration?: (tags: string[]) => Promise<number> | number
+  updateTags?: (tags: string[], durations?: { expire?: number }) => Promise<void> | void
 }
 
 interface ModernCacheHandlerState {
-  handler?: ModernCacheHandler;
-  installedFor?: string;
+  handler?: ModernCacheHandler
+  installedFor?: string
 }
 
-const MODERN_CACHE_HANDLER_STATE = Symbol.for('pnext.compat.modernCacheHandler');
+const MODERN_CACHE_HANDLER_STATE = Symbol.for('pnext.compat.modernCacheHandler')
 
 function state(): ModernCacheHandlerState {
   const global = globalThis as typeof globalThis & {
-    [MODERN_CACHE_HANDLER_STATE]?: ModernCacheHandlerState;
-  };
-  return (global[MODERN_CACHE_HANDLER_STATE] ??= {});
+    [MODERN_CACHE_HANDLER_STATE]?: ModernCacheHandlerState
+  }
+  return (global[MODERN_CACHE_HANDLER_STATE] ??= {})
 }
 
 export function installModernCacheHandlers(root: string): void {
-  const configured = defaultCacheHandlerPath();
-  const current = state();
+  const configured = defaultCacheHandlerPath()
+  const current = state()
   if (!configured) {
-    current.handler = undefined;
-    current.installedFor = undefined;
-    return;
+    current.handler = undefined
+    current.installedFor = undefined
+    return
   }
-  const filePath = resolveHandlerPath(configured, root);
-  if (current.installedFor === filePath) return;
-  const loaded = loadHandler(filePath, root);
-  if (!loaded) return;
-  current.handler = loaded;
-  current.installedFor = filePath;
+  const filePath = resolveHandlerPath(configured, root)
+  if (current.installedFor === filePath) return
+  const loaded = loadHandler(filePath, root)
+  if (!loaded) return
+  current.handler = loaded
+  current.installedFor = filePath
 }
 
 export function hasModernCacheHandler(): boolean {
-  return state().handler !== undefined;
+  return state().handler !== undefined
 }
 
 export async function modernCacheRefreshTags(): Promise<void> {
-  const refreshTags = state().handler?.refreshTags;
-  const handler = state().handler;
-  if (!handler || !refreshTags) return;
+  const refreshTags = state().handler?.refreshTags
+  const handler = state().handler
+  if (!handler || !refreshTags) return
   try {
-    await withNodeConsoleFormat(() => refreshTags.call(handler));
+    await withNodeConsoleFormat(() => refreshTags.call(handler))
   } catch {
     // best-effort
   }
 }
 
-export async function modernCacheGet(key: string, softTags = implicitSoftTags()): Promise<ModernCacheEntry | undefined> {
-  const handler = state().handler;
-  const get = handler?.get;
-  if (!handler || !get) return undefined;
+export async function modernCacheGet(
+  key: string,
+  softTags = implicitSoftTags(),
+): Promise<ModernCacheEntry | undefined> {
+  const handler = state().handler
+  const get = handler?.get
+  if (!handler || !get) return undefined
   try {
-    return await withNodeConsoleFormat(() => get.call(handler, key, softTags));
+    return await withNodeConsoleFormat(() => get.call(handler, key, softTags))
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
-export async function modernCacheSet(key: string, pendingEntry: Promise<ModernCacheEntry>): Promise<void> {
-  const handler = state().handler;
-  const set = handler?.set;
-  if (!handler || !set) return;
+export async function modernCacheSet(
+  key: string,
+  pendingEntry: Promise<ModernCacheEntry>,
+): Promise<void> {
+  const handler = state().handler
+  const set = handler?.set
+  if (!handler || !set) return
   try {
-    await withNodeConsoleFormat(() => set.call(handler, key, pendingEntry));
+    await withNodeConsoleFormat(() => set.call(handler, key, pendingEntry))
   } catch {
     // best-effort
   }
 }
 
-export async function modernCacheGetExpiration(tags = implicitSoftTags()): Promise<number | undefined> {
-  const handler = state().handler;
-  const getExpiration = handler?.getExpiration;
-  if (!handler || !getExpiration) return undefined;
+export async function modernCacheGetExpiration(
+  tags = implicitSoftTags(),
+): Promise<number | undefined> {
+  const handler = state().handler
+  const getExpiration = handler?.getExpiration
+  if (!handler || !getExpiration) return undefined
   try {
-    return await withNodeConsoleFormat(() => getExpiration.call(handler, tags));
+    return await withNodeConsoleFormat(() => getExpiration.call(handler, tags))
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
-export async function modernCacheUpdateTags(tags: string[], durations?: { expire?: number }): Promise<void> {
-  const handler = state().handler;
-  const updateTags = handler?.updateTags;
-  if (!handler || !updateTags) return;
+export async function modernCacheUpdateTags(
+  tags: string[],
+  durations?: { expire?: number },
+): Promise<void> {
+  const handler = state().handler
+  const updateTags = handler?.updateTags
+  if (!handler || !updateTags) return
   try {
-    await withNodeConsoleFormat(() => updateTags.call(handler, tags, durations));
+    await withNodeConsoleFormat(() => updateTags.call(handler, tags, durations))
   } catch {
     // best-effort
   }
@@ -120,40 +134,40 @@ export async function modernCacheUpdateTags(tags: string[], durations?: { expire
  * single-quoted util.inspect output verbatim.
  */
 async function withNodeConsoleFormat<T>(fn: () => Promise<T> | T): Promise<T> {
-  const original = console.log.bind(console);
+  const original = console.log.bind(console)
   console.log = (...args: unknown[]) => {
-    original(format(...args));
-  };
+    original(format(...args))
+  }
   try {
-    return await fn();
+    return await fn()
   } finally {
-    console.log = original;
+    console.log = original
   }
 }
 
 export function modernCacheKey(id: string, argsJson: string): string {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const buildId = process.env.NODE_ENV === 'development' ? 'development' : 'pnext';
+  const buildId = process.env.NODE_ENV === 'development' ? 'development' : 'pnext'
   // Fixed-width hex: Next's cache keys are whole-byte hex strings and the e2e
   // suites match them with `([0-9a-f]{2})+` — an odd-length (leading-zero
   // trimmed) hash would never match.
-  const hash = Bun.hash.wyhash(`${id}:${argsJson}`).toString(16).padStart(16, '0');
-  return JSON.stringify([buildId, hash, JSON.parse(argsJson)]);
+  const hash = Bun.hash.wyhash(`${id}:${argsJson}`).toString(16).padStart(16, '0')
+  return JSON.stringify([buildId, hash, JSON.parse(argsJson)])
 }
 
 export function modernCacheEntry(input: {
-  value: unknown;
-  tags: string[];
-  staleSeconds?: number;
-  expireSeconds?: number;
-  revalidateSeconds?: number;
-  storedAt: number;
+  value: unknown
+  tags: string[]
+  staleSeconds?: number
+  expireSeconds?: number
+  revalidateSeconds?: number
+  storedAt: number
 }): ModernCacheEntry {
   return {
     value: new ReadableStream<Uint8Array>({
       start(controller) {
-        controller.enqueue(new TextEncoder().encode(JSON.stringify(input.value)));
-        controller.close();
+        controller.enqueue(new TextEncoder().encode(JSON.stringify(input.value)))
+        controller.close()
       },
     }),
     tags: input.tags,
@@ -161,40 +175,41 @@ export function modernCacheEntry(input: {
     timestamp: input.storedAt,
     expire: input.expireSeconds ?? 31536000,
     revalidate: input.revalidateSeconds ?? 900,
-  };
+  }
 }
 
 export function clearModernCacheHandlerForTest(): void {
-  const current = state();
-  current.handler = undefined;
-  current.installedFor = undefined;
+  const current = state()
+  current.handler = undefined
+  current.installedFor = undefined
 }
 
 function defaultCacheHandlerPath(): string | undefined {
-  const cacheHandlers = getNextConfig().cacheHandlers;
-  if (!cacheHandlers || typeof cacheHandlers !== 'object' || Array.isArray(cacheHandlers)) return undefined;
-  const configured = (cacheHandlers as Record<string, unknown>).default;
-  return typeof configured === 'string' && configured.length > 0 ? configured : undefined;
+  const cacheHandlers = getNextConfig().cacheHandlers
+  if (!cacheHandlers || typeof cacheHandlers !== 'object' || Array.isArray(cacheHandlers))
+    return undefined
+  const configured = (cacheHandlers as Record<string, unknown>).default
+  return typeof configured === 'string' && configured.length > 0 ? configured : undefined
 }
 
 function resolveHandlerPath(configured: string, root: string): string {
-  const resolved = configured.startsWith('file:') ? fileURLToPath(configured) : configured;
-  if (path.isAbsolute(resolved)) return resolved;
-  return path.resolve(root, resolved);
+  const resolved = configured.startsWith('file:') ? fileURLToPath(configured) : configured
+  if (path.isAbsolute(resolved)) return resolved
+  return path.resolve(root, resolved)
 }
 
 function loadHandler(filePath: string, root: string): ModernCacheHandler | undefined {
-  if (!existsSync(filePath)) return undefined;
+  if (!existsSync(filePath)) return undefined
   try {
-    const require = createRequire(pathToFileURL(`${root}/index.js`).href);
+    const require = createRequire(pathToFileURL(`${root}/index.js`).href)
     try {
-      return pickHandler(require(filePath));
+      return pickHandler(require(filePath))
     } catch (error) {
-      if (!isNextDistMissing(error)) return undefined;
-      return loadCommonJsHandlerWithNextStubs(filePath, require);
+      if (!isNextDistMissing(error)) return undefined
+      return loadCommonJsHandlerWithNextStubs(filePath, require)
     }
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -203,73 +218,80 @@ function loadCommonJsHandlerWithNextStubs(
   rootRequire: NodeRequire,
 ): ModernCacheHandler | undefined {
   try {
-    const module = { exports: {} as unknown };
+    const module = { exports: {} as unknown }
     const localRequire = (specifier: string): unknown => {
       if (specifier === 'next/dist/server/lib/cache-handlers/default.external') {
-        return { default: createDefaultExternalHandler() };
+        return { default: createDefaultExternalHandler() }
       }
-      if (specifier.startsWith('next/dist/')) return {};
+      if (specifier.startsWith('next/dist/')) return {}
       if (specifier.startsWith('./') || specifier.startsWith('../')) {
-        return rootRequire(path.resolve(path.dirname(filePath), specifier));
+        return rootRequire(path.resolve(path.dirname(filePath), specifier))
       }
-      return rootRequire(specifier);
-    };
-    const source = readFileSync(filePath, 'utf8');
+      return rootRequire(specifier)
+    }
+    const source = readFileSync(filePath, 'utf8')
     // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const evaluate = new Function('require', 'module', 'exports', '__filename', '__dirname', source) as (
+    const evaluate = new Function(
+      'require',
+      'module',
+      'exports',
+      '__filename',
+      '__dirname',
+      source,
+    ) as (
       require: (specifier: string) => unknown,
       module: { exports: unknown },
       exports: unknown,
       filename: string,
       dirname: string,
-    ) => void;
-    evaluate(localRequire, module, module.exports, filePath, path.dirname(filePath));
-    return pickHandler(module.exports);
+    ) => void
+    evaluate(localRequire, module, module.exports, filePath, path.dirname(filePath))
+    return pickHandler(module.exports)
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 function isNextDistMissing(error: unknown): boolean {
-  const message = (error as { message?: unknown }).message;
-  return typeof message === 'string' && message.includes('next/dist/');
+  const message = (error as { message?: unknown }).message
+  return typeof message === 'string' && message.includes('next/dist/')
 }
 
 function pickHandler(mod: unknown): ModernCacheHandler | undefined {
   const candidate =
     mod && typeof mod === 'object' && 'default' in mod
       ? (mod as { default?: unknown }).default
-      : mod;
-  return candidate && typeof candidate === 'object' ? candidate : undefined;
+      : mod
+  return candidate && typeof candidate === 'object' ? candidate : undefined
 }
 
 function createDefaultExternalHandler(): ModernCacheHandler {
-  const entries = new Map<string, ModernCacheEntry>();
-  const tagExpirations = new Map<string, number>();
+  const entries = new Map<string, ModernCacheEntry>()
+  const tagExpirations = new Map<string, number>()
   return {
     get(cacheKey) {
-      return entries.get(cacheKey);
+      return entries.get(cacheKey)
     },
     async set(cacheKey, pendingEntry) {
-      entries.set(cacheKey, await pendingEntry);
+      entries.set(cacheKey, await pendingEntry)
     },
     refreshTags() {
-      return undefined;
+      return undefined
     },
     getExpiration(tags) {
-      let value = 0;
-      for (const tag of tags) value = Math.max(value, tagExpirations.get(tag) ?? 0);
-      return value;
+      let value = 0
+      for (const tag of tags) value = Math.max(value, tagExpirations.get(tag) ?? 0)
+      return value
     },
     updateTags(tags) {
-      const now = realNow();
-      for (const tag of tags) tagExpirations.set(tag, now);
+      const now = realNow()
+      for (const tag of tags) tagExpirations.set(tag, now)
     },
-  };
+  }
 }
 
 function implicitSoftTags(): string[] {
-  const pathname = new URL(currentRequest()?.url ?? 'http://pnext.local/').pathname || '/';
-  const leaf = pathname === '/' ? '/index' : pathname;
-  return ['_N_T_/layout', '_N_T_/page', '_N_T_/', `_N_T_${leaf}`];
+  const pathname = new URL(currentRequest()?.url ?? 'http://pnext.local/').pathname || '/'
+  const leaf = pathname === '/' ? '/index' : pathname
+  return ['_N_T_/layout', '_N_T_/page', '_N_T_/', `_N_T_${leaf}`]
 }