@checkstack/queue-memory-backend 0.4.20 → 0.4.21

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @checkstack/queue-memory-backend
 
+## 0.4.21
+
+### Patch Changes
+
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+  - @checkstack/backend-api@0.25.0
+  - @checkstack/common@0.17.0
+  - @checkstack/queue-api@0.3.14
+  - @checkstack/queue-memory-common@0.1.21
+
 ## 0.4.20
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/queue-memory-backend",
-  "version": "0.4.20",
+  "version": "0.4.21",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {
@@ -17,17 +17,17 @@
     "pack": "bunx @checkstack/scripts plugin-pack"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.24.1",
-    "@checkstack/queue-api": "0.3.13",
-    "@checkstack/queue-memory-common": "0.1.20",
-    "@checkstack/common": "0.16.0",
+    "@checkstack/backend-api": "0.25.0",
+    "@checkstack/queue-api": "0.3.14",
+    "@checkstack/queue-memory-common": "0.1.21",
+    "@checkstack/common": "0.17.0",
     "cron-parser": "^4.9.0",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@checkstack/tsconfig": "0.0.7",
-    "@checkstack/scripts": "0.6.2"
+    "@checkstack/scripts": "0.6.3"
   },
   "description": "Checkstack queue-memory-backend plugin",
   "author": {

package/src/benchmark.ts

@@ -8,6 +8,13 @@
  *   bun run src/benchmark.ts
  *
  * This is NOT a test file - it runs benchmarks and prints results.
+ *
+ * INTENTIONAL console.* usage: this is a standalone CLI report tool whose
+ * entire purpose is to print a human-readable benchmark table to stdout.
+ * `console.*` IS the output here, not stray debug logging, so the structured
+ * `Logger` abstraction used by the rest of the backend does not apply. The
+ * `no-console` lint rule is scoped to frontend packages and does not flag this
+ * backend script; the console calls below are deliberate and must stay.
  */
 
 import { InMemoryQueue } from "./memory-queue";

package/src/recurring-jobs.test.ts

@@ -1,8 +1,22 @@
 /**
  * Recurring Job Tests for InMemoryQueue
+ *
+ * Uses Bun's Jest-compatible fake timers (`jest.useFakeTimers`,
+ * `jest.advanceTimersByTime`) so interval-based recurring scheduling is driven
+ * deterministically instead of via real `Bun.sleep` waits. Real-time waits in
+ * the unit lane are a known flake source under the parallel runner; advancing a
+ * fake clock makes each "after N intervals" assertion exact and fast.
  */
 
-import { describe, it, expect, afterEach } from "bun:test";
+import {
+  describe,
+  it,
+  expect,
+  afterEach,
+  beforeEach,
+  jest,
+  setSystemTime,
+} from "bun:test";
 import { InMemoryQueue } from "./memory-queue";
 import type { Logger } from "@checkstack/backend-api";
 
@@ -19,17 +33,38 @@ function createTestQueue(name: string) {
     {
       concurrency: 10,
       maxQueueSize: 100,
-      delayMultiplier: 0.01, // Speed up delays for testing
-      heartbeatIntervalMs: 5,
+      // Real timing (multiplier 1) so advancing the fake clock by the interval
+      // in ms maps 1:1 to a scheduled fire.
+      delayMultiplier: 1,
+      heartbeatIntervalMs: 100,
     },
     testLogger,
   );
 }
 
