@donkeylabs/cli 0.1.0 → 0.4.0

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,14 +1,13 @@
 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: {
-		adapter: adapter({
-			serverEntry: './src/server/index.ts',
-		}),
+		adapter: adapter(),
 		alias: {
 			$server: '.@donkeylabs/server',
 		}

package/templates/sveltekit-app/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "extends": "./.svelte-kit/tsconfig.json",
   "compilerOptions": {
-    "rewriteRelativeImportExtensions": true,
     "allowJs": true,
     "checkJs": true,
     "esModuleInterop": true,
@@ -13,13 +12,9 @@
     "moduleResolution": "bundler"
   },
   "include": [
-    ".svelte-kit/ambient.d.ts",
-    ".svelte-kit/non-ambient.d.ts",
-    ".svelte-kit/types/**/$types.d.ts",
-    "vite.config.ts",
-    "src/**/*.js",
+    ".@donkeylabs/server/**/*.ts",
+    ".@donkeylabs/server/**/*.d.ts",
     "src/**/*.ts",
-    "src/**/*.svelte",
-    ".@donkeylabs/server/**/*.d.ts"
+    "src/**/*.svelte"
   ]
-}
+}

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

@@ -1,7 +1,8 @@
 import { sveltekit } from '@sveltejs/kit/vite';
 import tailwindcss from '@tailwindcss/vite';
 import { defineConfig } from 'vite';
+import { donkeylabsDev } from '@donkeylabs/adapter-sveltekit/vite';
 
 export default defineConfig({
-	plugins: [tailwindcss(), sveltekit()]
+	plugins: [donkeylabsDev(), tailwindcss(), sveltekit()]
 });

package/templates/starter/CLAUDE.md

@@ -1,144 +0,0 @@
-# {{PROJECT_NAME}}
-
-Built with @donkeylabs/server - a type-safe RPC framework for Bun.
-
-## Project Structure
-
-```
-src/
-├── index.ts              # Server entry point
-├── db.ts                 # Database setup
-├── routes/               # Route handlers
-│   └── health/
-│       ├── index.ts      # Route definitions
-│       └── ping/
-│           ├── handler.ts
-│           ├── models/
-│           │   └── model.ts  # Input/output schemas
-│           └── tests/
-│               ├── unit.test.ts
-│               └── integ.test.ts
-└── plugins/              # Business logic plugins
-    └── example/
-        ├── index.ts      # Plugin definition
-        ├── schema.ts     # DB types
-        └── migrations/   # SQL migrations
-docs/                     # Framework documentation
-```
-
-## Quick Start
-
-See `src/routes/health/ping/` for a complete example with handler, model, and tests.
-
-## Plugins
-
-Plugins encapsulate business logic with optional database schemas.
-
-```ts
-import { createPlugin } from "@donkeylabs/server";
-
-export const notesPlugin = createPlugin.define({
-  name: "notes",
-  service: async (ctx) => ({
-    async create(title: string) {
-      return ctx.db.insertInto("notes").values({ title }).execute();
-    },
-  }),
-});
-```
-
-→ See **docs/plugins.md** for schemas, migrations, and dependencies.
-
-## Routes
-
-Routes are organized by feature in `src/routes/`. Each route has:
-- `handler.ts` - Handler logic
-- `models/model.ts` - Zod schemas for input/output
-- `tests/unit.test.ts` - Unit tests
-- `tests/integ.test.ts` - Integration tests
-
-```ts
-// routes/notes/index.ts
-import { createRouter } from "@donkeylabs/server";
-import { createHandler } from "./create/handler";
-
-export const notesRouter = createRouter("notes")
-  .route("create").typed(createHandler);
-```
-
-→ See **docs/router.md** and **src/routes/health/** for examples.
-
-## Errors
-
-Use built-in error factories for proper HTTP responses.
-
-```ts
-throw ctx.errors.NotFound("User not found");
-throw ctx.errors.BadRequest("Invalid email");
-```
-
-→ See **docs/errors.md** for all error types and custom errors.
-
-## Core Services
-
-Available via `ctx.core`. **Only use what you need.**
-
-| Service | Purpose | Docs |
-|---------|---------|------|
-| `logger` | Structured logging | docs/logger.md |
-| `cache` | In-memory key-value cache | docs/cache.md |
-| `events` | Pub/sub between plugins | docs/events.md |
-| `jobs` | Background job queue | docs/jobs.md |
-| `cron` | Scheduled tasks | docs/cron.md |
-| `sse` | Server-sent events | docs/sse.md |
-| `rateLimiter` | Request rate limiting | docs/rate-limiter.md |
-
-→ See **docs/core-services.md** for overview.
-
-## Middleware
-
-Add authentication, logging, or other cross-cutting concerns.
-
-→ See **docs/middleware.md** for usage patterns.
-
-## API Client
-
-Generate a typed client for your frontend:
-
-```sh
-bun run gen:client --output ./frontend/src/lib/api
-```
-
-→ See **docs/api-client.md** for client configuration and usage.
-
-## Svelte 5 Frontend
-
-Build type-safe frontends with Svelte 5 and SvelteKit.
-
-```svelte
-<script lang="ts">
-  import { api } from "$lib/api";
-  let items = $state<Item[]>([]);
-
-  $effect(() => {
-    api.items.list({}).then((r) => items = r.items);
-  });
-</script>
-```
-
-→ See **docs/svelte-frontend.md** for patterns and SSE integration.
-
-## CLI Commands
-
-```sh
-bun run dev          # Start with hot reload
-bun run test         # Run tests
-bun run gen:types    # Generate types after adding plugins
-```
-
-## Guidelines
-
-- **Keep it simple** - don't add services you don't need
-- **One concern per plugin** - auth, notes, billing as separate plugins
-- **Minimal logging** - log errors and key events, not every call
-- **Read the docs** - check docs/*.md before implementing something complex

package/templates/starter/src/client.test.ts

@@ -1,7 +0,0 @@
-import { createApiClient } from "$server/client"
-
-
-const client = createApiClient("http://localhost:3000", {})
-
-client.api.health.ping({}).then(console.log)
-

package/templates/starter/src/db.ts

@@ -1,9 +0,0 @@
-import { Kysely } from "kysely";
-import { BunSqliteDialect } from "kysely-bun-sqlite";
-import { Database } from "bun:sqlite";
-
-export const db = new Kysely<any>({
-  dialect: new BunSqliteDialect({
-    database: new Database("app.db"),
-  }),
-});

package/templates/starter/src/routes/health/ping/index.ts

@@ -1,13 +0,0 @@
-// Route definition with full type inference
-import { createRoute } from "@donkeylabs/server";
-import { Input, Output } from "./schema";
-import { PingModel } from "./models/model";
-
-export const pingRoute = createRoute.typed({
-  input: Input,
-  output: Output,
-  handle: async (input, ctx) => {
-    const model = new PingModel(ctx);
-    return model.handle(input);
-  },
-});

package/templates/starter/src/routes/health/ping/models/model.ts

@@ -1,23 +0,0 @@
-// After running `bun run gen:types`, use typed Handler:
-import { Handler } from "@donkeylabs/server";
-import type { Health } from "$server/routes";
-import { AppContext } from "$server/context";
-
-/**
- * Model class with handler logic.
- */
-export class PingModel implements Handler<Health.Ping> {
-  ctx: AppContext;
-
-  constructor(ctx: AppContext) {
-    this.ctx = ctx;
-  }
-
-  handle(input: Health.Ping.Input): Health.Ping.Output {
-    return {
-      status: "ok",
-      timestamp: new Date().toISOString(),
-      echo: input.echo,
-    };
-  }
-}

