@donkeylabs/cli 0.1.0 → 0.4.0

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

@@ -1,263 +1,45 @@
 // Server entry for @donkeylabs/adapter-sveltekit
-import { AppServer, createPlugin, createRouter } from "@donkeylabs/server";
+import { AppServer } 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";
+
+// Import routes
+import {
+  counterRoutes,
+  cacheRoutes,
+  jobsRoutes,
+  cronRoutes,
+  ratelimitRoutes,
+  eventsRoutes,
+  sseRoutes,
+} from "./routes";
 
 // 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" });
-
-    // 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");
-  },
-});
-
-// Create routes
-const api = createRouter("api");
-
-// Counter routes
-api.route("counter.get").typed({
-  handle: async (_input, ctx) => ({ count: ctx.plugins.demo.getCounter() }),
-});
-
-api.route("counter.increment").typed({
-  handle: async (_input, ctx) => ({ count: ctx.plugins.demo.increment() }),
-});
-
-api.route("counter.decrement").typed({
-  handle: async (_input, ctx) => ({ count: ctx.plugins.demo.decrement() }),
-});
-
-api.route("counter.reset").typed({
-  handle: async (_input, ctx) => ({ count: ctx.plugins.demo.reset() }),
-});
-
-// Cache routes
-api.route("cache.set").typed({
-  input: z.object({
-    key: z.string(),
-    value: z.any(),
-    ttl: z.number().optional()
-  }),
-  handle: async (input, ctx) => ctx.plugins.demo.cacheSet(input.key, input.value, input.ttl),
-});
-
-api.route("cache.get").typed({
-  input: z.object({ key: z.string() }),
-  handle: async (input, ctx) => ctx.plugins.demo.cacheGet(input.key),
-});
-
-api.route("cache.delete").typed({
-  input: z.object({ key: z.string() }),
-  handle: async (input, ctx) => ctx.plugins.demo.cacheDelete(input.key),
-});
-
-api.route("cache.keys").typed({
-  handle: async (_input, ctx) => ctx.plugins.demo.cacheKeys(),
-});
-
-// Jobs routes
-api.route("jobs.enqueue").typed({
-  input: z.object({
-    name: z.string().default("demo-job"),
-    data: z.any().default({}),
-    delay: z.number().optional()
-  }),
-  handle: async (input, ctx) => ctx.plugins.demo.enqueueJob(input.name, input.data, input.delay),
-});
-
-api.route("jobs.stats").typed({
-  handle: async (_input, ctx) => ctx.plugins.demo.getJobStats(),
-});
-
-// Cron routes
-api.route("cron.list").typed({
-  handle: async (_input, ctx) => ({ tasks: ctx.plugins.demo.getCronTasks() }),
-});
-
-// Rate limiter routes
-api.route("ratelimit.check").typed({
-  input: z.object({
-    key: z.string().default("demo"),
-    limit: z.number().default(5),
-    window: z.number().default(60000)
-  }),
-  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),
-});
-
-// Events routes (internal pub/sub)
-api.route("events.emit").typed({
-  input: z.object({
-    event: z.string().default("demo.test"),
-    data: z.any().default({ test: true })
-  }),
-  handle: async (input, ctx) => ctx.plugins.demo.emitEvent(input.event, input.data),
-});
-
-// SSE routes
-api.route("sse.broadcast").typed({
-  input: z.object({
-    channel: z.string().default("events"),
-    event: z.string().default("manual"),
-    data: z.any()
-  }),
-  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
+// Create server with auto type generation in dev mode
 export const server = new AppServer({
   db,
   port: 0, // Port managed by adapter
+  generateTypes: {
+    output: "./src/lib/api.ts",
+  },
 });
 
-// Register plugin and routes
+// Register plugin
 server.registerPlugin(demoPlugin);
-server.use(api);
+
+// Register all routes
+server.use(counterRoutes);
+server.use(cacheRoutes);
+server.use(jobsRoutes);
+server.use(cronRoutes);
+server.use(ratelimitRoutes);
+server.use(eventsRoutes);
+server.use(sseRoutes);
+
+

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");
+  },
+});

package/templates/sveltekit-app/src/server/routes/cache/handlers/delete.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class DeleteCacheHandler implements Handler<Routes.Api.Cache.Delete> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Cache.Delete.Input): Routes.Api.Cache.Delete.Output {
+    return this.ctx.plugins.demo.cacheDelete(input.key);
+  }
+}

