gorsee 0.2.4 → 0.2.5

package/src/server/redis-client.ts

@@ -1,71 +0,0 @@
-type Awaitable<T> = T | Promise<T>
-
-export interface RedisLikeClient {
-  get(key: string): Awaitable<string | null>
-  set(key: string, value: string): Awaitable<unknown>
-  del(key: string): Awaitable<number>
-  keys(pattern: string): Awaitable<string[]>
-  expire?(key: string, seconds: number): Awaitable<number>
-  ttl?(key: string): Awaitable<number>
-}
-
-export function buildRedisKey(prefix: string, key: string): string {
-  return `${prefix}:${key}`
-}
-
-export function stripRedisPrefix(prefix: string, key: string): string {
-  const expected = `${prefix}:`
-  return key.startsWith(expected) ? key.slice(expected.length) : key
-}
-
-export interface NodeRedisClientLike {
-  get(key: string): Awaitable<string | null>
-  set(key: string, value: string): Awaitable<unknown>
-  del(key: string): Awaitable<number>
-  keys(pattern: string): Awaitable<string[]>
-  expire?(key: string, seconds: number): Awaitable<number>
-  ttl?(key: string): Awaitable<number>
-}
-
-export interface IORedisClientLike {
-  get(key: string): Awaitable<string | null>
-  set(key: string, value: string): Awaitable<unknown>
-  del(key: string): Awaitable<number>
-  keys(pattern: string): Awaitable<string[]>
-  expire?(key: string, seconds: number): Awaitable<number>
-  ttl?(key: string): Awaitable<number>
-}
-
-export function createNodeRedisLikeClient(client: NodeRedisClientLike): RedisLikeClient {
-  return {
-    get: (key) => client.get(key),
-    set: (key, value) => client.set(key, value),
-    del: (key) => client.del(key),
-    keys: (pattern) => client.keys(pattern),
-    expire: client.expire ? (key, seconds) => client.expire!(key, seconds) : undefined,
-    ttl: client.ttl ? (key) => client.ttl!(key) : undefined,
-  }
-}
-
-export function createIORedisLikeClient(client: IORedisClientLike): RedisLikeClient {
-  return createNodeRedisLikeClient(client)
-}
-
-export async function deleteExpiredRedisKeys(
-  client: RedisLikeClient,
-  pattern: string,
-  now: number,
-  parseCreatedAt: (value: string) => number | undefined,
-  maxEntryAgeMs: number,
-): Promise<number> {
-  let deleted = 0
-  for (const key of await client.keys(pattern)) {
-    const raw = await client.get(key)
-    if (raw === null) continue
-    const createdAt = parseCreatedAt(raw)
-    if (createdAt === undefined) continue
-    if (createdAt > now - maxEntryAgeMs) continue
-    deleted += await client.del(key)
-  }
-  return deleted
-}

package/src/server/request-preflight.ts

@@ -1,45 +0,0 @@
-import { handleRPCRequest, handleRPCRequestWithRegistry, type RPCRegistry } from "./rpc.ts"
-
-interface RateLimitResult {
-  allowed: boolean
-  resetAt: number
-}
-
-interface RateLimiterLike {
-  check(key: string): RateLimitResult
-}
-
-export function createRateLimitResponse(
-  rateLimiter: RateLimiterLike,
-  key: string,
-): Response | null {
-  const result = rateLimiter.check(key)
-  if (result.allowed) return null
-
-  return new Response("Too Many Requests", {
-    status: 429,
-    headers: {
-      "Retry-After": String(Math.ceil((result.resetAt - Date.now()) / 1000)),
-    },
-  })
-}
-
-export function applyResponseHeaders(
-  response: Response,
-  headers: Record<string, string>,
-): Response {
-  for (const key in headers) response.headers.set(key, headers[key]!)
-  return response
-}
-
-export async function handleRPCWithHeaders(
-  request: Request,
-  headers: Record<string, string>,
-  registry?: Pick<RPCRegistry, "getHandler">,
-): Promise<Response | null> {
-  const response = registry
-    ? await handleRPCRequestWithRegistry(request, registry)
-    : await handleRPCRequest(request)
-  if (!response) return null
-  return applyResponseHeaders(response, headers)
-}