package/templates/starter/src/routes/health/ping/schema.ts

@@ -1,14 +0,0 @@
-import { z } from "zod";
-
-export const Input = z.object({
-  echo: z.string().optional(),
-});
-
-export const Output = z.object({
-  status: z.literal("ok"),
-  timestamp: z.string(),
-  echo: z.string().optional(),
-});
-
-export type Input = z.infer<typeof Input>;
-export type Output = z.infer<typeof Output>;

package/templates/starter/src/routes/health/ping/tests/integ.test.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import type { Output } from "../models/model";
-
-const BASE_URL = "http://localhost:3000";
-
-describe("health/ping integration", () => {
-  // Note: Server must be running for integration tests
-  // Run with: bun run dev & bun test src/routes/health/ping/tests/integ.test.ts
-
-  it("POST /health.ping returns ok", async () => {
-    const res = await fetch(`${BASE_URL}/health.ping`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({}),
-    });
-    expect(res.ok).toBe(true);
-    const data = (await res.json()) as Output;
-    expect(data.status).toBe("ok");
-  });
-});

package/templates/starter/src/routes/health/ping/tests/unit.test.ts

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { PingModel } from "../models/model";
-import { Input } from "../schema";
-
-describe("health/ping model", () => {
-  it("returns ok status", () => {
-    const input = Input.parse({});
-    const ctx = {} as any;
-    const model = new PingModel(ctx);
-    const result = model.handle(input);
-    expect(result.status).toBe("ok");
-  });
-
-  it("echoes input", () => {
-    const input = Input.parse({ echo: "hello" });
-    const ctx = {} as any;
-    const model = new PingModel(ctx);
-    const result = model.handle(input);
-    expect(result.echo).toBe("hello");
-  });
-});

package/templates/starter/src/test-ctx.ts

@@ -1,24 +0,0 @@
-/// <reference path="../.@donkeylabs/server/registry.d.ts" />
-// Test that ctx.plugins.stats is typed correctly
-import type { ServerContext, InferService } from "@donkeylabs/server";
-import { statsPlugin } from "./plugins/stats";
-import type { StatsService } from "./plugins/stats";
-
-// Verify InferService works correctly
-type InferredService = InferService<typeof statsPlugin>;
-
-// This type assertion verifies that InferredService equals StatsService
-const _typeCheck: InferredService extends StatsService
-  ? StatsService extends InferredService
-    ? true
-    : false
-  : false = true;
-
-// Verify ctx.plugins.stats is typed as StatsService
-declare const ctx: ServerContext;
-const stats: StatsService = ctx.plugins.stats;  // Should compile without error
-
-// These methods should all work
-stats.recordRequest("test", 100);
-stats.getStats();
-stats.reset();