gorsee 0.2.4 → 0.2.6

package/src/cli/framework-md.ts

@@ -1,223 +0,0 @@
-// Generates FRAMEWORK.md -- AI context file optimized for LLM consumption
-
-export function generateFrameworkMD(projectName: string): string {
-  return `# ${projectName} -- Gorsee.js Framework Reference
-
-> This file is auto-generated. It provides complete context for AI assistants.
-> Include this file in your AI context window for best results.
-
-## Quick Reference
-
-\`\`\`
-Runtime: Bun | Language: TypeScript + JSX | Reactivity: Signals (no VDOM)
-\`\`\`
-
-## Project Structure
-
-\`\`\`
-routes/          Page and API routes (file-based routing)
-  index.ts       / (home page)
-  about.tsx      /about
-  users/
-    index.tsx    /users
-    [id].tsx     /users/:id (dynamic)
-  api/
-    health.ts    API endpoint (no UI)
-  _layout.tsx    Layout wrapper for folder
-  _middleware.ts Middleware for folder
-shared/          Shared types and utilities
-middleware/      Global middleware
-migrations/      Database migrations (SQL)
-public/          Static files
-app.config.ts    Configuration
-\`\`\`
-
-## Imports
-
-\`\`\`typescript
-// Browser-safe route code
-import { createSignal, createComputed, createEffect, createResource, createStore } from "gorsee/client"
-
-// Server-only code
-import { server, middleware, type Context, createDB, createAuth, cors, log } from "gorsee/server"
-\`\`\`
-
-## Import Boundaries
-
-- \`gorsee/client\` for route components, islands, navigation, forms, and reactive primitives
-- \`gorsee/server\` for middleware, loaders, RPC, auth, db, security, env, and logging
-- Root \`gorsee\` is compatibility-only and should not be used in new code
-- \`gorsee/compat\` is available as an explicit legacy migration entrypoint
-
-## Adapter Recipes
-
-\`\`\`typescript
-import { createClient } from "redis"
-import {
-  createAuth,
-  createRedisSessionStore,
-  createRedisCacheStore,
-  createNodeRedisLikeClient,
-  routeCache,
-} from "gorsee/server"
-
-const redis = createClient({ url: process.env.REDIS_URL })
-await redis.connect()
-const redisClient = createNodeRedisLikeClient(redis)
-
-const auth = createAuth({
-  secret: process.env.SESSION_SECRET!,
-  store: createRedisSessionStore(redisClient, { prefix: "app:sessions" }),
-})
-
-export const cache = routeCache({
-  maxAge: 60,
-  staleWhileRevalidate: 300,
-  store: createRedisCacheStore(redisClient, {
-    prefix: "app:cache",
-    maxEntryAgeMs: 360_000,
-  }),
-})
-\`\`\`
-
-- SQLite adapters are the default persistent single-node path
-- Redis adapters are the default multi-instance path
-- \`createNodeRedisLikeClient()\` and \`createIORedisLikeClient()\` normalize real Redis SDK clients to the framework adapter contract
-- RPC handlers remain process-local by design; do not try to distribute closures through Redis
-
-## Patterns
-
-### Page Route
-
-\`\`\`typescript
-// routes/users/index.tsx
-import { ssrJsx as h } from "gorsee/runtime"
-import { SafeSQL } from "gorsee/types"
-import { createDB } from "gorsee/db"
-
-const db = createDB()
-
-export default function UsersPage() {
-  const users = db.all<User>(SafeSQL\`SELECT * FROM users\`)
-  return h("ul", {
-    children: users.map(u => h("li", { children: u.name }))
-  })
-}
-\`\`\`
-
-### Dynamic Route
-
-\`\`\`typescript
-// routes/users/[id].tsx
-export default function UserPage(props: { params: { id: string } }) {
-  const user = db.get<User>(SafeSQL\`SELECT * FROM users WHERE id = \${Number(props.params.id)}\`)
-  if (!user) return h("div", { children: "Not found" })
-  return h("h1", { children: user.name })
-}
-\`\`\`
-
-### API Route
-
-\`\`\`typescript
-// routes/api/users.ts
-import type { Context } from "gorsee/server"
-
-export function GET(ctx: Context): Response {
-  return Response.json({ users: [] })
-}
-
-export function POST(ctx: Context): Response {
-  return Response.json({ created: true }, { status: 201 })
-}
-\`\`\`
-
-### Server Function
-
-\`\`\`typescript
-import { server } from "gorsee/server"
-
-const getUsers = server(async () => {
-  return db.all<User>(SafeSQL\`SELECT * FROM users\`)
-})
-// Client: getUsers() becomes fetch("/api/_rpc/...")
-// Server: runs directly
-\`\`\`
-
-### Middleware
-
-\`\`\`typescript
-// routes/_middleware.ts
-import { middleware } from "gorsee/server"
-
-export default middleware(async (ctx, next) => {
-  const session = ctx.cookies.get("session")
-  if (!session) return ctx.redirect("/login")
-  ctx.locals.user = await getUser(session)
-  return next()
-})
-\`\`\`
-
-### Signals
-
-\`\`\`typescript
-const [count, setCount] = createSignal(0)        // reactive value
-const doubled = createComputed(() => count() * 2) // derived
-createEffect(() => console.log(count()))          // side effect
-const [data] = createResource(fetchData)          // async resource
-const [store, setStore] = createStore({ a: 1 })   // reactive object
-\`\`\`
-
-### SafeSQL (prevents SQL injection at compile time)
-
-\`\`\`typescript
-// OK:
-db.get(SafeSQL\`SELECT * FROM users WHERE id = \${id}\`)
-
-// COMPILE ERROR -- string not assignable to SafeSQL:
-db.get(\`SELECT * FROM users WHERE id = \${id}\`)
-db.get("SELECT * FROM users WHERE id = " + id)
-\`\`\`
-
-## Configuration (app.config.ts)
-
-\`\`\`typescript
-export default {
-  port: 3000,
-  db: { driver: "sqlite", url: "./data.sqlite" },
-  log: "info",  // off | error | info | verbose | debug
-  security: { csp: true, hsts: true, csrf: true, rateLimit: { requests: 100, window: "1m" } },
-  deploy: { target: "bun" },  // bun | cloudflare | deno | node
-}
-\`\`\`
-
-## CLI
-
-\`\`\`
-gorsee dev          Start dev server
-gorsee build        Production build
-gorsee check        Type + safety + structure check
-gorsee routes       List all routes
-gorsee migrate      Run database migrations
-gorsee generate X   Generate CRUD for entity X
-\`\`\`
-
-## Error Codes
-
-| Code | Category | Description |
-|------|----------|-------------|
-| E001 | SafeSQL | Raw string in SQL query |
-| E002 | SafeHTML | Unsanitized HTML |
-| E003 | Server | Closure captures client variable |
-| E004 | URL | Invalid URL |
-| E005 | URL | Disallowed protocol |
-
-## Security (enabled by default)
-
-- CSP with nonce (no inline scripts except framework)
-- HSTS (production)
-- CSRF tokens (auto for POST)
-- Rate limiting (100 req/min default)
-- X-Frame-Options: DENY
-- X-Content-Type-Options: nosniff
-`
-}