package/src/server/route-request.ts

@@ -1,72 +0,0 @@
-import { createContext, runMiddlewareChain, RedirectError, type Context, type MiddlewareFn } from "./middleware.ts"
-import { resolvePageRoute, type ResolvedPageRoute } from "./page-render.ts"
-import type { MatchResult } from "../router/matcher.ts"
-
-type RouteModule = Record<string, unknown>
-
-interface RouteRequestContext {
-  match: MatchResult
-  request: Request
-  mod: RouteModule
-  ctx: Context
-}
-
-interface ResolvedRouteRequestContext extends RouteRequestContext {
-  resolved: ResolvedPageRoute
-}
-
-interface RouteRequestOptions {
-  match: MatchResult
-  request: Request
-  extraMiddlewares?: MiddlewareFn[]
-  onPartialRequest: (ctx: ResolvedRouteRequestContext) => Promise<Response>
-  onPageRequest: (ctx: ResolvedRouteRequestContext) => Promise<Response>
-  onRouteError?: (error: unknown, ctx: ResolvedRouteRequestContext) => Promise<Response>
-}
-
-export async function handleRouteRequest(options: RouteRequestOptions): Promise<Response> {
-  const { match, request, extraMiddlewares = [], onPartialRequest, onPageRequest, onRouteError } = options
-  const mod = await import(match.route.filePath)
-  const ctx = createContext(request, match.params)
-  let routeCtx: ResolvedRouteRequestContext | undefined
-
-  if (typeof mod.GET === "function" && request.method === "GET") return (mod.GET as Function)(ctx)
-  if (typeof mod.POST === "function" && request.method === "POST") return (mod.POST as Function)(ctx)
-
-  try {
-    const resolved = await resolvePageRoute(mod, match, ctx)
-    if (!resolved) return new Response("Route has no default export", { status: 500 })
-
-    routeCtx = { match, request, mod, ctx, resolved }
-    const currentRouteCtx = routeCtx
-    const middlewares = await loadRouteMiddlewares(match, extraMiddlewares)
-
-    return await runMiddlewareChain(middlewares, ctx, async () => {
-      if (request.headers.get("X-Gorsee-Navigate") === "partial") {
-        return onPartialRequest(currentRouteCtx)
-      }
-      return onPageRequest(currentRouteCtx)
-    })
-  } catch (error) {
-    if (error instanceof RedirectError) {
-      return new Response(null, {
-        status: error.status,
-        headers: { Location: error.url },
-      })
-    }
-    if (onRouteError && routeCtx) return onRouteError(error, routeCtx)
-    throw error
-  }
-}
-
-async function loadRouteMiddlewares(
-  match: MatchResult,
-  extraMiddlewares: MiddlewareFn[],
-): Promise<MiddlewareFn[]> {
-  const middlewares = [...extraMiddlewares]
-  for (const mwPath of match.route.middlewarePaths) {
-    const mwMod = await import(mwPath)
-    if (typeof mwMod.default === "function") middlewares.push(mwMod.default)
-  }
-  return middlewares
-}

package/src/server/rpc-hash.ts

