@donkeylabs/cli 2.1.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",

package/src/commands/generate-client.ts

@@ -18,7 +18,8 @@ export async function generateClientCommand(
   // Extract routes from server
   const entryPath = config.entry || "./src/index.ts";
   console.log(pc.dim(`Extracting routes from ${entryPath}...`));
-  const routes = await extractRoutesFromServer(entryPath);
+  const serverOutput = await extractRoutesFromServer(entryPath);
+  const routes = serverOutput.routes;
 
   if (routes.length === 0) {
     console.warn(pc.yellow("No routes found - generating empty client"));

package/src/commands/generate-utils.ts

@@ -36,15 +36,26 @@ export interface RouteInfo {
   eventsSource?: Record<string, string>;
 }
 
+export interface ProcessInfo {
+  name: string;
+  events?: Record<string, string>;
+  commands?: Record<string, string>;
+}
+
+export interface ServerOutput {
+  routes: RouteInfo[];
+  processes: ProcessInfo[];
+}
+
 /**
  * Run the server entry file with DONKEYLABS_GENERATE=1 to get typed route metadata
  */
-export async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]> {
+export async function extractRoutesFromServer(entryPath: string): Promise<ServerOutput> {
   const fullPath = join(process.cwd(), entryPath);
 
   if (!existsSync(fullPath)) {
     console.warn(pc.yellow(`Entry file not found: ${entryPath}`));
-    return [];
+    return { routes: [], processes: [] };
   }
 
   const TIMEOUT_MS = 10000; // 10 second timeout
@@ -66,7 +77,7 @@ export async function extractRoutesFromServer(entryPath: string): Promise<RouteI
       child.kill("SIGTERM");
       console.warn(pc.yellow(`Route extraction timed out after ${TIMEOUT_MS / 1000}s`));
       console.warn(pc.dim("Make sure routes are registered with server.use() before any blocking operations"));
-      resolve([]);
+      resolve({ routes: [], processes: [] });
     }, TIMEOUT_MS);
 
     child.stdout?.on("data", (data) => {
@@ -84,7 +95,7 @@ export async function extractRoutesFromServer(entryPath: string): Promise<RouteI
       if (code !== 0) {
         console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
         if (stderr) console.warn(pc.dim(stderr));
-        resolve([]);
+        resolve({ routes: [], processes: [] });
         return;
       }
 
@@ -105,17 +116,25 @@ export async function extractRoutesFromServer(entryPath: string): Promise<RouteI
             eventsSource: r.eventsType,
           };
         });
-        resolve(routes);
+
+        // Parse process definitions
+        const processes: ProcessInfo[] = (result.processes || []).map((p: any) => ({
+          name: p.name,
+          events: p.events,
+          commands: p.commands,
+        }));
+
+        resolve({ routes, processes });
       } catch (e) {
         console.warn(pc.yellow("Failed to parse route data from server"));
-        resolve([]);
+        resolve({ routes: [], processes: [] });
       }
     });
 
     child.on("error", (err) => {
       clearTimeout(timeout);
       console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
-      resolve([]);
+      resolve({ routes: [], processes: [] });
     });
   });
 }

package/src/commands/generate.ts

@@ -7,7 +7,7 @@ import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Database } from "bun:sqlite";
 import { generate, KyselyBunSqliteDialect } from "kysely-codegen";
 import * as ts from "typescript";
-import { loadConfig, extractRoutesFromServer, type DonkeylabsConfig, type RouteInfo } from "./generate-utils";
+import { loadConfig, extractRoutesFromServer, type DonkeylabsConfig, type RouteInfo, type ProcessInfo } from "./generate-utils";
 
 async function getPluginExportName(pluginPath: string): Promise<string | null> {
   try {
@@ -918,9 +918,11 @@ export async function generateCommand(_args: string[]): Promise<void> {
     );
   }
 
-  // Extract routes by running the server with DONKEYLABS_GENERATE=1
+  // Extract routes and processes by running the server with DONKEYLABS_GENERATE=1
   const entryPath = config.entry || "./src/index.ts";
-  const serverRoutes = await extractRoutesFromServer(entryPath);
+  const serverOutput = await extractRoutesFromServer(entryPath);
+  const serverRoutes = serverOutput.routes;
+  const serverProcesses = serverOutput.processes;
 
   // Find custom service definitions
   const services = await findServiceDefinitions(entryPath);
@@ -940,13 +942,22 @@ export async function generateCommand(_args: string[]): Promise<void> {
     );
   }
 
