bosbun 0.0.1

package/src/core/dev.ts

@@ -0,0 +1,193 @@
+import { spawn, type Subprocess } from "bun";
+import { watch } from "fs";
+import { join } from "path";
+
+console.log("🐰 Bunia dev server starting...\n");
+
+// ─── State ────────────────────────────────────────────────
+
+let appProcess: Subprocess | null = null;
+let sseClients = new Set<ReadableStreamDefaultController>();
+
+// ─── SSE Broadcast ────────────────────────────────────────
+
+function broadcastReload() {
+    const msg = new TextEncoder().encode("event: reload\ndata: ok\n\n");
+    for (const ctrl of sseClients) {
+        try {
+            ctrl.enqueue(msg);
+        } catch {
+            sseClients.delete(ctrl);
+        }
+    }
+    if (sseClients.size > 0) {
+        console.log(`📡 Reload sent to ${sseClients.size} client(s)`);
+    }
+}
+
+// ─── Build ────────────────────────────────────────────────
+
+const BUILD_SCRIPT = join(import.meta.dir, "build.ts");
+const BUNIA_NODE_MODULES = join(import.meta.dir, "..", "..", "node_modules");
+
+async function runBuild(): Promise<boolean> {
+    console.log("🏗️  Building...");
+    const proc = spawn(["bun", "run", BUILD_SCRIPT], {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: process.cwd(),
+    });
+    return (await proc.exited) === 0;
+}
+
+// ─── Ports ────────────────────────────────────────────────
+
+const DEV_PORT = Number(process.env.PORT) || 9000;
+const APP_PORT = DEV_PORT + 1; // internal, hidden from user
+
+async function startAppServer() {
+    if (appProcess) {
+        appProcess.kill();
+        await appProcess.exited;
+    }
+
+    // Read the server entry filename from the manifest written by build.ts
+    let serverEntry = "index.js";
+    try {
+        const manifest = await Bun.file("./dist/manifest.json").json();
+        serverEntry = manifest.serverEntry ?? "index.js";
+    } catch { }
+
+    appProcess = spawn(["bun", "run", `dist/server/${serverEntry}`], {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: process.cwd(),
+        env: {
+            ...process.env,
+            NODE_ENV: "development",
+            // Force app server to APP_PORT — prevents PORT from .env conflicting with the dev proxy
+            PORT: String(APP_PORT),
+            // Allow externalized deps (elysia, etc.) to resolve from bunia's node_modules
+            NODE_PATH: BUNIA_NODE_MODULES,
+        },
+    });
+}
+
+// ─── Build & Restart ──────────────────────────────────────
+
+let buildTimer: ReturnType<typeof setTimeout> | null = null;
+
+async function buildAndRestart() {
+    const ok = await runBuild();
+    if (!ok) {
+        console.error("❌ Build failed — fix errors and save again");
+        return;
+    }
+    await startAppServer();
+    // Give the app server a moment to bind its port
+    await Bun.sleep(200);
+    broadcastReload();
+}
+
+function scheduleBuild() {
+    if (buildTimer) clearTimeout(buildTimer);
+    buildTimer = setTimeout(buildAndRestart, 300);
+}
+
+// ─── Dev Proxy ────────────────────────────────────────────
+// Owns the SSE connection so it survives app server restarts.
+// All other requests are proxied to the app server.
+
+Bun.serve({
+    port: DEV_PORT,
+    idleTimeout: 255,
+    async fetch(req) {
+        const url = new URL(req.url);
+
+        // SSE endpoint — owned by dev server, not the app
+        if (url.pathname === "/__bunia/sse") {
+            return new Response(
+                new ReadableStream({
+                    start(ctrl) {
+                        sseClients.add(ctrl);
+                        // Initial keepalive so the browser knows the connection is open
+                        ctrl.enqueue(new TextEncoder().encode(":ok\n\n"));
+
+                        // Ping every 25s to prevent idle timeout
+                        const ping = setInterval(() => {
+                            try {
+                                ctrl.enqueue(new TextEncoder().encode(":ping\n\n"));
+                            } catch {
+                                clearInterval(ping);
+                                sseClients.delete(ctrl);
+                            }
+                        }, 25_000);
+
+                        req.signal.addEventListener("abort", () => {
+                            clearInterval(ping);
+                            sseClients.delete(ctrl);
+                        });
+                    },
+                }),
+                {
+                    headers: {
+                        "Content-Type": "text/event-stream; charset=utf-8",
+                        "Cache-Control": "no-cache",
+                        Connection: "keep-alive",
+                    },
+                },
+            );
+        }
+
+        // Proxy everything else to the app server
+        try {
+            const target = new URL(req.url);
+            target.hostname = "localhost";
+            target.port = String(APP_PORT);
+
+            return await fetch(new Request(target.toString(), {
+                method: req.method,
+                headers: req.headers,
+                body: req.body,
+                redirect: "manual",
+            }));
+        } catch {
+            return new Response("App server is starting...", {
+                status: 503,
+                headers: { "Content-Type": "text/plain", "Retry-After": "1" },
+            });
+        }
+    },
+});
+
+// ─── Initial Build ────────────────────────────────────────
+
+await buildAndRestart();
+
+console.log(`\n🌐 Open http://localhost:${DEV_PORT}\n`);
+
+// ─── File Watcher ─────────────────────────────────────────
+// Watch src/ recursively. Skip generated files to avoid loops.
+
+const GENERATED = [
+    join(process.cwd(), ".bunia"),
+    join(process.cwd(), "public", "bunia-tw.css"),
+];
+
+function isGenerated(path: string): boolean {
+    return GENERATED.some(g => path.startsWith(g));
+}
+
+watch(
+    join(process.cwd(), "src"),
+    { recursive: true },
+    (_event, filename) => {
+        if (!filename) return;
+        const abs = join(process.cwd(), "src", filename);
+        if (isGenerated(abs)) return;
+        console.log(`[watch] changed: ${filename}`);
+        scheduleBuild();
+    },
+);
+
+console.log("👀 Watching src/ for changes...\n");

