gorsee 0.1.2 → 0.2.0

package/bin/gorsee.js

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
-const { execSync } = require("child_process");
+import { execSync } from "child_process";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cli = join(__dirname, "..", "src", "cli", "index.ts");
 const args = process.argv.slice(2).join(" ");
+
 try {
-  execSync(`bun ${require("path").join(__dirname, "..", "src", "cli", "index.ts")} ${args}`, { stdio: "inherit" });
+  execSync(`bun ${cli} ${args}`, { stdio: "inherit" });
 } catch (e) {
   process.exit(e.status || 1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gorsee",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "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/index.ts

@@ -14,6 +14,7 @@ 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)",
   help: "Show this help message",
 }
 
@@ -55,6 +56,10 @@ 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 "help":
     case undefined:
     case "--help":

package/src/deploy/cloudflare.ts

@@ -0,0 +1,109 @@
+// Gorsee.js — Cloudflare Workers/Pages deploy adapter
+
+export function generateWranglerConfig(name: string): string {
+  const today = new Date().toISOString().split("T")[0]
+
+  return `# Gorsee.js — Cloudflare Workers configuration
+# Auto-generated by \`gorsee deploy cloudflare\`
+
+name = "${name}"
+main = "dist/worker.js"
+compatibility_date = "${today}"
+compatibility_flags = ["nodejs_compat"]
+
+[site]
+bucket = "./dist/client"
+
+[build]
+command = "bun run build"
+
+# KV namespace for caching (optional)
+# [[kv_namespaces]]
+# binding = "CACHE"
+# id = ""
+
+# Environment variables
+[vars]
+NODE_ENV = "production"
+
+# Production overrides
+[env.production]
+name = "${name}"
+route = { pattern = "*", zone_name = "" }
+`
+}
+
+export function generateCloudflareEntry(): string {
+  return `// Gorsee.js — Cloudflare Worker entry
+// Auto-generated by \`gorsee deploy cloudflare\`
+
+export default {
+  async fetch(
+    request: Request,
+    env: Record<string, unknown>,
+    ctx: ExecutionContext,
+  ): Promise<Response> {
+    const url = new URL(request.url)
+
+    // Serve static client assets from KV/site
+    if (url.pathname.startsWith("/_gorsee/")) {
+      const assetPath = url.pathname.slice("/_gorsee/".length)
+      // @ts-expect-error — __STATIC_CONTENT is injected by Cloudflare
+      const asset = await (env.__STATIC_CONTENT as any)?.get(assetPath)
+      if (asset) {
+        return new Response(asset, {
+          headers: {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "public, max-age=31536000, immutable",
+          },
+        })
+      }
+    }
+
+    // Serve public static files
+    const staticExts = [".css", ".ico", ".svg", ".png", ".jpg", ".woff2", ".txt"]
+    if (staticExts.some((ext) => url.pathname.endsWith(ext))) {
+      // @ts-expect-error — __STATIC_CONTENT is injected by Cloudflare
+      const asset = await (env.__STATIC_CONTENT as any)?.get(url.pathname.slice(1))
+      if (asset) {
+        return new Response(asset, {
+          headers: { "Cache-Control": "public, max-age=3600" },
+        })
+      }
+    }
+
+    // Forward all other requests to Gorsee server handler
+    // In production, this imports the built server bundle
+    try {
+      const { handleRequest } = await import("./server-handler.js")
+      return await handleRequest(request, env)
+    } catch {
+      return new Response("Internal Server Error", { status: 500 })
+    }
+  },
+}
+`
+}
+
+export interface CloudflareRoutesConfig {
+  version: number
+  include: string[]
+  exclude: string[]
+}
+
+export function generateCloudflareStaticAssets(): CloudflareRoutesConfig {
+  return {
+    version: 1,
+    include: ["/*"],
+    exclude: [
+      "/_gorsee/*",
+      "/favicon.ico",
+      "/robots.txt",
+      "/styles.css",
+      "/*.png",
+      "/*.jpg",
+      "/*.svg",
+      "/*.woff2",
+    ],
+  }
+}

package/src/deploy/fly.ts

@@ -0,0 +1,79 @@
+// Gorsee.js — Fly.io deploy adapter
+
+export function generateFlyConfig(appName: string): string {
+  return `# Gorsee.js — Fly.io configuration
+# Auto-generated by \`gorsee deploy fly\`
+
+app = "${appName}"
+primary_region = "iad"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[env]
+  NODE_ENV = "production"
+  PORT = "3000"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 1
+
+  [http_service.concurrency]
+    type = "requests"
+    hard_limit = 250
+    soft_limit = 200
+
+[[http_service.checks]]
+  grace_period = "10s"
+  interval = "30s"
+  method = "GET"
+  path = "/api/health"
+  timeout = "5s"
+
+[[vm]]
+  size = "shared-cpu-1x"
+  memory = "512mb"
+  processes = ["app"]
+  count_min = 1
+  count_max = 3
+`
+}
+
+export function generateFlyDockerfile(): string {
+  return `# Gorsee.js — Fly.io optimized Dockerfile
+# Auto-generated by \`gorsee deploy fly\`
+
+FROM oven/bun:1 AS builder
+WORKDIR /app
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+
+FROM oven/bun:1-slim
+WORKDIR /app
+
+COPY --from=builder /app/package.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/routes ./routes
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/.env* ./
+
+ENV NODE_ENV=production
+ENV PORT=3000
+
+# Fly.io runtime env vars are injected automatically:
+# FLY_ALLOC_ID, FLY_APP_NAME, FLY_REGION, FLY_MACHINE_ID
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \\
+  CMD curl -f http://localhost:3000/api/health || exit 1
+
+CMD ["bun", "run", "start"]
+`
+}

