@rangojs/router 0.0.0-experimental.002d056c

package/src/cache/segment-codec.ts

@@ -0,0 +1,256 @@
+/**
+ * Segment Codec
+ *
+ * RSC serialization/deserialization for cached segments.
+ * Handles the Flight protocol stream <-> string conversion
+ * and the segment-level encode/decode lifecycle.
+ */
+
+/// <reference types="@vitejs/plugin-rsc/types" />
+
+import type { ResolvedSegment } from "../types.js";
+import type { SerializedSegmentData } from "./types.js";
+import {
+  renderToReadableStream,
+  createTemporaryReferenceSet,
+} from "@vitejs/plugin-rsc/rsc";
+import { createFromReadableStream } from "@vitejs/plugin-rsc/rsc";
+
+// ============================================================================
+// Stream Utilities (internal)
+// ============================================================================
+
+/**
+ * Convert a ReadableStream to a string.
+ */
+export async function streamToString(
+  stream: ReadableStream<Uint8Array>,
+): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let result = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result += decoder.decode(value, { stream: true });
+  }
+
+  result += decoder.decode(); // flush
+  return result;
+}
+
+/**
+ * Convert a string to a ReadableStream.
+ */
+export function stringToStream(str: string): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  const uint8 = encoder.encode(str);
+
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(uint8);
+      controller.close();
+    },
+  });
+}
+
+// ============================================================================
+// RSC Serialization Primitives (internal)
+// ============================================================================
+
+/**
+ * RSC-serialize a value using React Server Components stream.
+ * Used for serializing loaderData, layout, loading components etc.
+ *
+ * Returns undefined for null/undefined inputs (component fields that are absent).
+ * For contexts where null is a valid result (loader caching, "use cache"),
+ * use serializeResult() instead which preserves null through RSC Flight.
+ */
+export async function rscSerialize(
+  value: unknown,
+): Promise<string | undefined> {
+  if (value === undefined || value === null) return undefined;
+
+  const temporaryReferences = createTemporaryReferenceSet();
+  const stream = renderToReadableStream(value, { temporaryReferences });
+  return streamToString(stream);
+}
+
+/**
+ * RSC-deserialize a value from a stored string.
+ */
+export async function rscDeserialize<T>(
+  encoded: string | undefined,
+): Promise<T | undefined> {
+  if (!encoded) return undefined;
+
+  const temporaryReferences = createTemporaryReferenceSet();
+  const stream = stringToStream(encoded);
+  return createFromReadableStream<T>(stream, { temporaryReferences });
+}
+
+// ============================================================================
+// Null-Preserving RSC Serialization (for caching)
+// ============================================================================
+
+/**
+ * RSC-serialize any value including null.
+ * Unlike rscSerialize(), this does NOT skip null — it serializes it through
+ * RSC Flight so that a loader returning null produces a valid cached entry
+ * rather than a permanent cache miss.
+ *
+ * Returns null only on serialization failure.
+ */
+export async function serializeResult(value: unknown): Promise<string | null> {
+  try {
+    const temporaryReferences = createTemporaryReferenceSet();
+    const stream = renderToReadableStream(value, { temporaryReferences });
+    return await streamToString(stream);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * RSC-deserialize a cached result string.
+ * Counterpart to serializeResult() — always receives a non-empty string.
+ */
+export async function deserializeResult<T>(encoded: string): Promise<T> {
+  const temporaryReferences = createTemporaryReferenceSet();
+  const stream = stringToStream(encoded);
+  return createFromReadableStream<T>(stream, { temporaryReferences });
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+/**
+ * RSC-deserialize a single encoded component string back to a React element.
+ * Used by the static handler runtime to revive pre-rendered components.
+ * Identical to deserializeResult<unknown>.
+ */
+export const deserializeComponent: (encoded: string) => Promise<unknown> =
+  deserializeResult;
+
+/**
+ * Serialize segments for storage.
+ * Each segment's component, layout, loading, and loaderData are RSC-serialized.
+ * Metadata is preserved as-is.
+ */
+export async function serializeSegments(
+  segments: ResolvedSegment[],
+): Promise<SerializedSegmentData[]> {
+  return Promise.all(
+    segments.map(async (segment): Promise<SerializedSegmentData> => {
+      const temporaryReferences = createTemporaryReferenceSet();
+
+      // Await component if it's a Promise (intercepts with loading keep component as Promise)
+      const componentResolved =
+        segment.component instanceof Promise
+          ? await segment.component
+          : segment.component;
+
+      // Serialize the component to RSC stream
+      const stream = renderToReadableStream(componentResolved, {
+        temporaryReferences,
+      });
+
+      // RSC-serialize loading: "null" string distinguishes explicit null from undefined
+      const encodedLoading =
+        segment.loading !== undefined
+          ? segment.loading === null
+            ? "null"
+            : await rscSerialize(segment.loading)
+          : undefined;
+
+      // Await loaderData / loaderDataPromise if they're Promises
+      const loaderDataResolved =
+        segment.loaderData instanceof Promise
+          ? await segment.loaderData
+          : segment.loaderData;
+      const loaderDataPromiseResolved =
+        segment.loaderDataPromise instanceof Promise
+          ? await segment.loaderDataPromise
+          : segment.loaderDataPromise;
+
+      // Parallelize stream-to-string and RSC serialization of sub-fields
+      const [
+        encoded,
+        encodedLayout,
+        encodedLoaderData,
+        encodedLoaderDataPromise,
+      ] = await Promise.all([
+        streamToString(stream),
+        segment.layout ? rscSerialize(segment.layout) : undefined,
+        rscSerialize(loaderDataResolved),
+        rscSerialize(loaderDataPromiseResolved),
+      ]);
+
+      return {
+        encoded,
+        encodedLayout,
+        encodedLoading,
+        encodedLoaderData,
+        encodedLoaderDataPromise,
+        metadata: {
+          id: segment.id,
+          type: segment.type,
+          namespace: segment.namespace,
+          index: segment.index,
+          params: segment.params,
+          slot: segment.slot,
+          belongsToRoute: segment.belongsToRoute,
+          layoutName: segment.layoutName,
+          parallelName: segment.parallelName,
+          loaderId: segment.loaderId,
+          loaderIds: segment.loaderIds,
+          transition: segment.transition,
+          mountPath: segment.mountPath,
+        },
+      };
+    }),
+  );
+}
+
+/**
+ * Deserialize segments from storage.
+ * Reconstructs ResolvedSegment objects from RSC-serialized data.
+ */
+export async function deserializeSegments(
+  data: SerializedSegmentData[],
+): Promise<ResolvedSegment[]> {
+  return Promise.all(
+    data.map(async (item): Promise<ResolvedSegment> => {
+      const temporaryReferences = createTemporaryReferenceSet();
+
+      // Handle the "null" sentinel for loading before RSC deserialization.
+      // During serialization, loading: null is stored as the string "null" to
+      // distinguish it from undefined.
+      const loadingIsNullSentinel = item.encodedLoading === "null";
+
+      const [component, layout, loaderData, loaderDataPromise, loadingData] =
+        await Promise.all([
+          createFromReadableStream(stringToStream(item.encoded), {
+            temporaryReferences,
+          }),
+          rscDeserialize(item.encodedLayout),
+          rscDeserialize(item.encodedLoaderData),
+          rscDeserialize(item.encodedLoaderDataPromise),
+          loadingIsNullSentinel
+            ? (null as any)
+            : rscDeserialize(item.encodedLoading),
+        ]);
+
+      return {
+        ...item.metadata,
+        component,
+        layout,
+        loading: loadingData,
+        loaderData,
+        loaderDataPromise,
+      } as ResolvedSegment;
+    }),
+  );
+}

package/src/cache/taint.ts

@@ -0,0 +1,98 @@
+/**
+ * Taint symbol for request-scoped objects.
+ *
+ * Objects branded with NOCACHE_SYMBOL (ctx, env, req) are excluded from
+ * "use cache" cache keys and trigger handle capture mode so that side
+ * effects (breadcrumbs, metadata) are recorded and replayed on cache hit.
+ */
+
+export const NOCACHE_SYMBOL: unique symbol = Symbol.for("rango:nocache") as any;
+
+/**
+ * Check if a value is tainted (request-scoped, should not be in cache key).
+ */
+export function isTainted(value: unknown): boolean {
+  return (
+    value !== null &&
+    value !== undefined &&
+    typeof value === "object" &&
+    (NOCACHE_SYMBOL as symbol) in (value as Record<symbol, unknown>)
+  );
+}
+
+/**
+ * Symbol stamped on tainted ctx during "use cache" function execution.
+ * cookies(), headers(), ctx.set(), ctx.header(), etc. check this flag and
+ * throw if present — reads would cache per-request data under a shared key,
+ * and side effects would be lost on cache hit.
+ *
+ * The value is a numeric reference count, not a boolean. Multiple concurrent
+ * cached functions sharing the same ctx/requestCtx each increment on entry
+ * and decrement on exit. Guards fire when count > 0.
+ */
+export const INSIDE_CACHE_EXEC: unique symbol = Symbol.for(
+  "rango:inside-cache-exec",
+) as any;
+
+/**
+ * Increment the INSIDE_CACHE_EXEC ref count on an object.
+ */
+export function stampCacheExec(obj: object): void {
+  const current = (obj as any)[INSIDE_CACHE_EXEC] ?? 0;
+  (obj as any)[INSIDE_CACHE_EXEC] = current + 1;
+}
+
+/**
+ * Decrement the INSIDE_CACHE_EXEC ref count on an object.
+ * Deletes the symbol when the count reaches zero so the `in` check
+ * used by guards no longer fires.
+ */
+export function unstampCacheExec(obj: object): void {
+  const current = (obj as any)[INSIDE_CACHE_EXEC] ?? 0;
+  if (current <= 1) {
+    delete (obj as any)[INSIDE_CACHE_EXEC];
+  } else {
+    (obj as any)[INSIDE_CACHE_EXEC] = current - 1;
+  }
+}
+
+/**
+ * Throw if ctx is inside a "use cache" execution.
+ * Call from side-effecting ctx methods (set, header, etc.) and cookie mutations.
+ */
+export function assertNotInsideCacheExec(
+  ctx: unknown,
+  methodName: string,
+): void {
+  if (
+    ctx !== null &&
+    ctx !== undefined &&
+    typeof ctx === "object" &&
+    (INSIDE_CACHE_EXEC as symbol) in (ctx as Record<symbol, unknown>)
+  ) {
+    throw new Error(
+      `ctx.${methodName}() cannot be called inside a "use cache" function. ` +
+        `Side effects on the request context are lost on cache hit because ` +
+        `the function body is skipped. Extract the data fetch into a separate ` +
+        `cached function and call ctx.${methodName}() outside it, or use the ` +
+        `route-level cache() DSL which caches all segments (handler + children) ` +
+        `together.`,
+    );
+  }
+}
+
+/**
+ * Brand symbol for functions wrapped by registerCachedFunction().
+ * Used at runtime to detect when a "use cache" function is misused
+ * (e.g., passed as middleware).
+ */
+export const CACHED_FN_SYMBOL: unique symbol = Symbol.for(
+  "rango:cached-fn",
+) as any;
+
+/**
+ * Check if a value is a "use cache" wrapped function.
+ */
+export function isCachedFunction(value: unknown): boolean {
+  return typeof value === "function" && (CACHED_FN_SYMBOL as symbol) in value;
+}

package/src/cache/types.ts

@@ -0,0 +1,342 @@
+/**
+ * Cache Store Types
+ *
+ * Generic caching interface supporting multiple value types.
+ * Designed to be implemented by different backends:
+ * - MemoryCacheStore (dev/testing)
+ * - Cloudflare Cache API adapter
+ * - Cloudflare KV adapter
+ * - Redis adapter
+ */
+
+import type { ResolvedSegment } from "../types.js";
+import type { RequestContext } from "../server/request-context.js";
+
+// ============================================================================
+// Segment Cache Store (low-level storage interface)
+// ============================================================================
+
+/**
+ * Result from cache get() including data and revalidation status
+ */
+export interface CacheGetResult {
+  /** The cached entry data */
+  data: CachedEntryData;
+  /**
+   * Whether the caller should trigger background revalidation.
+   * True when entry is stale AND not already being revalidated.
+   * The store atomically marks the entry as REVALIDATING when returning true.
+   */
+  shouldRevalidate: boolean;
+}
+
+/**
+ * Low-level segment cache store interface.
+ *
+ * Implementations handle the actual storage (memory, KV, Redis, etc.).
+ * The store deals with serialized data - RSC serialization is handled
+ * by the cache provider layer.
+ *
+ * @typeParam TEnv - Platform bindings type (e.g., Cloudflare env)
+ */
+export interface SegmentCacheStore<TEnv = unknown> {
+  /**
+   * Default cache options for this store.
+   * Used by cache() boundaries when ttl/swr are not explicitly specified.
+   */
+  readonly defaults?: CacheDefaults;
+
+  /**
+   * Custom key generator applied to all cache operations using this store.
+   * Receives the full RequestContext and the default-generated key.
+   * Return value becomes the final cache key (unless route overrides with `key` option).
+   *
+   * Resolution priority:
+   * 1. Route-level `key` function (full override)
+   * 2. Store-level `keyGenerator` (modifies default key)
+   * 3. Default key generation (prefix:pathname:params)
+   *
+   * @example Using headers for cache segmentation
+   * ```typescript
+   * keyGenerator: (ctx, defaultKey) => {
+   *   const segment = ctx.request.headers.get('x-user-segment') || 'default';
+   *   return `${segment}:${defaultKey}`;
+   * }
+   * ```
+   *
+   * @example Using env bindings (Cloudflare)
+   * ```typescript
+   * keyGenerator: (ctx, defaultKey) => {
+   *   const region = ctx.env.REGION || 'us';
+   *   return `${region}:${defaultKey}`;
+   * }
+   * ```
+   *
+   * @example Using cookies for locale
+   * ```typescript
+   * keyGenerator: (ctx, defaultKey) => {
+   *   const locale = cookies().get('locale')?.value || 'en';
+   *   return `${locale}:${defaultKey}`;
+   * }
+   * ```
+   */
+  readonly keyGenerator?: (
+    ctx: RequestContext<TEnv>,
+    defaultKey: string,
+  ) => string | Promise<string>;
+
+  /**
+   * Get cached entry data by key
+   * @returns Cache result with data and staleness, or null if not found/expired
+   */
+  get(key: string): Promise<CacheGetResult | null>;
+
+  /**
+   * Store entry data with TTL
+   * @param key - Cache key
+   * @param data - Serialized entry data
+   * @param ttl - Time-to-live in seconds
+   * @param swr - Optional stale-while-revalidate window in seconds
+   */
+  set(
+    key: string,
+    data: CachedEntryData,
+    ttl: number,
+    swr?: number,
+  ): Promise<void>;
+
+  /**
+   * Delete a cached entry
+   * @returns true if deleted, false if not found
+   */
+  delete(key: string): Promise<boolean>;
+
+  /**
+   * Clear all cached entries (optional, for testing)
+   */
+  clear?(): Promise<void>;
+
+  // ============================================================================
+  // Document Cache Methods (optional)
+  // ============================================================================
+  // These methods are for caching full HTTP responses (document-level caching).
+  // Stores that support response caching should implement these methods.
+
+  /**
+   * Get a cached Response by key.
+   * Returns the response and whether it should be revalidated (SWR).
+   */
+  getResponse?(
+    key: string,
+  ): Promise<{ response: Response; shouldRevalidate: boolean } | null>;
+
+  /**
+   * Store a Response with TTL and optional SWR window.
+   * @param key - Cache key
+   * @param response - Response to cache (will be cloned)
+   * @param ttl - Time-to-live in seconds
+   * @param swr - Optional stale-while-revalidate window in seconds
+   */
+  putResponse?(
+    key: string,
+    response: Response,
+    ttl: number,
+    swr?: number,
+  ): Promise<void>;
+
+  // ============================================================================
+  // Function Cache Methods (optional, for "use cache" directive)
+  // ============================================================================
+  // These methods cache individual function/component return values.
+  // Stores that support "use cache" should implement these methods.
+
+  /**
+   * Get a cached function result by key.
+   * Returns the serialized value, optional handle data, and staleness flag.
+   */
+  getItem?(key: string): Promise<CacheItemResult | null>;
+
+  /**
+   * Store a function result with TTL and optional SWR window.
+   * @param key - Cache key (format: use-cache:{functionId}:{serializedArgs})
+   * @param value - RSC-serialized return value
+   * @param options - TTL, SWR, handle data, and tags
+   */
+  setItem?(
+    key: string,
+    value: string,
+    options?: CacheItemOptions,
+  ): Promise<void>;
+}
+
+/**
+ * Result from getItem() for function-level caching ("use cache").
+ */
+export interface CacheItemResult {
+  /** RSC-serialized return value */
+  value: string;
+  /** Handle data captured during execution (breadcrumbs, metadata, etc.) */
+  handles?: Record<string, SegmentHandleData>;
+  /** Whether the entry is stale and should be revalidated */
+  shouldRevalidate: boolean;
+}
+
+/**
+ * Options for setItem() for function-level caching ("use cache").
+ */
+export interface CacheItemOptions {
+  /** Handle data to store alongside the value */
+  handles?: Record<string, SegmentHandleData>;
+  /** Time-to-live in seconds */
+  ttl?: number;
+  /** Stale-while-revalidate window in seconds */
+  swr?: number;
+  /** Cache tags for invalidation */
+  tags?: string[];
+}
+
+/**
+ * Serialized segment data stored in cache
+ * Note: loading is preserved to ensure consistent tree structure between cached and fresh renders
+ *
+ * @internal This type is an implementation detail and may change without notice.
+ */
+export interface SerializedSegmentData {
+  /** RSC-encoded component string */
+  encoded: string;
+  /** RSC-encoded layout string (if present) */
+  encodedLayout?: string;
+  /** RSC-encoded loading skeleton string (if present), or "null" for explicit null */
+  encodedLoading?: string;
+  /** RSC-encoded loaderData (if present) */
+  encodedLoaderData?: string;
+  /** RSC-encoded loaderDataPromise (if present) */
+  encodedLoaderDataPromise?: string;
+  /** Segment metadata (everything except component, layout, loading, and loader data) */
+  metadata: Omit<
+    ResolvedSegment,
+    "component" | "layout" | "loading" | "loaderData" | "loaderDataPromise"
+  >;
+}
+
+/**
+ * Raw data stored in cache for an entry
+ *
+ * @internal This type is an implementation detail and may change without notice.
+ */
+export interface CachedEntryData {
+  /** Serialized segments for this entry */
+  segments: SerializedSegmentData[];
+  /** Handle data keyed by segment ID */
+  handles: Record<string, SegmentHandleData>;
+  /** Expiration timestamp (ms since epoch) */
+  expiresAt: number;
+}
+
+// ============================================================================
+// Cache Configuration
+// ============================================================================
+
+/**
+ * Default cache options applied to all cache() boundaries.
+ * Individual cache() calls can override any of these values.
+ *
+ * @example
+ * ```ts
+ * const store = new CFCacheStore({
+ *   defaults: { ttl: 60, swr: 300 }
+ * });
+ * ```
+ */
+export interface CacheDefaults {
+  /**
+   * Default time-to-live in seconds.
+   * After TTL expires, cached entry is considered stale.
+   */
+  ttl?: number;
+  /**
+   * Default stale-while-revalidate window in seconds.
+   * During SWR window, stale content is served while revalidating in background.
+   */
+  swr?: number;
+}
+
+/**
+ * Cache configuration for RSC handler
+ */
+export interface CacheConfig {
+  /** Cache store implementation (includes defaults) */
+  store: SegmentCacheStore;
+  /** Enable/disable caching (default: true) */
+  enabled?: boolean;
+}
+
+/**
+ * Cache configuration - can be static or a function receiving env
+ */
+export type CacheConfigOrFactory<TEnv> =
+  | CacheConfig
+  | ((env: TEnv) => CacheConfig);
+
+// ============================================================================
+// Segment Cache Provider (request-level interface)
+// ============================================================================
+
+/**
+ * Handle data for a single segment
+ * Structure: { handleName: [values...] }
+ */
+export type SegmentHandleData = Record<string, unknown[]>;
+
+/**
+ * Result from cache get() including segments and their handle data
+ * Each entry can produce multiple segments (main + parallels)
+ */
+export interface CachedEntryResult {
+  /** All segments for this entry (main segment + parallels) */
+  segments: ResolvedSegment[];
+  /** Handle data keyed by segment ID */
+  handles: Record<string, SegmentHandleData>;
+}
+
+/**
+ * Segment cache provider interface
+ *
+ * Used by router to check/store segment cache during matching.
+ * Accessed via request context - if not present, caching is disabled.
+ *
+ * @internal Not currently implemented - CacheScope is used directly.
+ * Reserved for future extensibility.
+ */
+export interface SegmentCacheProvider {
+  /** Whether caching is enabled for this request */
+  readonly enabled: boolean;
+
+  /**
+   * Get cached segments and restore handles/loaders.
+   *
+   * Combines cache get with handle replay and loader data restoration.
+   * Returns tuple of [segments, segmentIds] if cache hit, null if miss or disabled.
+   *
+   * @param cacheKey - Cache key to look up
+   * @param params - Route params for cache key generation
+   * @param loaderPromises - Map to restore loader data into
+   * @returns Tuple of [segments, segmentIds] or null if miss
+   */
+  restore(
+    cacheKey: string,
+    params: Record<string, string>,
+    loaderPromises: Map<string, Promise<any>>,
+  ): Promise<[ResolvedSegment[], string[]] | null>;
+
+  /**
+   * Cache entry with automatic handle collection (non-blocking).
+   *
+   * Schedules caching via waitUntil - handles are collected after they settle.
+   * Validates segments have actual components before caching.
+   *
+   * @param cacheKey - The cache key to store under
+   * @param segments - All resolved segments for this entry
+   */
+  cacheEntry(cacheKey: string, segments: ResolvedSegment[]): void;
+}