package/src/core/env.ts

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// ─── Framework-reserved vars ─────────────────────────────
+// These are controlled by Bunia itself — users access them via process.env directly.
+const FRAMEWORK_VARS = new Set([
+    "PORT",
+    "NODE_ENV",
+    "BODY_SIZE_LIMIT",
+    "CSRF_ALLOWED_ORIGINS",
+    "CORS_ALLOWED_ORIGINS",
+    "CORS_ALLOWED_METHODS",
+    "CORS_ALLOWED_HEADERS",
+    "CORS_EXPOSED_HEADERS",
+    "CORS_CREDENTIALS",
+    "CORS_MAX_AGE",
+]);
+
+// ─── .env File Parser ────────────────────────────────────
+
+/** Parse a .env file content into key/value pairs. Skips comments and empty lines. */
+function parseEnvFile(content: string): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let value = trimmed.slice(eqIdx + 1).trim();
+        // Strip surrounding quotes (single or double)
+        if (
+            (value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))
+        ) {
+            value = value.slice(1, -1);
+        }
+        if (key) result[key] = value;
+    }
+    return result;
+}
+
+// ─── Env Loader ──────────────────────────────────────────
+
+/**
+ * Load .env files in order (later overrides earlier), then apply to process.env.
+ * System env vars take highest precedence (never overwritten).
+ *
+ * Load order:
+ *   1. .env
+ *   2. .env.local
+ *   3. .env.[mode]
+ *   4. .env.[mode].local
+ *
+ * @param mode   "development" | "production"
+ * @param dir    directory to look in (defaults to cwd)
+ * @returns merged env record (only vars from .env files, excluding framework vars)
+ */
+export function loadEnv(mode: string, dir?: string): Record<string, string> {
+    const root = dir ?? process.cwd();
+    const files = [
+        ".env",
+        ".env.local",
+        `.env.${mode}`,
+        `.env.${mode}.local`,
+    ];
+
+    let merged: Record<string, string> = {};
+    const loaded: string[] = [];
+
+    for (const filename of files) {
+        const filepath = join(root, filename);
+        if (!existsSync(filepath)) continue;
+        const content = readFileSync(filepath, "utf-8");
+        const parsed = parseEnvFile(content);
+        merged = { ...merged, ...parsed };
+        loaded.push(filename);
+    }
+
+    if (loaded.length > 0) {
+        console.log(`✓ Loaded ${loaded.join(", ")}`);
+    }
+
+    // Apply to process.env — system env wins (don't overwrite existing)
+    for (const [key, value] of Object.entries(merged)) {
+        if (!(key in process.env)) {
+            process.env[key] = value;
+        }
+    }
+
+    // Return only non-framework vars
+    const result: Record<string, string> = {};
+    for (const [key, value] of Object.entries(merged)) {
+        if (!FRAMEWORK_VARS.has(key)) {
+            result[key] = process.env[key] ?? value;
+        }
+    }
+
+    return result;
+}
+
+// ─── Classifier ──────────────────────────────────────────
+
+export interface ClassifiedEnv {
+    /** PUBLIC_STATIC_* — client+server, build-time inlined */
+    publicStatic: Record<string, string>;
+    /** PUBLIC_* (excluding PUBLIC_STATIC_*) — client+server, runtime */
+    publicDynamic: Record<string, string>;
+    /** STATIC_* — server only, build-time inlined */
+    privateStatic: Record<string, string>;
+    /** everything else — server only, runtime */
+    privateDynamic: Record<string, string>;
+}
+
+/** Classify env vars by prefix into the four visibility/timing buckets. */
+export function classifyEnvVars(env: Record<string, string>): ClassifiedEnv {
+    const publicStatic: Record<string, string> = {};
+    const publicDynamic: Record<string, string> = {};
+    const privateStatic: Record<string, string> = {};
+    const privateDynamic: Record<string, string> = {};
+
+    for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith("PUBLIC_STATIC_")) {
+            publicStatic[key] = value;
+        } else if (key.startsWith("PUBLIC_")) {
+            publicDynamic[key] = value;
+        } else if (key.startsWith("STATIC_")) {
+            privateStatic[key] = value;
+        } else {
+            privateDynamic[key] = value;
+        }
+    }
+
+    return { publicStatic, publicDynamic, privateStatic, privateDynamic };
+}