package/templates/sveltekit-app/src/server/routes/cache/handlers/get.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class GetCacheHandler implements Handler<Routes.Api.Cache.Get> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Cache.Get.Input): Routes.Api.Cache.Get.Output {
+    return this.ctx.plugins.demo.cacheGet(input.key);
+  }
+}

package/templates/sveltekit-app/src/server/routes/cache/handlers/keys.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class KeysCacheHandler implements Handler<Routes.Api.Cache.Keys> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Cache.Keys.Input): Routes.Api.Cache.Keys.Output {
+    return this.ctx.plugins.demo.cacheKeys();
+  }
+}

package/templates/sveltekit-app/src/server/routes/cache/handlers/set.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class SetCacheHandler implements Handler<Routes.Api.Cache.Set> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Cache.Set.Input): Routes.Api.Cache.Set.Output {
+    return this.ctx.plugins.demo.cacheSet(input.key, input.value, input.ttl);
+  }
+}

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

@@ -0,0 +1,46 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { SetCacheHandler } from "./handlers/set";
+import { GetCacheHandler } from "./handlers/get";
+import { DeleteCacheHandler } from "./handlers/delete";
+import { KeysCacheHandler } from "./handlers/keys";
+
+const router = createRouter("api");
+
+router.route("cache.set").typed(
+  defineRoute({
+    input: z.object({
+      key: z.string(),
+      value: z.any(),
+      ttl: z.number().optional()
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: SetCacheHandler,
+  })
+);
+
+router.route("cache.get").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ value: z.any().optional(), exists: z.boolean() }),
+    handle: GetCacheHandler,
+  })
+);
+
+router.route("cache.delete").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ success: z.boolean() }),
+    handle: DeleteCacheHandler,
+  })
+);
+
+router.route("cache.keys").typed(
+  defineRoute({
+    output: z.object({ keys: z.array(z.string()) }),
+    handle: KeysCacheHandler,
+  })
+);
+
+export default router;

package/templates/sveltekit-app/src/server/routes/counter/handlers/decrement.ts

@@ -0,0 +1,17 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class DecrementCounterHandler implements Handler<Routes.Api.Counter.Decrement> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Counter.Decrement.Input): Routes.Api.Counter.Decrement.Output {
+    return {
+      count: this.ctx.plugins.demo.decrement(),
+    };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/handlers/get.ts

@@ -0,0 +1,17 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class GetCounterHandler implements Handler<Routes.Api.Counter.Get> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Counter.Get.Input): Routes.Api.Counter.Get.Output {
+    return {
+      count: this.ctx.plugins.demo.getCounter(),
+    };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/handlers/increment.ts

@@ -0,0 +1,17 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class IncrementCounterHandler implements Handler<Routes.Api.Counter.Increment> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Counter.Increment.Input): Routes.Api.Counter.Increment.Output {
+    return {
+      count: this.ctx.plugins.demo.increment(),
+    };
+  }
+}

package/templates/sveltekit-app/src/server/routes/counter/handlers/reset.ts

@@ -0,0 +1,17 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class ResetCounterHandler implements Handler<Routes.Api.Counter.Reset> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Counter.Reset.Input): Routes.Api.Counter.Reset.Output {
+    return {
+      count: this.ctx.plugins.demo.reset(),
+    };
+  }
+}

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

@@ -0,0 +1,39 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { GetCounterHandler } from "./handlers/get";
+import { IncrementCounterHandler } from "./handlers/increment";
+import { DecrementCounterHandler } from "./handlers/decrement";
+import { ResetCounterHandler } from "./handlers/reset";
+
+const router = createRouter("api");
+
+router.route("counter.get").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: GetCounterHandler,
+  })
+);
+
+router.route("counter.increment").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: IncrementCounterHandler,
+  })
+);
+
+router.route("counter.decrement").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: DecrementCounterHandler,
+  })
+);
+
+router.route("counter.reset").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: ResetCounterHandler,
+  })
+);
+
+export default router;

package/templates/sveltekit-app/src/server/routes/cron/handlers/list.ts

@@ -0,0 +1,17 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class ListCronHandler implements Handler<Routes.Api.Cron.List> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Cron.List.Input): Routes.Api.Cron.List.Output {
+    return {
+      tasks: this.ctx.plugins.demo.getCronTasks()
+    };
+  }
+}