@donkeylabs/cli 0.1.0 → 0.4.0

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

@@ -3,6 +3,8 @@ import { defineConfig } from "@donkeylabs/server";
 export default defineConfig({
   plugins: ["./src/server/plugins/**/index.ts"],
   outDir: ".@donkeylabs/server",
+  entry: "./src/server/index.ts",
+  routes: "./src/server/routes/**/{route,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"
+    "prepare": "bun --bun svelte-kit sync || echo ''",
+    "check": "bun --bun svelte-kit sync && bun --bun svelte-check --tsconfig ./tsconfig.json",
+    "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.2",
     "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,248 @@
+// Auto-generated by @donkeylabs/server
+// DO NOT EDIT MANUALLY
+
+import { UnifiedApiClientBase, type ClientOptions } from "@donkeylabs/adapter-sveltekit/client";
+
+// Utility type that forces TypeScript to expand types on hover
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
 /**
- * Generated API client for the demo
- * Extends UnifiedApiClientBase to handle SSR direct calls and browser HTTP calls
+ * Handler interface for implementing route handlers in model classes.
+ * @example
+ * class CounterModel implements Handler<Routes.Counter.get> {
+ *   handle(input: Routes.Counter.get.Input): Routes.Counter.get.Output {
+ *     return { count: 0 };
+ *   }
+ * }
  */
-import { UnifiedApiClientBase } from "@donkeylabs/adapter-sveltekit/client";
+export interface Handler<T extends { Input: any; Output: any }> {
+  handle(input: T["Input"]): T["Output"] | Promise<T["Output"]>;
+}
 
-// Route type definitions
-export interface CounterResponse {
+// Re-export server context for model classes
+export { type ServerContext as AppContext } from "@donkeylabs/server";
+
+// ============================================
+// Route Types
+// ============================================
+
+export namespace Routes {
+  export namespace Counter {
+    export namespace get {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
   count: number;
-}
+}>;
+    }
 
-export interface CacheGetResponse {
+    export namespace increment {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
+  count: number;
+}>;
+    }
+
+    export namespace decrement {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
+  count: number;
+}>;
+    }
+
+    export namespace reset {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
+  count: number;
+}>;
+    }
+  }
+
+  export namespace Cache {
+    export namespace set {
+      export type Input = Expand<{
+  key: string;
   value: any;
+  ttl?: number;
+}>;
+      export type Output = Expand<{
+  success: boolean;
+}>;
+    }
+
+    export namespace get {
+      export type Input = Expand<{
+  key: string;
+}>;
+      export type Output = Expand<{
+  value?: any;
   exists: boolean;
-}
-
-export interface CacheKeysResponse {
+}>;
+    }
+
+    export namespace delete {
+      export type Input = Expand<{
+  key: string;
+}>;
+      export type Output = Expand<{
+  success: boolean;
+}>;
+    }
+
+    export namespace keys {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
   keys: string[];
-  size: number;
-}
+}>;
+    }
+  }
 
-export interface JobEnqueueResponse {
+  export namespace Jobs {
+    export namespace enqueue {
+      export type Input = Expand<{
+  name: string;
+  data: any;
+  delay?: number;
+}>;
+      export type Output = Expand<{
   jobId: string;
-}
+}>;
+    }
 
-export interface JobStatsResponse {
+    export namespace stats {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
   pending: number;
   running: number;
   completed: number;
-}
-
-export interface CronTask {
+}>;
+    }
+  }
+
+  export namespace Cron {
+    export namespace list {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
+  tasks: {
   id: string;
   name: string;
   expression: string;
   enabled: boolean;
   lastRun?: string;
   nextRun?: string;
-}
-
-export interface CronListResponse {
-  tasks: CronTask[];
-}
-
-export interface RateLimitResult {
+}[];
+}>;
+    }
+  }
+
+  export namespace Ratelimit {
+    export namespace check {
+      export type Input = Expand<{
+  key: string;
+  limit: number;
+  window: number;
+}>;
+      export type Output = Expand<{
   allowed: boolean;
   remaining: number;
-  limit: number;
-  resetAt: string;
-  retryAfter?: number;
-}
-
-export interface SSEClientsResponse {
+  resetAt: Date;
+}>;
+    }
+
+    export namespace reset {
+      export type Input = Expand<{
+  key: string;
+}>;
+      export type Output = Expand<{
+  success: boolean;
+}>;
+    }
+  }
+
+  export namespace Events {
+    export namespace emit {
+      export type Input = Expand<{
+  event: string;
+  data: any;
+}>;
+      export type Output = Expand<{
+  success: boolean;
+}>;
+    }
+  }
+
+  export namespace Sse {
+    export namespace broadcast {
+      export type Input = Expand<{
+  channel: string;
+  event: string;
+  data: any;
+}>;
+      export type Output = Expand<{
+  success: boolean;
+  recipients: number;
+}>;
+    }
+
+    export namespace clients {
+      export type Input = Expand<Record<string, never>>;
+      export type Output = Expand<{
   total: number;
   byChannel: number;
+}>;
+    }
+  }
 }
 
