@donkeylabs/server 2.0.18 → 2.0.20

package/src/core.ts

@@ -10,7 +10,7 @@ import type { Cron } from "./core/cron";
 import type { Jobs } from "./core/jobs";
 import type { SSE } from "./core/sse";
 import type { RateLimiter } from "./core/rate-limiter";
-import type { Errors, CustomErrorRegistry } from "./core/errors";
+import type { Errors, CustomErrorRegistry, ErrorFactory } from "./core/errors";
 import type { Workflows } from "./core/workflows";
 import type { Processes } from "./core/processes";
 import type { Audit } from "./core/audit";
@@ -408,7 +408,7 @@ export type InferEvents<T> = UnwrapPluginFactory<T> extends { events?: infer E }
 export type InferClientConfig<T> = UnwrapPluginFactory<T> extends { client?: infer C } ? C : undefined;
 export type InferCustomErrors<T> = UnwrapPluginFactory<T> extends { customErrors?: infer E } ? E : {};
 
-export type { ExtractServices, ExtractSchemas };
+export type { ExtractServices, ExtractSchemas, ErrorFactory };
 
 export type Plugin = {
     name: string;
@@ -494,10 +494,21 @@ export class PluginManager {
    * Records that a migration has been applied for a specific plugin.
    */
   private async recordMigration(pluginName: string, migrationName: string): Promise<void> {
-    await sql`
-      INSERT INTO __donkeylabs_migrations__ (plugin_name, migration_name)
-      VALUES (${pluginName}, ${migrationName})
-    `.execute(this.core.db);
+    try {
+      // Use ON CONFLICT DO NOTHING to handle race conditions on hot reload
+      await sql`
+        INSERT INTO __donkeylabs_migrations__ (plugin_name, migration_name)
+        VALUES (${pluginName}, ${migrationName})
+        ON CONFLICT (plugin_name, migration_name) DO NOTHING
+      `.execute(this.core.db);
+    } catch (e: any) {
+      // Fallback: ignore UNIQUE constraint errors (migration already recorded)
+      if (e?.code === "SQLITE_CONSTRAINT_UNIQUE" || e?.message?.includes("UNIQUE constraint failed")) {
+        // Already recorded, ignore
+        return;
+      }
+      throw e;
+    }
   }
 
   /**

package/src/index.ts

@@ -91,6 +91,14 @@ export function defineConfig(config: DonkeylabsConfig): DonkeylabsConfig {
 // Re-export HttpError for custom error creation
 export { HttpError } from "./core/errors";
 
+// Core services types
+export {
+  type Logger,
+  type LogLevel,
+  type ErrorFactory,
+  type ErrorFactories,
+} from "./core/index";
+
 // Workflows (step functions)
 export {
   workflow,
@@ -129,3 +137,9 @@ export {
   type IntegrationHarnessOptions,
   type IntegrationHarnessResult,
 } from "./harness";
+
+// E2E Testing - moved to separate subpath export: "@donkeylabs/server/testing"
+// import { createE2EFixtures, defineE2EConfig } from "@donkeylabs/server/testing";
+
+// Database Testing Utilities - moved to separate subpath export: "@donkeylabs/server/testing"
+// import { createTestDatabase, resetTestDatabase } from "@donkeylabs/server/testing";

package/src/server.ts

@@ -205,6 +205,8 @@ export class AppServer {
   private shutdownHandlers: OnShutdownHandler[] = [];
   private errorHandlers: OnErrorHandler[] = [];
   private isShuttingDown = false;
+  private isInitialized = false;
+  private initializationPromise: Promise<void> | null = null;
   private generateModeSetup = false;
 
   // Custom services registry
@@ -955,6 +957,27 @@ ${factoryFunction}
       process.exit(0);
     }
 
+    // Guard against multiple initializations using promise-based mutex
+    // This prevents race conditions when multiple requests arrive concurrently
+    if (this.isInitialized) {
+      this.coreServices.logger.debug("Server already initialized, skipping");
+      return;
+    }
+    if (this.initializationPromise) {
+      this.coreServices.logger.debug("Server initialization in progress, waiting...");
+      await this.initializationPromise;
+      return;
+    }
+
+    // Create the initialization promise - all concurrent callers will await this same promise
+    this.initializationPromise = this.doInitialize();
+    await this.initializationPromise;
+  }
+
+  /**
+   * Internal initialization logic - only called once via the promise mutex
+   */
+  private async doInitialize(): Promise<void> {
     const { logger } = this.coreServices;
 
     // Auto-generate types in dev mode if configured
@@ -963,6 +986,11 @@ ${factoryFunction}
     await this.manager.migrate();
     await this.manager.init();
 
+    // Pass plugins to workflows so handlers can access ctx.plugins
+    this.coreServices.workflows.setPlugins(this.manager.getServices());
+
+    this.isInitialized = true;
+
     this.coreServices.cron.start();
     this.coreServices.jobs.start();
     await this.coreServices.workflows.resume();
@@ -1185,34 +1213,20 @@ ${factoryFunction}
       process.exit(0);
     }
 
-    const { logger } = this.coreServices;
-
-    // Auto-generate types in dev mode if configured
-    await this.generateTypes();
-
-    // 1. Run migrations
-    await this.manager.migrate();
-
-    // 2. Initialize plugins
-    await this.manager.init();
-
-    // 3. Start background services
-    this.coreServices.cron.start();
-    this.coreServices.jobs.start();
-    await this.coreServices.workflows.resume();
-    this.coreServices.processes.start();
-    logger.info("Background services started (cron, jobs, workflows, processes)");
-
-    // 4. Build route map
-    for (const router of this.routers) {
-      for (const route of router.getRoutes()) {
-        if (this.routeMap.has(route.name)) {
-          logger.warn(`Duplicate route detected`, { route: route.name });
-        }
-        this.routeMap.set(route.name, route);
+    // Guard against multiple initializations using promise-based mutex
+    // This prevents race conditions when multiple requests arrive concurrently
+    if (!this.isInitialized) {
+      if (this.initializationPromise) {
+        this.coreServices.logger.debug("Server initialization in progress, waiting...");
+        await this.initializationPromise;
+      } else {
+        // Create the initialization promise - all concurrent callers will await this same promise
+        this.initializationPromise = this.doInitialize();
+        await this.initializationPromise;
       }
     }
-    logger.info(`Loaded ${this.routeMap.size} RPC routes`);
+
+    const { logger } = this.coreServices;
 
     // 5. Start HTTP server with port retry logic
     const fetchHandler = async (req: Request, server: ReturnType<typeof Bun.serve>) => {

package/src/testing/database.test.ts

@@ -0,0 +1,263 @@
+// packages/server/src/testing/database.test.ts
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import {
+  createTestDatabase,
+  resetTestDatabase,
+  seedTestData,
+} from "./database";
+import type { Kysely } from "kysely";
+
+describe("Database Testing Utilities", () => {
+  describe("createTestDatabase", () => {
+    let db: Kysely<any>;
+
+    afterEach(async () => {
+      if (db) {
+        await db.destroy();
+      }
+    });
+
+    it("should create an isolated SQLite database", async () => {
+      db = await createTestDatabase({
+        type: "sqlite",
+        isolated: true,
+      });
+
+      expect(db).toBeDefined();
+      // Verify it's functional by creating a table
+      await db.schema
+        .createTable("test_table")
+        .addColumn("id", "text", (col) => col.primaryKey())
+        .addColumn("name", "text")
+        .execute();
+
+      // Insert and query
+      await db
+        .insertInto("test_table" as any)
+        .values({ id: "1", name: "Test" })
+        .execute();
+
+      const result = await db
+        .selectFrom("test_table" as any)
+        .selectAll()
+        .executeTakeFirst();
+
+      expect(result).toEqual({ id: "1", name: "Test" });
+    });
+
+    it("should create an in-memory SQLite database", async () => {
+      db = await createTestDatabase({
+        type: "sqlite",
+        isolated: false,
+        connectionString: ":memory:",
+      });
+
+      expect(db).toBeDefined();
+
+      // Create and use table
+      await db.schema
+        .createTable("memory_test")
+        .addColumn("id", "integer", (col) => col.primaryKey())
+        .execute();
+
+      await db
+        .insertInto("memory_test" as any)
+        .values({ id: 1 })
+        .execute();
+
+      const count = await db
+        .selectFrom("memory_test" as any)
+        .select(db.fn.count("id").as("count"))
+        .executeTakeFirst();
+
+      expect(Number(count?.count)).toBe(1);
+    });
+
+    it("should cleanup isolated database on destroy", async () => {
+      db = await createTestDatabase({
+        type: "sqlite",
+        isolated: true,
+      });
+
+      await db.schema
+        .createTable("cleanup_test")
+        .addColumn("id", "text", (col) => col.primaryKey())
+        .execute();
+
+      // Destroy should not throw and should cleanup
+      await db.destroy();
+
+      // Clear reference so afterEach doesn't try to destroy again
+      db = null as any;
+    });
+
+    it("should throw for postgres without connection string", async () => {
+      const originalEnv = process.env.TEST_DATABASE_URL;
+      delete process.env.TEST_DATABASE_URL;
+
+      try {
+        await expect(
+          createTestDatabase({ type: "postgres" })
+        ).rejects.toThrow("TEST_DATABASE_URL not set for postgres");
+      } finally {
+        if (originalEnv) {
+          process.env.TEST_DATABASE_URL = originalEnv;
+        }
+      }
+    });
+
+    it("should throw for mysql without connection string", async () => {
+      const originalEnv = process.env.TEST_DATABASE_URL;
+      delete process.env.TEST_DATABASE_URL;
+
+      try {
+        await expect(
+          createTestDatabase({ type: "mysql" })
+        ).rejects.toThrow("TEST_DATABASE_URL not set for mysql");
+      } finally {
+        if (originalEnv) {
+          process.env.TEST_DATABASE_URL = originalEnv;
+        }
+      }
+    });
+
+    it("should throw for unsupported database type", async () => {
+      await expect(
+        createTestDatabase({ type: "mongo" as any })
+      ).rejects.toThrow("Unsupported database type: mongo");
+    });
+  });
+
+  describe("resetTestDatabase", () => {
+    let db: Kysely<any>;
+
+    beforeEach(async () => {
+      db = await createTestDatabase({
+        type: "sqlite",
+        isolated: true,
+      });
+
+      // Create test tables
+      await db.schema
+        .createTable("users")
+        .addColumn("id", "text", (col) => col.primaryKey())
+        .addColumn("email", "text")
+        .execute();
+
+      await db.schema
+        .createTable("posts")
+        .addColumn("id", "text", (col) => col.primaryKey())
+        .addColumn("title", "text")
+        .execute();
+    });
+
+    afterEach(async () => {
+      if (db) {
+        await db.destroy();
+      }
+    });
+
+    it("should truncate all tables", async () => {
+      // Insert data
+      await db.insertInto("users" as any).values({ id: "1", email: "a@b.com" }).execute();
+      await db.insertInto("users" as any).values({ id: "2", email: "c@d.com" }).execute();
+      await db.insertInto("posts" as any).values({ id: "1", title: "Post 1" }).execute();
+
+      // Verify data exists
+      const usersBefore = await db.selectFrom("users" as any).selectAll().execute();
+      const postsBefore = await db.selectFrom("posts" as any).selectAll().execute();
+      expect(usersBefore.length).toBe(2);
+      expect(postsBefore.length).toBe(1);
+
+      // Reset
+      await resetTestDatabase(db);
+
+      // Verify all tables are empty
+      const usersAfter = await db.selectFrom("users" as any).selectAll().execute();
+      const postsAfter = await db.selectFrom("posts" as any).selectAll().execute();
+      expect(usersAfter.length).toBe(0);
+      expect(postsAfter.length).toBe(0);
+    });
+
+    it("should handle empty tables", async () => {
+      // No data inserted, should not throw
+      await resetTestDatabase(db);
+
+      const users = await db.selectFrom("users" as any).selectAll().execute();
+      expect(users.length).toBe(0);
+    });
+  });
+
+  describe("seedTestData", () => {
+    let db: Kysely<any>;
+
+    beforeEach(async () => {
+      db = await createTestDatabase({
+        type: "sqlite",
+        isolated: true,
+      });
+
+      await db.schema
+        .createTable("users")
+        .addColumn("id", "text", (col) => col.primaryKey())
+        .addColumn("email", "text")
+        .addColumn("name", "text")
+        .execute();
+
+      await db.schema
+        .createTable("orders")
+        .addColumn("id", "text", (col) => col.primaryKey())
+        .addColumn("user_id", "text")
+        .addColumn("total", "integer")
+        .execute();
+    });
+
+    afterEach(async () => {
+      if (db) {
+        await db.destroy();
+      }
+    });
+
+    it("should seed data into multiple tables", async () => {
+      await seedTestData(db, {
+        users: [
+          { id: "u1", email: "user1@test.com", name: "User 1" },
+          { id: "u2", email: "user2@test.com", name: "User 2" },
+        ],
+        orders: [
+          { id: "o1", user_id: "u1", total: 100 },
+          { id: "o2", user_id: "u1", total: 200 },
+          { id: "o3", user_id: "u2", total: 50 },
+        ],
+      });
+
+      const users = await db.selectFrom("users" as any).selectAll().execute();
+      const orders = await db.selectFrom("orders" as any).selectAll().execute();
+
+      expect(users.length).toBe(2);
+      expect(orders.length).toBe(3);
+
+      expect(users[0].email).toBe("user1@test.com");
+      expect(orders[0].total).toBe(100);
+    });
+
+    it("should handle empty arrays", async () => {
+      await seedTestData(db, {
+        users: [],
+      });
+
+      const users = await db.selectFrom("users" as any).selectAll().execute();
+      expect(users.length).toBe(0);
+    });
+
+    it("should handle single table", async () => {
+      await seedTestData(db, {
+        users: [{ id: "1", email: "solo@test.com", name: "Solo" }],
+      });
+
+      const users = await db.selectFrom("users" as any).selectAll().execute();
+      expect(users.length).toBe(1);
+      expect(users[0].name).toBe("Solo");
+    });
+  });
+});

package/src/testing/database.ts

@@ -0,0 +1,173 @@
+// packages/server/src/testing/database.ts
+/**
+ * Database Testing Utilities
+ *
+ * Helper functions for setting up and managing test databases.
+ *
+ * Usage:
+ *   const db = await createTestDatabase({ type: "sqlite" });
+ *   await seedTestData(db, { users: [{ email: "test@example.com" }] });
+ *   // Run tests...
+ *   await db.destroy();
+ */
+
+import { Kysely, PostgresDialect, MysqlDialect } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import Database from "bun:sqlite";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// pg and mysql2 are optional - dynamically imported when needed
+
+export interface TestDatabaseOptions {
+  /** Database type */
+  type: "sqlite" | "postgres" | "mysql";
+  
+  /** Path to migrations (glob pattern) */
+  migrations?: string;
+  
+  /** Run migrations automatically */
+  runMigrations?: boolean;
+  
+  /** Isolated database (deleted after tests) */
+  isolated?: boolean;
+  
+  /** Connection string (for postgres/mysql) */
+  connectionString?: string;
+}
+
+/**
+ * Create a test database instance
+ */
+export async function createTestDatabase(options: TestDatabaseOptions): Promise<Kysely<any>> {
+  let db: Kysely<any>;
+  let cleanupPath: string | null = null;
+  
+  switch (options.type) {
+    case "sqlite": {
+      let dbPath: string;
+      
+      if (options.isolated !== false) {
+        // Create isolated temp database
+        const tmpDir = mkdtempSync(join(tmpdir(), "donkeylabs-test-"));
+        dbPath = join(tmpDir, "test.db");
+        cleanupPath = tmpDir;
+      } else {
+        dbPath = options.connectionString || ":memory:";
+      }
+      
+      db = new Kysely({
+        dialect: new BunSqliteDialect({
+          database: new Database(dbPath),
+        }),
+      });
+      break;
+    }
+    
+    case "postgres": {
+      const connectionString = options.connectionString || process.env.TEST_DATABASE_URL;
+      if (!connectionString) {
+        throw new Error("TEST_DATABASE_URL not set for postgres");
+      }
+
+      // Dynamic import - pg is optional peer dependency
+      // @ts-ignore - pg may not be installed
+      const { Pool: PGPool } = await import("pg");
+
+      db = new Kysely({
+        dialect: new PostgresDialect({
+          pool: new PGPool({
+            connectionString,
+            max: 5,
+          }),
+        }),
+      });
+      break;
+    }
+
+    case "mysql": {
+      const connectionString = options.connectionString || process.env.TEST_DATABASE_URL;
+      if (!connectionString) {
+        throw new Error("TEST_DATABASE_URL not set for mysql");
+      }
+
+      // Dynamic import - mysql2 is optional peer dependency
+      // @ts-ignore - mysql2 may not be installed
+      const { createPool: createMySQLPool } = await import("mysql2");
+
+      db = new Kysely({
+        dialect: new MysqlDialect({
+          pool: createMySQLPool({
+            uri: connectionString,
+            connectionLimit: 5,
+          }),
+        }),
+      });
+      break;
+    }
+    
+    default:
+      throw new Error(`Unsupported database type: ${options.type}`);
+  }
+  
+  // Run migrations if requested
+  if (options.runMigrations && options.migrations) {
+    await runMigrations(db, options.migrations);
+  }
+  
+  // Attach cleanup handler
+  if (cleanupPath) {
+    const originalDestroy = db.destroy.bind(db);
+    db.destroy = async () => {
+      await originalDestroy();
+      if (cleanupPath) {
+        rmSync(cleanupPath, { recursive: true, force: true });
+      }
+    };
+  }
+  
+  return db;
+}
+
+/**
+ * Reset test database (truncate all tables)
+ */
+export async function resetTestDatabase(db: Kysely<any>): Promise<void> {
+  // Get all tables
+  const tables = await db.introspection.getTables();
+  
+  // Truncate each table
+  for (const table of tables) {
+    await db.deleteFrom(table.name as any).execute();
+  }
+}
+
+/**
+ * Seed test data into database
+ */
+export async function seedTestData(
+  db: Kysely<any>,
+  data: Record<string, any[]>
+): Promise<void> {
+  for (const [table, rows] of Object.entries(data)) {
+    if (rows.length === 0) continue;
+    
+    for (const row of rows) {
+      await db.insertInto(table as any).values(row).execute();
+    }
+  }
+}
+
+/**
+ * Run migrations on test database (not yet implemented)
+ */
+async function runMigrations(_db: Kysely<any>, migrationsPath: string): Promise<void> {
+  // TODO: Implement migration runner integration
+  // This would scan the migrations path and run pending migrations
+  throw new Error(
+    `Migration runner not yet implemented. ` +
+    `Please run migrations manually or create tables directly in your tests. ` +
+    `Attempted path: ${migrationsPath}`
+  );
+}