@donkeylabs/server 2.0.19 → 2.0.21

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/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}`
+  );
+}

package/src/testing/e2e.test.ts

@@ -0,0 +1,189 @@
+// packages/server/src/testing/e2e.test.ts
+import { describe, it, expect } from "bun:test";
+import { defineE2EConfig, createE2EFixtures } from "./e2e";
+
+describe("E2E Testing Utilities", () => {
+  describe("defineE2EConfig", () => {
+    it("should return default configuration", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.testDir).toBe("./e2e");
+      expect(config.timeout).toBe(30000);
+      expect(config.expect?.timeout).toBe(5000);
+      expect(config.fullyParallel).toBe(true);
+      expect(config.use?.baseURL).toBe("http://localhost:3000");
+      expect(config.use?.trace).toBe("on-first-retry");
+      expect(config.use?.screenshot).toBe("only-on-failure");
+    });
+
+    it("should use custom port", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:4000",
+        port: 4000,
+      });
+
+      expect(config.use?.baseURL).toBe("http://localhost:4000");
+    });
+
+    it("should use custom timeout", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        timeout: 60000,
+      });
+
+      expect(config.timeout).toBe(60000);
+    });
+
+    it("should configure chromium by default", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.projects?.length).toBe(1);
+      expect(config.projects?.[0].name).toBe("chromium");
+    });
+
+    it("should add firefox when specified", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        browsers: ["firefox"],
+      });
+
+      // Chromium + Firefox
+      expect(config.projects?.length).toBe(2);
+      expect(config.projects?.some((p) => p.name === "firefox")).toBe(true);
+    });
+
+    it("should add webkit when specified", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        browsers: ["webkit"],
+      });
+
+      expect(config.projects?.some((p) => p.name === "webkit")).toBe(true);
+    });
+
+    it("should add mobile viewports when testMobile is true", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        testMobile: true,
+      });
+
+      const mobileProjects = config.projects?.filter(
+        (p) => p.name.includes("Mobile")
+      );
+      expect(mobileProjects?.length).toBe(2);
+      expect(mobileProjects?.some((p) => p.name === "Mobile Chrome")).toBe(true);
+      expect(mobileProjects?.some((p) => p.name === "Mobile Safari")).toBe(true);
+    });
+
+    it("should configure webServer for auto-start", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        serverEntry: "./src/server.ts",
+        autoStart: true,
+      });
+
+      expect(config.webServer).toBeDefined();
+      expect(config.webServer?.command).toBe("bun ./src/server.ts");
+      expect(config.webServer?.url).toBe("http://localhost:3000");
+    });
+
+    it("should use default dev command when no serverEntry", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.webServer?.command).toBe("bun run dev");
+    });
+
+    it("should disable webServer when autoStart is false", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        autoStart: false,
+      });
+
+      expect(config.webServer).toBeUndefined();
+    });
+
+    it("should configure CI settings based on environment", () => {
+      const originalCI = process.env.CI;
+
+      // Test non-CI
+      delete process.env.CI;
+      const nonCIConfig = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+      expect(nonCIConfig.forbidOnly).toBe(false);
+      expect(nonCIConfig.retries).toBe(0);
+
+      // Test CI
+      process.env.CI = "true";
+      const ciConfig = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+      expect(ciConfig.forbidOnly).toBe(true);
+      expect(ciConfig.retries).toBe(2);
+      expect(ciConfig.workers).toBe(1);
+
+      // Restore
+      if (originalCI) {
+        process.env.CI = originalCI;
+      } else {
+        delete process.env.CI;
+      }
+    });
+
+    it("should configure reporters", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.reporter).toEqual([["html"], ["list"]]);
+    });
+  });
+
+  describe("createE2EFixtures", () => {
+    const baseURL = "http://localhost:9999";
+
+    it("should create api fixture with all HTTP methods", () => {
+      const fixtures = createE2EFixtures(baseURL);
+
+      expect(fixtures.api).toBeDefined();
+      expect(typeof fixtures.api).toBe("function");
+    });
+
+    it("should create seed fixture", () => {
+      const fixtures = createE2EFixtures(baseURL);
+
+      expect(fixtures.seed).toBeDefined();
+      expect(typeof fixtures.seed).toBe("function");
+    });
+
+    it("should create cleanup fixture", () => {
+      const fixtures = createE2EFixtures(baseURL);
+
+      expect(fixtures.cleanup).toBeDefined();
+      expect(typeof fixtures.cleanup).toBe("function");
+    });
+
+    // Integration tests for fixtures would require a running server
+    // These tests verify the fixture structure
+  });
+
+  describe("E2EFixtures API client", () => {
+    // These tests require a mock server
+    // For now we just verify the structure
+
+    it("should have correct fixture structure", () => {
+      const fixtures = createE2EFixtures("http://test:3000");
+
+      // Verify all expected fixtures exist
+      expect(Object.keys(fixtures)).toContain("api");
+      expect(Object.keys(fixtures)).toContain("seed");
+      expect(Object.keys(fixtures)).toContain("cleanup");
+    });
+  });
+});