package/src/cli/index.ts

@@ -1,107 +0,0 @@
-#!/usr/bin/env bun
-// Gorsee.js CLI
-
-const args = process.argv.slice(2)
-const command = args[0]
-
-const COMMANDS: Record<string, string> = {
-  create: "Create a new Gorsee.js project",
-  dev: "Start development server with HMR",
-  build: "Production build (client + server)",
-  start: "Start production server",
-  check: "Check project: types, safety, structure",
-  routes: "List all routes with render modes",
-  migrate: "Run database migrations",
-  generate: "Generate CRUD scaffold for entity",
-  typegen: "Generate typed route definitions",
-  deploy: "Generate deploy config (vercel/fly/cloudflare/netlify/docker)",
-  test: "Run tests (unit/integration/e2e)",
-  docs: "Generate API documentation from routes",
-  upgrade: "Upgrade Gorsee.js to latest version",
-  help: "Show this help message",
-}
-
-async function main() {
-  switch (command) {
-    case "create":
-      const { runCreate } = await import("./cmd-create.ts")
-      await runCreate(args.slice(1))
-      break
-    case "dev":
-      const { runDev } = await import("./cmd-dev.ts")
-      await runDev(args.slice(1))
-      break
-    case "build":
-      const { runBuild } = await import("./cmd-build.ts")
-      await runBuild(args.slice(1))
-      break
-    case "start":
-      const { runStart } = await import("./cmd-start.ts")
-      await runStart(args.slice(1))
-      break
-    case "check":
-      const { runCheck } = await import("./cmd-check.ts")
-      await runCheck(args.slice(1))
-      break
-    case "routes":
-      const { runRoutes } = await import("./cmd-routes.ts")
-      await runRoutes(args.slice(1))
-      break
-    case "migrate":
-      const { runMigrate } = await import("./cmd-migrate.ts")
-      await runMigrate(args.slice(1))
-      break
-    case "generate":
-      const { runGenerate } = await import("./cmd-generate.ts")
-      await runGenerate(args.slice(1))
-      break
-    case "typegen":
-      const { runTypegen } = await import("./cmd-typegen.ts")
-      await runTypegen(args.slice(1))
-      break
-    case "deploy":
-      const { runDeploy } = await import("./cmd-deploy.ts")
-      await runDeploy(args.slice(1))
-      break
-    case "test": {
-      const { runTest } = await import("./cmd-test.ts")
-      await runTest(args.slice(1))
-      break
-    }
-    case "docs": {
-      const { runDocs } = await import("./cmd-docs.ts")
-      await runDocs(args.slice(1))
-      break
-    }
-    case "upgrade": {
-      const { runUpgrade } = await import("./cmd-upgrade.ts")
-      await runUpgrade(args.slice(1))
-      break
-    }
-    case "help":
-    case undefined:
-    case "--help":
-    case "-h":
-      printHelp()
-      break
-    default:
-      console.error(`Unknown command: ${command}`)
-      printHelp()
-      process.exit(1)
-  }
-}
-
-function printHelp() {
-  console.log("\n  gorsee - Full-stack TypeScript framework\n")
-  console.log("  Usage: gorsee <command> [options]\n")
-  console.log("  Commands:")
-  for (const [cmd, desc] of Object.entries(COMMANDS)) {
-    console.log(`    ${cmd.padEnd(12)} ${desc}`)
-  }
-  console.log()
-}
-
-main().catch((err) => {
-  console.error(err)
-  process.exit(1)
-})

