@rangojs/router 0.0.0-experimental.8 → 0.0.0-experimental.80

package/src/server/route-manifest-cache.ts

@@ -1,173 +0,0 @@
-/**
- * Route Manifest Cache
- *
- * Three-tier caching strategy for route manifest data:
- * 1. In-memory (same isolate) - instant
- * 2. SegmentCacheStore (caches.default on Cloudflare) - ~1-2ms
- * 3. Generate on-demand (cache miss) - ~98ms
- *
- * Benefits:
- * - Removes 725KB bundled manifest from worker code
- * - Typical cold start: 0-2ms (cache hit)
- * - Worst case: ~98ms (first request per colo)
- */
-
-import type { SegmentCacheStore, CachedEntryData } from "../cache/types.js";
-import type { GeneratedManifest } from "../build/generate-manifest.js";
-import { setCachedManifest, hasCachedManifest } from "../route-map-builder.js";
-
-/**
- * Cached route data structure
- */
-interface CachedRouteData {
-  /** Route name → pattern mapping for href() */
-  routeManifest: Record<string, string>;
-  /** Version string for cache invalidation */
-  version: string;
-}
-
-// ============================================================================
-// Tier 1: In-memory singleton (same isolate - instant)
-// ============================================================================
-
-let memoryManifest: CachedRouteData | null = null;
-
-/**
- * Options for getRouteManifestData
- */
-export interface GetRouteManifestOptions {
-  /** Cache store implementation (e.g., CFCacheStore). If omitted, memory-only caching is used. */
-  store?: SegmentCacheStore;
-  /** Optional function to schedule non-blocking cache write (e.g., ctx.waitUntil) */
-  waitUntil?: (promise: Promise<void>) => void;
-}
-
-/**
- * Get route manifest data with caching:
- * 1. In-memory (same isolate) - instant
- * 2. SegmentCacheStore (if provided, e.g., CFCacheStore on Cloudflare) - ~1-2ms
- * 3. Generate on-demand (cache miss) - ~98ms
- *
- * When no store is provided, only in-memory caching is used (memory-only mode).
- * This is suitable for development or when external cache is not available.
- *
- * @param generateFn - Function to generate manifest on cache miss
- * @param version - Version string for cache invalidation
- * @param options - Optional cache store and waitUntil function
- * @returns Cached or freshly generated route data
- */
-export async function getRouteManifestData(
-  generateFn: () => GeneratedManifest,
-  version: string,
-  options?: GetRouteManifestOptions
-): Promise<CachedRouteData> {
-  const { store, waitUntil } = options ?? {};
-  const cacheKey = `route-manifest:${version}`;
-
-  const startTime = performance.now();
-
-  // 1. In-memory check (same isolate) - instant
-  if (memoryManifest?.version === version) {
-    console.log("[route-manifest] HIT memory cache (same isolate)");
-    return memoryManifest;
-  }
-
-  // 2. Cache store check (if store provided) - ~1-2ms
-  if (store) {
-    try {
-      const cached = await store.get(cacheKey);
-      if (cached?.data) {
-        // Extract manifest from the CachedEntryData wrapper
-        const manifest = (cached.data as unknown as { manifest: CachedRouteData }).manifest;
-        if (manifest?.version === version) {
-          memoryManifest = manifest;
-          setCachedManifest(memoryManifest.routeManifest);
-          const duration = (performance.now() - startTime).toFixed(2);
-          console.log(`[route-manifest] HIT edge cache (${duration}ms, ${Object.keys(manifest.routeManifest).length} routes)`);
-          return memoryManifest;
-        }
-      }
-    } catch (error) {
-      // Cache miss or error - fall through to generation
-      console.warn("[route-manifest] Edge cache read failed:", error);
-    }
-  }
-
-  // 3. Generate on cache miss - ~98ms
-  const generated = generateFn();
-  memoryManifest = {
-    routeManifest: generated.routeManifest,
-    version,
-  };
-  // Make available to getGlobalRouteMap() for href()
-  setCachedManifest(memoryManifest.routeManifest);
-  const duration = (performance.now() - startTime).toFixed(2);
-  console.log(`[route-manifest] MISS - generated fresh (${duration}ms, ${Object.keys(generated.routeManifest).length} routes)`);
-
-  // Store in cache for other isolates (only if store provided)
-  // OFF RENDERING PATH via waitUntil
-  if (store) {
-    console.log("[route-manifest] Writing to edge cache (via waitUntil)...");
-    const cachePromise = (async () => {
-      try {
-        // Wrap in CachedEntryData format expected by SegmentCacheStore
-        const data: CachedEntryData = {
-          segments: [],
-          handles: {},
-          expiresAt: Date.now() + 31536000 * 1000, // 1 year
-        };
-        // Store manifest in a custom field
-        (data as unknown as { manifest: CachedRouteData }).manifest = memoryManifest!;
-        await store.set(cacheKey, data, 31536000); // 1 year TTL
-        console.log("[route-manifest] Edge cache write complete");
-      } catch (error) {
-        console.warn("[route-manifest] Edge cache write failed:", error);
-      }
-    })();
-
-    if (waitUntil) {
-      // Non-blocking: cache write happens after response is sent
-      waitUntil(cachePromise);
-    } else {
-      // Fallback: blocking write (dev mode or no waitUntil available)
-      await cachePromise;
-    }
-  }
-
-  return memoryManifest;
-}
-
-/**
- * Sync access to in-memory manifest (for href())
- * Returns null if not yet loaded
- *
- * @returns The route manifest or null if not loaded
- */
-export function getRouteManifestSync(): Record<string, string> | null {
-  return memoryManifest?.routeManifest ?? null;
-}
-
-/**
- * Clear in-memory cache (for testing)
- */
-export function clearRouteManifestCache(): void {
-  memoryManifest = null;
-}
-
-/**
- * Check if manifest is loaded in memory
- *
- * @returns true if manifest is available synchronously
- */
-export function isManifestLoaded(): boolean {
-  return memoryManifest !== null;
-}
-
-/**
- * Get the current cached version (for debugging)
- *
- * @returns The version string or null if not loaded
- */
-export function getManifestVersion(): string | null {
-  return memoryManifest?.version ?? null;
-}

