@donkeylabs/adapter-sveltekit 2.0.14 → 2.0.16

package/dist/vite.js

@@ -0,0 +1,611 @@
+/**
+ * Vite plugin for @donkeylabs/adapter-sveltekit dev server integration
+ *
+ * Supports two modes:
+ * - `bun --bun run dev`: Single-process mode (in-process, one port)
+ * - `bun run dev`: Subprocess mode (two processes, proxy)
+ */
+import { spawn, exec } from "node:child_process";
+import { resolve, join } from "node:path";
+import { watch, existsSync } from "node:fs";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+import http from "node:http";
+// Check if running with Bun runtime (bun --bun)
+const isBunRuntime = typeof globalThis.Bun !== "undefined";
+/**
+ * Get the global app server instance for SSR direct calls.
+ * This allows hooks to access the server without HTTP.
+ */
+export function getDevServer() {
+    return globalThis.__donkeylabs_dev_server__;
+}
+function setDevServer(server) {
+    globalThis.__donkeylabs_dev_server__ = server;
+}
+/**
+ * Vite plugin that integrates @donkeylabs/server with the dev server.
+ *
+ * - With `bun --bun run dev`: Runs in-process (single port, recommended)
+ * - With `bun run dev`: Spawns subprocess (two ports, fallback)
+ *
+ * @example
+ * // vite.config.ts
+ * import { donkeylabsDev } from "@donkeylabs/adapter-sveltekit/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     donkeylabsDev({ serverEntry: "./src/server/index.ts" }),
+ *     sveltekit()
+ *   ]
+ * });
+ */
+export function donkeylabsDev(options = {}) {
+    const { serverEntry = "./src/server/index.ts", backendPort = 3001, watchTypes = true, watchDir = "./src/server", hotReloadRoutes = true, routePatterns = ["**/routes/**/*.ts", "**/routes/**/*.js"], } = options;
+    // State for subprocess mode
+    let backendProcess = null;
+    let backendReady = false;
+    // State for in-process mode
+    let appServer = null;
+    let serverReady = false;
+    let viteServer = null;
+    // State for file watcher
+    let fileWatcher = null;
+    let isGenerating = false;
+    let lastGenerationTime = 0;
+    let debounceTimer = null;
+    // State for hot reload
+    let hotReloadTimer = null;
+    const HOT_RELOAD_DEBOUNCE_MS = 100;
+    const COOLDOWN_MS = 2000;
+    const DEBOUNCE_MS = 500;
+    // Patterns to ignore (generated files)
+    const IGNORED_PATTERNS = [/schema\.ts$/, /\.d\.ts$/, /api\.ts$/];
+    // Check if a file matches route patterns
+    function isRouteFile(filename) {
+        return routePatterns.some((pattern) => {
+            // Simple glob matching for common patterns
+            const regexPattern = pattern
+                .replace(/\*\*/g, ".*")
+                .replace(/\*/g, "[^/]*")
+                .replace(/\./g, "\\.");
+            return new RegExp(regexPattern).test(filename);
+        });
+    }
+    // Hot reload a route file
+    async function hotReloadRoute(filepath) {
+        if (!appServer || !serverReady || !viteServer || !hotReloadRoutes)
+            return;
+        console.log("\x1b[36m[donkeylabs-dev]\x1b[0m Hot reloading route:", filepath);
+        try {
+            // Invalidate the module in Vite's cache
+            const mod = viteServer.moduleGraph.getModuleById(filepath);
+            if (mod) {
+                viteServer.moduleGraph.invalidateModule(mod);
+            }
+            // Re-import the module with cache busting
+            const timestamp = Date.now();
+            const moduleUrl = `${filepath}?t=${timestamp}`;
+            // Import the fresh module
+            const freshModule = await viteServer.ssrLoadModule(moduleUrl);
+            // Find the router export (could be named 'router', 'default', or end with 'Router')
+            let newRouter = freshModule.router || freshModule.default;
+            if (!newRouter) {
+                for (const key of Object.keys(freshModule)) {
+                    if (key.endsWith("Router") && typeof freshModule[key]?.getRoutes === "function") {
+                        newRouter = freshModule[key];
+                        break;
+                    }
+                }
+            }
+            if (newRouter && typeof newRouter.getRoutes === "function") {
+                // Get the router prefix
+                const prefix = newRouter.getPrefix?.() || "";
+                if (prefix) {
+                    appServer.reloadRouter(prefix, newRouter);
+                    console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Route hot reload complete:", prefix);
+                }
+                else {
+                    // If no prefix, rebuild all routes
+                    appServer.rebuildRouteMap();
+                    console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Route map rebuilt");
+                }
+            }
+            else {
+                console.warn("\x1b[33m[donkeylabs-dev]\x1b[0m No router export found in:", filepath);
+            }
+        }
+        catch (err) {
+            console.error("\x1b[31m[donkeylabs-dev]\x1b[0m Hot reload error:", err.message);
+        }
+    }
+    function debouncedHotReload(filepath) {
+        if (hotReloadTimer)
+            clearTimeout(hotReloadTimer);
+        hotReloadTimer = setTimeout(() => hotReloadRoute(filepath), HOT_RELOAD_DEBOUNCE_MS);
+    }
+    function shouldIgnoreFile(filename) {
+        return IGNORED_PATTERNS.some((pattern) => pattern.test(filename));
+    }
+    async function regenerateTypes() {
+        const now = Date.now();
+        if (now - lastGenerationTime < COOLDOWN_MS || isGenerating)
+            return;
+        isGenerating = true;
+        lastGenerationTime = now;
+        console.log("\x1b[36m[donkeylabs-dev]\x1b[0m Server files changed, regenerating types...");
+        try {
+            await execAsync("bun run gen:types");
+            console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Types regenerated successfully");
+        }
+        catch (e) {
+            console.error("\x1b[31m[donkeylabs-dev]\x1b[0m Error regenerating types:", e.message);
+        }
+        finally {
+            isGenerating = false;
+            lastGenerationTime = Date.now();
+        }
+    }
+    async function ensureTypesGenerated() {
+        // Check if the client file exists (common locations)
+        const clientPaths = [
+            resolve(process.cwd(), "src/lib/api.ts"),
+            resolve(process.cwd(), "src/api.ts"),
+        ];
+        const clientExists = clientPaths.some((p) => existsSync(p));
+        if (clientExists)
+            return;
+        console.log("\x1b[36m[donkeylabs-dev]\x1b[0m Generated client not found, running initial type generation...");
+        isGenerating = true;
+        try {
+            await execAsync("bun run gen:types");
+            console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Initial types generated successfully");
+        }
+        catch (e) {
+            console.warn("\x1b[33m[donkeylabs-dev]\x1b[0m Initial type generation failed:", e.message);
+            console.warn("\x1b[33m[donkeylabs-dev]\x1b[0m Run 'bun run gen:types' manually to generate types");
+        }
+        finally {
+            isGenerating = false;
+            lastGenerationTime = Date.now();
+        }
+    }
+    function debouncedRegenerate() {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(regenerateTypes, DEBOUNCE_MS);
+    }
+    function startFileWatcher() {
+        if (fileWatcher)
+            return;
+        if (!watchTypes && !hotReloadRoutes)
+            return;
+        const watchPath = resolve(process.cwd(), watchDir);
+        try {
+            fileWatcher = watch(watchPath, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                if (!filename.endsWith(".ts") && !filename.endsWith(".js"))
+                    return;
+                if (shouldIgnoreFile(filename))
+                    return;
+                const fullPath = join(watchPath, filename);
+                // Check if this is a route file for hot reload
+                if (hotReloadRoutes && isRouteFile(filename)) {
+                    debouncedHotReload(fullPath);
+                }
+                // Also trigger type regeneration
+                if (watchTypes) {
+                    debouncedRegenerate();
+                }
+            });
+            const features = [
+                watchTypes ? "type generation" : null,
+                hotReloadRoutes ? "hot reload" : null,
+            ].filter(Boolean).join(", ");
+            console.log(`\x1b[36m[donkeylabs-dev]\x1b[0m Watching ${watchDir} for ${features}...`);
+        }
+        catch (err) {
+            console.warn(`\x1b[33m[donkeylabs-dev]\x1b[0m Could not watch ${watchDir}:`, err);
+        }
+    }
+    function stopFileWatcher() {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        if (hotReloadTimer)
+            clearTimeout(hotReloadTimer);
+        if (fileWatcher) {
+            fileWatcher.close();
+            fileWatcher = null;
+        }
+    }
+    return {
+        name: "donkeylabs-dev",
+        enforce: "pre",
+        // Read PORT env variable and configure Vite's server port
+        config(config) {
+            const envPort = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
+            if (envPort && !isNaN(envPort)) {
+                console.log(`[donkeylabs-dev] Using PORT=${envPort} from environment`);
+                return {
+                    server: {
+                        ...config.server,
+                        port: envPort,
+                    },
+                };
+            }
+        },
+        async configureServer(server) {
+            const serverEntryResolved = resolve(process.cwd(), serverEntry);
+            // Store vite server reference for hot reload
+            viteServer = server;
+            // Ensure types are generated on first start (if client file doesn't exist)
+            await ensureTypesGenerated();
+            // Start file watcher for auto type regeneration and hot reload
+            startFileWatcher();
+            if (isBunRuntime) {
+                // ========== IN-PROCESS MODE (bun --bun run dev) ==========
+                // Import and initialize server directly - no subprocess, no proxy
+                console.log("[donkeylabs-dev] Starting in-process mode (Bun runtime detected)");
+                // Log the actual URL once Vite's server starts listening
+                server.httpServer?.on("listening", () => {
+                    const address = server.httpServer?.address();
+                    if (address && typeof address === "object") {
+                        const host = address.address === "::" || address.address === "0.0.0.0" ? "localhost" : address.address;
+                        console.log(`[donkeylabs-dev] Ready at http://${host}:${address.port}`);
+                    }
+                });
+                try {
+                    const serverModule = await import(/* @vite-ignore */ serverEntryResolved);
+                    appServer = serverModule.server || serverModule.default;
+                    if (!appServer) {
+                        throw new Error("No server export found in " + serverEntry);
+                    }
+                    // Initialize without starting HTTP server
+                    await appServer.initialize();
+                    serverReady = true;
+                    // Set global reference for SSR direct calls (uses globalThis for cross-module sharing)
+                    setDevServer(appServer);
+                    console.log("[donkeylabs-dev] Server initialized (in-process mode)");
+                }
+                catch (err) {
+                    console.error("[donkeylabs-dev] Failed to initialize server:", err);
+                    throw err;
+                }
+                // Return middleware setup function
+                return () => {
+                    // In-process request handler
+                    const inProcessMiddleware = async (req, res, next) => {
+                        const url = req.url || "/";
+                        const urlObj = new URL(url, "http://localhost");
+                        const pathname = urlObj.pathname;
+                        // Handle SSE endpoint
+                        if (req.method === "GET" && pathname === "/sse") {
+                            if (!serverReady || !appServer)
+                                return next();
+                            const channels = urlObj.searchParams.get("channels")?.split(",").filter(Boolean) || [];
+                            const lastEventId = req.headers["last-event-id"] || undefined;
+                            const { client, response } = appServer.getCore().sse.addClient({ lastEventId });
+                            for (const channel of channels) {
+                                appServer.getCore().sse.subscribe(client.id, channel);
+                            }
+                            // Set SSE headers
+                            res.writeHead(200, {
+                                "Content-Type": "text/event-stream",
+                                "Cache-Control": "no-cache",
+                                "Connection": "keep-alive",
+                                "Access-Control-Allow-Origin": "*",
+                            });
+                            // Stream SSE data
+                            const reader = response.body?.getReader();
+                            let sseClosed = false;
+                            req.on("close", () => {
+                                sseClosed = true;
+                                reader?.cancel().catch(() => { });
+                                appServer.getCore().sse.removeClient(client.id);
+                            });
+                            if (reader) {
+                                const pump = async () => {
+                                    try {
+                                        while (!sseClosed) {
+                                            const { done, value } = await reader.read();
+                                            if (done || sseClosed)
+                                                break;
+                                            res.write(value);
+                                        }
+                                    }
+                                    catch {
+                                        // Connection closed
+                                    }
+                                };
+                                pump();
+                            }
+                            return; // Don't call next()
+                        }
+                        // Handle API routes (GET or POST for route names like /routeName.action)
+                        if ((req.method === "GET" || req.method === "POST") && /^\/[a-zA-Z][a-zA-Z0-9_.]*$/.test(pathname)) {
+                            if (!serverReady || !appServer)
+                                return next();
+                            const routeName = pathname.slice(1);
+                            if (!appServer.hasRoute(routeName))
+                                return next();
+                            // Build a proper Request object to pass to handleRequest
+                            const buildRequest = async () => {
+                                const fullUrl = `http://localhost${url}`;
+                                const headers = new Headers();
+                                for (const [key, value] of Object.entries(req.headers)) {
+                                    if (typeof value === "string") {
+                                        headers.set(key, value);
+                                    }
+                                    else if (Array.isArray(value)) {
+                                        for (const v of value)
+                                            headers.append(key, v);
+                                    }
+                                }
+                                if (req.method === "POST") {
+                                    // Collect body for POST
+                                    const chunks = [];
+                                    for await (const chunk of req) {
+                                        chunks.push(chunk);
+                                    }
+                                    const body = Buffer.concat(chunks);
+                                    return new Request(fullUrl, {
+                                        method: "POST",
+                                        headers,
+                                        body,
+                                    });
+                                }
+                                return new Request(fullUrl, { method: "GET", headers });
+                            };
+                            try {
+                                const request = await buildRequest();
+                                const ip = req.socket?.remoteAddress || "127.0.0.1";
+                                // Use handleRequest which properly handles all handler types (typed, raw, stream, sse, html)
+                                const response = await appServer.handleRequest(request, routeName, ip, { corsHeaders: { "Access-Control-Allow-Origin": "*" } });
+                                if (!response) {
+                                    return next();
+                                }
+                                // Stream the response back
+                                res.statusCode = response.status;
+                                for (const [key, value] of response.headers) {
+                                    res.setHeader(key, value);
+                                }
+                                // Flush headers immediately for streaming responses
+                                if (typeof res.flushHeaders === "function") {
+                                    res.flushHeaders();
+                                }
+                                // Handle body streaming (non-blocking for continuous streams like MJPEG)
+                                if (response.body) {
+                                    const reader = response.body.getReader();
+                                    let closed = false;
+                                    // Handle client disconnect
+                                    req.on("close", () => {
+                                        closed = true;
+                                        reader.cancel().catch(() => { });
+                                    });
+                                    // Pump without awaiting - allows continuous streams
+                                    const pump = async () => {
+                                        try {
+                                            while (!closed) {
+                                                const { done, value } = await reader.read();
+                                                if (done || closed) {
+                                                    if (!closed)
+                                                        res.end();
+                                                    break;
+                                                }
+                                                // Write and check if client is still connected
+                                                const canContinue = res.write(value);
+                                                if (!canContinue && !closed) {
+                                                    // Backpressure - wait for drain
+                                                    await new Promise(resolve => res.once("drain", resolve));
+                                                }
+                                            }
+                                        }
+                                        catch {
+                                            if (!closed)
+                                                res.end();
+                                        }
+                                    };
+                                    pump(); // Don't await - let it run in background
+                                }
+                                else {
+                                    res.end();
+                                }
+                            }
+                            catch (err) {
+                                console.error("[donkeylabs-dev] Request error:", err);
+                                res.statusCode = err.status || 500;
+                                res.setHeader("Content-Type", "application/json");
+                                res.end(JSON.stringify({ error: err.message || "Internal error" }));
+                            }
+                            return; // Don't call next()
+                        }
+                        next();
+                    };
+                    // CORS preflight
+                    const corsMiddleware = (req, res, next) => {
+                        if (req.method === "OPTIONS") {
+                            res.setHeader("Access-Control-Allow-Origin", "*");
+                            res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+                            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+                            res.statusCode = 204;
+                            res.end();
+                            return;
+                        }
+                        next();
+                    };
+                    // Add to front of middleware stack
+                    const stack = server.middlewares.stack;
+                    if (stack && Array.isArray(stack)) {
+                        stack.unshift({ route: "", handle: corsMiddleware });
+                        stack.unshift({ route: "", handle: inProcessMiddleware });
+                    }
+                    else {
+                        server.middlewares.use(inProcessMiddleware);
+                        server.middlewares.use(corsMiddleware);
+                    }
+                };
+            }
+            else {
+                // ========== SUBPROCESS MODE (bun run dev) ==========
+                // Spawn backend as separate process and proxy requests
+                console.log(`[donkeylabs-dev] Starting subprocess mode (backend on port ${backendPort})`);
+                const bootstrapCode = `
+          const serverModule = await import("${serverEntryResolved}");
+          const server = serverModule.server || serverModule.default;
+
+          if (!server) {
+            console.error("[donkeylabs-backend] No server export found");
+            process.exit(1);
+          }
+
+          server.port = ${backendPort};
+          await server.start();
+          console.log("[donkeylabs-backend] Server ready on port ${backendPort}");
+        `;
+                backendProcess = spawn("bun", ["--eval", bootstrapCode], {
+                    stdio: ["pipe", "pipe", "pipe"],
+                    env: { ...process.env, NODE_ENV: "development" },
+                });
+                backendProcess.stdout?.on("data", (data) => {
+                    const msg = data.toString().trim();
+                    if (msg) {
+                        console.log(msg);
+                        if (msg.includes("Server ready") || msg.includes("Server running")) {
+                            backendReady = true;
+                        }
+                    }
+                });
+                backendProcess.stderr?.on("data", (data) => {
+                    const msg = data.toString().trim();
+                    if (msg)
+                        console.error(msg);
+                });
+                backendProcess.on("error", (err) => {
+                    console.error("[donkeylabs-dev] Failed to start backend:", err);
+                });
+                backendProcess.on("exit", (code) => {
+                    if (code !== 0 && code !== null) {
+                        console.error(`[donkeylabs-dev] Backend exited with code ${code}`);
+                    }
+                    backendProcess = null;
+                    backendReady = false;
+                });
+                server.httpServer?.on("close", () => {
+                    if (backendProcess) {
+                        backendProcess.kill();
+                        backendProcess = null;
+                    }
+                });
+                // Return middleware setup function
+                return () => {
+                    const waitForBackend = new Promise((resolve) => {
+                        const check = () => (backendReady ? resolve() : setTimeout(check, 100));
+                        setTimeout(check, 500);
+                        setTimeout(() => {
+                            if (!backendReady) {
+                                console.warn("[donkeylabs-dev] Backend startup timeout");
+                                resolve();
+                            }
+                        }, 10000);
+                    });
+                    // Proxy middleware - handles GET and POST for API routes
+                    const proxyMiddleware = (req, res, next) => {
+                        const url = req.url || "/";
+                        const urlObj = new URL(url, "http://localhost");
+                        const pathname = urlObj.pathname;
+                        // API routes are GET or POST to paths like /routeName.action
+                        const isApiRoute = (req.method === "GET" || req.method === "POST") && /^\/[a-zA-Z][a-zA-Z0-9_.]*$/.test(pathname);
+                        if (!isApiRoute)
+                            return next();
+                        waitForBackend.then(() => {
+                            let proxyAborted = false;
+                            const proxyReq = http.request({
+                                hostname: "localhost",
+                                port: backendPort,
+                                path: url, // Include query string
+                                method: req.method,
+                                headers: { ...req.headers, host: `localhost:${backendPort}` },
+                            }, (proxyRes) => {
+                                if (proxyAborted)
+                                    return;
+                                res.setHeader("Access-Control-Allow-Origin", "*");
+                                res.statusCode = proxyRes.statusCode || 200;
+                                for (const [k, v] of Object.entries(proxyRes.headers)) {
+                                    if (v)
+                                        res.setHeader(k, v);
+                                }
+                                // Flush headers for streaming responses
+                                if (typeof res.flushHeaders === "function") {
+                                    res.flushHeaders();
+                                }
+                                // Stream response back (works for binary/streaming responses)
+                                proxyRes.pipe(res);
+                                // Clean up on proxy response end
+                                proxyRes.on("end", () => {
+                                    if (!proxyAborted)
+                                        res.end();
+                                });
+                            });
+                            // Handle client disconnect - abort proxy request
+                            req.on("close", () => {
+                                if (!proxyAborted) {
+                                    proxyAborted = true;
+                                    proxyReq.destroy();
+                                }
+                            });
+                            proxyReq.on("error", (err) => {
+                                if (proxyAborted)
+                                    return; // Ignore errors after abort
+                                console.error(`[donkeylabs-dev] Proxy error:`, err.message);
+                                res.statusCode = 502;
+                                res.end(JSON.stringify({ error: "Backend unavailable" }));
+                            });
+                            // For POST, pipe the body; for GET, just end
+                            if (req.method === "POST") {
+                                req.pipe(proxyReq);
+                            }
+                            else {
+                                proxyReq.end();
+                            }
+                        });
+                    };
+                    const corsMiddleware = (req, res, next) => {
+                        if (req.method === "OPTIONS") {
+                            res.setHeader("Access-Control-Allow-Origin", "*");
+                            res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+                            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+                            res.statusCode = 204;
+                            res.end();
+                            return;
+                        }
+                        next();
+                    };
+                    const stack = server.middlewares.stack;
+                    if (stack && Array.isArray(stack)) {
+                        stack.unshift({ route: "", handle: corsMiddleware });
+                        stack.unshift({ route: "", handle: proxyMiddleware });
+                    }
+                    else {
+                        server.middlewares.use(proxyMiddleware);
+                        server.middlewares.use(corsMiddleware);
+                    }
+                };
+            }
+        },
+        async closeBundle() {
+            stopFileWatcher();
+            viteServer = null;
+            if (backendProcess) {
+                backendProcess.kill();
+                backendProcess = null;
+            }
+            if (appServer) {
+                await appServer.shutdown?.();
+                appServer = null;
+                setDevServer(null);
+            }
+        },
+    };
+}
+export default donkeylabsDev;

package/package.json

@@ -1,38 +1,40 @@
 {
   "name": "@donkeylabs/adapter-sveltekit",
-  "version": "2.0.14",
+  "version": "2.0.16",
   "type": "module",
   "description": "SvelteKit adapter for @donkeylabs/server - seamless SSR/browser API integration",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./client": {
-      "types": "./src/client/index.ts",
-      "import": "./src/client/index.ts"
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
     },
     "./hooks": {
-      "types": "./src/hooks/index.ts",
-      "import": "./src/hooks/index.ts"
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
     },
     "./generator": {
-      "types": "./src/generator/index.ts",
-      "import": "./src/generator/index.ts"
+      "types": "./dist/generator/index.d.ts",
+      "import": "./dist/generator/index.js"
     },
     "./vite": {
-      "types": "./src/vite.ts",
-      "import": "./src/vite.ts"
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
     }
   },
   "files": [
-    "src",
+    "dist",
     "LICENSE",
     "README.md"
   ],
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
     "typecheck": "bun --bun tsc --noEmit"
   },
   "peerDependencies": {