@@ -1,17 +0,0 @@
-// Shared RPC hash function -- must produce identical IDs on server and client
-// ID = sha256(filePath + ":" + callIndex).slice(0, 12)
-
-import { createHash } from "node:crypto"
-
-export function hashRPC(filePath: string, index: number): string {
-  return createHash("sha256")
-    .update(`${filePath}:${index}`)
-    .digest("hex")
-    .slice(0, 12)
-}
-
-// Scan source for server() call positions and return their hashes
-export function scanServerCalls(source: string, filePath: string): string[] {
-  const matches = [...source.matchAll(/\bserver\s*\(\s*(?=async\s|function\s)/g)]
-  return matches.map((_, i) => hashRPC(filePath, i))
-}

package/src/server/rpc-utils.ts

@@ -1,27 +0,0 @@
-import type { RPCRegistry } from "./rpc.ts"
-
-export function createScopedRPCRegistry(registry: RPCRegistry, scope: string): RPCRegistry {
-  const prefix = `${scope}:`
-  const fileCounters = new Map<string, number>()
-  const scopedIds = new Set<string>()
-  return {
-    getHandler: (id) => registry.getHandler(prefix + id),
-    setHandler: (id, fn) => {
-      const scopedId = prefix + id
-      scopedIds.add(scopedId)
-      registry.setHandler(scopedId, fn)
-    },
-    deleteHandler: (id) => {
-      const scopedId = prefix + id
-      scopedIds.delete(scopedId)
-      registry.deleteHandler(scopedId)
-    },
-    clear: () => {
-      for (const scopedId of scopedIds) registry.deleteHandler(scopedId)
-      scopedIds.clear()
-      fileCounters.clear()
-    },
-    getFileCallCount: (file) => fileCounters.get(file) ?? 0,
-    setFileCallCount: (file, count) => { fileCounters.set(file, count) },
-  }
-}

package/src/server/rpc.ts

@@ -1,177 +0,0 @@
-// server() function + RPC registry
-// On server: registers function for RPC with hash(filePath:index)
-// On client: replaced by build plugin with fetch() stub
-
-import { stringify } from "devalue"
-import { hashRPC } from "./rpc-hash.ts"
-
-export interface ServerOptions {
-  middleware?: unknown[]
-}
-
-export type RPCHandler = (...args: unknown[]) => Promise<unknown>
-
-export interface RPCRegistry {
-  getHandler(id: string): RPCHandler | undefined
-  setHandler(id: string, fn: RPCHandler): void
-  deleteHandler(id: string): void
-  clear(): void
-  getFileCallCount(file: string): number
-  setFileCallCount(file: string, count: number): void
-}
-
-export function createMemoryRPCRegistry(): RPCRegistry {
-  const rpcHandlers = new Map<string, RPCHandler>()
-  const fileCallCounters = new Map<string, number>()
-  return {
-    getHandler: (id) => rpcHandlers.get(id),
-    setHandler: (id, fn) => { rpcHandlers.set(id, fn) },
-    deleteHandler: (id) => { rpcHandlers.delete(id) },
-    clear: () => {
-      rpcHandlers.clear()
-      fileCallCounters.clear()
-    },
-    getFileCallCount: (file) => fileCallCounters.get(file) ?? 0,
-    setFileCallCount: (file, count) => { fileCallCounters.set(file, count) },
-  }
-}
-
-const defaultRPCRegistry = createMemoryRPCRegistry()
-
-export function __registerRPC(id: string, fn: RPCHandler): void {
-  defaultRPCRegistry.setHandler(id, fn)
-}
-
-export function __resetRPCState(): void {
-  defaultRPCRegistry.clear()
-}
-
-export function getRPCHandler(id: string): RPCHandler | undefined {
-  return defaultRPCRegistry.getHandler(id)
-}
-
-function getCallerFile(): string | null {
-  const orig = Error.prepareStackTrace
-  Error.prepareStackTrace = (_err, stack) => stack
-  const err = new Error()
-  const stack = err.stack as unknown as NodeJS.CallSite[]
-  Error.prepareStackTrace = orig
-
-  // Walk up stack: 0=getCallerFile, 1=server(), 2=caller (route file)
-  for (let i = 2; i < stack.length; i++) {
-    const file = stack[i]?.getFileName()
-    if (file && !file.includes("/server/rpc.ts") && !file.includes("node_modules")) {
-      return file
-    }
-  }
-  return null
-}
-
-// server() wrapper -- registers with hash-based ID matching client transform
-export function server<TArgs extends unknown[], TReturn>(
-  fn: (...args: TArgs) => Promise<TReturn>,
-  _options?: ServerOptions
-): (...args: TArgs) => Promise<TReturn> {
-  const callerFile = getCallerFile()
-  if (callerFile) {
-    const counter = defaultRPCRegistry.getFileCallCount(callerFile)
-    defaultRPCRegistry.setFileCallCount(callerFile, counter + 1)
-    const id = hashRPC(callerFile, counter)
-    defaultRPCRegistry.setHandler(id, fn as (...args: unknown[]) => Promise<unknown>)
-  }
-  return fn
-}
-
-export async function handleRPCRequestWithRegistry(
-  request: Request,
-  registry: Pick<RPCRegistry, "getHandler">,
-): Promise<Response | null> {
-  const url = new URL(request.url)
-  const match = url.pathname.match(/^\/api\/_rpc\/([a-zA-Z0-9]+)$/)
-  if (!match) return null
-
-  const id = match[1]!
-  const handler = registry.getHandler(id)
-
-  if (!handler) {
-    return new Response(JSON.stringify({ error: `RPC handler not found: ${id}` }), {
-      status: 404,
-      headers: { "Content-Type": "application/json" },
-    })
-  }
-
-  try {
-    const MAX_RPC_BODY = 1024 * 1024 // 1MB
-    let args: unknown[] = []
-    if (request.method === "POST") {
-      const contentLength = Number(request.headers.get("content-length") ?? "0")
-      if (contentLength > MAX_RPC_BODY) {
-        return new Response(JSON.stringify({ error: "Request body too large" }), {
-          status: 413,
-          headers: { "Content-Type": "application/json" },
-        })
-      }
-      // Read body with actual size limit (Content-Length can be spoofed)
-      const reader = request.body?.getReader()
-      let bodyBytes = 0
-      const chunks: Uint8Array[] = []
-      if (reader) {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          bodyBytes += value.byteLength
-          if (bodyBytes > MAX_RPC_BODY) {
-            reader.cancel()
-            return new Response(JSON.stringify({ error: "Request body too large" }), {
-              status: 413,
-              headers: { "Content-Type": "application/json" },
-            })
-          }
-          chunks.push(value)
-        }
-      }
-      const body = new TextDecoder().decode(
-        chunks.length === 1 ? chunks[0] : Buffer.concat(chunks),
-      )
-      if (body) {
-        let parsed: unknown
-        try {
-          parsed = JSON.parse(body)
-        } catch {
-          return new Response(JSON.stringify({ error: "Invalid JSON in request body" }), {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          })
-        }
-        if (!Array.isArray(parsed)) {
-          return new Response(JSON.stringify({ error: "RPC args must be an array" }), {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          })
-        }
-        args = parsed
-      }
-    }
-
-    const result = await handler(...args)
-    const serialized = stringify(result)
-
-    return new Response(serialized, {
-      status: 200,
-      headers: { "Content-Type": "application/json" },
-    })
-  } catch (err) {
-    // Don't leak internal error details to the client
-    const isDev = process.env.NODE_ENV !== "production"
-    const message = isDev && err instanceof Error ? err.message : "Internal server error"
-    return new Response(JSON.stringify({ error: message }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" },
-    })
-  }
-}
-
-// RPC HTTP handler
-export async function handleRPCRequest(request: Request): Promise<Response | null> {
-  return handleRPCRequestWithRegistry(request, defaultRPCRegistry)
-}