package/src/core/envCodegen.ts

@@ -0,0 +1,94 @@
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import type { ClassifiedEnv } from "./env.ts";
+
+// ─── Env Module Codegen ──────────────────────────────────
+// Generates three files in .bunia/:
+//   env.server.ts  — all vars (static inlined, dynamic via process.env)
+//   env.client.ts  — only PUBLIC_* vars (PUBLIC_STATIC_* inlined, PUBLIC_* via window.__BUNIA_ENV__)
+//   types/env.d.ts — declare module 'bunia:env' for IDE autocomplete
+
+export function generateEnvModules(classified: ClassifiedEnv): void {
+    const buniaDir = join(process.cwd(), ".bunia");
+    const typesDir = join(buniaDir, "types");
+    mkdirSync(buniaDir, { recursive: true });
+    mkdirSync(typesDir, { recursive: true });
+
+    writeServerEnv(classified, buniaDir);
+    writeClientEnv(classified, buniaDir);
+    writeEnvTypes(classified, typesDir);
+}
+
+function writeServerEnv(classified: ClassifiedEnv, buniaDir: string): void {
+    const lines: string[] = [
+        "// Auto-generated by Bunia. Do not edit.",
+        "// bunia:env → server — all vars",
+        "",
+    ];
+
+    // PUBLIC_STATIC_* — inlined literals
+    for (const [key, value] of Object.entries(classified.publicStatic)) {
+        lines.push(`export const ${key} = ${JSON.stringify(value)};`);
+    }
+
+    // PUBLIC_* dynamic — read from process.env at runtime
+    for (const key of Object.keys(classified.publicDynamic)) {
+        lines.push(`export const ${key} = process.env.${key} ?? "";`);
+    }
+
+    // STATIC_* — inlined literals
+    for (const [key, value] of Object.entries(classified.privateStatic)) {
+        lines.push(`export const ${key} = ${JSON.stringify(value)};`);
+    }
+
+    // private dynamic — read from process.env at runtime
+    for (const key of Object.keys(classified.privateDynamic)) {
+        lines.push(`export const ${key} = process.env.${key} ?? "";`);
+    }
+
+    writeFileSync(join(buniaDir, "env.server.ts"), lines.join("\n") + "\n");
+}
+
+function writeClientEnv(classified: ClassifiedEnv, buniaDir: string): void {
+    const lines: string[] = [
+        "// Auto-generated by Bunia. Do not edit.",
+        "// bunia:env → client — PUBLIC_* vars only",
+        "",
+        "const __env: Record<string, string> =",
+        "  typeof window !== 'undefined' && (window as any).__BUNIA_ENV__ || {};",
+        "",
+    ];
+
+    // PUBLIC_STATIC_* — inlined literals
+    for (const [key, value] of Object.entries(classified.publicStatic)) {
+        lines.push(`export const ${key} = ${JSON.stringify(value)};`);
+    }
+
+    // PUBLIC_* dynamic — read from window.__BUNIA_ENV__ at runtime
+    for (const key of Object.keys(classified.publicDynamic)) {
+        lines.push(`export const ${key} = __env.${key} ?? "";`);
+    }
+
+    writeFileSync(join(buniaDir, "env.client.ts"), lines.join("\n") + "\n");
+}
+
+function writeEnvTypes(classified: ClassifiedEnv, typesDir: string): void {
+    const allKeys = [
+        ...Object.keys(classified.publicStatic),
+        ...Object.keys(classified.publicDynamic),
+        ...Object.keys(classified.privateStatic),
+        ...Object.keys(classified.privateDynamic),
+    ];
+
+    const declarations = allKeys.map(key => `    export const ${key}: string;`);
+
+    const content = [
+        "// Auto-generated by Bunia. Do not edit.",
+        "declare module 'bunia:env' {",
+        ...declarations,
+        "}",
+        "",
+    ].join("\n");
+
+    writeFileSync(join(typesDir, "env.d.ts"), content);
+}

