@donkeylabs/cli 0.1.1 → 0.4.0

package/src/commands/generate.ts

@@ -84,55 +84,164 @@ interface ExtractedRoute {
   handler: string;
 }
 
-async function extractRoutesFromServer(entryPath: string): Promise<ExtractedRoute[]> {
-  const fullPath = join(process.cwd(), entryPath);
+interface RouteInfo {
+  name: string;
+  prefix: string;
+  routeName: string;
+  handler: "typed" | "raw" | string;
+  inputSource?: string;
+  outputSource?: string;
+}
+
+/**
+ * Extract a balanced block from source code starting at a given position
+ */
+function extractBalancedBlock(source: string, startPos: number, open = "{", close = "}"): string {
+  let depth = 0;
+  let start = -1;
+  let end = -1;
+
+  for (let i = startPos; i < source.length; i++) {
+    if (source[i] === open) {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (source[i] === close) {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+
+  if (start !== -1 && end !== -1) {
+    return source.slice(start, end + 1);
+  }
+  return "";
+}
+
+/**
+ * Extract Zod schema from input/output definition
+ */
+function extractZodSchema(configBlock: string, key: "input" | "output"): string | undefined {
+  // Find where the key starts
+  const keyPattern = new RegExp(`${key}\\s*:\\s*`);
+  const match = configBlock.match(keyPattern);
+  if (!match || match.index === undefined) return undefined;
+
+  const startPos = match.index + match[0].length;
+
+  // Check if it starts with z.
+  const afterKey = configBlock.slice(startPos);
+  if (!afterKey.startsWith("z.")) return undefined;
+
+  // Find the end of the Zod expression by tracking parentheses
+  let depth = 0;
+  let endPos = 0;
+  let inParen = false;
+
+  for (let i = 0; i < afterKey.length; i++) {
+    const char = afterKey[i];
+
+    if (char === "(") {
+      depth++;
+      inParen = true;
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0 && inParen) {
+        endPos = i + 1;
+        // Check for chained methods like .optional()
+        const rest = afterKey.slice(endPos);
+        const chainMatch = rest.match(/^\s*\.\w+\(\)/);
+        if (chainMatch) {
+          endPos += chainMatch[0].length;
+        }
+        break;
+      }
+    } else if (depth === 0 && inParen) {
+      break;
+    }
+  }
+
+  if (endPos > 0) {
+    return afterKey.slice(0, endPos).trim();
+  }
+  return undefined;
+}
+
+/**
+ * Extract routes from a server/router source file by parsing the code
+ */
+async function extractRoutesFromSource(filePath: string): Promise<RouteInfo[]> {
+  const fullPath = join(process.cwd(), filePath);
 
   if (!existsSync(fullPath)) {
-    console.warn(pc.yellow(`Entry file not found: ${entryPath}, skipping route extraction`));
+    console.warn(pc.yellow(`Entry file not found: ${filePath}, skipping route extraction`));
     return [];
   }
 
-  return new Promise((resolve) => {
-    const child = spawn("bun", [fullPath], {
-      env: { ...process.env, DONKEYLABS_GENERATE: "1" },
-      stdio: ["inherit", "pipe", "pipe"],
-      cwd: process.cwd(),
-    });
+  const content = await readFile(fullPath, "utf-8");
+  const routes: RouteInfo[] = [];
 
-    let stdout = "";
-    let stderr = "";
+  // Find all createRouter calls with their positions
+  const routerPattern = /createRouter\s*\(\s*["']([^"']+)["']\s*\)/g;
+  const routerPositions: { prefix: string; pos: number }[] = [];
 
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
+  let routerMatch;
+  while ((routerMatch = routerPattern.exec(content)) !== null) {
+    routerPositions.push({
+      prefix: routerMatch[1] || "",
+      pos: routerMatch.index,
     });
+  }
 
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
+  // Sort by position
+  routerPositions.sort((a, b) => a.pos - b.pos);
 
-    child.on("close", (code) => {
-      if (code !== 0) {
-        console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
-        if (stderr) console.warn(pc.dim(stderr));
-        resolve([]);
-        return;
-      }
+  // Find all route definitions with their positions
+  const routePattern = /\.route\s*\(\s*["']([^"']+)["']\s*\)\s*\.(typed|raw|[\w]+)\s*\(/g;
 
-      try {
-        // Parse the JSON output from server
-        const result = JSON.parse(stdout.trim());
-        resolve(result.routes || []);
-      } catch (e) {
-        console.warn(pc.yellow("Failed to parse route data from server"));
-        resolve([]);
+  let routeMatch;
+  while ((routeMatch = routePattern.exec(content)) !== null) {
+    const routeName = routeMatch[1] || "";
+    const handler = routeMatch[2] || "typed";
+    const routePos = routeMatch.index;
+
+    // Find which router this route belongs to (most recent one before this position)
+    let currentPrefix = "";
+    for (const router of routerPositions) {
+      if (router.pos < routePos) {
+        currentPrefix = router.prefix;
+      } else {
+        break;
       }
-    });
+    }
 
-    child.on("error", (err) => {
-      console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
-      resolve([]);
+    // Extract the config block
+    const configStartPos = routeMatch.index + routeMatch[0].length - 1; // Position of the (
+    const configBlock = extractBalancedBlock(content, configStartPos, "(", ")");
+
+    // Remove outer parens and the inner braces wrapper
+    let innerConfig = configBlock.slice(1, -1).trim(); // Remove ( and )
+    if (innerConfig.startsWith("{") && innerConfig.endsWith("}")) {
+      innerConfig = innerConfig.slice(1, -1); // Remove { and }
+    }
+
+    // Extract input and output schemas
+    const inputSource = extractZodSchema(innerConfig, "input");
+    const outputSource = extractZodSchema(innerConfig, "output");
+
+    routes.push({
+      name: currentPrefix ? `${currentPrefix}.${routeName}` : routeName,
+      prefix: currentPrefix,
+      routeName,
+      handler,
+      inputSource,
+      outputSource,
     });
-  });
+  }
+
+  return routes;
 }
 
 
@@ -179,6 +288,98 @@ async function findPlugins(
   return plugins;
 }
 
+async function findRouteFiles(pattern: string): Promise<string[]> {
+  const files: string[] = [];
+  const baseDir = pattern.includes("**")
+    ? pattern.split("**")[0] || "."
+    : dirname(pattern);
+  const fileName = basename(pattern.replace("**/", ""));
+
+  const targetDir = join(process.cwd(), baseDir);
+  if (!existsSync(targetDir)) return files;
+
+  async function scanDir(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scanDir(fullPath);
+      } else if (entry.name === fileName) {
+        files.push(relative(process.cwd(), fullPath));
+      }
+    }
+  }
+
+  await scanDir(targetDir);
+  return files;
+}
+
+/**
+ * Run the server entry file with DONKEYLABS_GENERATE=1 to get typed route metadata
+ */
+async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]> {
+  const fullPath = join(process.cwd(), entryPath);
+
+  if (!existsSync(fullPath)) {
+    console.warn(pc.yellow(`Entry file not found: ${entryPath}`));
+    return [];
+  }
+
+  return new Promise((resolve) => {
+    const child = spawn("bun", [fullPath], {
+      env: { ...process.env, DONKEYLABS_GENERATE: "1" },
+      stdio: ["inherit", "pipe", "pipe"],
+      cwd: process.cwd(),
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
+        if (stderr) console.warn(pc.dim(stderr));
+        resolve([]);
+        return;
+      }
+
+      try {
+        const result = JSON.parse(stdout.trim());
+        // Convert server output to RouteInfo format
+        const routes: RouteInfo[] = (result.routes || []).map((r: any) => {
+          const parts = r.name.split(".");
+          return {
+            name: r.name,
+            prefix: parts.slice(0, -1).join("."),
+            routeName: parts[parts.length - 1] || r.name,
+            handler: r.handler || "typed",
+            // Server outputs TypeScript strings directly now
+            inputSource: r.inputType,
+            outputSource: r.outputType,
+          };
+        });
+        resolve(routes);
+      } catch (e) {
+        console.warn(pc.yellow("Failed to parse route data from server"));
+        resolve([]);
+      }
+    });
+
+    child.on("error", (err) => {
+      console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
+      resolve([]);
+    });
+  });
+}
+
 export async function generateCommand(_args: string[]): Promise<void> {
   const config = await loadConfig();
   const outDir = config.outDir || ".@donkeylabs/server";
@@ -189,7 +390,7 @@ export async function generateCommand(_args: string[]): Promise<void> {
   const plugins = await findPlugins(config.plugins);
   const fileRoutes = await findRoutes(config.routes || "./src/routes/**/schema.ts");
 
-  // Extract routes from server entry file
+  // Extract routes by running the server with DONKEYLABS_GENERATE=1
   const entryPath = config.entry || "./src/index.ts";
   const serverRoutes = await extractRoutesFromServer(entryPath);
 
@@ -391,14 +592,14 @@ export type GlobalContext = AppContext;
 }
 
 // Route file structure: /src/routes/<namespace>/<route-name>/schema.ts
-interface RouteInfo {
+interface SchemaRouteInfo {
   namespace: string;
   name: string;
   schemaPath: string;
 }
 
-async function findRoutes(_pattern: string): Promise<RouteInfo[]> {
-  const routes: RouteInfo[] = [];
+async function findRoutes(_pattern: string): Promise<SchemaRouteInfo[]> {
+  const routes: SchemaRouteInfo[] = [];
   const routesDir = join(process.cwd(), "src/routes");
 
   if (!existsSync(routesDir)) {
@@ -438,9 +639,9 @@ function toPascalCase(str: string): string {
     .replace(/^./, (c) => c.toUpperCase());
 }
 
-async function generateRouteTypes(routes: RouteInfo[], outPath: string): Promise<void> {
+async function generateRouteTypes(routes: SchemaRouteInfo[], outPath: string): Promise<void> {
   // Group routes by namespace
-  const byNamespace = new Map<string, RouteInfo[]>();
+  const byNamespace = new Map<string, SchemaRouteInfo[]>();
   for (const route of routes) {
     if (!byNamespace.has(route.namespace)) {
       byNamespace.set(route.namespace, []);

package/templates/starter/src/index.ts

@@ -1,48 +1,37 @@
 import { db } from "./db";
-import { AppServer } from "@donkeylabs/server";
+import { AppServer, createRouter } from "@donkeylabs/server";
 import { healthRouter } from "./routes/health";
 import { statsPlugin } from "./plugins/stats";
-import { z } from "zod";
 
 const server = new AppServer({
   port: Number(process.env.PORT) || 3000,
   db,
   config: { env: process.env.NODE_ENV || "development" },
+  generateTypes: {
+    output: "./.@donkeylabs/server/api.ts",
+    baseImport: 'import { ApiClientBase, type ApiClientOptions } from "@donkeylabs/server/client";',
+    baseClass: "ApiClientBase",
+    constructorSignature: "baseUrl: string, options?: ApiClientOptions",
+    constructorBody: "super(baseUrl, options);",
+    factoryFunction: `/**
+ * Create an API client instance
+ * @param baseUrl - The base URL of the API server
+ */
+export function createApi(baseUrl: string, options?: ApiClientOptions) {
+  return new ApiClient(baseUrl, options);
+}`,
+  },
 });
 
 // Register plugins
 server.registerPlugin(statsPlugin);
 
-// Register routes with middleware applied at router level
+const api = createRouter("api")
+// Register routes
+api.router(healthRouter);
 
-const api = server.router("api")
-.middleware
-.timing()
 
-const hello = api.router("hello")
-hello.route("test").typed({
-  input: z.string(),
-  output: z.string(),
-  handle: (input, ctx) => {
-    // ctx.plugins.stats should now be typed correctly
-    const stats = ctx.plugins.stats;
-    return input;
-  }
-}).route("ping").typed({
-  input: z.string(),
-  output: z.string(),
-  handle: (input, ctx) => {
-    return input;
-  }
-})
-.route("pong").typed({
-  input: z.string(),
-  output: z.string(),
-  handle: (input, ctx) => {
-    return input;
-  }
-})
 
-api.router(healthRouter)
 
+server.use(api);
 await server.start();

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

@@ -0,0 +1,22 @@
+
+// Types from generated api.ts (run server once to generate)
+import type { Handler, Routes, AppContext } from "$server/api";
+
+/**
+ * Ping Handler
+ */
+export class PingHandler implements Handler<Routes.Api.Health.Ping> {
+  ctx: AppContext;
+
+  constructor(ctx: AppContext) {
+    this.ctx = ctx;
+  }
+
+  handle(input: Routes.Api.Health.Ping.Input): Routes.Api.Health.Ping.Output {
+    return {
+      status: "ok",
+      timestamp: new Date().toISOString(),
+      echo: input.echo,
+    };
+  }
+}

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

@@ -1,5 +1,19 @@
+
 import { createRouter } from "@donkeylabs/server";
-import { pingRoute } from "./ping";
+import { z } from "zod";
+import { PingHandler } from "./handlers/ping";
 
 export const healthRouter = createRouter("health")
-  .route("ping").typed(pingRoute);
+  .route("ping").typed({
+    input: z.object({
+      name: z.string(),
+      cool: z.number(),
+      echo: z.string().optional(),
+    }),
+    output: z.object({
+      status: z.literal("ok"),
+      timestamp: z.string(),
+      echo: z.string().optional(),
+    }),
+    handle: PingHandler,
+  });

package/templates/sveltekit-app/bun.lock

@@ -4,8 +4,8 @@
     "": {
       "name": "my-sveltekit-app",
       "dependencies": {
-        "@donkeylabs/adapter-sveltekit": "0.1.1",
-        "@donkeylabs/cli": "0.1.0",
+        "@donkeylabs/adapter-sveltekit": "0.1.2",
+        "@donkeylabs/cli": "0.1.1",
         "@donkeylabs/server": "0.3.1",
         "bits-ui": "^2.15.4",
         "clsx": "^2.1.1",
@@ -28,9 +28,9 @@
     },
   },
   "packages": {
-    "@donkeylabs/adapter-sveltekit": ["@donkeylabs/adapter-sveltekit@0.1.1", "", { "peerDependencies": { "@donkeylabs/server": "*", "@sveltejs/kit": "^2.0.0" } }, "sha512-CokdEH6+vBoNvM1HYXp1/kd8WYEokEY/MrAToGE+QlcQ+gd5x74X+Yu792WX+C+ntM4oVFqMQToHxr6m46/n1w=="],
+    "@donkeylabs/adapter-sveltekit": ["@donkeylabs/adapter-sveltekit@0.1.2", "", { "peerDependencies": { "@donkeylabs/server": "*", "@sveltejs/kit": "^2.0.0" } }, "sha512-VvjRQ8XZQw6T+DYLjq5Sjz+u1k8LqkcZOTVZuB4SfC6TdGxGD7CkU/7NQ7gwlk/2pDNP7tqwMD3yGfP86A6j4Q=="],
 
-    "@donkeylabs/cli": ["@donkeylabs/cli@0.1.0", "", { "dependencies": { "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "@donkeylabs/server": "*" }, "bin": { "donkeylabs": "src/index.ts" } }, "sha512-aIvXr/wLGET/+JvLny7m4Jid1NYQWX9Js2z3KmQRGq6T4JPddpzZ3lmz9SalqqWMowkVODZNWew4y5QSBbe9CA=="],
+    "@donkeylabs/cli": ["@donkeylabs/cli@0.1.1", "", { "dependencies": { "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "@donkeylabs/server": "*" }, "bin": { "donkeylabs": "src/index.ts" } }, "sha512-lMGXz/KGCoN15siUf05Sl3NxoR5Qn0h44gXqRocHr51SLV8R/o2On2ELF4iHdTNV9hPJp3sjhNmcO3mMzQex2A=="],
 
     "@donkeylabs/server": ["@donkeylabs/server@0.3.1", "", { "dependencies": { "@modelcontextprotocol/sdk": "^1.25.2", "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "kysely": "^0.27.0 || ^0.28.0", "typescript": "^5", "zod": "^3.20.0" }, "bin": { "donkeylabs-mcp": "mcp/server.ts" } }, "sha512-rpYKD7dKNwpcw51aO/pL1Zh1r6FlAqp0UIUJ+9nV1Cm/4hKq6WQHM/AtmPhM25ZRvnSbriB4X8o28UVJR8dN2w=="],
 

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

@@ -4,6 +4,7 @@ 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

@@ -8,8 +8,8 @@
     "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",
+    "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"
   },
@@ -26,7 +26,7 @@
   "dependencies": {
     "@donkeylabs/cli": "0.1.1",
     "@donkeylabs/adapter-sveltekit": "0.1.2",
-    "@donkeylabs/server": "0.3.1",
+    "@donkeylabs/server": "0.3.2",
     "bits-ui": "^2.15.4",
     "clsx": "^2.1.1",
     "kysely": "^0.27.6",