package/src/server/sqlite-cache-store.ts

@@ -1,109 +0,0 @@
-import { Database } from "bun:sqlite"
-import type { CacheEntry, CacheStore } from "./cache.ts"
-
-interface SQLiteCacheStoreOptions {
-  maxEntryAgeMs?: number
-  pruneExpiredOnInit?: boolean
-  pruneExpiredOnGet?: boolean
-  pruneExpiredOnSet?: boolean
-  pruneExpiredOnKeys?: boolean
-}
-
-function ensureCacheTable(sqlite: Database): void {
-  sqlite.run(`
-    CREATE TABLE IF NOT EXISTS gorsee_route_cache (
-      cache_key TEXT PRIMARY KEY,
-      body TEXT NOT NULL,
-      headers TEXT NOT NULL,
-      status INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
-      revalidating INTEGER NOT NULL DEFAULT 0
-    )
-  `)
-}
-
-function pruneExpiredRows(sqlite: Database, maxEntryAgeMs: number, now: number = Date.now()): number {
-  const cutoff = now - maxEntryAgeMs
-  const result = sqlite.prepare("DELETE FROM gorsee_route_cache WHERE created_at <= ?1").run(cutoff)
-  return (result as { changes?: number }).changes ?? 0
-}
-
-export function createSQLiteCacheStore(
-  path = ":memory:",
-  options: SQLiteCacheStoreOptions = {},
-): CacheStore & { close(): void; deleteExpired(now?: number): number } {
-  const sqlite = new Database(path)
-  sqlite.run("PRAGMA journal_mode=WAL;")
-  ensureCacheTable(sqlite)
-  const {
-    maxEntryAgeMs = 24 * 60 * 60 * 1000,
-    pruneExpiredOnInit = true,
-    pruneExpiredOnGet = true,
-    pruneExpiredOnSet = true,
-    pruneExpiredOnKeys = true,
-  } = options
-
-  if (pruneExpiredOnInit) pruneExpiredRows(sqlite, maxEntryAgeMs)
-
-  return {
-    async get(key) {
-      if (pruneExpiredOnGet) pruneExpiredRows(sqlite, maxEntryAgeMs)
-      const row = sqlite.prepare(`
-        SELECT body, headers, status, created_at, revalidating
-        FROM gorsee_route_cache
-        WHERE cache_key = ?1
-      `).get(key) as {
-        body: string
-        headers: string
-        status: number
-        created_at: number
-        revalidating: number
-      } | null
-      if (!row) return undefined
-      return {
-        body: row.body,
-        headers: JSON.parse(row.headers) as Record<string, string>,
-        status: row.status,
-        createdAt: row.created_at,
-        revalidating: row.revalidating === 1,
-      }
-    },
-    async set(key, entry) {
-      if (pruneExpiredOnSet) pruneExpiredRows(sqlite, maxEntryAgeMs)
-      sqlite.prepare(`
-        INSERT INTO gorsee_route_cache (cache_key, body, headers, status, created_at, revalidating)
-        VALUES (?1, ?2, ?3, ?4, ?5, ?6)
-        ON CONFLICT(cache_key) DO UPDATE SET
-          body = excluded.body,
-          headers = excluded.headers,
-          status = excluded.status,
-          created_at = excluded.created_at,
-          revalidating = excluded.revalidating
-      `).run(
-        key,
-        entry.body,
-        JSON.stringify(entry.headers),
-        entry.status,
-        entry.createdAt,
-        entry.revalidating ? 1 : 0,
-      )
-    },
-    async delete(key) {
-      sqlite.prepare("DELETE FROM gorsee_route_cache WHERE cache_key = ?1").run(key)
-    },
-    async clear() {
-      sqlite.prepare("DELETE FROM gorsee_route_cache").run()
-    },
-    async keys() {
-      if (pruneExpiredOnKeys) pruneExpiredRows(sqlite, maxEntryAgeMs)
-      const rows = sqlite.prepare("SELECT cache_key FROM gorsee_route_cache").all() as Array<{ cache_key: string }>
-      return rows.map((row) => row.cache_key)
-    },
-    deleteExpired(now = Date.now()) {
-      return pruneExpiredRows(sqlite, maxEntryAgeMs, now)
-    },
-    close() {
-      sqlite.close()
-    },
-  }
-}