package/src/core/errors.ts

@@ -0,0 +1,23 @@
+// ─── Error / Redirect Helpers ────────────────────────────
+// Throw these from load() functions; the server catches and handles them.
+
+export class HttpError extends Error {
+    constructor(public status: number, message: string) {
+        super(message);
+        this.name = "HttpError";
+    }
+}
+
+export class Redirect {
+    constructor(public status: number, public location: string) {}
+}
+
+/** Throw an HTTP error from a load() function. */
+export function error(status: number, message: string): never {
+    throw new HttpError(status, message);
+}
+
+/** Redirect the user from a load() function. */
+export function redirect(status: number, location: string): never {
+    throw new Redirect(status, location);
+}

package/src/core/hooks.ts

@@ -0,0 +1,74 @@
+// ─── Bunia Hooks ─────────────────────────────────────────
+// SvelteKit-compatible middleware API.
+// Usage in src/hooks.server.ts:
+//
+//   import { sequence } from "bunia";
+//   export const handle = sequence(authHandle, loggingHandle);
+
+// ─── Cookie Types ─────────────────────────────────────────
+
+export interface CookieOptions {
+    path?: string;
+    domain?: string;
+    /** Max-Age in seconds */
+    maxAge?: number;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+
+export interface Cookies {
+    /** Get a cookie value by name */
+    get(name: string): string | undefined;
+    /** Get all incoming cookies as a plain object */
+    getAll(): Record<string, string>;
+    /** Set a cookie (added to the response as Set-Cookie) */
+    set(name: string, value: string, options?: CookieOptions): void;
+    /** Delete a cookie by setting Max-Age=0 */
+    delete(name: string, options?: Pick<CookieOptions, "path" | "domain">): void;
+}
+
+// ─── Event Types ──────────────────────────────────────────
+
+export type RequestEvent = {
+    request: Request;
+    url: URL;
+    locals: Record<string, any>;
+    params: Record<string, string>;
+    cookies: Cookies;
+};
+
+export type LoadEvent = {
+    url: URL;
+    params: Record<string, string>;
+    locals: Record<string, any>;
+    cookies: Cookies;
+    fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    parent: () => Promise<Record<string, any>>;
+};
+
+export type ResolveFunction = (event: RequestEvent) => MaybePromise<Response>;
+
+export type Handle = (input: {
+    event: RequestEvent;
+    resolve: ResolveFunction;
+}) => MaybePromise<Response>;
+
+type MaybePromise<T> = T | Promise<T>;
+
+// ─── Middleware Composition ────────────────────────────────
+
+/**
+ * Compose multiple `handle` functions into a single handler.
+ * Each handler's `resolve` points to the next handler in the chain.
+ */
+export function sequence(...handlers: Handle[]): Handle {
+    return ({ event, resolve }) => {
+        function apply(i: number, e: RequestEvent): MaybePromise<Response> {
+            if (i >= handlers.length) return resolve(e);
+            return handlers[i]!({ event: e, resolve: (next) => apply(i + 1, next) });
+        }
+        return apply(0, event);
+    };
+}