npm - gorsee - Versions diffs - 0.2.1 → 0.2.3 - Mend

gorsee 0.2.1 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/README.md +132 -4
package/package.json +7 -4
package/src/auth/index.ts +48 -17
package/src/auth/redis-session-store.ts +46 -0
package/src/auth/sqlite-session-store.ts +98 -0
package/src/auth/store-utils.ts +21 -0
package/src/build/client.ts +25 -7
package/src/build/manifest.ts +34 -0
package/src/build/route-metadata.ts +12 -0
package/src/build/ssg.ts +19 -49
package/src/cli/bun-plugin.ts +23 -2
package/src/cli/cmd-build.ts +42 -71
package/src/cli/cmd-check.ts +40 -26
package/src/cli/cmd-create.ts +20 -5
package/src/cli/cmd-deploy.ts +10 -2
package/src/cli/cmd-dev.ts +9 -9
package/src/cli/cmd-docs.ts +11 -4
package/src/cli/cmd-generate.ts +15 -7
package/src/cli/cmd-migrate.ts +15 -7
package/src/cli/cmd-routes.ts +12 -5
package/src/cli/cmd-start.ts +14 -5
package/src/cli/cmd-test.ts +11 -3
package/src/cli/cmd-typegen.ts +13 -3
package/src/cli/cmd-upgrade.ts +10 -2
package/src/cli/context.ts +12 -0
package/src/cli/framework-md.ts +43 -16
package/src/client.ts +26 -0
package/src/dev/partial-handler.ts +17 -74
package/src/dev/request-handler.ts +36 -67
package/src/dev.ts +92 -157
package/src/index-client.ts +4 -0
package/src/index.ts +17 -2
package/src/prod.ts +195 -253
package/src/runtime/project.ts +73 -0
package/src/server/cache-utils.ts +23 -0
package/src/server/cache.ts +37 -14
package/src/server/html-shell.ts +69 -0
package/src/server/index.ts +40 -2
package/src/server/manifest.ts +36 -0
package/src/server/middleware.ts +18 -2
package/src/server/not-found.ts +35 -0
package/src/server/page-render.ts +123 -0
package/src/server/redis-cache-store.ts +87 -0
package/src/server/redis-client.ts +71 -0
package/src/server/request-preflight.ts +45 -0
package/src/server/route-request.ts +72 -0
package/src/server/rpc-utils.ts +27 -0
package/src/server/rpc.ts +70 -18
package/src/server/sqlite-cache-store.ts +109 -0
package/src/server/static-file.ts +63 -0
package/src/server-entry.ts +36 -0

package/src/prod.ts CHANGED Viewed

@@ -2,309 +2,251 @@
 // Serves pre-built client bundles + SSR pages from dist/
 import { createRouter, matchRoute, buildStaticMap } from "./router/index.ts"
-import { handleRPCRequest } from "./server/rpc.ts"
 import { securityHeaders } from "./security/headers.ts"
 import { createRateLimiter } from "./security/rate-limit.ts"
-import { renderToString, ssrJsx } from "./runtime/server.ts"
 import { renderToStream, streamJsx } from "./runtime/stream.ts"
-import { createContext, runMiddlewareChain, RedirectError, type MiddlewareFn } from "./server/middleware.ts"
-import { compress } from "./server/compress.ts"
 import { resetServerHead, getServerHead } from "./runtime/head.ts"
+import type { MiddlewareFn } from "./server/middleware.ts"
+import { compress } from "./server/compress.ts"
 import { log, setLogLevel } from "./log/index.ts"
 import { loadEnv } from "./env/index.ts"
-import { getMimeType } from "./server/mime.ts"
-import { fileETag, isNotModified } from "./server/etag.ts"
-import { join, resolve } from "node:path"
-import { readFile } from "node:fs/promises"
+import { generateNonce, wrapHTML } from "./server/html-shell.ts"
+import { renderNotFoundPage } from "./server/not-found.ts"
+import { createRateLimitResponse, handleRPCWithHeaders } from "./server/request-preflight.ts"
+import {
+  buildPartialResponsePayload,
+  createClientScriptPath,
+  renderPageDocument,
+} from "./server/page-render.ts"
+import { handleRouteRequest } from "./server/route-request.ts"
+import { servePrefixedStaticFile, serveStaticFile } from "./server/static-file.ts"
+import {
+  getClientBundleForRoute,
+  getPrerenderedHtmlPath,
+  isPrerenderedRoute,
+  loadBuildManifest,
+} from "./server/manifest.ts"
+import { join } from "node:path"
+import { createProjectContext, resolveRuntimeEnv, type RuntimeOptions } from "./runtime/project.ts"
 // Route type used implicitly via createRouter return
