gorsee 0.2.0 → 0.2.2

package/src/dev.ts

@@ -2,7 +2,7 @@
 // Orchestrator: routing + security + HMR + static serving
 
 import { createRouter, matchRoute, buildStaticMap } from "./router/index.ts"
-import { handleRPCRequest, __resetRPCState } from "./server/rpc.ts"
+import { __resetRPCState } from "./server/rpc.ts"
 import { securityHeaders } from "./security/headers.ts"
 import { createRateLimiter } from "./security/rate-limit.ts"
 import { EVENT_REPLAY_SCRIPT } from "./runtime/event-replay.ts"
@@ -14,182 +14,122 @@ import { renderErrorOverlay } from "./dev/error-overlay.ts"
 import { handlePageRequest } from "./dev/request-handler.ts"
 import { handlePartialNavigation } from "./dev/partial-handler.ts"
 import { loadEnv } from "./env/index.ts"
-import { getMimeType } from "./server/mime.ts"
-import { join, resolve } from "node:path"
+import { generateNonce, wrapHTML } from "./server/html-shell.ts"
+import { renderNotFoundPage } from "./server/not-found.ts"
+import { createRateLimitResponse, handleRPCWithHeaders } from "./server/request-preflight.ts"
+import { servePrefixedStaticFile, serveStaticFile } from "./server/static-file.ts"
+import { join } from "node:path"
 import type { Route } from "./router/index.ts"
+import { createProjectContext, resolveRuntimeEnv, type RuntimeOptions } from "./runtime/project.ts"
 
-const CWD = process.cwd()
-const ROUTES_DIR = join(CWD, "routes")
-const PUBLIC_DIR = join(CWD, "public")
-const CLIENT_DIR = join(CWD, ".gorsee", "client")
-const PORT = Number(process.env.PORT) || 3000
-
-let routes: Route[] = []
-let staticMap = new Map<string, Route>()
-let clientBuild: BuildResult = { entryMap: new Map() }
-
-const rateLimiter = createRateLimiter(200, "1m")
-
-// --- Static file serving ---
-
-async function tryServeStatic(pathname: string): Promise<Response | null> {
-  if (pathname === "/") return null
-  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()) {
-      return new Response(file, {
-        headers: { "Content-Type": getMimeType(filePath) },
-      })
-    }
-  } catch {}
-  return null
+interface StartDevServerOptions extends RuntimeOptions {
+  port?: number
 }
 