package/src/vite/expose-handle-id.ts

@@ -1,209 +0,0 @@
-import type { Plugin, ResolvedConfig } from "vite";
-import MagicString from "magic-string";
-import path from "node:path";
-import crypto from "node:crypto";
-
-/**
- * Normalize path to forward slashes
- */
-function normalizePath(p: string): string {
-  return p.split(path.sep).join("/");
-}
-
-/**
- * Generate a short hash for a handle ID
- * Uses first 8 chars of SHA-256 hash for uniqueness while keeping IDs short
- * Appends export name for easier debugging: "abc123#Breadcrumbs"
- */
-function hashHandleId(filePath: string, exportName: string): string {
-  const input = `${filePath}#${exportName}`;
-  const hash = crypto.createHash("sha256").update(input).digest("hex");
-  return `${hash.slice(0, 8)}#${exportName}`;
-}
-
-/**
- * Check if file imports createHandle from rsc-router
- */
-function hasCreateHandleImport(code: string): boolean {
-  // Match: import { createHandle } from "@rangojs/router" or "@rangojs/router/..."
-  const pattern =
-    /import\s*\{[^}]*\bcreateHandle\b[^}]*\}\s*from\s*["']@rangojs\/router(?:\/[^"']+)?["']/;
-  return pattern.test(code);
-}
-
-/**
- * Analyze createHandle arguments to determine injection strategy
- * Returns: { hasArgs: boolean, firstArgIsString: boolean, firstArgIsFunction: boolean }
- */
-function analyzeCreateHandleArgs(
-  code: string,
-  startPos: number,
-  endPos: number
-): { hasArgs: boolean; firstArgIsString: boolean; firstArgIsFunction: boolean } {
-  // Extract the content between parentheses
-  const content = code.slice(startPos, endPos).trim();
-
-  if (!content) {
-    return { hasArgs: false, firstArgIsString: false, firstArgIsFunction: false };
-  }
-
-  // Check if first arg starts with a quote (string literal)
-  const firstArgIsString = /^["']/.test(content);
-
-  // Check if first arg starts with ( for arrow function or function keyword
-  const firstArgIsFunction =
-    content.startsWith("(") ||
-    content.startsWith("function") ||
-    // Check for identifier that could be a collect function reference
-    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*(?:,|$)/.test(content);
-
-  return { hasArgs: true, firstArgIsString, firstArgIsFunction };
-}
-
-/**
- * Transform export const X = createHandle(...) patterns to inject $$id
- *
- * Handles these cases:
- * 1. createHandle() - no args -> inject (undefined, "id")
- * 2. createHandle("name") - string name -> inject (, "id") after existing arg
- * 3. createHandle(collectFn) - collect function -> inject (collectFn, "id")
- * 4. createHandle("name", collectFn) - both -> inject (, "id") after existing args
- */
-function transformHandleExports(
-  code: string,
-  filePath: string,
-  sourceId?: string,
-  isBuild: boolean = false
-): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
-  // Quick bail-out
-  if (!code.includes("createHandle")) {
-    return null;
-  }
-
-  // Must have direct import from rsc-router
-  if (!hasCreateHandleImport(code)) {
-    return null;
-  }
-
-  // Match: export const X = createHandle<...>(
-  // Captures the export name (X)
-  const pattern = /export\s+const\s+(\w+)\s*=\s*createHandle\s*(?:<[^>]*>)?\s*\(/g;
-
-  const s = new MagicString(code);
-  let hasChanges = false;
-  let match: RegExpExecArray | null;
-
-  while ((match = pattern.exec(code)) !== null) {
-    const exportName = match[1];
-    const matchEnd = match.index + match[0].length;
-
-    // Find the end of the createHandle(...) call
-    let parenDepth = 1;
-    let i = matchEnd;
-    while (i < code.length && parenDepth > 0) {
-      if (code[i] === "(") parenDepth++;
-      if (code[i] === ")") parenDepth--;
-      i++;
-    }
-
-    // i now points just after the closing )
-    const closeParenPos = i - 1;
-
-    // Analyze what arguments exist
-    const args = analyzeCreateHandleArgs(code, matchEnd, closeParenPos);
-
-    // Find the semicolon or end of statement
-    let statementEnd = i;
-    while (statementEnd < code.length && /\s/.test(code[statementEnd])) {
-      statementEnd++;
-    }
-    if (code[statementEnd] === ";") {
-      statementEnd++;
-    }
-
-    // Generate ID: hashed in production, readable in dev
-    const handleId = isBuild
-      ? hashHandleId(filePath, exportName)
-      : `${filePath}#${exportName}`;
-
-    // Inject $$id as the last parameter
-    let paramInjection: string;
-    if (!args.hasArgs) {
-      // No args: createHandle() -> createHandle(undefined, "id")
-      paramInjection = `undefined, "${handleId}"`;
-    } else {
-      // Has args: createHandle(x) -> createHandle(x, "id")
-      paramInjection = `, "${handleId}"`;
-    }
-    s.appendLeft(closeParenPos, paramInjection);
-
-    // Also set $$id property for external access
-    const propInjection = `\n${exportName}.$$id = "${handleId}";`;
-    s.appendRight(statementEnd, propInjection);
-    hasChanges = true;
-  }
-
-  if (!hasChanges) {
-    return null;
-  }
-
-  return {
-    code: s.toString(),
-    map: s.generateMap({ source: sourceId, includeContent: true }),
-  };
-}
-
-/**
- * Vite plugin that exposes $$id on createHandle calls.
- *
- * When users create handles with createHandle(), this plugin:
- * 1. Injects a $$id as the last parameter (used as the handle name)
- * 2. Sets $$id property on the exported constant for external access
- *
- * This allows handles to be created without explicit names:
- * - Before: export const Breadcrumbs = createHandle<Item>("breadcrumbs")
- * - After:  export const Breadcrumbs = createHandle<Item>()
- *
- * The name is auto-generated from file path + export name.
- *
- * Requirements:
- * - Must use direct import: import { createHandle } from "@rangojs/router"
- * - Must use named export: export const MyHandle = createHandle(...)
- */
-export function exposeHandleId(): Plugin {
-  let config: ResolvedConfig;
-  let isBuild = false;
-
-  return {
-    name: "@rangojs/router:expose-handle-id",
-    enforce: "post",
-
-    configResolved(resolvedConfig) {
-      config = resolvedConfig;
-      isBuild = config.command === "build";
-    },
-
-    transform(code, id) {
-      // Skip node_modules
-      if (id.includes("/node_modules/")) {
-        return;
-      }
-
-      // Quick bail-out
-      if (!code.includes("createHandle")) {
-        return;
-      }
-
-      // Must have direct import from rsc-router
-      if (!hasCreateHandleImport(code)) {
-        return;
-      }
-
-      // Get relative path for the ID
-      const relativePath = normalizePath(path.relative(config.root, id));
-
-      // Transform: inject $$id
-      return transformHandleExports(code, relativePath, id, isBuild);
-    },
-  };
-}