+  // Log process definitions found
+  if (serverProcesses.length > 0) {
+    console.log(
+      pc.green("Found processes:"),
+      serverProcesses.map((p) => pc.dim(p.name)).join(", ")
+    );
+  }
+
   // Generate all files
   await generateRegistry(plugins, outPath);
   await generateContext(plugins, services, outPath);
   await generateRouteTypes(fileRoutes, outPath);
   await generateEventTypes(serverEvents, outPath);
+  await generateProcessTypes(serverProcesses, outPath);
 
-  const generated = ["registry", "context", "routes", "events"];
+  const generated = ["registry", "context", "routes", "events", "processes"];
 
   // Determine client output path
   const clientOutput = config.client?.output || join(outPath, "client.ts");
@@ -1454,3 +1465,99 @@ ${eventRegistryEntries.join("\n")}
 
   await writeFile(join(outPath, "events.ts"), content);
 }
+
+/**
+ * Generate processes.ts with typed events, commands, and ProcessRegistry augmentation.
+ */
+async function generateProcessTypes(processes: ProcessInfo[], outPath: string): Promise<void> {
+  if (processes.length === 0) {
+    const content = `// Auto-generated by donkeylabs generate
+// Processes - import as: import { type ProcessEventMap, type ProcessCommandMap } from ".@donkeylabs/server/processes";
+
+/** Map of all process event names to their data types */
+export interface ProcessEventMap {}
+
+/** Map of all process command names to their data types */
+export interface ProcessCommandMap {}
+
+// Augment ProcessRegistry for typed send() (empty when no processes defined)
+declare module "@donkeylabs/server" {
+  interface ProcessRegistry {}
+}
+`;
+    await writeFile(join(outPath, "processes.ts"), content);
+    return;
+  }
+
+  const namespaceBlocks: string[] = [];
+  const eventMapEntries: string[] = [];
+  const commandMapEntries: string[] = [];
+  const registryEntries: string[] = [];
+
+  for (const proc of processes) {
+    const pascalName = toPascalCase(proc.name);
+
+    const eventDecls: string[] = [];
+    const commandDecls: string[] = [];
+
+    // Generate event types
+    if (proc.events) {
+      for (const [eventName, tsType] of Object.entries(proc.events)) {
+        const pascalEvent = toPascalCase(eventName);
+        eventDecls.push(`    export type ${pascalEvent} = ${tsType};`);
+        eventMapEntries.push(`  "${proc.name}.${eventName}": ${pascalName}.Events.${pascalEvent};`);
+      }
+    }
+
+    // Generate command types
+    if (proc.commands) {
+      for (const [cmdName, tsType] of Object.entries(proc.commands)) {
+        const pascalCmd = toPascalCase(cmdName);
+        commandDecls.push(`    export type ${pascalCmd} = ${tsType};`);
+        commandMapEntries.push(`  "${proc.name}.${cmdName}": ${pascalName}.Commands.${pascalCmd};`);
+      }
+    }
+
+    // Build namespace
+    const eventsNs = eventDecls.length > 0
+      ? `  export namespace Events {\n${eventDecls.join("\n")}\n  }`
+      : `  export namespace Events {}`;
+    const commandsNs = commandDecls.length > 0
+      ? `  export namespace Commands {\n${commandDecls.join("\n")}\n  }`
+      : `  export namespace Commands {}`;
+
+    namespaceBlocks.push(`export namespace ${pascalName} {\n${eventsNs}\n${commandsNs}\n}`);
+
+    // Registry entry
+    registryEntries.push(`    "${proc.name}": {
+      events: ${pascalName}.Events;
+      commands: ${pascalName}.Commands;
+    };`);
+  }
+
+  const content = `// Auto-generated by donkeylabs generate
+// Processes - import as: import { type ProcessEventMap, type ProcessCommandMap } from ".@donkeylabs/server/processes";
+
+// Process type namespaces
+${namespaceBlocks.join("\n\n")}
+
+/** Map of all process event names to their data types */
+export interface ProcessEventMap {
+${eventMapEntries.join("\n")}
+}
+
+/** Map of all process command names to their data types */
+export interface ProcessCommandMap {
+${commandMapEntries.join("\n")}
+}
+
+// Augment ProcessRegistry for typed send()
+declare module "@donkeylabs/server" {
+  interface ProcessRegistry {
+${registryEntries.join("\n")}
+  }
+}
+`;
+
+  await writeFile(join(outPath, "processes.ts"), content);
+}