-async function tryServeClientBundle(pathname: string): Promise<Response | null> {
-  if (!pathname.startsWith("/_gorsee/")) return null
-  const relPath = pathname.slice("/_gorsee/".length)
-  try {
-    const filePath = resolve(CLIENT_DIR, relPath)
-    if (!filePath.startsWith(CLIENT_DIR)) return null
-    const file = Bun.file(filePath)
-    if (await file.exists()) {
-      return new Response(file, {
-        headers: { "Content-Type": "application/javascript" },
-      })
-    }
-  } catch {}
-  return null
+interface DevRuntimeState {
+  cwd: string
+  routesDir: string
+  publicDir: string
+  clientDir: string
+  rateLimiter: ReturnType<typeof createRateLimiter>
+  routes: Route[]
+  staticMap: Map<string, Route>
+  clientBuild: BuildResult
 }
 
-// --- HTML shell ---
-
-function generateNonce(): string {
-  const bytes = new Uint8Array(16)
-  crypto.getRandomValues(bytes)
-  return btoa(String.fromCharCode(...bytes))
-}
+// --- Static file serving ---
 
-interface HTMLWrapOptions {
-  title?: string
-  clientScript?: string
-  loaderData?: unknown
-  params?: Record<string, string>
-  cssFiles?: string[]
+async function tryServeStatic(publicDir: string, pathname: string): Promise<Response | null> {
+  if (pathname === "/") return null
+  return serveStaticFile(publicDir, pathname.slice(1))
 }
 
-function wrapHTML(
-  body: string,
-  nonce: string,
-  options: HTMLWrapOptions = {},
-): string {
-  const { title = "Gorsee App", clientScript, loaderData, params, cssFiles = [] } = 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")}
-</head>
-<body>
-${EVENT_REPLAY_SCRIPT.replace("<script", `<script nonce="${nonce}"`)}
-  <div id="app">${body}</div>${dataScript}${paramsScript}${clientTag}
-${HMR_CLIENT_SCRIPT.replace("<script", `<script nonce="${nonce}"`)}
-</body>
-</html>`
+async function tryServeClientBundle(clientDir: string, pathname: string): Promise<Response | null> {
+  return servePrefixedStaticFile(pathname, "/_gorsee/", clientDir, {
+    contentType: "application/javascript",
+  })
 }
 
 // --- 404 page ---
 
-async function render404Page(nonce: string): Promise<string> {
-  try {
-    const notFoundPath = join(ROUTES_DIR, "404.tsx")
-    const file = Bun.file(notFoundPath)
-    if (await file.exists()) {
-      const mod = await import(notFoundPath)
-      if (typeof mod.default === "function") {
-        const { ssrJsx, renderToString } = await import("./runtime/server.ts")
-        const vnode = ssrJsx(mod.default as any, {})
-        const body = renderToString(vnode)
-        return wrapHTML(body, nonce, { title: "404 - Not Found" })
-      }
-    }
-  } catch {}
-  return wrapHTML("<h1>404</h1><p>Page not found</p>", nonce)
+async function render404Page(routesDir: string, nonce: string): Promise<string> {
+  return renderNotFoundPage(routesDir, nonce, {
+    bodyPrefix: [EVENT_REPLAY_SCRIPT.replace("<script", `<script nonce="${nonce}"`)],
+    bodySuffix: [HMR_CLIENT_SCRIPT.replace("<script", `<script nonce="${nonce}"`)],
+  })
 }
 
 // --- Build & watch ---
 
-let buildInProgress = false
-let buildQueued = false
+async function createDevRuntimeState(cwd: string): Promise<DevRuntimeState> {
+  const { paths } = createProjectContext({ cwd })
+  return {
+    cwd,
+    routesDir: paths.routesDir,
+    publicDir: paths.publicDir,
+    clientDir: join(paths.gorseeDir, "client"),
+    rateLimiter: createRateLimiter(200, "1m"),
+    routes: [],
+    staticMap: new Map(),
+    clientBuild: { entryMap: new Map() },
+  }
+}
 
-async function rebuildClient() {
-  if (buildInProgress) {
-    buildQueued = true
+async function rebuildClient(state: DevRuntimeState, buildState: { inProgress: boolean, queued: boolean }) {
+  if (buildState.inProgress) {
+    buildState.queued = true
     return
   }
-  buildInProgress = true
+  buildState.inProgress = true
   try {
     __resetRPCState()
-    routes = await createRouter(ROUTES_DIR)
-    staticMap = buildStaticMap(routes)
-    clientBuild = await buildClientBundles(routes, CWD)
-    log.info("client build complete", { routes: clientBuild.entryMap.size })
+    state.routes = await createRouter(state.routesDir)
+    state.staticMap = buildStaticMap(state.routes)
+    state.clientBuild = await buildClientBundles(state.routes, state.cwd)
+    log.info("client build complete", { routes: state.clientBuild.entryMap.size })
   } catch (err) {
     log.error("client build failed", { error: String(err) })
   } finally {
-    buildInProgress = false
-    if (buildQueued) {
-      buildQueued = false
-      await rebuildClient()
+    buildState.inProgress = false
+    if (buildState.queued) {
+      buildState.queued = false
+      await rebuildClient(state, buildState)
     }
   }
 }
 
 // --- Server ---
 
-async function main() {
-  await loadEnv(CWD)
-  setLogLevel("info")
-  log.info("scanning routes", { dir: ROUTES_DIR })
-
-  routes = await createRouter(ROUTES_DIR)
-  staticMap = buildStaticMap(routes)
-  for (const route of routes) {
+export async function startDevServer(options: StartDevServerOptions = {}) {
+  const runtime = createProjectContext(options)
+  const cwd = runtime.cwd
+  const state = await createDevRuntimeState(cwd)
+  const buildState = { inProgress: false, queued: false }
+
+  await loadEnv(cwd)
+  const envConfig = resolveRuntimeEnv(process.env)
+  const port = options.port ?? envConfig.port
+  setLogLevel(envConfig.logLevel)
+  log.info("scanning routes", { dir: state.routesDir })
+
+  state.routes = await createRouter(state.routesDir)
+  state.staticMap = buildStaticMap(state.routes)
+  for (const route of state.routes) {
     log.info("route registered", { path: route.path, file: route.filePath })
   }
 
-  await rebuildClient()
+  await rebuildClient(state, buildState)
 
   startWatcher({
-    dirs: [ROUTES_DIR, join(CWD, "shared"), join(CWD, "middleware")],
+    dirs: [state.routesDir, runtime.paths.sharedDir, runtime.paths.middlewareDir],
     onChange: async () => {
-      await rebuildClient()
+      await rebuildClient(state, buildState)
       notifyReload()
     },
   })
 
   const server = Bun.serve({
-    port: PORT,
+    port,
     async fetch(request, server) {
       const url = new URL(request.url)
       const pathname = url.pathname
@@ -202,37 +142,29 @@ async function main() {
 
       // Rate limiting by IP
       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)) },
-        })
-      }
+      const rateLimitResponse = createRateLimitResponse(state.rateLimiter, ip)
+      if (rateLimitResponse) return rateLimitResponse
 
       const start = performance.now()
       const nonce = generateNonce()
       const secHeaders = securityHeaders({}, nonce)
 
       // 1. RPC
-      const rpcResponse = await handleRPCRequest(request)
-      if (rpcResponse) {
-        for (const k in secHeaders) rpcResponse.headers.set(k, secHeaders[k]!)
-        return rpcResponse
-      }
+      const rpcResponse = await handleRPCWithHeaders(request, secHeaders)
+      if (rpcResponse) return rpcResponse
 
       // 2. Client bundles
-      const bundleResponse = await tryServeClientBundle(pathname)
+      const bundleResponse = await tryServeClientBundle(state.clientDir, pathname)
       if (bundleResponse) return bundleResponse
 
       // 3. Static files
-      const staticResponse = await tryServeStatic(pathname)
+      const staticResponse = await tryServeStatic(state.publicDir, pathname)
       if (staticResponse) return staticResponse
 
       // 4. Route matching
-      const match = matchRoute(routes, pathname, staticMap)
+      const match = matchRoute(state.routes, pathname, state.staticMap)
       if (!match) {
-        const notFoundHtml = await render404Page(nonce)
+        const notFoundHtml = await render404Page(state.routesDir, nonce)
         return new Response(notFoundHtml, {
           status: 404,
           headers: { "Content-Type": "text/html", ...secHeaders },
@@ -242,11 +174,11 @@ async function main() {
       try {
         // Partial navigation (SPA client-side routing)
         if (request.headers.get("X-Gorsee-Navigate") === "partial") {
-          return await handlePartialNavigation({ match, request, clientBuild })
+          return await handlePartialNavigation({ match, request, clientBuild: state.clientBuild })
         }
 
         return await handlePageRequest({
-          match, request, nonce, start, clientBuild, secHeaders, wrapHTML,
+          match, request, nonce, start, clientBuild: state.clientBuild, secHeaders, wrapHTML,
         })
       } catch (err) {
         const errObj = err instanceof Error ? err : new Error(String(err))
@@ -265,9 +197,12 @@ async function main() {
   })
 
   log.info("dev server started", { url: `http://localhost:${server.port}` })
+  return server
 }
 
-main().catch((err) => {
-  console.error("Failed to start dev server:", err)
-  process.exit(1)
-})
+if (import.meta.main) {
+  startDevServer().catch((err) => {
+    console.error("Failed to start dev server:", err)
+    process.exit(1)
+  })
+}

package/src/index-client.ts

@@ -0,0 +1,4 @@
+// Browser-safe root entry used by client bundling.
+// Mirrors the explicit public `gorsee/client` entrypoint.
+
+export * from "./client.ts"

package/src/index.ts

@@ -1,6 +1,8 @@
-// Gorsee.js -- main entry point
-// Re-exports core APIs for convenience
+// Gorsee.js -- compatibility entry point.
+// Prefer "gorsee/client" for browser-safe APIs, "gorsee/server" for server-only APIs,
+// or "gorsee/compat" when you need an explicit legacy migration path.
 
+/** @deprecated Import from "gorsee/client" instead. */
 export {
   createSignal,
   createComputed,
@@ -13,16 +15,29 @@ export {
   createMutation,
 } from "./reactive/index.ts"
 
+/** @deprecated Import from "gorsee/client" instead. */
 export { Suspense } from "./runtime/suspense.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { Link } from "./runtime/link.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { Head } from "./runtime/head.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { navigate, onNavigate, beforeNavigate, getCurrentPath } from "./runtime/router.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { useFormAction } from "./runtime/form.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { Image } from "./runtime/image.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { ErrorBoundary } from "./runtime/error-boundary.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { island } from "./runtime/island.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { createEventSource } from "./server/sse.ts"
+/** @deprecated Import from "gorsee/server" instead. */
 export { createAuth } from "./auth/index.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { typedLink, typedNavigate } from "./runtime/typed-routes.ts"
+/** @deprecated Import from "gorsee/client" instead. */
 export { defineForm, validateForm, fieldAttrs } from "./runtime/validated-form.ts"
+/** @deprecated Import from "gorsee/server" instead. */
 export { definePlugin, createPluginRunner, type GorseePlugin, type PluginContext } from "./plugins/index.ts"