package/src/server/sse.ts

@@ -1,96 +0,0 @@
-import { createSignal, type SignalGetter } from "../reactive/signal.ts"
-
-export interface SSEOptions {
-  headers?: Record<string, string>
-}
-
-export interface SSEStream {
-  response: Response
-  send: (event: string, data: unknown) => void
-  close: () => void
-}
-
-export function createSSEStream(options?: SSEOptions): SSEStream {
-  let controller: ReadableStreamDefaultController<Uint8Array> | null = null
-  const encoder = new TextEncoder()
-
-  const stream = new ReadableStream<Uint8Array>({
-    start(ctrl) {
-      controller = ctrl
-    },
-    cancel() {
-      controller = null
-    },
-  })
-
-  const response = new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      ...options?.headers,
-    },
-  })
-
-  function send(event: string, data: unknown): void {
-    if (!controller) return
-    const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
-    controller.enqueue(encoder.encode(payload))
-  }
-
-  function close(): void {
-    if (controller) {
-      controller.close()
-      controller = null
-    }
-  }
-
-  return { response, send, close }
-}
-
-// --- Client-side: reactive EventSource signal ---
-
-export interface EventSourceSignal<T> {
-  readonly value: SignalGetter<T>
-  readonly connected: SignalGetter<boolean>
-  close: () => void
-}
-
-export function createEventSource<T>(
-  url: string,
-  event: string,
-  initialValue: T,
-): EventSourceSignal<T> {
-  const [value, setValue] = createSignal<T>(initialValue)
-  const [connected, setConnected] = createSignal(false)
-
-  if (typeof globalThis.EventSource === "undefined") {
-    return { value, connected, close: () => {} }
-  }
-
-  const source = new EventSource(url)
-
-  source.addEventListener("open", () => {
-    setConnected(true)
-  })
-
-  source.addEventListener(event, (e: MessageEvent) => {
-    try {
-      const parsed = JSON.parse(String(e.data)) as T
-      setValue(parsed)
-    } catch {
-      // ignore malformed messages
-    }
-  })
-
-  source.addEventListener("error", () => {
-    setConnected(false)
-  })
-
-  function close(): void {
-    source.close()
-    setConnected(false)
-  }
-
-  return { value, connected, close }
-}