-/**
- * Typed API client for the demo server
- */
+// ============================================
+// API Client
+// ============================================
+
 export class ApiClient extends UnifiedApiClientBase {
-  // Counter routes
+  constructor(options?: ClientOptions) {
+    super(options);
+  }
+
   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", {}),
+    get: (input: Routes.Counter.get.Input): Promise<Routes.Counter.get.Output> => this.request("api.counter.get", input),
+    increment: (input: Routes.Counter.increment.Input): Promise<Routes.Counter.increment.Output> => this.request("api.counter.increment", input),
+    decrement: (input: Routes.Counter.decrement.Input): Promise<Routes.Counter.decrement.Output> => this.request("api.counter.decrement", input),
+    reset: (input: Routes.Counter.reset.Input): Promise<Routes.Counter.reset.Output> => this.request("api.counter.reset", input)
   };
 
-  // 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", {}),
+    set: (input: Routes.Cache.set.Input): Promise<Routes.Cache.set.Output> => this.request("api.cache.set", input),
+    get: (input: Routes.Cache.get.Input): Promise<Routes.Cache.get.Output> => this.request("api.cache.get", input),
+    delete: (input: Routes.Cache.delete.Input): Promise<Routes.Cache.delete.Output> => this.request("api.cache.delete", input),
+    keys: (input: Routes.Cache.keys.Input): Promise<Routes.Cache.keys.Output> => this.request("api.cache.keys", input)
   };
 
-  // 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", {}),
+    enqueue: (input: Routes.Jobs.enqueue.Input): Promise<Routes.Jobs.enqueue.Output> => this.request("api.jobs.enqueue", input),
+    stats: (input: Routes.Jobs.stats.Input): Promise<Routes.Jobs.stats.Output> => this.request("api.jobs.stats", input)
   };
 
-  // Cron routes
   cron = {
-    list: () =>
-      this.request<{}, CronListResponse>("api.cron.list", {}),
+    list: (input: Routes.Cron.list.Input): Promise<Routes.Cron.list.Output> => this.request("api.cron.list", input)
   };
 
-  // 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),
+    check: (input: Routes.Ratelimit.check.Input): Promise<Routes.Ratelimit.check.Output> => this.request("api.ratelimit.check", input),
+    reset: (input: Routes.Ratelimit.reset.Input): Promise<Routes.Ratelimit.reset.Output> => this.request("api.ratelimit.reset", input)
   };
 
-  // Events routes
   events = {
-    emit: (input: { event?: string; data?: any }) =>
-      this.request<typeof input, { success: boolean }>("api.events.emit", input),
+    emit: (input: Routes.Events.emit.Input): Promise<Routes.Events.emit.Output> => this.request("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", {}),
+  sse = {
+    broadcast: (input: Routes.Sse.broadcast.Input): Promise<Routes.Sse.broadcast.Output> => this.request("api.sse.broadcast", input),
+    clients: (input: Routes.Sse.clients.Input): Promise<Routes.Sse.clients.Output> => 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();
- *
- * @example
- * // In +page.svelte (browser - HTTP calls)
- * const api = createApi();
- * const data = await api.counter.get();
  */
-export function createApi(options?: { locals?: any }) {
+export function createApi(options?: ClientOptions) {
   return new ApiClient(options);
 }

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

@@ -4,13 +4,13 @@ import { createApi } from '$lib/api';
 
 export const load: PageServerLoad = async ({ locals }) => {
   // Create API client with locals for direct SSR calls (no HTTP!)
-  const api = createApi({ locals });
+  const client = createApi({ locals });
 
   try {
     // Direct service call through typed client
-    const { count } = await api.counter.get();
+    const result = await client.counter.get({});
     return {
-      count,
+      count: result.count,
       loadedAt: new Date().toISOString(),
       isSSR: true,
     };