bunderstack 0.15.0 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunderstack",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "Batteries-included backend framework for Bun: CRUD APIs, auth, file storage, realtime, tRPC, email, and validated env from a single Drizzle schema and config object.",
   "keywords": [
     "backend",

package/src/jobs/cron-runner.ts

@@ -22,11 +22,13 @@ export async function runScheduledSlot(args: {
   run: (scheduledFor: Date) => Promise<void> | void
   leaseMs?: number
   heartbeatIntervalMs?: number
+  heartbeatCleanupTimeoutMs?: number
 }): Promise<CronRunResult> {
   const { db, taskId, schedule, slot, now, run } = args
   const leaseMs = args.leaseMs ?? LEASE_MS
   const heartbeatIntervalMs =
     args.heartbeatIntervalMs ?? Math.max(1, Math.floor(leaseMs / 4))
+  const heartbeatCleanupTimeoutMs = args.heartbeatCleanupTimeoutMs ?? 1_000
 
   if (slot % 60_000 !== 0 || !cronMatches(parseCron(schedule), slot)) {
     throw new Error('[bunderstack] cron slot does not match its schedule')
@@ -45,9 +47,12 @@ export async function runScheduledSlot(args: {
       startedAt: now,
     })
     .onConflictDoNothing({ target: [t.taskId, t.scheduledAt] })
-    .returning({ taskId: t.taskId })
+    .returning({ taskId: t.taskId, attempts: t.attempts })
 
-  if (!inserted[0]) {
+  let ownershipAttempt: number
+  if (inserted[0]) {
+    ownershipAttempt = Number(inserted[0].attempts)
+  } else {
     const existing = await db
       .select({ status: t.status, lockedUntil: t.lockedUntil })
       .from(t)
@@ -74,42 +79,75 @@ export async function runScheduledSlot(args: {
           or(eq(t.status, 'failed'), lt(t.lockedUntil, now)),
         ),
       )
-      .returning({ taskId: t.taskId })
-    if (!reclaimed[0]) return { status: 'running' }
+      .returning({ taskId: t.taskId, attempts: t.attempts })
+    const reclaimedRow = reclaimed[0]
+    if (!reclaimedRow) return { status: 'running' }
+    ownershipAttempt = Number(reclaimedRow.attempts)
   }
 
   let heartbeatTimer: Timer | undefined
-  const stopHeartbeat = () => {
+  let heartbeatInFlight: Promise<void> | undefined
+  let heartbeatStopped = false
+
+  const scheduleHeartbeat = () => {
+    heartbeatTimer = setTimeout(() => {
+      heartbeatTimer = undefined
+      if (heartbeatStopped) return
+
+      heartbeatInFlight = (async () => {
+        try {
+          const renewUntil = Date.now() + leaseMs
+          await db
+            .update(t)
+            .set({ lockedUntil: renewUntil })
+            .where(
+              and(
+                eq(t.taskId, taskId),
+                eq(t.scheduledAt, slot),
+                eq(t.status, 'running'),
+                eq(t.startedAt, now),
+                eq(t.attempts, ownershipAttempt),
+              ),
+            )
+        } catch {
+          // Best effort renewal
+        }
+      })()
+
+      void heartbeatInFlight.finally(() => {
+        heartbeatInFlight = undefined
+        if (!heartbeatStopped) scheduleHeartbeat()
+      })
+    }, heartbeatIntervalMs)
+  }
+
+  const stopHeartbeat = async () => {
+    heartbeatStopped = true
     if (heartbeatTimer) {
-      clearInterval(heartbeatTimer)
+      clearTimeout(heartbeatTimer)
       heartbeatTimer = undefined
     }
-  }
+    const inFlight = heartbeatInFlight
+    if (!inFlight) return
 
-  heartbeatTimer = setInterval(async () => {
+    let cleanupTimer: Timer | undefined
     try {
-      const renewUntil = Date.now() + leaseMs
-      await db
-        .update(t)
-        .set({ lockedUntil: renewUntil })
-        .where(
-          and(
-            eq(t.taskId, taskId),
-            eq(t.scheduledAt, slot),
-            eq(t.status, 'running'),
-            eq(t.startedAt, now),
-          ),
-        )
-    } catch {
-      // Best effort renewal
+      await Promise.race([
+        inFlight,
+        new Promise<void>((resolve) => {
+          cleanupTimer = setTimeout(resolve, heartbeatCleanupTimeoutMs)
+        }),
+      ])
+    } finally {
+      if (cleanupTimer) clearTimeout(cleanupTimer)
     }
-  }, heartbeatIntervalMs)
+  }
+
+  scheduleHeartbeat()
 
   try {
     await run(new Date(slot))
 
-    stopHeartbeat()
-
     const updated = await db
       .update(t)
       .set({ status: 'succeeded', lockedUntil: null, finishedAt: Date.now() })
@@ -119,6 +157,7 @@ export async function runScheduledSlot(args: {
           eq(t.scheduledAt, slot),
           eq(t.status, 'running'),
           eq(t.startedAt, now),
+          eq(t.attempts, ownershipAttempt),
         ),
       )
       .returning({ taskId: t.taskId })
@@ -131,8 +170,6 @@ export async function runScheduledSlot(args: {
 
     return { status: 'succeeded' }
   } catch (error) {
-    stopHeartbeat()
-
     const message = error instanceof Error ? error.message : String(error)
     await db
       .update(t)
@@ -148,11 +185,12 @@ export async function runScheduledSlot(args: {
           eq(t.scheduledAt, slot),
           eq(t.status, 'running'),
           eq(t.startedAt, now),
+          eq(t.attempts, ownershipAttempt),
         ),
       )
     throw error
   } finally {
-    stopHeartbeat()
+    await stopHeartbeat()
   }
 }
 
@@ -165,6 +203,7 @@ export async function runCronSlot(args: {
   now: number
   leaseMs?: number
   heartbeatIntervalMs?: number
+  heartbeatCleanupTimeoutMs?: number
 }): Promise<CronRunResult> {
   const definition = args.defs[args.name]
   if (!definition || definition.kind !== 'cron') {
@@ -178,6 +217,7 @@ export async function runCronSlot(args: {
     now: args.now,
     leaseMs: args.leaseMs,
     heartbeatIntervalMs: args.heartbeatIntervalMs,
+    heartbeatCleanupTimeoutMs: args.heartbeatCleanupTimeoutMs,
     run: (scheduledFor) =>
       definition.handler({ scheduledFor }, args.ctx as never),
   })