package/src/server/static-file.ts

@@ -1,63 +0,0 @@
-import { getMimeType } from "./mime.ts"
-import { fileETag, isNotModified } from "./etag.ts"
-import { resolve } from "node:path"
-
-export interface StaticFileOptions {
-  contentType?: string
-  cacheControl?: string
-  request?: Request
-  etag?: boolean
-  extraHeaders?: Record<string, string>
-}
-
-export async function serveStaticFile(
-  rootDir: string,
-  relativePath: string,
-  options: StaticFileOptions = {},
-): Promise<Response | null> {
-  const {
-    contentType,
-    cacheControl,
-    request,
-    etag = false,
-    extraHeaders = {},
-  } = options
-
-  try {
-    const filePath = resolve(rootDir, relativePath)
-    if (!filePath.startsWith(rootDir)) return null
-
-    const file = Bun.file(filePath)
-    if (!await file.exists()) return null
-
-    const headers: Record<string, string> = {
-      "Content-Type": contentType ?? getMimeType(filePath),
-      ...extraHeaders,
-    }
-
-    if (cacheControl) headers["Cache-Control"] = cacheControl
-
-    if (etag) {
-      const tag = await fileETag(filePath)
-      if (tag && request && isNotModified(request, tag)) {
-        return new Response(null, { status: 304, headers: extraHeaders })
-      }
-      if (tag) headers["ETag"] = tag
-    }
-
-    return new Response(file, { headers })
-  } catch {
-    return null
-  }
-}
-
-export async function servePrefixedStaticFile(
-  pathname: string,
-  prefix: string,
-  rootDir: string,
-  options: StaticFileOptions = {},
-): Promise<Response | null> {
-  if (!pathname.startsWith(prefix)) return null
-  const relativePath = pathname.slice(prefix.length)
-  return serveStaticFile(rootDir, relativePath, options)
-}