@donkeylabs/cli 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",
@@ -24,6 +24,9 @@
     "typecheck": "bun --bun tsc --noEmit"
   },
   "dependencies": {
+    "kysely": "^0.27.0",
+    "kysely-bun-sqlite": "^0.3.0",
+    "kysely-codegen": "^0.17.0",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2"
   },

package/src/commands/generate.ts

@@ -1,8 +1,12 @@
-import { readdir, writeFile, readFile, mkdir } from "node:fs/promises";
+import { readdir, writeFile, readFile, mkdir, unlink } from "node:fs/promises";
 import { join, relative, dirname, basename } from "node:path";
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import pc from "picocolors";
+import { Kysely, Migrator, FileMigrationProvider } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { Database } from "bun:sqlite";
+import { generate, KyselyBunSqliteDialect } from "kysely-codegen";
 
 interface DonkeylabsConfig {
   plugins: string[];
@@ -325,6 +329,8 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
     return [];
   }
 
+  const TIMEOUT_MS = 10000; // 10 second timeout
+
   return new Promise((resolve) => {
     const child = spawn("bun", [fullPath], {
       env: { ...process.env, DONKEYLABS_GENERATE: "1" },
@@ -334,6 +340,16 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
 
     let stdout = "";
     let stderr = "";
+    let timedOut = false;
+
+    // Timeout handler
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      console.warn(pc.yellow(`Route extraction timed out after ${TIMEOUT_MS / 1000}s`));
+      console.warn(pc.dim("Make sure your entry file handles DONKEYLABS_GENERATE=1 and calls process.exit(0)"));
+      resolve([]);
+    }, TIMEOUT_MS);
 
     child.stdout?.on("data", (data) => {
       stdout += data.toString();
@@ -344,6 +360,9 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
     });
 
     child.on("close", (code) => {
+      clearTimeout(timeout);
+      if (timedOut) return; // Already resolved
+
       if (code !== 0) {
         console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
         if (stderr) console.warn(pc.dim(stderr));
@@ -374,12 +393,105 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
     });
 
     child.on("error", (err) => {
+      clearTimeout(timeout);
       console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
       resolve([]);
     });
   });
 }
 
+/**
+ * Generate schema.ts from plugin migrations using kysely-codegen
+ */
+async function generatePluginSchemas(
+  plugins: { name: string; path: string; exportName: string }[]
+): Promise<string[]> {
+  const generated: string[] = [];
+
+  for (const plugin of plugins) {
+    const pluginDir = dirname(join(process.cwd(), plugin.path));
+    const migrationsDir = join(pluginDir, "migrations");
+
+    // Skip plugins without migrations folder
+    if (!existsSync(migrationsDir)) {
+      continue;
+    }
+
+    // Check if there are any migration files
+    const migrationFiles = await readdir(migrationsDir);
+    const hasMigrations = migrationFiles.some(
+      (f) => f.endsWith(".ts") && !f.endsWith(".d.ts")
+    );
+
+    if (!hasMigrations) {
+      continue;
+    }
+
+    console.log(pc.dim(`  Generating schema for ${plugin.name}...`));
+
+    const dbPath = join(process.cwd(), `.temp_schema_${plugin.name}.db`);
+
+    try {
+      // Create temp SQLite database
+      const db = new Kysely<any>({
+        dialect: new BunSqliteDialect({
+          database: new Database(dbPath),
+        }),
+      });
+
+      // Run migrations using Kysely's FileMigrationProvider
+      const migrator = new Migrator({
+        db,
+        provider: new FileMigrationProvider({
+          fs: await import("node:fs/promises"),
+          path: await import("node:path"),
+          migrationFolder: migrationsDir,
+        }),
+      });
+
+      const { error } = await migrator.migrateToLatest();
+
+      if (error) {
+        console.warn(
+          pc.yellow(`  Warning: Migration failed for ${plugin.name}: ${error}`)
+        );
+        await db.destroy();
+        try {
+          await unlink(dbPath);
+        } catch {}
+        continue;
+      }
+
+      // Generate schema.ts using kysely-codegen
+      const schemaPath = join(pluginDir, "schema.ts");
+
+      await generate({
+        db,
+        outFile: schemaPath,
+        dialect: new KyselyBunSqliteDialect(),
+      });
+
+      generated.push(plugin.name);
+
+      // Cleanup
+      await db.destroy();
+      try {
+        await unlink(dbPath);
+      } catch {}
+    } catch (err: any) {
+      console.warn(
+        pc.yellow(`  Warning: Schema generation failed for ${plugin.name}: ${err.message}`)
+      );
+      // Cleanup on error
+      try {
+        await unlink(dbPath);
+      } catch {}
+    }
+  }
+
+  return generated;
+}
+
 export async function generateCommand(_args: string[]): Promise<void> {
   const config = await loadConfig();
   const outDir = config.outDir || ".@donkeylabs/server";
@@ -390,6 +502,15 @@ export async function generateCommand(_args: string[]): Promise<void> {
   const plugins = await findPlugins(config.plugins);
   const fileRoutes = await findRoutes(config.routes || "./src/routes/**/schema.ts");
 
+  // Generate schema.ts from migrations for plugins that have them
+  const schemaPlugins = await generatePluginSchemas(plugins);
+  if (schemaPlugins.length > 0) {
+    console.log(
+      pc.green("Generated schemas:"),
+      schemaPlugins.map((p) => pc.dim(p)).join(", ")
+    );
+  }
+
   // Extract routes by running the server with DONKEYLABS_GENERATE=1
   const entryPath = config.entry || "./src/index.ts";
   const serverRoutes = await extractRoutesFromServer(entryPath);

package/src/commands/init.ts

@@ -166,6 +166,9 @@ export async function initCommand(args: string[]) {
     console.log(pc.dim("  Run 'bun install' manually to install dependencies.\n"));
   } else {
     console.log(pc.green("\n✓ Dependencies installed\n"));
+
+    // Copy CLAUDE.md and docs/ from @donkeylabs/server to project root
+    await copyDocsFromServer(targetDir);
   }
 
   // Ask about MCP setup
@@ -319,3 +322,31 @@ async function copyDirectory(src: string, dest: string): Promise<void> {
     }
   }
 }
