gorsee 0.1.3 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gorsee",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Full-stack TypeScript framework — islands, reactive WebSocket, optimistic mutations, built-in auth, type-safe routes",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,16 @@
     "./env": "./src/env/index.ts",
     "./auth": "./src/auth/index.ts",
     "./routes": "./src/runtime/typed-routes.ts",
-    "./cli/cmd-create": "./src/cli/cmd-create.ts"
+    "./cli/cmd-create": "./src/cli/cmd-create.ts",
+    "./plugins": "./src/plugins/index.ts",
+    "./plugins/drizzle": "./src/plugins/drizzle.ts",
+    "./plugins/prisma": "./src/plugins/prisma.ts",
+    "./plugins/tailwind": "./src/plugins/tailwind.ts",
+    "./plugins/lucia": "./src/plugins/lucia.ts",
+    "./plugins/s3": "./src/plugins/s3.ts",
+    "./plugins/resend": "./src/plugins/resend.ts",
+    "./plugins/stripe": "./src/plugins/stripe.ts",
+    "./deploy": "./src/deploy/index.ts"
   },
   "files": [
     "src/",

package/src/cli/cmd-deploy.ts

@@ -0,0 +1,141 @@
+// Gorsee.js — CLI deploy command
+
+import { writeFile, access, mkdir } from "node:fs/promises"
+import { join } from "node:path"
+
+type Target = "vercel" | "fly" | "cloudflare" | "netlify" | "docker"
+
+const TARGETS: Target[] = ["vercel", "fly", "cloudflare", "netlify", "docker"]
+
+const DETECT_FILES: Record<string, Target> = {
+  "vercel.json": "vercel",
+  "fly.toml": "fly",
+  "wrangler.toml": "cloudflare",
+  "netlify.toml": "netlify",
+  "Dockerfile": "docker",
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function detectTarget(cwd: string): Promise<Target | null> {
+  for (const [file, target] of Object.entries(DETECT_FILES)) {
+    if (await fileExists(join(cwd, file))) return target
+  }
+  return null
+}
+
+async function writeAndLog(filePath: string, content: string): Promise<void> {
+  await writeFile(filePath, content, "utf-8")
+  console.log(`  created ${filePath}`)
+}
+
+async function deployVercel(cwd: string): Promise<void> {
+  const { generateVercelConfig, generateVercelServerlessEntry } = await import("../deploy/vercel.ts")
+  await writeAndLog(join(cwd, "vercel.json"), JSON.stringify(generateVercelConfig(), null, 2))
+  await mkdir(join(cwd, "api"), { recursive: true })
+  await writeAndLog(join(cwd, "api/index.ts"), generateVercelServerlessEntry())
+  console.log("\n  Next steps:")
+  console.log("    1. Install Vercel CLI: npm i -g vercel")
+  console.log("    2. Run: vercel")
+  console.log("    3. Follow prompts to link your project")
+}
+
+async function deployFly(cwd: string, appName: string): Promise<void> {
+  const { generateFlyConfig, generateFlyDockerfile } = await import("../deploy/fly.ts")
+  await writeAndLog(join(cwd, "fly.toml"), generateFlyConfig(appName))
+  await writeAndLog(join(cwd, "Dockerfile"), generateFlyDockerfile())
+  console.log("\n  Next steps:")
+  console.log("    1. Install Fly CLI: curl -L https://fly.io/install.sh | sh")
+  console.log(`    2. Run: fly launch --name ${appName}`)
+  console.log("    3. Deploy: fly deploy")
+}
+
+async function deployCloudflare(cwd: string, name: string): Promise<void> {
+  const { generateWranglerConfig, generateCloudflareEntry, generateCloudflareStaticAssets } =
+    await import("../deploy/cloudflare.ts")
+  await writeAndLog(join(cwd, "wrangler.toml"), generateWranglerConfig(name))
+  await writeAndLog(join(cwd, "worker.ts"), generateCloudflareEntry())
+  await writeAndLog(join(cwd, "_routes.json"), JSON.stringify(generateCloudflareStaticAssets(), null, 2))
+  console.log("\n  Next steps:")
+  console.log("    1. Install Wrangler: npm i -g wrangler")
+  console.log("    2. Authenticate: wrangler login")
+  console.log("    3. Deploy: wrangler deploy")
+}
+
+async function deployNetlify(cwd: string): Promise<void> {
+  const { generateNetlifyConfig, generateNetlifyFunction } = await import("../deploy/netlify.ts")
+  await writeAndLog(join(cwd, "netlify.toml"), generateNetlifyConfig())
+  const edgeFnDir = join(cwd, "netlify/edge-functions")
+  await mkdir(edgeFnDir, { recursive: true })
+  await writeAndLog(join(edgeFnDir, "gorsee-handler.ts"), generateNetlifyFunction())
+  console.log("\n  Next steps:")
+  console.log("    1. Install Netlify CLI: npm i -g netlify-cli")
+  console.log("    2. Run: netlify init")
+  console.log("    3. Deploy: netlify deploy --prod")
+}
+
+async function deployDocker(cwd: string): Promise<void> {
+  const { generateDockerfile, generateDockerignore } = await import("../deploy/dockerfile.ts")
+  await writeAndLog(join(cwd, "Dockerfile"), generateDockerfile())
+  await writeAndLog(join(cwd, ".dockerignore"), generateDockerignore())
+  console.log("\n  Next steps:")
+  console.log("    1. Build image: docker build -t gorsee-app .")
+  console.log("    2. Run: docker run -p 3000:3000 gorsee-app")
+}
+
+export async function runDeploy(args: string[]): Promise<void> {
+  const cwd = process.cwd()
+  const initOnly = args.includes("--init")
+  const targetArg = args.find((a) => !a.startsWith("-")) as Target | undefined
+
+  let target = targetArg ?? null
+  if (!target) {
+    target = await detectTarget(cwd)
+    if (!target) {
+      console.error("  No deploy target specified and none detected.")
+      console.error(`  Usage: gorsee deploy <${TARGETS.join("|")}> [--init]`)
+      process.exit(1)
+    }
+    console.log(`  Auto-detected target: ${target}`)
+  }
+
+  if (!TARGETS.includes(target)) {
+    console.error(`  Unknown target: ${target}`)
+    console.error(`  Available: ${TARGETS.join(", ")}`)
+    process.exit(1)
+  }
+
+  const projectName = cwd.split("/").pop() ?? "gorsee-app"
+  console.log(`\n  Generating ${target} deploy config...\n`)
+
+  switch (target) {
+    case "vercel":
+      await deployVercel(cwd)
+      break
+    case "fly":
+      await deployFly(cwd, projectName)
+      break
+    case "cloudflare":
+      await deployCloudflare(cwd, projectName)
+      break
+    case "netlify":
+      await deployNetlify(cwd)
+      break
+    case "docker":
+      await deployDocker(cwd)
+      break
+  }
+
+  if (initOnly) {
+    console.log("\n  Config generated (--init mode). Deploy manually when ready.")
+  }
+
+  console.log()
+}

package/src/cli/cmd-docs.ts

@@ -0,0 +1,145 @@
+// gorsee docs -- generate API documentation from route files
+
+import { join } from "node:path"
+import { readFile, mkdir, writeFile } from "node:fs/promises"
+import { createRouter, type Route } from "../router/scanner.ts"
+
+const HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"] as const
+
+interface DocFlags {
+  output: string
+  format: "md" | "json" | "html"
+  routesOnly: boolean
+}
+
+interface RouteDoc {
+  path: string
+  methods: string[]
+  hasLoader: boolean
+  isApi: boolean
+  hasMiddleware: boolean
+  title: string
+  meta: Record<string, unknown> | null
+}
+
+export function parseDocsFlags(args: string[]): DocFlags {
+  const flags: DocFlags = { output: "docs/api.md", format: "md", routesOnly: false }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!
+    if (arg === "--output" && args[i + 1]) flags.output = args[++i]!
+    else if (arg === "--format" && args[i + 1]) {
+      const fmt = args[++i]!
+      if (fmt === "md" || fmt === "json" || fmt === "html") flags.format = fmt
+    } else if (arg === "--routes-only") flags.routesOnly = true
+  }
+
+  return flags
+}
+
+async function extractRouteInfo(route: Route): Promise<RouteDoc> {
+  const content = await readFile(route.filePath, "utf-8")
+  const methods: string[] = []
+
+  for (const method of HTTP_METHODS) {
+    if (new RegExp(`export\\s+(async\\s+)?function\\s+${method}\\b`, "i").test(content)) {
+      methods.push(method)
+    }
+  }
+
+  const hasDefault = /export\s+default\s+/.test(content)
+  const hasLoader = /export\s+(async\s+)?function\s+loader\b/.test(content)
+  const isApi = !hasDefault || methods.length > 0
+
+  if (methods.length === 0 && hasDefault) methods.push("GET")
+  if (methods.length === 0 && hasLoader) methods.push("GET")
+
+  // Extract title from JSDoc or component name
+  let title = ""
+  const jsdocMatch = content.match(/\/\*\*\s*\n?\s*\*\s*(.+?)(?:\n|\*\/)/s)
+  if (jsdocMatch) title = jsdocMatch[1]!.trim()
+
+  // Extract meta export
+  let meta: Record<string, unknown> | null = null
+  const metaMatch = content.match(/export\s+const\s+meta\s*=\s*(\{[^}]+\})/)
+  if (metaMatch) {
+    try { meta = JSON.parse(metaMatch[1]!.replace(/'/g, '"')) } catch { /* skip */ }
+  }
+
+  return {
+    path: route.path,
+    methods,
+    hasLoader,
+    isApi,
+    hasMiddleware: route.middlewarePaths.length > 0,
+    title,
+    meta,
+  }
+}
+
+function generateMarkdown(docs: RouteDoc[]): string {
+  const lines = ["# API Documentation", "", "| Path | Methods | Type | Loader | Middleware |", "| --- | --- | --- | --- | --- |"]
+  for (const doc of docs) {
+    const type = doc.isApi ? "API" : "Page"
+    const mw = doc.hasMiddleware ? "Yes" : "-"
+    lines.push(`| ${doc.path} | ${doc.methods.join(", ")} | ${type} | ${doc.hasLoader ? "Yes" : "-"} | ${mw} |`)
+  }
+  return lines.join("\n") + "\n"
+}
+
+function generateJson(docs: RouteDoc[]): string {
+  return JSON.stringify(docs, null, 2) + "\n"
+}
+
+function generateHtml(docs: RouteDoc[]): string {
+  const rows = docs.map((d) => {
+    const type = d.isApi ? "API" : "Page"
+    const mw = d.hasMiddleware ? "Yes" : "-"
+    return `<tr><td>${d.path}</td><td>${d.methods.join(", ")}</td><td>${type}</td><td>${d.hasLoader ? "Yes" : "-"}</td><td>${mw}</td></tr>`
+  }).join("\n      ")
+
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>API Docs</title>
+<style>body{font-family:sans-serif;margin:2rem}table{border-collapse:collapse;width:100%}
+th,td{border:1px solid #ddd;padding:8px;text-align:left}th{background:#f5f5f5}</style>
+</head><body><h1>API Documentation</h1>
+<table><thead><tr><th>Path</th><th>Methods</th><th>Type</th><th>Loader</th><th>Middleware</th></tr></thead>
+  <tbody>${rows}</tbody></table></body></html>\n`
+}
+
+const GENERATORS: Record<string, (docs: RouteDoc[]) => string> = {
+  md: generateMarkdown,
+  json: generateJson,
+  html: generateHtml,
+}
+
+export async function runDocs(args: string[]) {
+  const cwd = process.cwd()
+  const flags = parseDocsFlags(args)
+  const routesDir = join(cwd, "routes")
+
+  const routes = await createRouter(routesDir)
+  if (routes.length === 0) {
+    console.log("\n  No routes found in routes/\n")
+    return
+  }
+
+  const docs: RouteDoc[] = []
+  for (const route of routes) {
+    const info = await extractRouteInfo(route)
+    if (flags.routesOnly && info.isApi) continue
+    docs.push(info)
+  }
+
+  const generate = GENERATORS[flags.format]!
+  const content = generate(docs)
+
+  const outputPath = join(cwd, flags.output)
+  await mkdir(join(outputPath, ".."), { recursive: true })
+  await writeFile(outputPath, content, "utf-8")
+
+  console.log(`\n  Generated docs for ${docs.length} routes -> ${flags.output}\n`)
+}
+
+export { extractRouteInfo, generateMarkdown, generateJson, generateHtml }
+export type { RouteDoc, DocFlags }

package/src/cli/cmd-test.ts

@@ -0,0 +1,121 @@
+// gorsee test -- smart test runner wrapping bun test
+
+import { readdir, stat } from "node:fs/promises"
+import { join } from "node:path"
+
+interface TestFlags {
+  watch: boolean
+  coverage: boolean
+  filter: string | null
+  e2e: boolean
+  unit: boolean
+  integration: boolean
+}
+
+function parseFlags(args: string[]): TestFlags {
+  const flags: TestFlags = {
+    watch: false,
+    coverage: false,
+    filter: null,
+    e2e: false,
+    unit: false,
+    integration: false,
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!
+    if (arg === "--watch") flags.watch = true
+    else if (arg === "--coverage") flags.coverage = true
+    else if (arg === "--filter" && args[i + 1]) flags.filter = args[++i]!
+    else if (arg === "--e2e") flags.e2e = true
+    else if (arg === "--unit") flags.unit = true
+    else if (arg === "--integration") flags.integration = true
+  }
+
+  return flags
+}
+
+async function findTestFiles(dir: string, pattern: RegExp): Promise<string[]> {
+  const results: string[] = []
+  let entries: string[]
+  try {
+    entries = await readdir(dir)
+  } catch {
+    return results
+  }
+
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry === "dist") continue
+    const fullPath = join(dir, entry)
+    const s = await stat(fullPath)
+    if (s.isDirectory()) {
+      results.push(...(await findTestFiles(fullPath, pattern)))
+    } else if (pattern.test(fullPath)) {
+      results.push(fullPath)
+    }
+  }
+  return results
+}
+
+function getTestPattern(flags: TestFlags): RegExp {
+  if (flags.e2e) return /(?:\.e2e\.test\.ts$|e2e\/.*\.test\.ts$)/
+  if (flags.integration) return /(?:\.integration\.test\.ts$|tests\/integration\/.*\.test\.ts$)/
+  if (flags.unit) return /(?:\.unit\.test\.ts$|tests\/unit\/.*\.test\.ts$)/
+  return /\.test\.ts$/
+}
+
+/** Build bun test args from parsed flags */
+export function buildTestArgs(flags: TestFlags, files: string[]): string[] {
+  const bunArgs = ["test"]
+
+  if (flags.watch) bunArgs.push("--watch")
+  if (flags.coverage) bunArgs.push("--coverage")
+  if (flags.filter) {
+    bunArgs.push("--bail", "--filter", flags.filter)
+  }
+
+  bunArgs.push(...files)
+  return bunArgs
+}
+
+export async function runTest(args: string[]) {
+  const cwd = process.cwd()
+  const flags = parseFlags(args)
+  const pattern = getTestPattern(flags)
+
+  const files = await findTestFiles(cwd, pattern)
+
+  if (files.length === 0) {
+    const kind = flags.e2e ? "e2e" : flags.integration ? "integration" : flags.unit ? "unit" : "any"
+    console.log(`\n  No ${kind} test files found.\n`)
+    return
+  }
+
+  console.log(`\n  Running ${files.length} test file(s)...\n`)
+
+  const bunArgs = buildTestArgs(flags, files)
+
+  const proc = Bun.spawn(["bun", ...bunArgs], {
+    cwd,
+    stdout: "inherit",
+    stderr: "inherit",
+    env: {
+      ...process.env,
+      NODE_ENV: "test",
+      GORSEE_TEST: "1",
+    },
+  })
+
+  const exitCode = await proc.exited
+
+  console.log()
+  if (exitCode === 0) {
+    console.log(`  Tests passed (${files.length} file(s))`)
+  } else {
+    console.log(`  Tests failed (exit code ${exitCode})`)
+    process.exit(exitCode)
+  }
+}
+
+// Re-export for testing
+export { parseFlags, findTestFiles, getTestPattern }

package/src/cli/cmd-upgrade.ts

@@ -0,0 +1,135 @@
+// gorsee upgrade -- upgrade framework version with migration guidance
+
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+
+interface UpgradeFlags {
+  check: boolean
+  force: boolean
+}
+
+export function parseUpgradeFlags(args: string[]): UpgradeFlags {
+  const flags: UpgradeFlags = { check: false, force: false }
+  for (const arg of args) {
+    if (arg === "--check") flags.check = true
+    else if (arg === "--force") flags.force = true
+  }
+  return flags
+}
+
+/** Compare semver strings: -1 (a < b), 0 (equal), 1 (a > b) */
+export function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^v/, "").split(".").map(Number)
+  const pb = b.replace(/^v/, "").split(".").map(Number)
+  for (let i = 0; i < 3; i++) {
+    const va = pa[i] ?? 0
+    const vb = pb[i] ?? 0
+    if (va < vb) return -1
+    if (va > vb) return 1
+  }
+  return 0
+}
+
+async function getCurrentVersion(cwd: string): Promise<string | null> {
+  try {
+    const pkg = await readFile(join(cwd, "node_modules/gorsee/package.json"), "utf-8")
+    return JSON.parse(pkg).version ?? null
+  } catch {
+    return null
+  }
+}
+
+export const NPM_REGISTRY_URL = "https://registry.npmjs.org/gorsee/latest"
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const res = await fetch(NPM_REGISTRY_URL)
+    if (!res.ok) return null
+    const data = (await res.json()) as { version?: string }
+    return data.version ?? null
+  } catch {
+    return null
+  }
+}
+
+async function checkMigrationHints(cwd: string): Promise<string[]> {
+  const hints: string[] = []
+
+  // Check tsconfig.json jsx setting
+  try {
+    const tsconfig = await readFile(join(cwd, "tsconfig.json"), "utf-8")
+    const parsed = JSON.parse(tsconfig)
+    if (parsed.compilerOptions?.jsx !== "react-jsx") {
+      hints.push("tsconfig.json: set compilerOptions.jsx to \"react-jsx\"")
+    }
+  } catch { /* no tsconfig */ }
+
+  // Check for deprecated app.config.ts keys
+  try {
+    const config = await readFile(join(cwd, "app.config.ts"), "utf-8")
+    if (config.includes("ssr:")) {
+      hints.push("app.config.ts: 'ssr' key is deprecated, use 'rendering' instead")
+    }
+  } catch { /* no config */ }
+
+  return hints
+}
+
+export async function runUpgrade(args: string[]) {
+  const cwd = process.cwd()
+  const flags = parseUpgradeFlags(args)
+
+  const current = await getCurrentVersion(cwd)
+  if (!current) {
+    console.log("\n  Gorsee.js not found in node_modules. Run: bun add gorsee\n")
+    return
+  }
+
+  console.log(`\n  Current version: v${current}`)
+
+  const latest = await fetchLatestVersion()
+  if (!latest) {
+    console.log("  Could not fetch latest version from npm registry.\n")
+    return
+  }
+
+  if (compareVersions(current, latest) >= 0) {
+    console.log(`  Already up to date (v${current})\n`)
+    return
+  }
+
+  console.log(`  Latest version:  v${latest}`)
+  console.log(`  Upgrade: v${current} -> v${latest}`)
+
+  if (flags.check) {
+    console.log()
+    return
+  }
+
+  if (!flags.force) {
+    console.log("\n  Run with --force to install, or confirm interactively.")
+  }
+
+  console.log("\n  Installing gorsee@latest...")
+  const proc = Bun.spawn(["bun", "add", "gorsee@latest"], {
+    cwd,
+    stdout: "inherit",
+    stderr: "inherit",
+  })
+  const exitCode = await proc.exited
+
+  if (exitCode !== 0) {
+    console.log(`\n  Install failed (exit code ${exitCode})\n`)
+    process.exit(exitCode)
+  }
+
+  const hints = await checkMigrationHints(cwd)
+  if (hints.length > 0) {
+    console.log("\n  Migration hints:")
+    for (const hint of hints) {
+      console.log(`    - ${hint}`)
+    }
+  }
+
+  console.log(`\n  Upgraded successfully to v${latest}\n`)
+}

package/src/cli/index.ts

@@ -14,6 +14,10 @@ const COMMANDS: Record<string, string> = {
   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",
 }
 
@@ -55,6 +59,25 @@ async function main() {
       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":