@donkeylabs/cli 2.1.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "2.1.0",
+  "version": "2.3.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,27 @@ 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[];
+  coreEvents?: Record<string, string>;
+}
+
 /**
  * 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 +78,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 +96,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 +117,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, coreEvents: result.coreEvents });
       } 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 generateEventTypes(serverEvents, outPath, serverOutput.coreEvents);
+  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");
@@ -1362,9 +1373,17 @@ function parseZodObjectFields(objectContent: string): string {
 
 /**
  * Generate events.ts with namespace-nested types and EventMap.
+ * Includes both core framework events and user-defined events.
  */
-async function generateEventTypes(events: EventDefinitionInfo[], outPath: string): Promise<void> {
-  if (events.length === 0) {
+async function generateEventTypes(
+  events: EventDefinitionInfo[],
+  outPath: string,
+  coreEvents?: Record<string, string>
+): Promise<void> {
+  const hasCoreEvents = coreEvents && Object.keys(coreEvents).length > 0;
+  const hasUserEvents = events.length > 0;
+
+  if (!hasCoreEvents && !hasUserEvents) {
     // Still generate an empty file for consistency
     const content = `// Auto-generated by donkeylabs generate
 // Events - import as: import { type EventMap, type EventName } from ".@donkeylabs/server/events";
@@ -1387,10 +1406,32 @@ declare module "@donkeylabs/server" {
     return;
   }
 
-  // Group events by namespace (first part of event name)
+  // Group ALL events by namespace (first part of event name)
   // e.g., "order.created" -> namespace "Order", event "Created"
-  const byNamespace = new Map<string, { eventName: string; pascalName: string; schemaSource: string; fullName: string }[]>();
+  // e.g., "workflow.step.started" -> namespace "Workflow", event "StepStarted"
+  const byNamespace = new Map<string, { eventName: string; pascalName: string; tsType: string; fullName: string; isCore: boolean }[]>();
+
+  // Add core events first (using pre-computed TS type strings)
+  if (hasCoreEvents) {
+    for (const [eventFullName, tsTypeString] of Object.entries(coreEvents!)) {
+      const parts = eventFullName.split(".");
+      const namespace = toPascalCase(parts[0] || "App");
+      const eventName = parts.slice(1).map(p => toPascalCase(p)).join("") || toPascalCase(parts[0] || "Event");
+
+      if (!byNamespace.has(namespace)) {
+        byNamespace.set(namespace, []);
+      }
+      byNamespace.get(namespace)!.push({
+        eventName,
+        pascalName: eventName,
+        tsType: tsTypeString,
+        fullName: eventFullName,
+        isCore: true,
+      });
+    }
+  }
 
+  // Add user-defined events (from Zod schemas)
   for (const event of events) {
     const parts = event.name.split(".");
     const namespace = toPascalCase(parts[0] || "App");
@@ -1402,25 +1443,41 @@ declare module "@donkeylabs/server" {
     byNamespace.get(namespace)!.push({
       eventName,
       pascalName: eventName,
-      schemaSource: event.schemaSource,
+      tsType: zodSchemaToTypeScript(event.schemaSource),
       fullName: event.name,
+      isCore: false,
     });
   }
 
   // Generate namespace blocks
   const namespaceBlocks: string[] = [];
+  const coreNamespaceBlocks: string[] = [];
+  const userNamespaceBlocks: string[] = [];
   const eventMapEntries: string[] = [];
   const eventRegistryEntries: string[] = [];
   const eventNames: string[] = [];
 
+  // Track which namespaces are core-only, user-only, or mixed
   for (const [namespace, nsEvents] of byNamespace) {
+    const hasCoreInNs = nsEvents.some(e => e.isCore);
+    const hasUserInNs = nsEvents.some(e => !e.isCore);
+
     const eventTypeDecls = nsEvents.map(e => {
-      const tsType = zodSchemaToTypeScript(e.schemaSource);
       return `  /** Event data for "${e.fullName}" */
-  export type ${e.pascalName} = ${tsType};`;
+  export type ${e.pascalName} = ${e.tsType};`;
     }).join("\n\n");
 
-    namespaceBlocks.push(`export namespace ${namespace} {\n${eventTypeDecls}\n}`);
+    const block = `export namespace ${namespace} {\n${eventTypeDecls}\n}`;
+
+    if (hasCoreInNs && !hasUserInNs) {
+      coreNamespaceBlocks.push(block);
+    } else if (!hasCoreInNs && hasUserInNs) {
+      userNamespaceBlocks.push(block);
+    } else {
+      // Mixed - put in core section
+      coreNamespaceBlocks.push(block);
+    }
+    namespaceBlocks.push(block);
 
     // Add to EventMap and EventRegistry
     for (const e of nsEvents) {
@@ -1430,11 +1487,20 @@ declare module "@donkeylabs/server" {
     }
   }
 
+  // Build the output with clear sections
+  const sections: string[] = [];
+
+  if (coreNamespaceBlocks.length > 0) {
+    sections.push(`// Core framework events\n${coreNamespaceBlocks.join("\n\n")}`);
+  }
+  if (userNamespaceBlocks.length > 0) {
+    sections.push(`// User-defined events\n${userNamespaceBlocks.join("\n\n")}`);
+  }
+
   const content = `// Auto-generated by donkeylabs generate
 // Events - import as: import { type EventMap, type EventName, Order, User } from ".@donkeylabs/server/events";
 
-// Event type namespaces - use as Order.Created, User.Signup, etc.
-${namespaceBlocks.join("\n\n")}
+${sections.join("\n\n")}
 
 /** Map of all event names to their data types */
 export interface EventMap {
@@ -1454,3 +1520,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);
+}