-const CWD = process.cwd()
-const ROUTES_DIR = join(CWD, "routes")
-const PUBLIC_DIR = join(CWD, "public")
-const DIST_DIR = join(CWD, "dist")
-const CLIENT_DIR = join(DIST_DIR, "client")
-const PORT = Number(process.env.PORT) || 3000
-interface BuildManifest {
-  routes: Record<string, { js?: string; hasLoader: boolean }>
-  chunks: string[]
-  buildTime: string
-}
-async function loadManifest(): Promise<BuildManifest> {
-  const raw = await readFile(join(DIST_DIR, "manifest.json"), "utf-8")
-  return JSON.parse(raw)
-}
-function generateNonce(): string {
-  const bytes = new Uint8Array(16)
-  crypto.getRandomValues(bytes)
-  return btoa(String.fromCharCode(...bytes))
+interface StartProductionServerOptions extends RuntimeOptions {
+  port?: number
+  registerSignalHandlers?: boolean
 }
-interface HTMLWrapOptions {
-  title?: string
-  clientScript?: string
-  loaderData?: unknown
-  params?: Record<string, string>
-  cssFiles?: string[]
-  headElements?: string[]
-}
-function wrapHTML(body: string, nonce: string, options: HTMLWrapOptions = {}): string {
-  const { title = "Gorsee App", clientScript, loaderData, params, cssFiles = [], headElements = [] } = options
-  let dataScript = ""
-  if (loaderData !== undefined) {
-    const json = JSON.stringify(loaderData).replace(/</g, "\\u003c")
-    dataScript = `\n  <script id="__GORSEE_DATA__" type="application/json" nonce="${nonce}">${json}</script>`
-  }
-  let paramsScript = ""
-  if (params && Object.keys(params).length > 0) {
-    paramsScript = `\n  <script nonce="${nonce}">window.__GORSEE_PARAMS__=${JSON.stringify(params)}</script>`
-  }
-  const clientTag = clientScript
-    ? `\n  <script type="module" src="${clientScript}" nonce="${nonce}"></script>`
-    : ""
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>${title}</title>
-  <link rel="stylesheet" href="/styles.css" />
-${cssFiles.map((f: string) => `  <link rel="stylesheet" href="${f}" />`).join("\n")}
-${headElements.join("\n")}
-</head>
-<body>
-  <div id="app">${body}</div>${dataScript}${paramsScript}${clientTag}
-</body>
-</html>`
+interface ProductionRuntimeState {
+  cwd: string
+  routesDir: string
+  publicDir: string
+  distDir: string
+  clientDir: string
+  manifest: Awaited<ReturnType<typeof loadBuildManifest>>
+  routes: Awaited<ReturnType<typeof createRouter>>
+  staticMap: ReturnType<typeof buildStaticMap>
+  rateLimiter: ReturnType<typeof createRateLimiter>
+  compressMiddleware: ReturnType<typeof compress>
 }
-async function tryServeStatic(pathname: string, request: Request): Promise<Response | null> {
+async function tryServeStatic(
+  pathname: string,
+  request: Request,
+  publicDir: string,
+  clientDir: string,
+  secHeaders: Record<string, string>,
+): Promise<Response | null> {
   if (pathname === "/") return null
   // Client assets from dist/
-  if (pathname.startsWith("/_gorsee/")) {
-    const relPath = pathname.slice("/_gorsee/".length)
-    const filePath = resolve(CLIENT_DIR, relPath)
-    if (!filePath.startsWith(CLIENT_DIR)) return null
-    try {
-      const file = Bun.file(filePath)
-      if (await file.exists()) {
-        return new Response(file, {
-          headers: {
-            "Content-Type": "application/javascript",
-            "Cache-Control": "public, max-age=31536000, immutable",
-          },
-        })
-      }
-    } catch {}
-    return null
-  }
+  const bundleResponse = await servePrefixedStaticFile(pathname, "/_gorsee/", clientDir, {
+    contentType: "application/javascript",
+    cacheControl: "public, max-age=31536000, immutable",
+    extraHeaders: secHeaders,
+  })
+  if (bundleResponse) return bundleResponse
   // Public files
-  try {
-    const filePath = resolve(PUBLIC_DIR, pathname.slice(1))
-    if (!filePath.startsWith(PUBLIC_DIR)) return null
-    const file = Bun.file(filePath)
-    if (await file.exists()) {
-      const etag = await fileETag(filePath)
-      if (etag && isNotModified(request, etag)) {
-        return new Response(null, { status: 304 })
-      }
-      const headers: Record<string, string> = {
-        "Content-Type": getMimeType(filePath),
-        "Cache-Control": "public, max-age=3600",
-      }
-      if (etag) headers["ETag"] = etag
-      return new Response(file, { headers })
-    }
-  } catch {}
-  return null
+  return serveStaticFile(publicDir, pathname.slice(1), {
+    request,
+    etag: true,
+    cacheControl: "public, max-age=3600",
+    extraHeaders: secHeaders,
+  })
 }
-export async function startProductionServer() {
-  await loadEnv(CWD)
-  setLogLevel(process.env.LOG_LEVEL === "debug" ? "debug" : "info")
+async function tryServePrerenderedPage(
+  pathname: string,
+  request: Request,
+  manifest: Awaited<ReturnType<typeof loadBuildManifest>>,
+  distDir: string,
+  secHeaders: Record<string, string>,
+): Promise<Response | null> {
+  if (request.method !== "GET") return null
+  if (!isPrerenderedRoute(manifest, pathname)) return null
+  return serveStaticFile(join(distDir, "static"), getPrerenderedHtmlPath(pathname), {
+    request,
+    etag: true,
+    cacheControl: "public, max-age=3600",
+    contentType: "text/html; charset=utf-8",
+    extraHeaders: secHeaders,
+  })
+}
-  const manifest = await loadManifest()
-  log.info("loaded manifest", { routes: Object.keys(manifest.routes).length, built: manifest.buildTime })
+export async function startProductionServer(options: StartProductionServerOptions = {}) {
+  const runtime = createProjectContext(options)
+  const registerSignalHandlers = options.registerSignalHandlers ?? true
-  const routes = await createRouter(ROUTES_DIR)
-  const staticMap = buildStaticMap(routes)
-  const rateLimiter = createRateLimiter(
-    Number(process.env.RATE_LIMIT) || 1000,
-    process.env.RATE_WINDOW || "1m",
-  )
-  const compressMiddleware = compress()
-  log.info("production server starting", { routes: routes.length })
+  await loadEnv(runtime.cwd)
+  const envConfig = resolveRuntimeEnv(process.env)
+  const port = options.port ?? envConfig.port
+  const fetchHandler = await createProductionFetchHandler({ cwd: runtime.cwd, env: process.env })
+  log.info("production server starting", { cwd: runtime.cwd })
   const server = Bun.serve({
-    port: PORT,
-    async fetch(request, server) {
-      const url = new URL(request.url)
-      const pathname = url.pathname
+    port,
+    fetch: fetchHandler,
+  })
-      // Rate limiting
-      const ip = server.requestIP(request)?.address ?? "unknown"
-      const rl = rateLimiter.check(ip)
-      if (!rl.allowed) {
-        return new Response("Too Many Requests", {
-          status: 429,
-          headers: { "Retry-After": String(Math.ceil((rl.resetAt - Date.now()) / 1000)) },
-        })
-      }
+  log.info("production server started", { url: `http://localhost:${server.port}` })
-      const nonce = generateNonce()
-      const secHeaders = securityHeaders({}, nonce)
+  // Graceful shutdown
+  if (registerSignalHandlers) {
+    const shutdown = () => {
+      log.info("shutting down...")
+      server.stop(true) // close existing connections gracefully
+      process.exit(0)
+    }
+    process.on("SIGTERM", shutdown)
+    process.on("SIGINT", shutdown)
+  }
-      // RPC
-      const rpcResponse = await handleRPCRequest(request)
-      if (rpcResponse) {
-        for (const k in secHeaders) rpcResponse.headers.set(k, secHeaders[k]!)
-        return rpcResponse
-      }
+  return server
+}
-      // Static files
-      const staticResponse = await tryServeStatic(pathname, request)
-      if (staticResponse) return staticResponse
+export async function createProductionFetchHandler(
+  options: Pick<StartProductionServerOptions, "cwd" | "env"> = {},
+): Promise<(request: Request, server?: { requestIP(request: Request): { address: string } | null }) => Promise<Response>> {
+  const state = await loadProductionRuntimeState(options)
-      // Route matching
-      const match = matchRoute(routes, pathname, staticMap)
-      if (!match) {
-        return new Response(wrapHTML("<h1>404</h1><p>Page not found</p>", nonce), {
-          status: 404,
-          headers: { "Content-Type": "text/html", ...secHeaders },
-        })
-      }
+  return async (request, server) => {
+    const url = new URL(request.url)
+    const pathname = url.pathname
-      try {
-        const mod = await import(match.route.filePath)
+    const ip = server?.requestIP(request)?.address ?? "unknown"
+    const rateLimitResponse = createRateLimitResponse(state.rateLimiter, ip)
+    if (rateLimitResponse) return rateLimitResponse
-        // API route
-        const ctx = createContext(request, match.params)
-        if (typeof mod.GET === "function" && request.method === "GET") return mod.GET(ctx)
-        if (typeof mod.POST === "function" && request.method === "POST") return mod.POST(ctx)
+    const nonce = generateNonce()
+    const secHeaders = securityHeaders({}, nonce)
-        const component = mod.default as Function | undefined
-        if (typeof component !== "function") {
-          return new Response("Route has no default export", { status: 500 })
-        }
+    const rpcResponse = await handleRPCWithHeaders(request, secHeaders)
+    if (rpcResponse) return rpcResponse
-        // Middleware chain: compression + inherited route middleware
-        const middlewares: MiddlewareFn[] = [compressMiddleware]
-        for (const mwPath of match.route.middlewarePaths) {
-          const mwMod = await import(mwPath)
-          if (typeof mwMod.default === "function") middlewares.push(mwMod.default)
-        }
+    const staticResponse = await tryServeStatic(pathname, request, state.publicDir, state.clientDir, secHeaders)
+    if (staticResponse) return staticResponse
-        return await runMiddlewareChain(middlewares, ctx, async () => {
-          // Parallel loading: import layout modules + run page loader simultaneously
-          const layoutPaths = match.route.layoutPaths ?? []
-          const layoutImportPromises = layoutPaths.map((lp) => import(lp))
-          const pageLoaderPromise = typeof mod.loader === "function" ? mod.loader(ctx) : undefined
+    const prerenderedResponse = await tryServePrerenderedPage(pathname, request, state.manifest, state.distDir, secHeaders)
+    if (prerenderedResponse) return prerenderedResponse
-          const [layoutMods, loaderData] = await Promise.all([
-            Promise.all(layoutImportPromises),
-            pageLoaderPromise,
-          ])
+    const match = matchRoute(state.routes, pathname, state.staticMap)
+    if (!match) {
+      return new Response(await renderNotFoundPage(state.routesDir, nonce), {
+        status: 404,
+        headers: { "Content-Type": "text/html", ...secHeaders },
+      })
+    }
-          // Run layout loaders in parallel
-          const layoutLoaderPromises = layoutMods.map((lm) =>
-            typeof lm.loader === "function" ? lm.loader(ctx) : undefined,
+    try {
+      return await handleRouteRequest({
+        match,
+        request,
+        extraMiddlewares: [state.compressMiddleware satisfies MiddlewareFn],
+        onPartialRequest: async ({ ctx, resolved }) => {
+          const { pageComponent, loaderData, cssFiles } = resolved
+          const rendered = renderPageDocument(pageComponent, ctx, match.params, loaderData)
+          const clientScript = createClientScriptPath(getClientBundleForRoute(state.manifest, match.route.path))
+          const partialPayload = buildPartialResponsePayload(
+            rendered,
+            loaderData,
+            match.params,
+            cssFiles,
+            clientScript,
           )
-          const layoutLoaderResults = await Promise.all(layoutLoaderPromises)
-          // CSS
-          const cssFiles: string[] = []
-          if (typeof mod.css === "string") cssFiles.push(mod.css)
-          if (Array.isArray(mod.css)) cssFiles.push(...(mod.css as string[]))
-          // Nested layout wrapping: outermost first, innermost wraps page
-          let pageComponent: Function = component
-          for (let i = layoutMods.length - 1; i >= 0; i--) {
-            const Layout = layoutMods[i]!.default
-            if (typeof Layout === "function") {
-              const inner = pageComponent
-              const layoutData = layoutLoaderResults[i]
-              pageComponent = (props: Record<string, unknown>) =>
-                Layout({ ...props, data: layoutData, children: inner(props) })
-            }
-          }
-          // Partial navigation
-          if (request.headers.get("X-Gorsee-Navigate") === "partial") {
-            resetServerHead()
-            const pageProps = { params: match.params, ctx, data: loaderData }
-            const vnode = ssrJsx(pageComponent as any, pageProps)
-            const html = renderToString(vnode)
-            const headElements = getServerHead()
-            let title: string | undefined
-            for (const el of headElements) {
-              const titleMatch = el.match(/<title>(.+?)<\/title>/)
-              if (titleMatch) { title = titleMatch[1]; break }
-            }
-            const manifestRoute = manifest.routes[match.route.path]
-            const clientScript = manifestRoute?.js ? `/_gorsee/${manifestRoute.js}` : undefined
-            return new Response(JSON.stringify({ html, data: loaderData, params: match.params, title, css: cssFiles, script: clientScript }), {
-              headers: { "Content-Type": "application/json", ...secHeaders },
-            })
-          }
+          return new Response(JSON.stringify(partialPayload), {
+            headers: { "Content-Type": "application/json", ...secHeaders },
+          })
+        },
+        onPageRequest: async ({ ctx, resolved }) => {
+          const { pageComponent, loaderData, cssFiles, renderMode } = resolved
-          // Full SSR
           const pageProps = { params: match.params, ctx, data: loaderData }
-          const manifestRoute = manifest.routes[match.route.path]
-          const clientScript = manifestRoute?.js ? `/_gorsee/${manifestRoute.js}` : undefined
-          resetServerHead()
-          const renderMode = (mod.render as string) ?? "async"
+          const clientScript = createClientScriptPath(getClientBundleForRoute(state.manifest, match.route.path))
           if (renderMode === "stream") {
+            resetServerHead()
             const vnode = streamJsx(pageComponent as any, pageProps)
             const stream = renderToStream(vnode, {
-              shell: (body: string) => wrapHTML(body, nonce, { clientScript, loaderData, params: match.params, cssFiles, headElements: getServerHead() }),
+              shell: (body: string) => wrapHTML(body, nonce, {
+                clientScript,
+                loaderData,
+                params: match.params,
+                cssFiles,
+                headElements: getServerHead(),
+              }),
             })
             return new Response(stream, {
               headers: { "Content-Type": "text/html", ...secHeaders },
             })
           }
-          const vnode = ssrJsx(pageComponent as any, pageProps)
-          const body = renderToString(vnode)
-          const html = wrapHTML(body, nonce, { clientScript, loaderData, params: match.params, cssFiles, headElements: getServerHead() })
+          const rendered = renderPageDocument(pageComponent, ctx, match.params, loaderData)
+          const html = wrapHTML(rendered.html, nonce, {
+            clientScript,
+            loaderData,
+            params: match.params,
+            cssFiles,
+            headElements: rendered.headElements,
+          })
           return new Response(html, {
             headers: { "Content-Type": "text/html", ...secHeaders },
           })
-        })
-      } catch (err) {
-        if (err instanceof RedirectError) {
-          return new Response(null, {
-            status: err.status,
-            headers: { Location: err.url },
-          })
-        }
-        const message = err instanceof Error ? err.message : String(err)
-        log.error("request error", { path: pathname, error: message })
-        return new Response(wrapHTML("<h1>500</h1><p>Internal Server Error</p>", nonce), {
-          status: 500,
-          headers: { "Content-Type": "text/html", ...secHeaders },
-        })
-      }
-    },
-  })
+        },
+      })
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      log.error("request error", { path: pathname, error: message })
+      return new Response(wrapHTML("<h1>500</h1><p>Internal Server Error</p>", nonce), {
+        status: 500,
+        headers: { "Content-Type": "text/html", ...secHeaders },
+      })
+    }
+  }
+}
-  log.info("production server started", { url: `http://localhost:${server.port}` })
+async function loadProductionRuntimeState(options: RuntimeOptions = {}): Promise<ProductionRuntimeState> {
+  const runtime = createProjectContext(options)
-  // Graceful shutdown
-  const shutdown = () => {
-    log.info("shutting down...")
-    server.stop(true) // close existing connections gracefully
-    process.exit(0)
+  await loadEnv(runtime.cwd)
+  const envConfig = resolveRuntimeEnv(process.env)
+  setLogLevel(envConfig.logLevel)
+  const manifest = await loadBuildManifest(runtime.paths.distDir)
+  log.info("loaded manifest", { routes: Object.keys(manifest.routes).length, built: manifest.buildTime })
+  const routes = await createRouter(runtime.paths.routesDir)
+  const staticMap = buildStaticMap(routes)
+  const rateLimiter = createRateLimiter(envConfig.rateLimit, envConfig.rateWindow)
+  return {
+    cwd: runtime.cwd,
+    routesDir: runtime.paths.routesDir,
+    publicDir: runtime.paths.publicDir,
+    distDir: runtime.paths.distDir,
+    clientDir: runtime.paths.clientDir,
+    manifest,
+    routes,
+    staticMap,
+    rateLimiter,
+    compressMiddleware: compress(),
   }
-  process.on("SIGTERM", shutdown)
-  process.on("SIGINT", shutdown)
 }

package/src/runtime/project.ts ADDED Viewed

@@ -0,0 +1,73 @@
+import { join } from "node:path"
+export interface RuntimeOptions {
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+}
+export interface ProjectPaths {
+  cwd: string
+  routesDir: string
+  publicDir: string
+  distDir: string
+  clientDir: string
+  serverDir: string
+  gorseeDir: string
+  sharedDir: string
+  middlewareDir: string
+  migrationsDir: string
+  docsDir: string
+  dataFile: string
+}
+export interface ProjectContext {
+  cwd: string
+  env: NodeJS.ProcessEnv
+  paths: ProjectPaths
+}
+export interface RuntimeEnvConfig {
+  port: number
+  logLevel: "info" | "debug"
+  rateLimit: number
+  rateWindow: string
+  isProduction: boolean
+}
+export function resolveProjectPaths(cwd: string): ProjectPaths {
+  const gorseeDir = join(cwd, ".gorsee")
+  const distDir = join(cwd, "dist")
+  return {
+    cwd,
+    routesDir: join(cwd, "routes"),
+    publicDir: join(cwd, "public"),
+    distDir,
+    clientDir: join(distDir, "client"),
+    serverDir: join(distDir, "server"),
+    gorseeDir,
+    sharedDir: join(cwd, "shared"),
+    middlewareDir: join(cwd, "middleware"),
+    migrationsDir: join(cwd, "migrations"),
+    docsDir: join(cwd, "docs"),
+    dataFile: join(cwd, "data.sqlite"),
+  }
+}
+export function createProjectContext(options: RuntimeOptions = {}): ProjectContext {
+  const cwd = options.cwd ?? process.cwd()
+  return {
+    cwd,
+    env: options.env ?? process.env,
+    paths: resolveProjectPaths(cwd),
+  }
+}
+export function resolveRuntimeEnv(env: NodeJS.ProcessEnv): RuntimeEnvConfig {
+  return {
+    port: Number(env.PORT || "3000"),
+    logLevel: env.LOG_LEVEL === "debug" ? "debug" : "info",
+    rateLimit: Number(env.RATE_LIMIT) || 1000,
+    rateWindow: env.RATE_WINDOW || "1m",
+    isProduction: env.NODE_ENV === "production",
+  }
+}

package/src/server/cache-utils.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import type { CacheEntry, CacheStore } from "./cache.ts"
+export function createNamespacedCacheStore(store: CacheStore, namespace: string): CacheStore {
+  const prefix = `${namespace}:`
+  return {
+    get: (key) => store.get(prefix + key),
+    set: async (key, entry) => { await store.set(prefix + key, entry) },
+    delete: async (key) => { await store.delete(prefix + key) },
+    clear: async () => {
+      const keys = await store.keys()
+      for await (const key of keys) {
+        if (key.startsWith(prefix)) await store.delete(key)
+      }
+    },
+    keys: async function* () {
+      const keys = await store.keys()
+      for await (const key of keys) {
+        if (!key.startsWith(prefix)) continue
+        yield key.slice(prefix.length)
+      }
+    },
+  }
+}