package/src/client.ts

@@ -1,26 +0,0 @@
-// Explicit browser-safe public entrypoint.
-// Use this in route components and client-facing modules.
-
-export {
-  createSignal,
-  createComputed,
-  createEffect,
-  createResource,
-  createStore,
-  createLive,
-  invalidateResource,
-  invalidateAll,
-  createMutation,
-} from "./reactive/index.ts"
-
-export { Suspense } from "./runtime/suspense.ts"
-export { Link } from "./runtime/link.ts"
-export { Head } from "./runtime/head.ts"
-export { navigate, onNavigate, beforeNavigate, getCurrentPath } from "./runtime/router.ts"
-export { useFormAction } from "./runtime/form.ts"
-export { Image } from "./runtime/image.ts"
-export { ErrorBoundary } from "./runtime/error-boundary.ts"
-export { island } from "./runtime/island.ts"
-export { createEventSource } from "./server/sse.ts"
-export { typedLink, typedNavigate } from "./runtime/typed-routes.ts"
-export { defineForm, validateForm, fieldAttrs } from "./runtime/validated-form.ts"

package/src/db/index.ts

@@ -1,2 +0,0 @@
-export { createDB, type DB } from "./sqlite.ts"
-export { runMigrations, createMigration, type MigrationResult } from "./migrate.ts"

package/src/db/migrate.ts

@@ -1,89 +0,0 @@
-// Database migration runner
-// Reads SQL files from migrations/ dir, applies in order
-// Tracks applied migrations in _migrations table
-
-import { Database } from "bun:sqlite"
-import { readdir, readFile } from "node:fs/promises"
-import { join, extname } from "node:path"
-
-interface MigrationRecord {
-  name: string
-  applied_at: string
-}
-
-export interface MigrationResult {
-  applied: string[]
-  skipped: string[]
-  errors: string[]
-}
-
-export async function runMigrations(dbPath: string, migrationsDir: string): Promise<MigrationResult> {
-  const db = new Database(dbPath)
-  db.run("PRAGMA journal_mode=WAL;")
-
-  // Create migrations table if not exists
-  db.run(`CREATE TABLE IF NOT EXISTS _migrations (
-    name TEXT PRIMARY KEY,
-    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-  )`)
-
-  // Get already applied
-  const applied = new Set(
-    db.query("SELECT name FROM _migrations ORDER BY name").all()
-      .map((r) => (r as MigrationRecord).name)
-  )
-
-  // Read migration files
-  let files: string[]
-  try {
-    files = await readdir(migrationsDir)
-  } catch {
-    db.close()
-    return { applied: [], skipped: [], errors: ["migrations/ directory not found"] }
-  }
-
-  const sqlFiles = files
-    .filter((f) => extname(f) === ".sql")
-    .sort()
-
-  const result: MigrationResult = { applied: [], skipped: [], errors: [] }
-
-  for (const file of sqlFiles) {
-    if (applied.has(file)) {
-      result.skipped.push(file)
-      continue
-    }
-
-    try {
-      const sql = await readFile(join(migrationsDir, file), "utf-8")
-      db.run("BEGIN")
-      try {
-        db.run(sql)
-        db.run("INSERT INTO _migrations (name) VALUES (?)", [file])
-        db.run("COMMIT")
-        result.applied.push(file)
-      } catch (err) {
-        db.run("ROLLBACK")
-        throw err
-      }
-    } catch (err) {
-      result.errors.push(`${file}: ${err instanceof Error ? err.message : String(err)}`)
-    }
-  }
-
-  db.close()
-  return result
-}
-
-export async function createMigration(migrationsDir: string, name: string): Promise<string> {
-  const { mkdir, writeFile } = await import("node:fs/promises")
-  await mkdir(migrationsDir, { recursive: true })
-
-  const timestamp = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14)
-  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase()
-  const filename = `${timestamp}_${safeName}.sql`
-  const filepath = join(migrationsDir, filename)
-
-  await writeFile(filepath, `-- Migration: ${name}\n-- Created: ${new Date().toISOString()}\n\n`)
-  return filename
-}

