@donkeylabs/server 2.0.31 → 2.0.33

package/docs/workflows.md

@@ -97,9 +97,12 @@ Limit concurrent instances per workflow name:
 const server = new AppServer({
   db,
   workflows: {
-    concurrentWorkflows: 1, // 0 = unlimited
+    concurrentWorkflows: 1, // default for all workflows (0 = unlimited)
   },
 });
+
+// Per-register override
+ctx.core.workflows.register(orderWorkflow, { maxConcurrent: 1 });
 ```
 
 ### 3. Track Progress

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/server",
-  "version": "2.0.31",
+  "version": "2.0.33",
   "type": "module",
   "description": "Type-safe plugin system for building RPC-style APIs with Bun",
   "main": "./src/index.ts",

package/src/core/workflows.ts

@@ -766,7 +766,7 @@ export interface WorkflowsConfig {
   sqlitePragmas?: SqlitePragmaConfig;
   /** Disable in-process watchdog timers (use external watchdog instead) */
   useWatchdog?: boolean;
-  /** Max concurrent instances per workflow name (0 = unlimited, default: 0) */
+  /** Default max concurrent instances per workflow name (0 = unlimited, default: 0) */
   concurrentWorkflows?: number;
   /** Resume strategy for orphaned workflows (default: "blocking") */
   resumeStrategy?: WorkflowResumeStrategy;
@@ -796,6 +796,8 @@ export interface WorkflowRegisterOptions {
    * workflows.register(myWorkflow, { modulePath: import.meta.url });
    */
   modulePath?: string;
+  /** Max concurrent instances for this workflow (overrides defaults) */
+  maxConcurrent?: number;
 }
 
 export interface Workflows {
@@ -874,6 +876,7 @@ class WorkflowsImpl implements Workflows {
   private sqlitePragmas?: SqlitePragmaConfig;
   private useWatchdog: boolean;
   private concurrentWorkflows: number;
+  private workflowConcurrencyOverrides = new Map<string, number>();
   private resumeStrategy!: WorkflowResumeStrategy;
   private workflowModulePaths = new Map<string, string>();
   private isolatedProcesses = new Map<string, IsolatedProcessInfo>();
@@ -1002,6 +1005,10 @@ class WorkflowsImpl implements Workflows {
     }
 
     this.definitions.set(definition.name, definition);
+
+    if (options?.maxConcurrent !== undefined) {
+      this.workflowConcurrencyOverrides.set(definition.name, options.maxConcurrent);
+    }
   }
 
   async start<T = any>(workflowName: string, input: T): Promise<string> {
@@ -1010,12 +1017,13 @@ class WorkflowsImpl implements Workflows {
       throw new Error(`Workflow "${workflowName}" is not registered`);
     }
 
-    if (this.concurrentWorkflows > 0) {
+    const limit = this.getConcurrencyLimit(workflowName);
+    if (limit > 0) {
       const running = await this.adapter.getInstancesByWorkflow(workflowName, "running");
       const pending = await this.adapter.getInstancesByWorkflow(workflowName, "pending");
-      if (running.length + pending.length >= this.concurrentWorkflows) {
+      if (running.length + pending.length >= limit) {
         throw new Error(
-          `Workflow "${workflowName}" has reached its concurrency limit (${this.concurrentWorkflows})`
+          `Workflow "${workflowName}" has reached its concurrency limit (${limit})`
         );
       }
     }
@@ -2005,6 +2013,13 @@ class WorkflowsImpl implements Workflows {
     await this.adapter.updateInstance(instanceId, { metadata });
   }
 
+  private getConcurrencyLimit(workflowName: string): number {
+    if (this.workflowConcurrencyOverrides.has(workflowName)) {
+      return this.workflowConcurrencyOverrides.get(workflowName) ?? 0;
+    }
+    return this.concurrentWorkflows;
+  }
+
   private async markOrphanedAsFailed(
     instances: WorkflowInstance[],
     reason: string