+
+/**
+ * Copy CLAUDE.md and docs/ from @donkeylabs/server to project root
+ * for AI-assisted development
+ */
+async function copyDocsFromServer(targetDir: string): Promise<void> {
+  const serverPkgPath = join(targetDir, "node_modules", "@donkeylabs", "server");
+
+  if (!existsSync(serverPkgPath)) {
+    return; // Server package not installed
+  }
+
+  // Copy CLAUDE.md
+  const claudeMdSrc = join(serverPkgPath, "CLAUDE.md");
+  if (existsSync(claudeMdSrc)) {
+    const claudeMdDest = join(targetDir, "CLAUDE.md");
+    await copyFile(claudeMdSrc, claudeMdDest);
+    console.log(pc.green("  Created:"), "CLAUDE.md (AI instructions)");
+  }
+
+  // Copy docs/ directory
+  const docsSrc = join(serverPkgPath, "docs");
+  if (existsSync(docsSrc)) {
+    const docsDest = join(targetDir, "docs");
+    await copyDirectory(docsSrc, docsDest);
+    console.log(pc.green("  Created:"), "docs/ (detailed documentation)");
+  }
+}

package/templates/starter/src/index.ts

@@ -1,8 +1,15 @@
-import { db } from "./db";
 import { AppServer, createRouter } from "@donkeylabs/server";
+import { Kysely } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { Database } from "bun:sqlite";
 import { healthRouter } from "./routes/health";
 import { statsPlugin } from "./plugins/stats";
 
