@donkeylabs/cli 0.1.0 → 0.1.1

package/templates/sveltekit-app/donkeylabs.config.ts

@@ -3,6 +3,7 @@ import { defineConfig } from "@donkeylabs/server";
 export default defineConfig({
   plugins: ["./src/server/plugins/**/index.ts"],
   outDir: ".@donkeylabs/server",
+  entry: "./src/server/index.ts",
   adapter: "@donkeylabs/adapter-sveltekit",
   client: {
     output: "./src/lib/api.ts",

package/templates/sveltekit-app/package.json

@@ -4,15 +4,16 @@
   "version": "0.0.1",
   "type": "module",
   "scripts": {
-    "dev": "bun --bun vite dev",
-    "build": "vite build",
+    "dev": "bun run gen:types && bun run dev:watch & bun --bun vite dev",
+    "dev:watch": "bun --watch --no-clear-screen scripts/watch-server.ts",
+    "build": "bun run gen:types && vite build",
     "preview": "bun build/server/entry.js",
     "prepare": "svelte-kit sync || echo ''",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "gen:types": "donkeylabs generate"
+    "gen:types": "donkeylabs generate",
+    "cli": "donkeylabs"
   },
   "devDependencies": {
-    "@donkeylabs/cli": "*",
     "@sveltejs/kit": "^2.49.1",
     "@sveltejs/vite-plugin-svelte": "^6.2.1",
     "@tailwindcss/vite": "^4.1.18",
@@ -23,8 +24,9 @@
     "vite": "^7.2.6"
   },
   "dependencies": {
-    "@donkeylabs/adapter-sveltekit": "*",
-    "@donkeylabs/server": "*",
+    "@donkeylabs/cli": "0.1.1",
+    "@donkeylabs/adapter-sveltekit": "0.1.2",
+    "@donkeylabs/server": "0.3.1",
     "bits-ui": "^2.15.4",
     "clsx": "^2.1.1",
     "kysely": "^0.27.6",

package/templates/sveltekit-app/scripts/watch-server.ts

@@ -0,0 +1,55 @@
+// Watch server files and regenerate types on changes
+import { watch } from "node:fs";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+
+const execAsync = promisify(exec);
+
+const serverDir = join(import.meta.dir, "..", "src", "server");
+let isGenerating = false;
+let pendingGenerate = false;
+
+async function regenerate() {
+  if (isGenerating) {
+    pendingGenerate = true;
+    return;
+  }
+
+  isGenerating = true;
+  console.log("\x1b[36m[watch]\x1b[0m Server files changed, regenerating types...");
+
+  try {
+    await execAsync("bun run gen:types");
+    console.log("\x1b[32m[watch]\x1b[0m Types regenerated successfully");
+  } catch (e: any) {
+    console.error("\x1b[31m[watch]\x1b[0m Error regenerating types:", e.message);
+  } finally {
+    isGenerating = false;
+    if (pendingGenerate) {
+      pendingGenerate = false;
+      await regenerate();
+    }
+  }
+}
+
+// Debounce to avoid multiple rapid regenerations
+let debounceTimer: Timer | null = null;
+
+function debouncedRegenerate() {
+  if (debounceTimer) clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(regenerate, 300);
+}
+
+// Watch server directory recursively
+watch(serverDir, { recursive: true }, (eventType, filename) => {
+  if (!filename) return;
+  if (!filename.endsWith(".ts")) return;
+
+  debouncedRegenerate();
+});
+
+console.log("\x1b[36m[watch]\x1b[0m Watching src/server/ for changes...");
+
+// Keep process alive
+await new Promise(() => {});

package/templates/sveltekit-app/src/lib/api.ts

@@ -1,134 +1,74 @@
-/**
- * Generated API client for the demo
- * Extends UnifiedApiClientBase to handle SSR direct calls and browser HTTP calls
- */
-import { UnifiedApiClientBase } from "@donkeylabs/adapter-sveltekit/client";
-
-// Route type definitions
-export interface CounterResponse {
-  count: number;
-}
-
-export interface CacheGetResponse {
-  value: any;
-  exists: boolean;
-}
-
-export interface CacheKeysResponse {
-  keys: string[];
-  size: number;
-}
-
-export interface JobEnqueueResponse {
-  jobId: string;
-}
-
-export interface JobStatsResponse {
-  pending: number;
-  running: number;
-  completed: number;
-}
-
-export interface CronTask {
-  id: string;
-  name: string;
-  expression: string;
-  enabled: boolean;
-  lastRun?: string;
-  nextRun?: string;
-}
-
-export interface CronListResponse {
-  tasks: CronTask[];
-}
-
-export interface RateLimitResult {
-  allowed: boolean;
-  remaining: number;
-  limit: number;
-  resetAt: string;
-  retryAfter?: number;
-}
+// Auto-generated by donkeylabs generate
+// DO NOT EDIT MANUALLY
 
-export interface SSEClientsResponse {
-  total: number;
-  byChannel: number;
-}
+import { UnifiedApiClientBase, type ClientOptions } from "@donkeylabs/adapter-sveltekit/client";
 
-/**
- * Typed API client for the demo server
- */
 export class ApiClient extends UnifiedApiClientBase {
-  // Counter routes
-  counter = {
-    get: () => this.request<{}, CounterResponse>("api.counter.get", {}),
-    increment: () => this.request<{}, CounterResponse>("api.counter.increment", {}),
-    decrement: () => this.request<{}, CounterResponse>("api.counter.decrement", {}),
-    reset: () => this.request<{}, CounterResponse>("api.counter.reset", {}),
-  };
-
-  // Cache routes
-  cache = {
-    set: (input: { key: string; value: any; ttl?: number }) =>
-      this.request<typeof input, { success: boolean }>("api.cache.set", input),
-    get: (input: { key: string }) =>
-      this.request<typeof input, CacheGetResponse>("api.cache.get", input),
-    delete: (input: { key: string }) =>
-      this.request<typeof input, { success: boolean }>("api.cache.delete", input),
-    keys: () =>
-      this.request<{}, CacheKeysResponse>("api.cache.keys", {}),
-  };
-
-  // Jobs routes
-  jobs = {
-    enqueue: (input: { name?: string; data?: any; delay?: number }) =>
-      this.request<typeof input, JobEnqueueResponse>("api.jobs.enqueue", input),
-    stats: () =>
-      this.request<{}, JobStatsResponse>("api.jobs.stats", {}),
-  };
-
-  // Cron routes
-  cron = {
-    list: () =>
-      this.request<{}, CronListResponse>("api.cron.list", {}),
-  };
-
-  // Rate limiter routes
-  ratelimit = {
-    check: (input: { key?: string; limit?: number; window?: number }) =>
-      this.request<typeof input, RateLimitResult>("api.ratelimit.check", input),
-    reset: (input: { key?: string }) =>
-      this.request<typeof input, { success: boolean }>("api.ratelimit.reset", input),
-  };
-
-  // Events routes
-  events = {
-    emit: (input: { event?: string; data?: any }) =>
-      this.request<typeof input, { success: boolean }>("api.events.emit", input),
-  };
-
-  // SSE routes
-  sseRoutes = {
-    broadcast: (input: { channel?: string; event?: string; data: any }) =>
-      this.request<typeof input, { success: boolean }>("api.sse.broadcast", input),
-    clients: () =>
-      this.request<{}, SSEClientsResponse>("api.sse.clients", {}),
+  constructor(options?: ClientOptions) {
+    super(options);
+  }
+
+  api = {
+    counter: {
+      get: (input: any) => this.request("api.counter.get", input),
+      increment: (input: any) => this.request("api.counter.increment", input),
+      decrement: (input: any) => this.request("api.counter.decrement", input),
+      reset: (input: any) => this.request("api.counter.reset", input)
+    },
+    cache: {
+      set: (input: any) => this.request("api.cache.set", input),
+      get: (input: any) => this.request("api.cache.get", input),
+      delete: (input: any) => this.request("api.cache.delete", input),
+      keys: (input: any) => this.request("api.cache.keys", input)
+    },
+    jobs: {
+      enqueue: (input: any) => this.request("api.jobs.enqueue", input),
+      stats: (input: any) => this.request("api.jobs.stats", input)
+    },
+    cron: {
+      list: (input: any) => this.request("api.cron.list", input)
+    },
+    ratelimit: {
+      check: (input: any) => this.request("api.ratelimit.check", input),
+      reset: (input: any) => this.request("api.ratelimit.reset", input)
+    },
+    events: {
+      emit: (input: any) => this.request("api.events.emit", input)
+    },
+    sse: {
+      broadcast: (input: any) => this.request("api.sse.broadcast", input),
+      clients: (input: any) => this.request("api.sse.clients", input)
+    }
   };
 }
 
 /**
  * Create an API client instance
  *
- * @example
- * // In +page.server.ts (SSR - direct calls)
- * const api = createApi({ locals });
- * const data = await api.counter.get();
+ * @param options.locals - Pass SvelteKit locals for SSR direct calls (no HTTP overhead)
+ * @param options.baseUrl - Override the base URL for HTTP calls
+ *
+ * @example SSR usage in +page.server.ts:
+ * ```ts
+ * export const load = async ({ locals }) => {
+ *   const api = createApi({ locals });
+ *   const data = await api.myRoute.get({}); // Direct call, no HTTP!
+ *   return { data };
+ * };
+ * ```
  *
- * @example
- * // In +page.svelte (browser - HTTP calls)
- * const api = createApi();
- * const data = await api.counter.get();
+ * @example Browser usage in +page.svelte:
+ * ```svelte
+ * <script>
+ *   import { createApi } from '$lib/api';
+ *   const api = createApi(); // HTTP calls
+ *   let data = $state(null);
+ *   async function load() {
+ *     data = await api.myRoute.get({});
+ *   }
+ * </script>
+ * ```
  */
-export function createApi(options?: { locals?: any }) {
+export function createApi(options?: ClientOptions) {
   return new ApiClient(options);
 }

package/templates/sveltekit-app/src/routes/+page.server.ts

@@ -8,9 +8,9 @@ export const load: PageServerLoad = async ({ locals }) => {
 
   try {
     // Direct service call through typed client
-    const { count } = await api.counter.get();
+    const result = await api.api.counter.get({}) as { count: number };
     return {
-      count,
+      count: result.count,
       loadedAt: new Date().toISOString(),
       isSSR: true,
     };

package/templates/sveltekit-app/src/server/index.ts

@@ -1,155 +1,24 @@
 // Server entry for @donkeylabs/adapter-sveltekit
-import { AppServer, createPlugin, createRouter } from "@donkeylabs/server";
+import { AppServer, createRouter } from "@donkeylabs/server";
 import { Kysely } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Database } from "bun:sqlite";
 import { z } from "zod";
+import { demoPlugin } from "./plugins/demo";
 
 // Simple in-memory database
 const db = new Kysely<{}>({
   dialect: new BunSqliteDialect({ database: new Database(":memory:") }),
 });
 
-// Random event messages for SSE demo
-const eventMessages = [
-  "User logged in",
-  "New order placed",
-  "Payment received",
-  "Item shipped",
-  "Review submitted",
-  "Comment added",
-  "File uploaded",
-  "Task completed",
-  "Alert triggered",
-  "Sync finished",
-];
-
-// Demo plugin with all core service integrations
-const demoPlugin = createPlugin.define({
-  name: "demo",
-  service: async (ctx) => {
-    let counter = 0;
-
-    return {
-      // Counter
-      getCounter: () => counter,
-      increment: () => ++counter,
-      decrement: () => --counter,
-      reset: () => { counter = 0; return counter; },
-
-      // Cache helpers
-      cacheSet: async (key: string, value: any, ttl?: number) => {
-        await ctx.core.cache.set(key, value, ttl);
-        return { success: true };
-      },
-      cacheGet: async (key: string) => {
-        const value = await ctx.core.cache.get(key);
-        const exists = await ctx.core.cache.has(key);
-        return { value, exists };
-      },
-      cacheDelete: async (key: string) => {
-        await ctx.core.cache.delete(key);
-        return { success: true };
-      },
-      cacheKeys: async () => {
-        const keys = await ctx.core.cache.keys();
-        return { keys, size: keys.length };
-      },
-
-      // Jobs helpers
-      enqueueJob: async (name: string, data: any, delay?: number) => {
-        let jobId: string;
-        if (delay && delay > 0) {
-          const runAt = new Date(Date.now() + delay);
-          jobId = await ctx.core.jobs.schedule(name, data, runAt);
-        } else {
-          jobId = await ctx.core.jobs.enqueue(name, data);
-        }
-        return { jobId };
-      },
-      getJobStats: async () => {
-        const pending = await ctx.core.jobs.getByName("demo-job", "pending");
-        const running = await ctx.core.jobs.getByName("demo-job", "running");
-        const completed = await ctx.core.jobs.getByName("demo-job", "completed");
-        return {
-          pending: pending.length,
-          running: running.length,
-          completed: completed.length,
-        };
-      },
-
-      // Cron helpers
-      getCronTasks: () => ctx.core.cron.list().map(t => ({
-        id: t.id,
-        name: t.name,
-        expression: t.expression,
-        enabled: t.enabled,
-        lastRun: t.lastRun?.toISOString(),
-        nextRun: t.nextRun?.toISOString(),
-      })),
-
-      // Rate limiter helpers
-      checkRateLimit: async (key: string, limit: number, window: number) => {
-        return ctx.core.rateLimiter.check(key, limit, window);
-      },
-      resetRateLimit: async (key: string) => {
-        await ctx.core.rateLimiter.reset(key);
-        return { success: true };
-      },
-
-      // Events helpers (internal pub/sub)
-      emitEvent: async (event: string, data: any) => {
-        await ctx.core.events.emit(event, data);
-        return { success: true };
-      },
-
-      // SSE broadcast
-      broadcast: (channel: string, event: string, data: any) => {
-        ctx.core.sse.broadcast(channel, event, data);
-        return { success: true };
-      },
-      getSSEClients: () => ({
-        total: ctx.core.sse.getClients().length,
-        byChannel: ctx.core.sse.getClientsByChannel("events").length,
-      }),
-    };
-  },
-  init: async (ctx) => {
-    // Register job handler for demo
-    ctx.core.jobs.register("demo-job", async (data) => {
-      ctx.core.logger.info("Demo job executed", { data });
-      // Broadcast job completion via SSE
-      ctx.core.sse.broadcast("events", "job-completed", {
-        id: Date.now(),
-        message: `Job completed: ${data.message || "No message"}`,
-        timestamp: new Date().toISOString(),
-      });
-    });
-
-    // Schedule cron job to broadcast SSE events every 5 seconds
-    ctx.core.cron.schedule("*/5 * * * * *", () => {
-      const message = eventMessages[Math.floor(Math.random() * eventMessages.length)];
-      ctx.core.sse.broadcast("events", "cron-event", {
-        id: Date.now(),
-        message,
-        timestamp: new Date().toISOString(),
-        source: "cron",
-      });
-    }, { name: "sse-broadcaster" });
+// Create server
+export const server = new AppServer({
+  db,
+  port: 0, // Port managed by adapter
+});
 
-    // Listen for internal events and broadcast to SSE
-    ctx.core.events.on("demo.*", (data) => {
-      ctx.core.sse.broadcast("events", "internal-event", {
-        id: Date.now(),
-        message: `Internal event: ${JSON.stringify(data)}`,
-        timestamp: new Date().toISOString(),
-        source: "events",
-      });
-    });
+server.registerPlugin(demoPlugin);
 
-    ctx.core.logger.info("Demo plugin initialized with all core services");
-  },
-});
 
 // Create routes
 const api = createRouter("api");
@@ -202,7 +71,7 @@ api.route("jobs.enqueue").typed({
     data: z.any().default({}),
     delay: z.number().optional()
   }),
-  handle: async (input, ctx) => ctx.plugins.demo.enqueueJob(input.name, input.data, input.delay),
+  handle: async (input, ctx) => ctx.plugins.demo.enqueueJob(input.name!, input.data, input.delay),
 });
 
 api.route("jobs.stats").typed({
@@ -221,12 +90,12 @@ api.route("ratelimit.check").typed({
     limit: z.number().default(5),
     window: z.number().default(60000)
   }),
-  handle: async (input, ctx) => ctx.plugins.demo.checkRateLimit(input.key, input.limit, input.window),
+  handle: async (input, ctx) => ctx.plugins.demo.checkRateLimit(input.key!, input.limit!, input.window!),
 });
 
 api.route("ratelimit.reset").typed({
   input: z.object({ key: z.string().default("demo") }),
-  handle: async (input, ctx) => ctx.plugins.demo.resetRateLimit(input.key),
+  handle: async (input, ctx) => ctx.plugins.demo.resetRateLimit(input.key!),
 });
 
 // Events routes (internal pub/sub)
@@ -235,7 +104,7 @@ api.route("events.emit").typed({
     event: z.string().default("demo.test"),
     data: z.any().default({ test: true })
   }),
-  handle: async (input, ctx) => ctx.plugins.demo.emitEvent(input.event, input.data),
+  handle: async (input, ctx) => ctx.plugins.demo.emitEvent(input.event!, input.data),
 });
 
 // SSE routes
@@ -245,19 +114,24 @@ api.route("sse.broadcast").typed({
     event: z.string().default("manual"),
     data: z.any()
   }),
-  handle: async (input, ctx) => ctx.plugins.demo.broadcast(input.channel, input.event, input.data),
+  handle: async (input, ctx) => ctx.plugins.demo.broadcast(input.channel!, input.event!, input.data),
 });
 
 api.route("sse.clients").typed({
   handle: async (_input, ctx) => ctx.plugins.demo.getSSEClients(),
 });
 
-// Create server
-export const server = new AppServer({
-  db,
-  port: 0, // Port managed by adapter
-});
 
 // Register plugin and routes
-server.registerPlugin(demoPlugin);
 server.use(api);
+
+// Handle DONKEYLABS_GENERATE for type generation
+if (process.env.DONKEYLABS_GENERATE === "1") {
+  // Extract routes and output as JSON for CLI
+  const routes = api.getRoutes().map((r) => ({
+    name: r.name,
+    handler: r.handler || "typed",
+  }));
+  console.log(JSON.stringify({ routes }));
+  process.exit(0);
+}

package/templates/sveltekit-app/src/server/plugins/demo/index.ts

@@ -0,0 +1,144 @@
+// Demo plugin with all core service integrations
+import { createPlugin } from "@donkeylabs/server";
+
+
+// Random event messages for SSE demo
+const eventMessages = [
+  "User logged in",
+  "New order placed",
+  "Payment received",
+  "Item shipped",
+  "Review submitted",
+  "Comment added",
+  "File uploaded",
+  "Task completed",
+  "Alert triggered",
+  "Sync finished",
+];
+
+
+export const demoPlugin = createPlugin.define({
+  name: "demo",
+  service: async (ctx) => {
+    let counter = 0;
+
+    return {
+      // Counter
+      getCounter: () => counter,
+      increment: () => ++counter,
+      decrement: () => --counter,
+      reset: () => { counter = 0; return counter; },
+
+      // Cache helpers
+      cacheSet: async (key: string, value: any, ttl?: number) => {
+        await ctx.core.cache.set(key, value, ttl);
+        return { success: true };
+      },
+      cacheGet: async (key: string) => {
+        const value = await ctx.core.cache.get(key);
+        const exists = await ctx.core.cache.has(key);
+        return { value, exists };
+      },
+      cacheDelete: async (key: string) => {
+        await ctx.core.cache.delete(key);
+        return { success: true };
+      },
+      cacheKeys: async () => {
+        const keys = await ctx.core.cache.keys();
+        return { keys, size: keys.length };
+      },
+
+      // Jobs helpers
+      enqueueJob: async (name: string, data: any, delay?: number) => {
+        let jobId: string;
+        if (delay && delay > 0) {
+          const runAt = new Date(Date.now() + delay);
+          jobId = await ctx.core.jobs.schedule(name, data, runAt);
+        } else {
+          jobId = await ctx.core.jobs.enqueue(name, data);
+        }
+        return { jobId };
+      },
+      getJobStats: async () => {
+        const pending = await ctx.core.jobs.getByName("demo-job", "pending");
+        const running = await ctx.core.jobs.getByName("demo-job", "running");
+        const completed = await ctx.core.jobs.getByName("demo-job", "completed");
+        return {
+          pending: pending.length,
+          running: running.length,
+          completed: completed.length,
+        };
+      },
+
+      // Cron helpers
+      getCronTasks: () => ctx.core.cron.list().map(t => ({
+        id: t.id,
+        name: t.name,
+        expression: t.expression,
+        enabled: t.enabled,
+        lastRun: t.lastRun?.toISOString(),
+        nextRun: t.nextRun?.toISOString(),
+      })),
+
+      // Rate limiter helpers
+      checkRateLimit: async (key: string, limit: number, window: number) => {
+        return ctx.core.rateLimiter.check(key, limit, window);
+      },
+      resetRateLimit: async (key: string) => {
+        await ctx.core.rateLimiter.reset(key);
+        return { success: true };
+      },
+
+      // Events helpers (internal pub/sub)
+      emitEvent: async (event: string, data: any) => {
+        await ctx.core.events.emit(event, data);
+        return { success: true };
+      },
+
+      // SSE broadcast
+      broadcast: (channel: string, event: string, data: any) => {
+        ctx.core.sse.broadcast(channel, event, data);
+        return { success: true };
+      },
+      getSSEClients: () => ({
+        total: ctx.core.sse.getClients().length,
+        byChannel: ctx.core.sse.getClientsByChannel("events").length,
+      }),
+    };
+  },
+  init: async (ctx) => {
+    // Register job handler for demo
+    ctx.core.jobs.register("demo-job", async (data) => {
+      ctx.core.logger.info("Demo job executed", { data });
+      // Broadcast job completion via SSE
+      ctx.core.sse.broadcast("events", "job-completed", {
+        id: Date.now(),
+        message: `Job completed: ${data.message || "No message"}`,
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    // Schedule cron job to broadcast SSE events every 5 seconds
+    ctx.core.cron.schedule("*/5 * * * * *", () => {
+      const message = eventMessages[Math.floor(Math.random() * eventMessages.length)];
+      ctx.core.sse.broadcast("events", "cron-event", {
+        id: Date.now(),
+        message,
+        timestamp: new Date().toISOString(),
+        source: "cron",
+      });
+    }, { name: "sse-broadcaster" });
+
+    // Listen for internal events and broadcast to SSE
+    ctx.core.events.on("demo.*", (data) => {
+      ctx.core.sse.broadcast("events", "internal-event", {
+        id: Date.now(),
+        message: `Internal event: ${JSON.stringify(data)}`,
+        timestamp: new Date().toISOString(),
+        source: "events",
+      });
+    });
+
+    ctx.core.logger.info("Demo plugin initialized with all core services");
+  },
+});