@donkeylabs/server 2.0.34 → 2.0.37

package/package.json

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

package/src/core/logs-adapter-kysely.ts

@@ -49,6 +49,8 @@ const LOG_LEVEL_VALUES: Record<LogLevel, number> = {
 export interface KyselyLogsAdapterConfig {
   /** Database file path (default: ".donkeylabs/logs.db") */
   dbPath?: string;
+  /** Use an existing Kysely instance */
+  db?: Kysely<Database>;
 }
 
 // ============================================
@@ -61,6 +63,11 @@ export class KyselyLogsAdapter implements LogsAdapter {
   private ensureTablePromise: Promise<void> | null = null;
 
   constructor(config: KyselyLogsAdapterConfig = {}) {
+    if (config.db) {
+      this.db = config.db;
+      return;
+    }
+
     const dbPath = config.dbPath ?? ".donkeylabs/logs.db";
 
     // Ensure directory exists

package/src/core/logs.ts

@@ -8,6 +8,7 @@
 
 import type { Events } from "./events";
 import type { LogLevel } from "./logger";
+import type { Kysely } from "kysely";
 
 // ============================================
 // Types
@@ -72,6 +73,8 @@ export interface LogsConfig {
   maxBufferSize?: number;
   /** Database path (default: ".donkeylabs/logs.db") */
   dbPath?: string;
+  /** Use an existing Kysely instance for logs storage */
+  db?: Kysely<any>;
 }
 
 // ============================================

package/src/core/migrations/workflows/002_add_metadata_column.ts

@@ -7,13 +7,8 @@
 import { sql, type Kysely } from "kysely";
 
 export async function up(db: Kysely<any>): Promise<void> {
-  // SQLite doesn't support IF NOT EXISTS for ALTER TABLE ADD COLUMN
-  // Check if column exists first
-  const tableInfo = await sql<{ name: string }>`
-    PRAGMA table_info(__donkeylabs_workflow_instances__)
-  `.execute(db);
-
-  const hasMetadataColumn = tableInfo.rows.some((row) => row.name === "metadata");
+  const dialect = getDialectName(db);
+  const hasMetadataColumn = await columnExists(db, dialect);
 
   if (!hasMetadataColumn) {
     await sql`
@@ -26,3 +21,42 @@ export async function down(db: Kysely<any>): Promise<void> {
   // SQLite doesn't support DROP COLUMN directly
   // In practice, we don't need to remove it - the column can stay
 }
+
+async function columnExists(db: Kysely<any>, dialect: string): Promise<boolean> {
+  if (dialect.includes("postgres")) {
+    const result = await sql<{ name: string }>`
+      SELECT column_name as name
+      FROM information_schema.columns
+      WHERE table_name = '__donkeylabs_workflow_instances__'
+        AND column_name = 'metadata'
+        AND table_schema = current_schema()
+    `.execute(db);
+    return result.rows.length > 0;
+  }
+
+  if (dialect.includes("mysql")) {
+    const result = await sql<{ name: string }>`
+      SELECT column_name as name
+      FROM information_schema.columns
+      WHERE table_name = '__donkeylabs_workflow_instances__'
+        AND column_name = 'metadata'
+        AND table_schema = database()
+    `.execute(db);
+    return result.rows.length > 0;
+  }
+
+  const tableInfo = await sql<{ name: string }>`
+    PRAGMA table_info(__donkeylabs_workflow_instances__)
+  `.execute(db);
+
+  return tableInfo.rows.some((row) => row.name === "metadata");
+}
+
+function getDialectName(db: Kysely<any>): string {
+  try {
+    const adapter = (db as any).getExecutor?.().adapter;
+    return adapter?.constructor?.name?.toLowerCase() ?? "";
+  } catch {
+    return "";
+  }
+}

package/src/core/processes.ts

@@ -170,8 +170,8 @@ export interface SpawnOptions {
 // ============================================
 
 export interface ProcessesConfig {
-  /** SQLite adapter configuration */
-  adapter?: SqliteProcessAdapterConfig;
+  /** Adapter instance or sqlite adapter configuration */
+  adapter?: ProcessAdapter | SqliteProcessAdapterConfig;
   /** Socket server configuration */
   socket?: ProcessSocketConfig;
   /** Events service for emitting process events */
@@ -278,7 +278,11 @@ export class ProcessesImpl implements Processes {
   private isShuttingDown = false;
 
   constructor(config: ProcessesConfig = {}) {
-    this.adapter = new SqliteProcessAdapter(config.adapter);
+    if (config.adapter && typeof (config.adapter as ProcessAdapter).get === "function") {
+      this.adapter = config.adapter as ProcessAdapter;
+    } else {
+      this.adapter = new SqliteProcessAdapter(config.adapter as SqliteProcessAdapterConfig | undefined);
+    }
     this.events = config.events;
     this.heartbeatCheckInterval = config.heartbeatCheckInterval ?? 10000;
     this.autoRecoverOrphans = config.autoRecoverOrphans ?? true;

package/src/core/watchdog-executor.ts

@@ -1,10 +1,11 @@
-import { Kysely } from "kysely";
+import { Kysely, PostgresDialect, MysqlDialect } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import Database from "bun:sqlite";
 import { ProcessClient } from "./process-client";
 import { KyselyWorkflowAdapter } from "./workflow-adapter-kysely";
 import { KyselyJobAdapter } from "./job-adapter-kysely";
 import { SqliteProcessAdapter } from "./process-adapter-sqlite";
+import { KyselyProcessAdapter } from "./process-adapter-kysely";
 import { WatchdogRunner, type WatchdogRunnerConfig } from "./watchdog-runner";
 
 interface WatchdogConfig extends WatchdogRunnerConfig {
@@ -17,6 +18,10 @@ interface WatchdogConfig extends WatchdogRunnerConfig {
     synchronous?: "OFF" | "NORMAL" | "FULL" | "EXTRA";
     journalMode?: "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "WAL" | "OFF";
   };
+  database?: {
+    type: "sqlite" | "postgres" | "mysql";
+    connectionString: string;
+  };
 }
 
 const raw = process.env.DONKEYLABS_WATCHDOG_CONFIG;
@@ -27,19 +32,21 @@ if (!raw) {
 const config: WatchdogConfig = JSON.parse(raw);
 const client = await ProcessClient.connect();
 
-const workflowAdapter = config.workflows?.dbPath
-  ? new KyselyWorkflowAdapter(createDb(config.workflows.dbPath, config.sqlitePragmas), {
+const workflowAdapter = config.workflows?.dbPath || config.database
+  ? new KyselyWorkflowAdapter(await createDb(config.workflows?.dbPath, config), {
       cleanupDays: 0,
     })
   : undefined;
-const jobAdapter = config.jobs?.dbPath
-  ? new KyselyJobAdapter(createDb(config.jobs.dbPath, config.sqlitePragmas), {
+const jobAdapter = config.jobs?.dbPath || config.database
+  ? new KyselyJobAdapter(await createDb(config.jobs?.dbPath, config), {
       cleanupDays: 0,
     })
   : undefined;
 const processAdapter = config.processes?.dbPath
   ? new SqliteProcessAdapter({ path: config.processes.dbPath, cleanupDays: 0 })
-  : undefined;
+  : config.database
+    ? new KyselyProcessAdapter(await createDb(undefined, config))
+    : undefined;
 
 const runner = new WatchdogRunner(config, {
   workflowsAdapter: workflowAdapter,
@@ -60,21 +67,52 @@ process.on("SIGTERM", async () => {
   client.disconnect();
 });
 
-function createDb(
-  dbPath: string,
-  pragmas?: { busyTimeout?: number; synchronous?: string; journalMode?: string }
-): Kysely<any> {
-  const sqlite = new Database(dbPath);
-  const busyTimeout = pragmas?.busyTimeout ?? 5000;
-  sqlite.run(`PRAGMA busy_timeout = ${busyTimeout}`);
-  if (pragmas?.journalMode) {
-    sqlite.run(`PRAGMA journal_mode = ${pragmas.journalMode}`);
+async function createDb(
+  dbPath: string | undefined,
+  config: WatchdogConfig
+): Promise<Kysely<any>> {
+  const dbConfig = config.database;
+
+  if (!dbConfig || dbConfig.type === "sqlite") {
+    const sqlitePath = dbConfig?.connectionString ?? dbPath;
+    if (!sqlitePath) {
+      throw new Error("SQLite dbPath or connectionString is required for watchdog");
+    }
+    const sqlite = new Database(sqlitePath);
+    const pragmas = config.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 (pragmas?.synchronous) {
-    sqlite.run(`PRAGMA synchronous = ${pragmas.synchronous}`);
+
+  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),
+      }),
+    });
   }
 
-  return new Kysely<any>({
-    dialect: new BunSqliteDialect({ database: sqlite }),
-  });
+  throw new Error(`Unsupported database type: ${dbConfig.type}`);
 }

package/src/core.ts

@@ -544,10 +544,15 @@ export class PluginManager {
    * This table tracks which migrations have been applied for each plugin.
    */
   private async ensureMigrationsTable(): Promise<void> {
-    await this.core.db.schema
+    const table = this.core.db.schema
       .createTable("__donkeylabs_migrations__")
-      .ifNotExists()
-      .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+      .ifNotExists();
+
+    const withId = this.isPostgresDialect()
+      ? table.addColumn("id", "serial", (col) => col.primaryKey())
+      : table.addColumn("id", "integer", (col) => col.primaryKey().autoIncrement());
+
+    await withId
       .addColumn("plugin_name", "text", (col) => col.notNull())
       .addColumn("migration_name", "text", (col) => col.notNull())
       .addColumn("executed_at", "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`))
@@ -559,6 +564,16 @@ export class PluginManager {
               ON __donkeylabs_migrations__(plugin_name, migration_name)`.execute(this.core.db);
   }
 
+  private isPostgresDialect(): boolean {
+    try {
+      const adapter = (this.core.db as any).getExecutor?.().adapter;
+      const name = adapter?.constructor?.name?.toLowerCase() ?? "";
+      return name.includes("postgres");
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Checks if a migration has already been applied for a specific plugin.
    */

package/src/server.ts

@@ -266,6 +266,7 @@ export class AppServer {
     // Create logs service with its own database
     const logsAdapter = options.logs?.adapter ?? new KyselyLogsAdapter({
       dbPath: options.logs?.dbPath,
+      db: options.logs?.db,
     });
     const logs = createLogs({
       ...options.logs,
@@ -296,6 +297,7 @@ export class AppServer {
     // Create adapters - use Kysely by default, or legacy SQLite if requested
     const jobAdapter = options.jobs?.adapter ?? (useLegacy ? undefined : new KyselyJobAdapter(options.db));
     const workflowAdapter = options.workflows?.adapter ?? (useLegacy ? undefined : new KyselyWorkflowAdapter(options.db));
+    const processAdapter = options.processes?.adapter ?? (useLegacy ? undefined : new KyselyProcessAdapter(options.db));
     const auditAdapter = options.audit?.adapter ?? new KyselyAuditAdapter(options.db);
 
     // Jobs can emit events and use Kysely adapter, with logger for scoped logging
@@ -327,6 +329,7 @@ export class AppServer {
     const processes = createProcesses({
       ...options.processes,
       events,
+      adapter: processAdapter,
       useWatchdog: options.watchdog?.enabled ? true : options.processes?.useWatchdog,
     });
 
@@ -1107,7 +1110,13 @@ ${factoryFunction}
     const services = this.watchdogConfig.services ?? ["workflows", "jobs", "processes"];
     const workflowsDbPath = this.coreServices.workflows.getDbPath?.();
     const jobsDbPath = (this.options.jobs?.dbPath ?? workflowsDbPath ?? ".donkeylabs/jobs.db") as string;
-    const processesDbPath = (this.options.processes?.adapter?.path ?? ".donkeylabs/processes.db") as string;
+    const adapterConfig = this.options.processes?.adapter;
+    let processesDbPath: string | undefined;
+    if (adapterConfig && typeof adapterConfig === "object" && "path" in adapterConfig) {
+      processesDbPath = (adapterConfig as any).path ?? ".donkeylabs/processes.db";
+    } else if (!adapterConfig && !this.options.database) {
+      processesDbPath = ".donkeylabs/processes.db";
+    }
 
     const config = {
       intervalMs: this.watchdogConfig.intervalMs ?? 5000,
@@ -1123,6 +1132,7 @@ ${factoryFunction}
       jobs: jobsDbPath ? { dbPath: jobsDbPath } : undefined,
       processes: processesDbPath ? { dbPath: processesDbPath } : undefined,
       sqlitePragmas: this.options.workflows?.sqlitePragmas,
+      database: this.options.database,
     };
 
     try {