@donkeylabs/cli 0.1.0 → 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);
 
@@ -206,17 +407,21 @@ export async function generateCommand(_args: string[]): Promise<void> {
   // Check if adapter provides a custom generator
   if (config.adapter) {
     try {
-      // Dynamically import adapter's generator
-      const adapterModule = await import(`${config.adapter}/generator`);
-      if (adapterModule.generateClient) {
-        await adapterModule.generateClient(config, serverRoutes, clientOutput);
-        generated.push(`client (${config.adapter})`);
-        console.log(pc.green("Generated:"), generated.map(g => pc.dim(g)).join(", "));
-        return;
+      // Resolve the adapter path from the project's node_modules
+      const adapterPath = join(process.cwd(), "node_modules", config.adapter, "src/generator/index.ts");
+      if (existsSync(adapterPath)) {
+        const adapterModule = await import(adapterPath);
+        if (adapterModule.generateClient) {
+          await adapterModule.generateClient(config, serverRoutes, clientOutput);
+          generated.push(`client (${config.adapter})`);
+          console.log(pc.green("Generated:"), generated.map(g => pc.dim(g)).join(", "));
+          return;
+        }
       }
-    } catch (e) {
+    } catch (e: any) {
       // Adapter doesn't provide generator or import failed, fall back to default
       console.log(pc.dim(`Note: Adapter ${config.adapter} has no custom generator, using default`));
+      console.log(pc.dim(`Error: ${e.message}`));
     }
   }
 
@@ -232,10 +437,14 @@ async function generateRegistry(
   outPath: string
 ) {
   const importLines = plugins
-    .map(
-      (p) =>
-        `import { ${p.exportName} } from "${join(process.cwd(), p.path).replace(/\.ts$/, "")}";`
-    )
+    .map((p) => {
+      // Calculate relative path from outPath to plugin
+      const pluginAbsPath = join(process.cwd(), p.path).replace(/\.ts$/, "");
+      const relativePath = relative(outPath, pluginAbsPath);
+      // Ensure path starts with ./ or ../
+      const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+      return `import { ${p.exportName} } from "${importPath}";`;
+    })
     .join("\n");
 
   const pluginRegistryEntries = plugins
@@ -383,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)) {
@@ -430,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/package.json

@@ -9,13 +9,13 @@
     "gen:types": "donkeylabs generate"
   },
   "dependencies": {
-    "@donkeylabs/server": "*",
+    "@donkeylabs/server": "latest",
     "kysely": "^0.27.0",
     "kysely-bun-sqlite": "^0.3.0",
     "zod": "^3.24.0"
   },
   "devDependencies": {
-    "@donkeylabs/cli": "*",
+    "@donkeylabs/cli": "latest",
     "@types/bun": "latest"
   }
-}
+}

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,
+  });