@donkeylabs/server 2.0.18 → 2.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/server",
-  "version": "2.0.18",
+  "version": "2.0.19",
   "type": "module",
   "description": "Type-safe plugin system for building RPC-style APIs with Bun",
   "main": "./src/index.ts",
@@ -30,6 +30,10 @@
       "types": "./src/process-client.ts",
       "import": "./src/process-client.ts"
     },
+    "./testing": {
+      "types": "./src/testing/index.ts",
+      "import": "./src/testing/index.ts"
+    },
     "./context": {
       "types": "./context.d.ts"
     },
@@ -68,7 +72,10 @@
     "kysely": "^0.27.0 || ^0.28.0",
     "zod": "^3.20.0",
     "@aws-sdk/client-s3": "^3.0.0",
-    "@aws-sdk/s3-request-presigner": "^3.0.0"
+    "@aws-sdk/s3-request-presigner": "^3.0.0",
+    "@playwright/test": "^1.40.0",
+    "pg": "^8.0.0",
+    "mysql2": "^3.0.0"
   },
   "peerDependenciesMeta": {
     "@aws-sdk/client-s3": {
@@ -76,6 +83,15 @@
     },
     "@aws-sdk/s3-request-presigner": {
       "optional": true
+    },
+    "@playwright/test": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
     }
   },
   "dependencies": {

package/src/core/cron.ts

@@ -109,21 +109,109 @@ class CronExpression {
     );
   }
 
+  /**
+   * Get the next run time using an optimized jump algorithm.
+   * Instead of iterating second-by-second (which could be 31M iterations),
+   * this jumps directly to the next valid value for each field.
+   */
   getNextRun(from: Date = new Date()): Date {
     const next = new Date(from);
     next.setMilliseconds(0);
     next.setSeconds(next.getSeconds() + 1);
 
-    // Search up to 1 year ahead
-    const maxIterations = 366 * 24 * 60 * 60;
-    for (let i = 0; i < maxIterations; i++) {
-      if (this.matches(next)) {
-        return next;
+    const [seconds, minutes, hours, daysOfMonth, months, daysOfWeek] = this.fields;
+
+    // Maximum iterations to prevent infinite loops (covers 4 years to handle leap years)
+    const maxYearIterations = 4;
+    const startYear = next.getFullYear();
+
+    // Iterate through potential dates (worst case: a few hundred iterations)
+    for (let yearOffset = 0; yearOffset <= maxYearIterations; yearOffset++) {
+      // Try each valid month
+      for (const month of months) {
+        const targetMonth = month - 1; // JS months are 0-indexed
+
+        // Skip months in the past
+        if (next.getFullYear() === startYear + yearOffset) {
+          if (targetMonth < next.getMonth()) continue;
+        }
+
+        // Set to this month
+        if (targetMonth !== next.getMonth() || next.getFullYear() !== startYear + yearOffset) {
+          next.setFullYear(startYear + yearOffset, targetMonth, 1);
+          next.setHours(0, 0, 0, 0);
+        }
+
+        // Get days in this month
+        const daysInMonth = new Date(next.getFullYear(), targetMonth + 1, 0).getDate();
+
+        // Try each valid day of month
+        for (const dayOfMonth of daysOfMonth) {
+          if (dayOfMonth > daysInMonth) continue; // Skip invalid days for this month
+
+          // Check if this day matches day-of-week constraint
+          const testDate = new Date(next.getFullYear(), targetMonth, dayOfMonth);
+          const dayOfWeek = testDate.getDay();
+          if (!daysOfWeek.includes(dayOfWeek)) continue;
+
+          // Skip days in the past
+          if (testDate < new Date(from.getFullYear(), from.getMonth(), from.getDate())) continue;
+
+          // Set to this day
+          if (dayOfMonth !== next.getDate()) {
+            next.setDate(dayOfMonth);
+            next.setHours(0, 0, 0, 0);
+          }
+
+          // Try each valid hour
+          for (const hour of hours) {
+            // Skip hours in the past for today
+            if (next.getFullYear() === from.getFullYear() &&
+                next.getMonth() === from.getMonth() &&
+                next.getDate() === from.getDate() &&
+                hour < from.getHours()) continue;
+
+            if (hour !== next.getHours()) {
+              next.setHours(hour, 0, 0, 0);
+            }
+
+            // Try each valid minute
+            for (const minute of minutes) {
+              // Skip minutes in the past for this hour
+              if (next.getFullYear() === from.getFullYear() &&
+                  next.getMonth() === from.getMonth() &&
+                  next.getDate() === from.getDate() &&
+                  next.getHours() === from.getHours() &&
+                  minute < from.getMinutes()) continue;
+
+              if (minute !== next.getMinutes()) {
+                next.setMinutes(minute, 0, 0);
+              }
+
+              // Try each valid second
+              for (const second of seconds) {
+                // Skip seconds in the past for this minute
+                if (next.getFullYear() === from.getFullYear() &&
+                    next.getMonth() === from.getMonth() &&
+                    next.getDate() === from.getDate() &&
+                    next.getHours() === from.getHours() &&
+                    next.getMinutes() === from.getMinutes() &&
+                    second <= from.getSeconds()) continue;
+
+                next.setSeconds(second);
+
+                // Verify the date is still valid (handles edge cases like month rollover)
+                if (next > from && this.matches(next)) {
+                  return next;
+                }
+              }
+            }
+          }
+        }
       }
-      next.setSeconds(next.getSeconds() + 1);
     }
 
-    throw new Error("Could not find next run time within 1 year");
+    throw new Error("Could not find next run time within 4 years");
   }
 }
 

package/src/core/workflows.ts

@@ -195,6 +195,8 @@ export interface WorkflowContext {
   getStepResult<T = any>(stepName: string): T | undefined;
   /** Core services (logger, events, cache, etc.) */
   core: CoreServices;
+  /** Plugin services - available for business logic in workflow handlers */
+  plugins: Record<string, any>;
 }
 
 // ============================================
@@ -558,6 +560,8 @@ export interface Workflows {
   stop(): Promise<void>;
   /** Set core services (called after initialization to resolve circular dependency) */
   setCore(core: CoreServices): void;
+  /** Set plugin services (called after plugins are initialized) */
+  setPlugins(plugins: Record<string, any>): void;
 }
 
 // ============================================
@@ -570,6 +574,7 @@ class WorkflowsImpl implements Workflows {
   private jobs?: Jobs;
   private sse?: SSE;
   private core?: CoreServices;
+  private plugins: Record<string, any> = {};
   private definitions = new Map<string, WorkflowDefinition>();
   private running = new Map<string, { timeout?: ReturnType<typeof setTimeout> }>();
   private pollInterval: number;
@@ -587,6 +592,10 @@ class WorkflowsImpl implements Workflows {
     this.core = core;
   }
 
+  setPlugins(plugins: Record<string, any>): void {
+    this.plugins = plugins;
+  }
+
   register(definition: WorkflowDefinition): void {
     if (this.definitions.has(definition.name)) {
       throw new Error(`Workflow "${definition.name}" is already registered`);
@@ -1150,6 +1159,7 @@ class WorkflowsImpl implements Workflows {
         return steps[stepName] as T | undefined;
       },
       core: this.core!,
+      plugins: this.plugins,
     };
   }
 

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>) => {