@c9up/bay 0.1.13 → 0.2.0

package/src/testing/FakeQueue.ts

@@ -9,7 +9,7 @@
  * the fake into a runtime build.
  */
 
-import type { Job, QueueDriver } from "../QueueManager.js";
+import type { JobRecord, QueueDriver } from "../QueueManager.js";
 
 export interface FakeQueuePredicate {
 	/** Custom payload predicate — receives the job's `payload` and
@@ -23,12 +23,12 @@ export interface FakeQueuePredicate {
 
 export type FakeQueuePredicateArg =
 	| FakeQueuePredicate
-	| ((job: Job) => boolean);
+	| ((job: JobRecord) => boolean);
 
 export class FakeQueue implements QueueDriver {
-	#pushed: Job[] = [];
+	#pushed: JobRecord[] = [];
 
-	async push(job: Job): Promise<void> {
+	async push(job: JobRecord): Promise<void> {
 		// Reject duplicate ids to surface the most common test-fixture
 		// mistake — two `makeJob({ id: 'x' })` reused across pushes
 		// silently corrupts later `fail`/`complete`/`retry` lookups.
@@ -43,25 +43,35 @@ export class FakeQueue implements QueueDriver {
 	/** Always returns `null` — fake queues never auto-dispatch.
 	 *  Tests that need handler execution should use the memory
 	 *  driver directly. */
-	async pop(): Promise<Job | null> {
+	/**
+	 * Always empty: this fake captures what was dispatched, it does not run it.
+	 *
+	 * The parameter is declared so the queue names a caller asks for are part of
+	 * the signature a test reads, even though nothing here serves them.
+	 */
+	async pop(_queues?: readonly string[]): Promise<JobRecord | null> {
 		return null;
 	}
 
-	async fail(job: Job, error: string): Promise<void> {
+	async fail(job: JobRecord, error: string): Promise<void> {
 		const found = this.#requireJob(job, "fail");
 		found.status = "failed";
 		found.error = error;
 	}
 
-	async complete(job: Job): Promise<void> {
+	async complete(job: JobRecord): Promise<void> {
 		const found = this.#requireJob(job, "complete");
 		found.status = "completed";
 		found.processedAt = Date.now();
 	}
 
-	async retry(job: Job): Promise<void> {
+	async retry(job: JobRecord): Promise<void> {
 		const found = this.#requireJob(job, "retry");
-		found.attempts += 1;
+		// `attempts` is the WORKER's counter, not the driver's: `processOne`
+		// increments it before it calls this, and neither real driver touches it
+		// again. Incrementing here counted the same attempt twice, so a fake
+		// exhausted `maxAttempts` in half the tries the real queue takes — a
+		// test double that disagrees with what it stands in for.
 		found.status = "pending";
 		// Reset transient state from the prior failure so a retried
 		// job's invariants match a fresh push (a real driver would
@@ -73,9 +83,9 @@ export class FakeQueue implements QueueDriver {
 
 	/** Look up the captured copy of a job by id. Throws when the id
 	 *  isn't present — silent no-op on a missing job is the most
-	 *  insidious test bug (caller's local Job ref shows the new
+	 *  insidious test bug (caller's local job ref shows the new
 	 *  status while the FakeQueue's internal capture is unchanged). */
-	#requireJob(job: Job, verb: string): Job {
+	#requireJob(job: JobRecord, verb: string): JobRecord {
 		const found = this.#pushed.find((j) => j.id === job.id);
 		if (!found) {
 			throw new Error(
@@ -85,7 +95,7 @@ export class FakeQueue implements QueueDriver {
 		return found;
 	}
 
-	async failed(): Promise<Job[]> {
+	async failed(): Promise<JobRecord[]> {
 		return this.#pushed
 			.filter((j) => j.status === "failed")
 			.map((j) => ({ ...j }));
@@ -100,7 +110,7 @@ export class FakeQueue implements QueueDriver {
 	 * shallow clone so test-side mutations can't bleed back into the
 	 * internal capture store — avoids cross-test contamination.
 	 */
-	getPushed(): Job[] {
+	getPushed(): JobRecord[] {
 		return this.#pushed.map((j) => ({ ...j }));
 	}
 
@@ -129,7 +139,7 @@ export class FakeQueue implements QueueDriver {
 function makeMatcher(
 	name: string,
 	predicate: FakeQueuePredicateArg | undefined,
-): (j: Job) => boolean {
+): (j: JobRecord) => boolean {
 	// Function-form predicate — caller does ALL the matching, the
 	// `name` arg is still a hard prerequisite.
 	if (typeof predicate === "function") {
@@ -162,7 +172,7 @@ function describePredicate(
 	return `, ${JSON.stringify(predicate)}`;
 }
 
-function describeCaptured(captured: Job[]): string {
+function describeCaptured(captured: JobRecord[]): string {
 	if (captured.length === 0) return "Captured: (none)";
 	const lines = captured.map(
 		(j, i) =>

package/dist/stores.d.ts

@@ -1,41 +0,0 @@
-/**
- * The queue store factories a config file names — `{ default, stores }`.
- *
- * The shape AdonisJS gives a package with several backends and one selected:
- * a `stores` namespace imported beside `defineConfig`, each entry that
- * namespace's result, and the selection read from the environment. Bay had a
- * single `driver: "memory"` and told everyone else to build the manager by
- * hand, which meant Redis could not be reached from a config file at all.
- *
- *   import { defineConfig, stores } from '@c9up/bay'
- *
- *   export default defineConfig({
- *     default: env.get('QUEUE_STORE'),
- *     stores: {
- *       memory: stores.memory(),
- *       redis:  stores.redis({ connection: 'main' }),
- *     },
- *   })
- *
- * Factories are lazy: only the store an application actually uses is built, so
- * naming a Redis queue in a config that runs in memory opens no connection.
- */
-import type { RedisClientSource } from "./drivers/RedisDriver.js";
-import type { QueueDriver } from "./QueueManager.js";
-/** A driver, built on first use. */
-export type QueueStoreFactory = () => QueueDriver;
-export declare const stores: {
-    /** In memory. Jobs do not survive a restart — for tests and dev. */
-    memory(): QueueStoreFactory;
-    /**
-     * Redis. `connection` takes an ioredis-shaped client, a function answering
-     * one, or the NAME of a `@c9up/quasar` connection — the last resolved at
-     * first use, without bay importing quasar, which stays an optional peer.
-     */
-    redis(options: {
-        connection: RedisClientSource | string;
-        prefix?: string;
-        visibilityTimeoutMs?: number;
-    }): QueueStoreFactory;
-};
-//# sourceMappingURL=stores.d.ts.map

package/dist/stores.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../src/stores.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,oCAAoC;AACpC,MAAM,MAAM,iBAAiB,GAAG,MAAM,WAAW,CAAC;AAElD,eAAO,MAAM,MAAM;IAClB,oEAAoE;cAC1D,iBAAiB;IAI3B;;;;OAIG;mBACY;QACd,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAC;QACvC,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC7B,GAAG,iBAAiB;CAWrB,CAAC"}

package/dist/stores.js

@@ -1,46 +0,0 @@
-/**
- * The queue store factories a config file names — `{ default, stores }`.
- *
- * The shape AdonisJS gives a package with several backends and one selected:
- * a `stores` namespace imported beside `defineConfig`, each entry that
- * namespace's result, and the selection read from the environment. Bay had a
- * single `driver: "memory"` and told everyone else to build the manager by
- * hand, which meant Redis could not be reached from a config file at all.
- *
- *   import { defineConfig, stores } from '@c9up/bay'
- *
- *   export default defineConfig({
- *     default: env.get('QUEUE_STORE'),
- *     stores: {
- *       memory: stores.memory(),
- *       redis:  stores.redis({ connection: 'main' }),
- *     },
- *   })
- *
- * Factories are lazy: only the store an application actually uses is built, so
- * naming a Redis queue in a config that runs in memory opens no connection.
- */
-import { MemoryDriver } from "./drivers/MemoryDriver.js";
-import { RedisDriver } from "./drivers/RedisDriver.js";
-import { quasarConnection } from "./quasar.js";
-export const stores = {
-    /** In memory. Jobs do not survive a restart — for tests and dev. */
-    memory() {
-        return () => new MemoryDriver();
-    },
-    /**
-     * Redis. `connection` takes an ioredis-shaped client, a function answering
-     * one, or the NAME of a `@c9up/quasar` connection — the last resolved at
-     * first use, without bay importing quasar, which stays an optional peer.
-     */
-    redis(options) {
-        const source = typeof options.connection === "string"
-            ? quasarConnection(options.connection)
-            : options.connection;
-        return () => new RedisDriver(source, {
-            prefix: options.prefix,
-            visibilityTimeoutMs: options.visibilityTimeoutMs,
-        });
-    },
-};
-//# sourceMappingURL=stores.js.map

package/dist/stores.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stores.js","sourceRoot":"","sources":["../src/stores.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAK/C,MAAM,CAAC,MAAM,MAAM,GAAG;IACrB,oEAAoE;IACpE,MAAM;QACL,OAAO,GAAG,EAAE,CAAC,IAAI,YAAY,EAAE,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAIL;QACA,MAAM,MAAM,GACX,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ;YACrC,CAAC,CAAC,gBAAgB,CAAC,OAAO,CAAC,UAAU,CAAC;YACtC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QACvB,OAAO,GAAG,EAAE,CACX,IAAI,WAAW,CAAC,MAAM,EAAE;YACvB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;SAChD,CAAC,CAAC;IACL,CAAC;CACD,CAAC"}

package/src/stores.ts

@@ -1,59 +0,0 @@
-/**
- * The queue store factories a config file names — `{ default, stores }`.
- *
- * The shape AdonisJS gives a package with several backends and one selected:
- * a `stores` namespace imported beside `defineConfig`, each entry that
- * namespace's result, and the selection read from the environment. Bay had a
- * single `driver: "memory"` and told everyone else to build the manager by
- * hand, which meant Redis could not be reached from a config file at all.
- *
- *   import { defineConfig, stores } from '@c9up/bay'
- *
- *   export default defineConfig({
- *     default: env.get('QUEUE_STORE'),
- *     stores: {
- *       memory: stores.memory(),
- *       redis:  stores.redis({ connection: 'main' }),
- *     },
- *   })
- *
- * Factories are lazy: only the store an application actually uses is built, so
- * naming a Redis queue in a config that runs in memory opens no connection.
- */
-
-import { MemoryDriver } from "./drivers/MemoryDriver.js";
-import type { RedisClientSource } from "./drivers/RedisDriver.js";
-import { RedisDriver } from "./drivers/RedisDriver.js";
-import type { QueueDriver } from "./QueueManager.js";
-import { quasarConnection } from "./quasar.js";
-
-/** A driver, built on first use. */
-export type QueueStoreFactory = () => QueueDriver;
-
-export const stores = {
-	/** In memory. Jobs do not survive a restart — for tests and dev. */
-	memory(): QueueStoreFactory {
-		return () => new MemoryDriver();
-	},
-
-	/**
-	 * Redis. `connection` takes an ioredis-shaped client, a function answering
-	 * one, or the NAME of a `@c9up/quasar` connection — the last resolved at
-	 * first use, without bay importing quasar, which stays an optional peer.
-	 */
-	redis(options: {
-		connection: RedisClientSource | string;
-		prefix?: string;
-		visibilityTimeoutMs?: number;
-	}): QueueStoreFactory {
-		const source: RedisClientSource =
-			typeof options.connection === "string"
-				? quasarConnection(options.connection)
-				: options.connection;
-		return () =>
-			new RedisDriver(source, {
-				prefix: options.prefix,
-				visibilityTimeoutMs: options.visibilityTimeoutMs,
-			});
-	},
-};