@donkeylabs/cli 0.1.1 → 0.4.0

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

@@ -1,137 +1,45 @@
 // Server entry for @donkeylabs/adapter-sveltekit
-import { AppServer, 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:") }),
 });
 
-// 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
 server.registerPlugin(demoPlugin);
 
+// Register all routes
+server.use(counterRoutes);
+server.use(cacheRoutes);
+server.use(jobsRoutes);
+server.use(cronRoutes);
+server.use(ratelimitRoutes);
+server.use(eventsRoutes);
+server.use(sseRoutes);
 
-// 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(),
-});
-
-
-// Register plugin and routes
-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/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()
+    };
+  }
+}

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

@@ -0,0 +1,24 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { ListCronHandler } from "./handlers/list";
+
+const router = createRouter("api");
+
+router.route("cron.list").typed(
+  defineRoute({
+    output: z.object({
+      tasks: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        expression: z.string(),
+        enabled: z.boolean(),
+        lastRun: z.string().optional(),
+        nextRun: z.string().optional()
+      }))
+    }),
+    handle: ListCronHandler,
+  })
+);
+
+export default router;

package/templates/sveltekit-app/src/server/routes/events/handlers/emit.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class EmitEventHandler implements Handler<Routes.Api.Events.Emit> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Events.Emit.Input): Routes.Api.Events.Emit.Output {
+    return this.ctx.plugins.demo.emitEvent(input.event!, input.data);
+  }
+}

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

@@ -0,0 +1,19 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { EmitEventHandler } from "./handlers/emit";
+
+const router = createRouter("api");
+
+router.route("events.emit").typed(
+  defineRoute({
+    input: z.object({
+      event: z.string().default("demo.test"),
+      data: z.any().default({ test: true })
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: EmitEventHandler,
+  })
+);
+
+export default router;

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

@@ -0,0 +1,8 @@
+// Export all route modules
+export { default as counterRoutes } from "./counter";
+export { default as cacheRoutes } from "./cache";
+export { default as jobsRoutes } from "./jobs";
+export { default as cronRoutes } from "./cron";
+export { default as ratelimitRoutes } from "./ratelimit";
+export { default as eventsRoutes } from "./events";
+export { default as sseRoutes } from "./sse";

package/templates/sveltekit-app/src/server/routes/jobs/handlers/enqueue.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class EnqueueJobHandler implements Handler<Routes.Api.Jobs.Enqueue> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Jobs.Enqueue.Input): Routes.Api.Jobs.Enqueue.Output {
+    return this.ctx.plugins.demo.enqueueJob(input.name!, input.data, input.delay);
+  }
+}

package/templates/sveltekit-app/src/server/routes/jobs/handlers/stats.ts

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

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

@@ -0,0 +1,28 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { EnqueueJobHandler } from "./handlers/enqueue";
+import { StatsJobHandler } from "./handlers/stats";
+
+const router = createRouter("api");
+
+router.route("jobs.enqueue").typed(
+  defineRoute({
+    input: z.object({
+      name: z.string().default("demo-job"),
+      data: z.any().default({}),
+      delay: z.number().optional()
+    }),
+    output: z.object({ jobId: z.string() }),
+    handle: EnqueueJobHandler,
+  })
+);
+
+router.route("jobs.stats").typed(
+  defineRoute({
+    output: z.object({ pending: z.number(), running: z.number(), completed: z.number() }),
+    handle: StatsJobHandler,
+  })
+);
+
+export default router;

package/templates/sveltekit-app/src/server/routes/ratelimit/handlers/check.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class CheckRateLimitHandler implements Handler<Routes.Api.Ratelimit.Check> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Ratelimit.Check.Input): Routes.Api.Ratelimit.Check.Output {
+    return this.ctx.plugins.demo.checkRateLimit(input.key!, input.limit!, input.window!);
+  }
+}

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

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

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

@@ -0,0 +1,29 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { CheckRateLimitHandler } from "./handlers/check";
+import { ResetRateLimitHandler } from "./handlers/reset";
+
+const router = createRouter("api");
+
+router.route("ratelimit.check").typed(
+  defineRoute({
+    input: z.object({
+      key: z.string().default("demo"),
+      limit: z.number().default(5),
+      window: z.number().default(60000)
+    }),
+    output: z.object({ allowed: z.boolean(), remaining: z.number(), resetAt: z.date() }),
+    handle: CheckRateLimitHandler,
+  })
+);
+
+router.route("ratelimit.reset").typed(
+  defineRoute({
+    input: z.object({ key: z.string().default("demo") }),
+    output: z.object({ success: z.boolean() }),
+    handle: ResetRateLimitHandler,
+  })
+);
+
+export default router;

package/templates/sveltekit-app/src/server/routes/sse/handlers/broadcast.ts

@@ -0,0 +1,15 @@
+
+import type { Handler, AppContext } from "$lib/api";
+import type { Routes } from "$lib/api";
+
+export class BroadcastSseHandler implements Handler<Routes.Api.Sse.Broadcast> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Sse.Broadcast.Input): Routes.Api.Sse.Broadcast.Output {
+    return this.ctx.plugins.demo.broadcast(input.channel!, input.event!, input.data);
+  }
+}

package/templates/sveltekit-app/src/server/routes/sse/handlers/clients.ts

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

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

@@ -0,0 +1,28 @@
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+import { BroadcastSseHandler } from "./handlers/broadcast";
+import { ClientsSseHandler } from "./handlers/clients";
+
+const router = createRouter("api");
+
+router.route("sse.broadcast").typed(
+  defineRoute({
+    input: z.object({
+      channel: z.string().default("events"),
+      event: z.string().default("manual"),
+      data: z.any()
+    }),
+    output: z.object({ success: z.boolean(), recipients: z.number() }),
+    handle: BroadcastSseHandler,
+  })
+);
+
+router.route("sse.clients").typed(
+  defineRoute({
+    output: z.object({ total: z.number(), byChannel: z.number() }),
+    handle: ClientsSseHandler,
+  })
+);
+
+export default router;

package/templates/sveltekit-app/{svelte.config.js → svelte.config.ts}

@@ -1,8 +1,9 @@
 import adapter from '@donkeylabs/adapter-sveltekit';
 import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
 
-/** @type {import('@sveltejs/kit').Config} */
-const config = {
+import type { Config } from '@sveltejs/kit';
+
+const config: Config = {
 	preprocess: vitePreprocess(),
 
 	kit: {