+/**
+ * Advance the fake clock by `ms` and let the queue's async processing
+ * (enqueue -> processNext -> async consumer) drain. Several microtask flushes
+ * cover the multi-hop async path between a timer firing and the handler
+ * completing.
+ */
+async function advanceAndDrain(ms: number): Promise<void> {
+  jest.advanceTimersByTime(ms);
+  for (let i = 0; i < 10; i++) {
+    await Promise.resolve();
+  }
+}
+
 describe("InMemoryQueue Recurring Jobs", () => {
   let queue: InMemoryQueue<string> | undefined;
 
+  beforeEach(() => {
+    jest.useFakeTimers();
+    setSystemTime(new Date("2026-01-18T10:00:00Z"));
+  });
+
   afterEach(async () => {
+    jest.useRealTimers();
     if (queue) {
       await queue.stop();
       queue = undefined;
@@ -49,11 +84,12 @@ describe("InMemoryQueue Recurring Jobs", () => {
 
     await queue.scheduleRecurring("payload", {
       jobId: "recurring-success",
-      intervalSeconds: 0.5, // 5ms with multiplier
+      intervalSeconds: 1,
     });
 
-    // Wait for multiple executions
-    await Bun.sleep(100);
+    // Two intervals -> at least two executions (re-scheduled after each run).
+    await advanceAndDrain(1000);
+    await advanceAndDrain(1000);
 
     expect(executionCount).toBeGreaterThanOrEqual(2);
   });
@@ -72,10 +108,11 @@ describe("InMemoryQueue Recurring Jobs", () => {
 
     await queue.scheduleRecurring("payload", {
       jobId: "recurring-failure",
-      intervalSeconds: 0.5,
+      intervalSeconds: 1,
     });
 
-    await Bun.sleep(100);
+    await advanceAndDrain(1000);
+    await advanceAndDrain(1000);
 
     // Should still reschedule despite failures
     expect(executionCount).toBeGreaterThanOrEqual(2);
@@ -103,7 +140,11 @@ describe("InMemoryQueue Recurring Jobs", () => {
       intervalSeconds: 60, // Long interval so only retries should execute
     });
 
-    await Bun.sleep(200);
+    // Retries use exponential backoff (2s, then 4s) on their own delayed
+    // schedule. Drain past the full backoff window (~6s) but stay well under
+    // the 60s recurring interval, so only retries — not a reschedule — run.
+    await advanceAndDrain(3000);
+    await advanceAndDrain(5000);
 
     // Should complete after retries, not reschedule
     expect(completed).toBe(true);
@@ -123,14 +164,14 @@ describe("InMemoryQueue Recurring Jobs", () => {
 
     await queue.scheduleRecurring("payload", {
       jobId: "recurring-cancel",
-      intervalSeconds: 0.5,
+      intervalSeconds: 1,
     });
 
-    await Bun.sleep(50);
+    await advanceAndDrain(1000);
     const countBeforeCancel = executionCount;
 
     await queue.cancelRecurring("recurring-cancel");
-    await Bun.sleep(100);
+    await advanceAndDrain(2000);
 
     // Should not have executed more after cancellation
     expect(countBeforeCancel).toBeGreaterThanOrEqual(1);
@@ -148,23 +189,24 @@ describe("InMemoryQueue Recurring Jobs", () => {
       { consumerGroup: "test", maxRetries: 0 },
     );
 
-    // Schedule with original payload
+    // Schedule with original payload on a slow interval.
     await queue.scheduleRecurring("original-payload", {
       jobId: "recurring-update",
-      intervalSeconds: 5, // 50ms with multiplier - slow interval
+      intervalSeconds: 10,
     });
 
-    await Bun.sleep(20);
+    await advanceAndDrain(2000);
 
-    // Update to new payload and faster interval
+    // Update to new payload and a faster interval.
     await queue.scheduleRecurring("updated-payload", {
       jobId: "recurring-update",
-      intervalSeconds: 0.5, // 5ms with multiplier
+      intervalSeconds: 1,
     });
 
-    await Bun.sleep(80);
+    await advanceAndDrain(1000);
+    await advanceAndDrain(1000);
 
-    // Should have the updated payload multiple times
+    // Should have the updated payload multiple times.
     const updatedPayloads = payloads.filter((p) => p === "updated-payload");
     expect(updatedPayloads.length).toBeGreaterThanOrEqual(2);
   });
@@ -180,24 +222,25 @@ describe("InMemoryQueue Recurring Jobs", () => {
       { consumerGroup: "test", maxRetries: 0 },
     );
 
-    // Schedule with a long interval (won't fire again during test)
+    // Schedule with a long interval (won't fire again during the test).
     await queue.scheduleRecurring("payload", {
       jobId: "recurring-test",
       intervalSeconds: 100, // Very long, should only execute once initially
     });
 
-    await Bun.sleep(30);
+    await advanceAndDrain(2000);
     const countAfterFirst = executionCount;
 
-    // Update to a short interval
+    // Update to a short interval.
     await queue.scheduleRecurring("payload", {
       jobId: "recurring-test",
-      intervalSeconds: 0.5, // 5ms with multiplier
+      intervalSeconds: 1,
     });
 
-    await Bun.sleep(80);
+    await advanceAndDrain(1000);
+    await advanceAndDrain(1000);
 
-    // Should have executed multiple times with new interval
+    // Should have executed multiple times with the new interval.
     expect(executionCount).toBeGreaterThan(countAfterFirst);
     expect(executionCount - countAfterFirst).toBeGreaterThanOrEqual(2);
   });