package/src/db/sqlite.ts

@@ -1,40 +0,0 @@
-import { Database, type SQLQueryBindings } from "bun:sqlite"
-import type { SafeSQLValue } from "../types/safe-sql.ts"
-
-export interface DB {
-  get<T>(query: SafeSQLValue): T | null
-  all<T>(query: SafeSQLValue): T[]
-  run(query: SafeSQLValue): { changes: number }
-  close(): void
-}
-
-function toBindings(params: readonly unknown[]): SQLQueryBindings[] {
-  return params as SQLQueryBindings[]
-}
-
-export function createDB(path: string = ":memory:"): DB {
-  const sqlite = new Database(path)
-  sqlite.run("PRAGMA journal_mode=WAL;")
-
-  return {
-    get<T>(query: SafeSQLValue): T | null {
-      const stmt = sqlite.prepare(query.text)
-      return stmt.get(...toBindings(query.params)) as T | null
-    },
-
-    all<T>(query: SafeSQLValue): T[] {
-      const stmt = sqlite.prepare(query.text)
-      return stmt.all(...toBindings(query.params)) as T[]
-    },
-
-    run(query: SafeSQLValue): { changes: number } {
-      const stmt = sqlite.prepare(query.text)
-      const result = stmt.run(...toBindings(query.params))
-      return { changes: (result as { changes?: number }).changes ?? 0 }
-    },
-
-    close(): void {
-      sqlite.close()
-    },
-  }
-}

package/src/deploy/index.ts

@@ -1,31 +0,0 @@
-// Gorsee.js — Deploy adapters barrel export
-
-export {
-  generateDockerfile,
-  generateDockerignore,
-} from "./dockerfile.ts"
-
-export {
-  generateVercelConfig,
-  generateVercelServerlessEntry,
-  generateVercelBuildOutput,
-  type VercelConfig,
-  type VercelOutputConfig,
-} from "./vercel.ts"
-
-export {
-  generateFlyConfig,
-  generateFlyDockerfile,
-} from "./fly.ts"
-
-export {
-  generateWranglerConfig,
-  generateCloudflareEntry,
-  generateCloudflareStaticAssets,
-  type CloudflareRoutesConfig,
-} from "./cloudflare.ts"
-
-export {
-  generateNetlifyConfig,
-  generateNetlifyFunction,
-} from "./netlify.ts"

package/src/deploy/vercel.ts