+// Simple in-memory database
+const db = new Kysely<{}>({
+  dialect: new BunSqliteDialect({ database: new Database(":memory:") }),
+});
+
 const server = new AppServer({
   port: Number(process.env.PORT) || 3000,
   db,
@@ -26,12 +33,22 @@ export function createApi(baseUrl: string, options?: ApiClientOptions) {
 // Register plugins
 server.registerPlugin(statsPlugin);
 
-const api = createRouter("api")
+const api = createRouter("api");
 // Register routes
 api.router(healthRouter);
 
+server.use(api);
 
+// Handle DONKEYLABS_GENERATE mode for CLI type generation
+if (process.env.DONKEYLABS_GENERATE === "1") {
+  const routes = api.getRoutes().map((route) => ({
+    name: route.name,
+    handler: route.handler || "typed",
+    inputType: route.input ? "(generated)" : undefined,
+    outputType: route.output ? "(generated)" : undefined,
+  }));
+  console.log(JSON.stringify({ routes }));
+  process.exit(0);
+}
 
-
-server.use(api);
 await server.start();

package/templates/sveltekit-app/package.json

@@ -24,9 +24,9 @@
     "vite": "^7.2.6"
   },
   "dependencies": {
-    "@donkeylabs/cli": "^0.4.2",
-    "@donkeylabs/adapter-sveltekit": "^0.4.2",
-    "@donkeylabs/server": "^0.4.2",
+    "@donkeylabs/cli": "^0.4.4",
+    "@donkeylabs/adapter-sveltekit": "^0.4.4",
+    "@donkeylabs/server": "^0.4.4",
     "bits-ui": "^2.15.4",
     "clsx": "^2.1.1",
     "kysely": "^0.27.6",

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

@@ -4,17 +4,7 @@ import { Kysely } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Database } from "bun:sqlite";
 import { demoPlugin } from "./plugins/demo";
-
-// Import routes
-import {
-  counterRoutes,
-  cacheRoutes,
-  jobsRoutes,
-  cronRoutes,
-  ratelimitRoutes,
-  eventsRoutes,
-  sseRoutes,
-} from "./routes";
+import demoRoutes from "./routes/demo";
 
 // Simple in-memory database
 const db = new Kysely<{}>({
@@ -33,13 +23,17 @@ export const server = new AppServer({
 // 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);
-
+// Register routes
+server.use(demoRoutes);
 
+// Handle DONKEYLABS_GENERATE mode for CLI type generation
+if (process.env.DONKEYLABS_GENERATE === "1") {
+  const routes = demoRoutes.getRoutes().map((route) => ({
+    name: route.name,
+    handler: route.handler || "typed",
+    inputType: route.input ? "(generated)" : undefined,
+    outputType: route.output ? "(generated)" : undefined,
+  }));
+  console.log(JSON.stringify({ routes }));
+  process.exit(0);
+}

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

@@ -0,0 +1,237 @@
+/**
+ * Demo Router - Showcases @donkeylabs/server core features
+ *
+ * Routes delegate to the demo plugin service which handles
+ * the core service integrations with proper types.
+ */
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+
+const demo = createRouter("api");
+
+// =============================================================================
+// COUNTER - Uses plugin service for state
+// =============================================================================
+
+demo.route("counter.get").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.getCounter() };
+    },
+  })
+);
+
+demo.route("counter.increment").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.increment() };
+    },
+  })
+);
+
+demo.route("counter.decrement").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.decrement() };
+    },
+  })
+);
+
+demo.route("counter.reset").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.reset() };
+    },
+  })
+);
+
+// =============================================================================
+// CACHE - In-memory caching (via plugin service)
+// =============================================================================
+
+demo.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: async (input, ctx) => {
+      return ctx.plugins.demo.cacheSet(input.key, input.value, input.ttl);
+    },
+  })
+);
+
+demo.route("cache.get").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ value: z.any().optional(), exists: z.boolean() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.cacheGet(input.key);
+    },
+  })
+);
+
+demo.route("cache.delete").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.cacheDelete(input.key);
+    },
+  })
+);
+
+demo.route("cache.keys").typed(
+  defineRoute({
+    output: z.object({ keys: z.array(z.string()), size: z.number() }),
+    handle: async (_, ctx) => {
+      return ctx.plugins.demo.cacheKeys();
+    },
+  })
+);
+
+// =============================================================================
+// SSE - Server-Sent Events (via plugin service)
+// =============================================================================
+
+demo.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() }),
+    handle: async (input, ctx) => {
+      const channel = input.channel ?? "events";
+      const event = input.event ?? "manual";
+      return ctx.plugins.demo.broadcast(channel, event, input.data);
+    },
+  })
+);
+
+demo.route("sse.clients").typed(
+  defineRoute({
+    output: z.object({ total: z.number(), byChannel: z.number() }),
+    handle: async (_, ctx) => {
+      return ctx.plugins.demo.getSSEClients();
+    },
+  })
+);
+
+// =============================================================================
+// JOBS - Background job queue (via plugin service)
+// =============================================================================
+
+demo.route("jobs.enqueue").typed(
+  defineRoute({
+    input: z.object({
+      name: z.string().default("demo-job"),
+      data: z.record(z.any()).optional(),
+      delay: z.number().optional(),
+    }),
+    output: z.object({ jobId: z.string() }),
+    handle: async (input, ctx) => {
+      const name = input.name ?? "demo-job";
+      return ctx.plugins.demo.enqueueJob(name, input.data || {}, input.delay);
+    },
+  })
+);
+
+demo.route("jobs.stats").typed(
+  defineRoute({
+    output: z.object({
+      pending: z.number(),
+      running: z.number(),
+      completed: z.number(),
+    }),
+    handle: async (_, ctx) => {
+      return ctx.plugins.demo.getJobStats();
+    },
+  })
+);
+
+// =============================================================================
+// EVENTS - Pub/sub system (via plugin service)
+// =============================================================================
+
+demo.route("events.emit").typed(
+  defineRoute({
+    input: z.object({
+      event: z.string(),
+      data: z.record(z.any()).optional(),
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.emitEvent(input.event, input.data || {});
+    },
+  })
+);
+
+// =============================================================================
+// RATE LIMITING (via plugin service)
+// =============================================================================
+
+demo.route("ratelimit.check").typed(
+  defineRoute({
+    input: z.object({
+      key: z.string(),
+      limit: z.number().default(10),
+      window: z.number().default(60),
+    }),
+    output: z.object({
+      allowed: z.boolean(),
+      remaining: z.number(),
+      limit: z.number(),
+      resetAt: z.date(),
+    }),
+    handle: async (input, ctx) => {
+      const limit = input.limit ?? 10;
+      const window = input.window ?? 60;
+      return ctx.plugins.demo.checkRateLimit(input.key, limit, window * 1000);
+    },
+  })
+);
+
+demo.route("ratelimit.reset").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      return ctx.plugins.demo.resetRateLimit(input.key);
+    },
+  })
+);
+
+// =============================================================================
+// CRON - Scheduled tasks info (via plugin service)
+// =============================================================================
+
+demo.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: async (_, ctx) => {
+      return { tasks: ctx.plugins.demo.getCronTasks() };
+    },
+  })
+);
+
+export default demo;

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

@@ -1,15 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,46 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,39 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,19 +0,0 @@
-
-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

@@ -1,8 +0,0 @@
-// 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

@@ -1,15 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,28 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,29 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-
-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

@@ -1,28 +0,0 @@
-
-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;