package/src/deploy/index.ts

@@ -0,0 +1,31 @@
+// 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/netlify.ts

@@ -0,0 +1,77 @@
+// Gorsee.js — Netlify deploy adapter
+
+export function generateNetlifyConfig(): string {
+  return `# Gorsee.js — Netlify configuration
+# Auto-generated by \`gorsee deploy netlify\`
+
+[build]
+  command = "bun run build"
+  publish = "dist/client"
+
+[build.environment]
+  NODE_VERSION = "20"
+
+[[edge_functions]]
+  function = "gorsee-handler"
+  path = "/*"
+
+# Static assets bypass edge functions
+[[edge_functions]]
+  function = "gorsee-handler"
+  path = "/_gorsee/*"
+  excludedPath = true
+
+[[redirects]]
+  from = "/_gorsee/*"
+  to = "/client/:splat"
+  status = 200
+
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/edge-functions/gorsee-handler"
+  status = 200
+  force = false
+
+[[headers]]
+  for = "/_gorsee/*"
+  [headers.values]
+    Cache-Control = "public, max-age=31536000, immutable"
+`
+}
+
+export function generateNetlifyFunction(): string {
+  return `// Gorsee.js — Netlify Edge Function
+// Auto-generated by \`gorsee deploy netlify\`
+// Place in: netlify/edge-functions/gorsee-handler.ts
+
+import type { Context } from "https://edge.netlify.com"
+
+export default async function handler(
+  request: Request,
+  context: Context,
+): Promise<Response> {
+  const url = new URL(request.url)
+
+  // Skip static assets — handled by Netlify CDN
+  if (url.pathname.startsWith("/_gorsee/")) {
+    return context.next()
+  }
+
+  const staticExts = [".css", ".ico", ".svg", ".png", ".jpg", ".woff2", ".txt"]
+  if (staticExts.some((ext) => url.pathname.endsWith(ext))) {
+    return context.next()
+  }
+
+  // Forward to Gorsee server handler
+  try {
+    const { handleRequest } = await import("../../dist/server-handler.js")
+    return await handleRequest(request, { netlifyContext: context })
+  } catch (err) {
+    console.error("Gorsee handler error:", err)
+    return new Response("Internal Server Error", { status: 500 })
+  }
+}
+
+export const config = { path: "/*" }
+`
+}

package/src/deploy/vercel.ts

@@ -0,0 +1,94 @@
+// 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/index.ts

@@ -25,3 +25,4 @@ export { createEventSource } from "./server/sse.ts"
 export { createAuth } from "./auth/index.ts"
 export { typedLink, typedNavigate } from "./runtime/typed-routes.ts"
 export { defineForm, validateForm, fieldAttrs } from "./runtime/validated-form.ts"
+export { definePlugin, createPluginRunner, type GorseePlugin, type PluginContext } from "./plugins/index.ts"

package/src/plugins/drizzle.ts

@@ -0,0 +1,84 @@
+// Drizzle ORM integration plugin -- zero external dependencies
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface DrizzlePluginConfig {
+  schema: string
+  out: string
+  dialect: "sqlite" | "postgres" | "mysql"
+  connectionUrl?: string
+}
+
+let drizzleInstance: unknown = null
+
+/** Returns the current drizzle instance (available after setup) */
+export function getDrizzle<T = unknown>(): T {
+  if (!drizzleInstance) {
+    throw new Error("Drizzle not initialized. Did you register drizzlePlugin?")
+  }
+  return drizzleInstance as T
+}
+
+/** Middleware that attaches drizzle instance to ctx.locals.db */
+export function drizzleMiddleware(instance: unknown): MiddlewareFn {
+  return async (ctx: Context, next) => {
+    ctx.locals.db = instance
+    return next()
+  }
+}
+
+/** Generates drizzle.config.ts content string */
+export function generateDrizzleConfig(config: DrizzlePluginConfig): string {
+  const dbCredentials =
+    config.dialect === "sqlite"
+      ? `{ url: "${config.connectionUrl ?? "./data.db"}" }`
+      : `{ connectionString: "${config.connectionUrl ?? ""}" }`
+
+  return `import { defineConfig } from "drizzle-kit"
+
+export default defineConfig({
+  schema: "${config.schema}",
+  out: "${config.out}",
+  dialect: "${config.dialect}",
+  dbCredentials: ${dbCredentials},
+})
+`
+}
+
+/** Creates a Drizzle ORM integration plugin */
+export function drizzlePlugin(config: DrizzlePluginConfig): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-drizzle",
+
+    async setup(app) {
+      if (config.dialect === "sqlite") {
+        const { Database } = await import("bun:sqlite" as string)
+        const db = new Database(config.connectionUrl ?? "./data.db")
+        db.exec("PRAGMA journal_mode=WAL")
+
+        // Dynamic import for drizzle-orm/bun-sqlite
+        try {
+          const { drizzle } = await import("drizzle-orm/bun-sqlite" as string)
+          drizzleInstance = drizzle(db)
+        } catch {
+          // If drizzle-orm not installed, store raw db
+          drizzleInstance = db
+        }
+      } else {
+        // For postgres/mysql, store connection URL for user to configure
+        drizzleInstance = { dialect: config.dialect, url: config.connectionUrl }
+      }
+
+      app.addMiddleware(drizzleMiddleware(drizzleInstance))
+    },
+
+    async teardown() {
+      if (drizzleInstance && typeof (drizzleInstance as any).close === "function") {
+        ;(drizzleInstance as any).close()
+      }
+      drizzleInstance = null
+    },
+  })
+}