@@ -1,94 +0,0 @@
-// Gorsee.js — Vercel deploy adapter
-
-export interface VercelConfig {
-  version: number
-  framework: null
-  buildCommand: string
-  outputDirectory: string
-  routes: Array<{ src: string; dest?: string; headers?: Record<string, string> }>
-}
-
-export function generateVercelConfig(): VercelConfig {
-  return {
-    version: 2,
-    framework: null,
-    buildCommand: "bun run build",
-    outputDirectory: ".vercel/output",
-    routes: [
-      {
-        src: "/_gorsee/(.*)",
-        headers: { "Cache-Control": "public, max-age=31536000, immutable" },
-      },
-      { src: "/(.*)", dest: "/api/index" },
-    ],
-  }
-}
-
-export function generateVercelServerlessEntry(): string {
-  return `// Gorsee.js — Vercel serverless entry
-// Auto-generated by \`gorsee deploy vercel\`
-
-import { startProductionServer } from "./dist/prod.js"
-
-let initialized = false
-
-async function ensureInit() {
-  if (!initialized) {
-    initialized = true
-    // Production server setup without Bun.serve()
-  }
-}
-
-export default async function handler(request: Request): Promise<Response> {
-  await ensureInit()
-
-  const url = new URL(request.url)
-
-  // Serve static client assets
-  if (url.pathname.startsWith("/_gorsee/")) {
-    return new Response(null, { status: 404 })
-  }
-
-  // Forward to Gorsee production handler
-  const { createRouter, matchRoute, buildStaticMap } = await import("./dist/router/index.js")
-  const { renderToString, ssrJsx } = await import("./dist/runtime/server.js")
-  const { handleRPCRequest } = await import("./dist/server/rpc.js")
-
-  // RPC handling
-  const rpcResponse = await handleRPCRequest(request)
-  if (rpcResponse) return rpcResponse
-
-  // Return placeholder — full implementation wires into prod.ts handler
-  return new Response("Gorsee on Vercel", {
-    headers: { "Content-Type": "text/html" },
-  })
-}
-`
-}
-
-export interface VercelOutputConfig {
-  version: number
-  routes: Array<{ src: string; dest?: string; headers?: Record<string, string> }>
-}
-
-export function generateVercelBuildOutput(routes: string[]): VercelOutputConfig {
-  const outputRoutes: VercelOutputConfig["routes"] = [
-    {
-      src: "/_gorsee/(.*)",
-      dest: "/static/_gorsee/$1",
-      headers: { "Cache-Control": "public, max-age=31536000, immutable" },
-    },
-    {
-      src: "/favicon\\.ico|/robots\\.txt|/styles\\.css",
-      dest: "/static/$0",
-    },
-  ]
-
-  for (const route of routes) {
-    outputRoutes.push({ src: route, dest: "/functions/index" })
-  }
-
-  outputRoutes.push({ src: "/(.*)", dest: "/functions/index" })
-
-  return { version: 3, routes: outputRoutes }
-}

package/src/dev/hmr.ts

@@ -1,31 +0,0 @@
-// HMR (Hot Module Reload) via WebSocket
-// Server pushes "reload" messages, client refreshes the page
-
-export const HMR_CLIENT_SCRIPT = `<script data-g-hmr>
-(function(){
-  var ws = new WebSocket((location.protocol==="https:"?"wss://":"ws://") + location.host + "/__gorsee_hmr");
-  ws.onmessage = function(e) {
-    if (e.data === "reload") location.reload();
-  };
-  ws.onclose = function() {
-    setTimeout(function(){ location.reload(); }, 1000);
-  };
-})();
-</script>`
-
-// Set of connected WebSocket clients
-const clients = new Set<{ send(data: string): void }>()
-
-export function addHMRClient(ws: { send(data: string): void }): void {
-  clients.add(ws)
-}
-
-export function removeHMRClient(ws: { send(data: string): void }): void {
-  clients.delete(ws)
-}
-
-export function notifyReload(): void {
-  for (const ws of clients) {
-    try { ws.send("reload") } catch {}
-  }
-}

package/src/dev/partial-handler.ts

@@ -1,52 +0,0 @@
-// Handles partial navigation requests (X-Gorsee-Navigate: partial)
-// Returns JSON with rendered HTML + metadata instead of full page
-
-import { createContext } from "../server/middleware.ts"
-import {
-  buildPartialResponsePayload,
-  createClientScriptPath,
-  renderPageDocument,
-  resolvePageRoute,
-} from "../server/page-render.ts"
-import type { MatchResult } from "../router/matcher.ts"
-import type { BuildResult } from "../build/client.ts"
-
-interface PartialRenderOptions {
-  match: MatchResult
-  request: Request
-  clientBuild: BuildResult
-}
-
-export async function handlePartialNavigation(opts: PartialRenderOptions): Promise<Response> {
-  const { match, request, clientBuild } = opts
-  const mod = await import(match.route.filePath)
-  const ctx = createContext(request, match.params)
-
-  // API routes don't support partial navigation
-  if (typeof mod.GET === "function" || typeof mod.POST === "function") {
-    return new Response("Not a page route", { status: 400 })
-  }
-
-  const resolved = await resolvePageRoute(mod, match, ctx)
-  if (!resolved) {
-    return new Response(JSON.stringify({ error: "Route has no default export" }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" },
-    })
-  }
-
-  const { pageComponent, loaderData, cssFiles } = resolved
-  const rendered = renderPageDocument(pageComponent, ctx, match.params, loaderData)
-  const clientScript = createClientScriptPath(clientBuild.entryMap.get(match.route.path))
-  const result = buildPartialResponsePayload(
-    rendered,
-    loaderData,
-    match.params,
-    cssFiles,
-    clientScript,
-  )
-
-  return new Response(JSON.stringify(result), {
-    headers: { "Content-Type": "application/json" },
-  })
-}