@donkeylabs/server 2.0.32 → 2.0.34

package/docs/workflows.md

@@ -98,14 +98,10 @@ const server = new AppServer({
   db,
   workflows: {
     concurrentWorkflows: 1, // default for all workflows (0 = unlimited)
-    concurrentWorkflowsByName: {
-      testWorkflow: 1,
-      ingestionWorkflow: 1,
-    },
   },
 });
 
-// Or per-register override
+// Per-register override
 ctx.core.workflows.register(orderWorkflow, { maxConcurrent: 1 });
 ```
 
@@ -338,6 +334,10 @@ You can tune subprocess termination and SQLite pragmas used by isolated workflow
 ```ts
 const server = new AppServer({
   db,
+  database: {
+    type: "postgres",
+    connectionString: process.env.DATABASE_URL!,
+  },
   watchdog: {
     enabled: true,
     intervalMs: 5000,

package/package.json

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

package/src/core/index.ts

@@ -135,6 +135,7 @@ export {
   type Workflows,
   type WorkflowsConfig,
   type SqlitePragmaConfig,
+  type WorkflowDatabaseConfig,
   type WorkflowRegisterOptions,
   type WorkflowDefinition,
   type WorkflowInstance,

package/src/core/subprocess-bootstrap.ts

@@ -1,4 +1,4 @@
-import { Kysely } from "kysely";
+import { Kysely, PostgresDialect, MysqlDialect } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import Database from "bun:sqlite";
 import {
@@ -30,13 +30,17 @@ export interface SubprocessPluginMetadata {
 }
 
 export interface SubprocessBootstrapOptions {
-  dbPath: string;
+  dbPath?: string;
   coreConfig?: Record<string, any>;
   sqlitePragmas?: {
     busyTimeout?: number;
     synchronous?: "OFF" | "NORMAL" | "FULL" | "EXTRA";
     journalMode?: "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "WAL" | "OFF";
   };
+  database?: {
+    type: "sqlite" | "postgres" | "mysql";
+    connectionString: string;
+  };
   pluginMetadata: SubprocessPluginMetadata;
   startServices?: {
     cron?: boolean;
@@ -57,20 +61,7 @@ export interface SubprocessBootstrapResult {
 export async function bootstrapSubprocess(
   options: SubprocessBootstrapOptions
 ): Promise<SubprocessBootstrapResult> {
-  const sqlite = new Database(options.dbPath);
-  const pragmas = options.sqlitePragmas;
-  const busyTimeout = pragmas?.busyTimeout ?? 5000;
-  sqlite.run(`PRAGMA busy_timeout = ${busyTimeout}`);
-  if (pragmas?.journalMode) {
-    sqlite.run(`PRAGMA journal_mode = ${pragmas.journalMode}`);
-  }
-  if (pragmas?.synchronous) {
-    sqlite.run(`PRAGMA synchronous = ${pragmas.synchronous}`);
-  }
-
-  const db = new Kysely<any>({
-    dialect: new BunSqliteDialect({ database: sqlite }),
-  });
+  const db = await createSubprocessDatabase(options);
 
   const cache = createCache();
   const events = createEvents();
@@ -166,12 +157,57 @@ export async function bootstrapSubprocess(
     }
 
     await db.destroy();
-    sqlite.close();
   };
 
   return { core, manager, db, workflowAdapter, cleanup };
 }
 
+async function createSubprocessDatabase(options: SubprocessBootstrapOptions): Promise<Kysely<any>> {
+  const dbConfig = options.database;
+  if (!dbConfig || dbConfig.type === "sqlite") {
+    const sqlitePath = dbConfig?.connectionString ?? options.dbPath;
+    if (!sqlitePath) {
+      throw new Error("SQLite dbPath or connectionString is required for subprocess workflows");
+    }
+    const sqlite = new Database(sqlitePath);
+    const pragmas = options.sqlitePragmas;
+    const busyTimeout = pragmas?.busyTimeout ?? 5000;
+    sqlite.run(`PRAGMA busy_timeout = ${busyTimeout}`);
+    if (pragmas?.journalMode) {
+      sqlite.run(`PRAGMA journal_mode = ${pragmas.journalMode}`);
+    }
+    if (pragmas?.synchronous) {
+      sqlite.run(`PRAGMA synchronous = ${pragmas.synchronous}`);
+    }
+
+    return new Kysely<any>({
+      dialect: new BunSqliteDialect({ database: sqlite }),
+    });
+  }
+
+  if (dbConfig.type === "postgres") {
+    // @ts-ignore optional dependency
+    const { Pool: PGPool } = await import("pg");
+    return new Kysely<any>({
+      dialect: new PostgresDialect({
+        pool: new PGPool({ connectionString: dbConfig.connectionString }),
+      }),
+    });
+  }
+
+  if (dbConfig.type === "mysql") {
+    // @ts-ignore optional dependency
+    const { createPool: createMySQLPool } = await import("mysql2");
+    return new Kysely<any>({
+      dialect: new MysqlDialect({
+        pool: createMySQLPool(dbConfig.connectionString),
+      }),
+    });
+  }
+
+  throw new Error(`Unsupported database type: ${dbConfig.type}`);
+}
+
 async function loadConfiguredPlugins(
   metadata: SubprocessPluginMetadata
 ): Promise<ConfiguredPlugin[]> {

package/src/core/workflow-executor.ts

@@ -20,7 +20,7 @@ interface ExecutorConfig {
   socketPath?: string;
   tcpPort?: number;
   modulePath: string;
-  dbPath: string;
+  dbPath?: string;
   pluginNames: string[];
   pluginModulePaths: Record<string, string>;
   pluginConfigs: Record<string, any>;
@@ -30,6 +30,10 @@ interface ExecutorConfig {
     synchronous?: "OFF" | "NORMAL" | "FULL" | "EXTRA";
     journalMode?: "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "WAL" | "OFF";
   };
+  database?: {
+    type: "sqlite" | "postgres" | "mysql";
+    connectionString: string;
+  };
 }
 
 // ============================================
@@ -53,6 +57,7 @@ async function main(): Promise<void> {
     pluginConfigs,
     coreConfig,
     sqlitePragmas,
+    database,
   } = config;
 
   const socket = await connectToSocket(socketPath, tcpPort);
@@ -76,6 +81,7 @@ async function main(): Promise<void> {
 
     const bootstrap = await bootstrapSubprocess({
       dbPath,
+      database,
       coreConfig,
       sqlitePragmas,
       pluginMetadata: {

package/src/core/workflows.ts

@@ -756,6 +756,8 @@ export interface WorkflowsConfig {
   tcpPortRange?: [number, number];
   /** Database file path (required for isolated workflows) */
   dbPath?: string;
+  /** Database config for isolated workflow subprocesses */
+  database?: WorkflowDatabaseConfig;
   /** Heartbeat timeout in ms (default: 60000) */
   heartbeatTimeout?: number;
   /** Timeout waiting for isolated subprocess readiness (ms, default: 10000) */
@@ -768,8 +770,6 @@ export interface WorkflowsConfig {
   useWatchdog?: boolean;
   /** Default max concurrent instances per workflow name (0 = unlimited, default: 0) */
   concurrentWorkflows?: number;
-  /** Per-workflow concurrency overrides */
-  concurrentWorkflowsByName?: Record<string, number>;
   /** Resume strategy for orphaned workflows (default: "blocking") */
   resumeStrategy?: WorkflowResumeStrategy;
 }
@@ -782,6 +782,11 @@ export interface SqlitePragmaConfig {
   journalMode?: "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "WAL" | "OFF";
 }
 
+export interface WorkflowDatabaseConfig {
+  type: "sqlite" | "postgres" | "mysql";
+  connectionString: string;
+}
+
 /** Options for registering a workflow */
 export interface WorkflowRegisterOptions {
   /**
@@ -872,13 +877,13 @@ class WorkflowsImpl implements Workflows {
   private socketDir: string;
   private tcpPortRange: [number, number];
   private dbPath?: string;
+  private databaseConfig?: WorkflowDatabaseConfig;
   private heartbeatTimeoutMs: number;
   private readyTimeoutMs: number;
   private killGraceMs: number;
   private sqlitePragmas?: SqlitePragmaConfig;
   private useWatchdog: boolean;
   private concurrentWorkflows: number;
-  private concurrentWorkflowsByName: Record<string, number>;
   private workflowConcurrencyOverrides = new Map<string, number>();
   private resumeStrategy!: WorkflowResumeStrategy;
   private workflowModulePaths = new Map<string, string>();
@@ -912,13 +917,13 @@ class WorkflowsImpl implements Workflows {
     this.socketDir = config.socketDir ?? "/tmp/donkeylabs-workflows";
     this.tcpPortRange = config.tcpPortRange ?? [49152, 65535];
     this.dbPath = config.dbPath;
+    this.databaseConfig = config.database;
     this.heartbeatTimeoutMs = config.heartbeatTimeout ?? 60000;
     this.readyTimeoutMs = config.readyTimeout ?? 10000;
     this.killGraceMs = config.killGraceMs ?? 5000;
     this.sqlitePragmas = config.sqlitePragmas;
     this.useWatchdog = config.useWatchdog ?? false;
     this.concurrentWorkflows = config.concurrentWorkflows ?? 0;
-    this.concurrentWorkflowsByName = config.concurrentWorkflowsByName ?? {};
     this.resumeStrategy = config.resumeStrategy ?? "blocking";
   }
 
@@ -952,6 +957,9 @@ class WorkflowsImpl implements Workflows {
   }
 
   async resolveDbPath(): Promise<void> {
+    if (this.databaseConfig && this.databaseConfig.type !== "sqlite") {
+      return;
+    }
     if (this.dbPath) return;
     if (!this.core?.db) return;
 
@@ -1064,8 +1072,9 @@ class WorkflowsImpl implements Workflows {
     // Start execution (isolated or inline based on definition.isolated)
     const isIsolated = definition.isolated !== false;
     const modulePath = this.workflowModulePaths.get(workflowName);
+    const canIsolate = Boolean(this.dbPath || this.databaseConfig);
 
-    if (isIsolated && modulePath && this.dbPath) {
+    if (isIsolated && modulePath && canIsolate) {
       // Execute in isolated subprocess
       await this.executeIsolatedWorkflow(instance.id, definition, input, modulePath);
     } else {
@@ -1074,10 +1083,10 @@ class WorkflowsImpl implements Workflows {
         console.warn(
           `[Workflows] Workflow "${workflowName}" falling back to inline execution (no modulePath)`
         );
-      } else if (isIsolated && modulePath && !this.dbPath) {
+      } else if (isIsolated && modulePath && !canIsolate) {
         console.warn(
           `[Workflows] Workflow "${workflowName}" falling back to inline execution (dbPath could not be auto-detected). ` +
-            `Set workflows.dbPath in your server config to enable isolated execution.`
+            `Set workflows.dbPath or workflows.database in your server config to enable isolated execution.`
         );
       }
       this.startInlineWorkflow(instance.id, definition);
@@ -1517,6 +1526,7 @@ class WorkflowsImpl implements Workflows {
       pluginConfigs,
       coreConfig,
       sqlitePragmas: this.sqlitePragmas,
+      database: this.databaseConfig,
     };
 
     // Spawn the subprocess
@@ -2021,9 +2031,6 @@ class WorkflowsImpl implements Workflows {
     if (this.workflowConcurrencyOverrides.has(workflowName)) {
       return this.workflowConcurrencyOverrides.get(workflowName) ?? 0;
     }
-    if (this.concurrentWorkflowsByName[workflowName] !== undefined) {
-      return this.concurrentWorkflowsByName[workflowName] ?? 0;
-    }
     return this.concurrentWorkflows;
   }
 

package/src/server.ts

@@ -69,6 +69,11 @@ export interface ServerConfig {
   /** Maximum port attempts if port is in use. Default: 5 */
   maxPortAttempts?: number;
   db: CoreServices["db"];
+  /** Serializable database config for subprocesses */
+  database?: {
+    type: "sqlite" | "postgres" | "mysql";
+    connectionString: string;
+  };
   config?: Record<string, any>;
   /** Auto-generate client types on startup in dev mode */
   generateTypes?: TypeGenerationConfig;
@@ -314,6 +319,7 @@ export class AppServer {
       jobs,
       sse,
       adapter: workflowAdapter,
+      database: options.database,
       useWatchdog: options.watchdog?.enabled ? true : options.workflows?.useWatchdog,
     });