@c9up/bay 0.1.13 → 0.2.1

package/src/quasar.ts

@@ -1,84 +1,40 @@
 /**
  * Resolving a Redis connection by name, from `@c9up/quasar`.
  *
- * Bay does not depend on quasar: it is an optional peer, and this module
- * never imports it statically. The specifier is built at runtime so the
- * TypeScript build stays free of it too — a hard type import would make echo
- * unbuildable for anyone who queues in memory.
- *
- * The shape is checked before use rather than asserted, the same way bay
- * duck-types its host framework.
+ * The loading, the shape check and the messages are the same in every package
+ * that offers a Redis-backed option, so they are vendored rather than written
+ * again: `src/vendor/quasarConnection.ts`, generated from one source. What is
+ * specific to this package — the commands it issues, and what it does with
+ * them — stays here, because that is the part a reader needs.
  */
 
 import type { RedisClient } from "./drivers/RedisDriver.js";
+import { quasarConnection as loadQuasarConnection } from "./vendor/quasarConnection.js";
 
-/** The slice of quasar's manager this needs: a connection, by name. */
-interface ConnectionSource {
-	connection(name?: string): unknown;
-}
-
-function isConnectionSource(value: unknown): value is ConnectionSource {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "connection") === "function"
-	);
-}
-
-function isRedisClient(value: unknown): value is RedisClient {
-	if (typeof value !== "object" || value === null) return false;
-	// The commands this driver actually issues — every non-optional member of
-	// `RedisClient`. A connection missing one would fail on the first job push,
-	// far from the cause. `lmove` is deliberately absent: the driver declares it
-	// optional and falls back when it is not there.
-	const required = [
-		"rpush",
-		"lpop",
-		"lrem",
-		"llen",
-		"lrange",
-		"del",
-		"set",
-		"get",
-	];
-	return required.every(
-		(name) => typeof Reflect.get(value, name) === "function",
-	);
-}
+// The commands this driver actually issues — every non-optional member of
+// `RedisClient`. `lmove` is deliberately absent: the driver declares it
+// optional and falls back when it is not there.
+const REQUIRED = [
+	"rpush",
+	"lpop",
+	"lrem",
+	"llen",
+	"lrange",
+	"del",
+	"set",
+	"get",
+] as const;
 
 /**
- * A resolver for `new RedisDriver(quasarConnection("jobs"))` — quasar is
- * loaded on the first queue command, not at config time.
+ * A resolver — quasar is loaded on first use, not at config time.
  */
 export function quasarConnection(name?: string): () => Promise<RedisClient> {
-	return async () => {
-		const specifier = "@c9up/quasar/services/main";
-		let loaded: unknown;
-		try {
-			loaded = await import(/* @vite-ignore */ specifier);
-		} catch (cause) {
-			throw new Error(
-				`Bay: the "${name ?? "default"}" queue asks for a quasar connection, but @c9up/quasar is not installed.\n` +
-					"  pnpm add @c9up/quasar",
-				{ cause },
-			);
-		}
-
-		const manager = isConnectionSource(loaded)
-			? loaded
-			: Reflect.get(Object(loaded), "default");
-		if (!isConnectionSource(manager)) {
-			throw new Error(
-				"Bay: @c9up/quasar/services/main did not expose a connection() manager",
-			);
-		}
-
-		const connection = manager.connection(name);
-		if (!isRedisClient(connection)) {
-			throw new Error(
-				`Bay: quasar connection "${name ?? "default"}" does not carry the commands this queue needs`,
-			);
-		}
-		return connection;
-	};
+	return async () =>
+		loadQuasarConnection<RedisClient>({
+			pkg: "bay",
+			name,
+			required: REQUIRED,
+			what: "the queue driver",
+			raise: (_reason, message, cause) => new Error(message, { cause }),
+		});
 }

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/src/{nodeEnv.ts → vendor/nodeEnv.ts}

@@ -1,13 +1,20 @@
+// Generated from scripts/vendor/nodeEnv.ts — do not edit.
+//
+// This package is published and built from its own repository, so the file
+// has to exist here rather than be imported. `pnpm vendor:sync` rewrites it,
+// and `pnpm vendor:check` fails if this copy has drifted from the original.
+
 /**
- * Reading `NODE_ENV`, with the aliases people actually set.
+ * `NODE_ENV`, read the way every runtime actually spells it.
  *
- * `NODE_ENV=prod` is ordinary in a Dockerfile or a platform dashboard. Read
- * verbatim it answers "not production" — and here that decides whether a queue
- * silently accepts a delivery guarantee weaker than the one it advertises.
+ * `NODE_ENV=prod` is ordinary in a Dockerfile or a platform dashboard, and a
+ * bare `=== "production"` answers "not production" for it. What that costs
+ * differs per package, so the consequence is stated where the decision is
+ * taken, not here.
  *
- * Duplicated rather than imported: bay depends on no other package in this
- * workspace, and a safety decision that only holds when an optional peer is
- * installed is not a decision.
+ * The tables mirror the framework's (`@c9up/ream`, src/env/nodeEnv.ts), which
+ * is the origin rather than a peer: it formats to different rules and exposes
+ * `currentNodeEnv()` instead of `inProduction()`.
  */
 
 const DEV_ENVS = ["dev", "develop", "development"];

package/src/vendor/quasarConnection.ts

@@ -0,0 +1,129 @@
+// Generated from scripts/vendor/quasarConnection.ts — do not edit.
+//
+// This package is published and built from its own repository, so the file
+// has to exist here rather than be imported. `pnpm vendor:sync` rewrites it,
+// and `pnpm vendor:check` fails if this copy has drifted from the original.
+
+/**
+ * Resolving a Redis connection by name, from `@c9up/quasar`.
+ *
+ * No package here depends on quasar: it is an optional peer, and this module
+ * never imports it statically — the specifier is built at runtime so the
+ * TypeScript build stays free of it too. A host that never names a connection
+ * neither installs it nor pays for it.
+ *
+ * What varies between callers is passed in rather than copied: which commands
+ * they will issue, and what they are doing with them. Both end up in the
+ * message, because "the connection is missing lpop" is only useful next to
+ * "which the queue's atomic pop issues".
+ */
+
+/** The slice of quasar's manager this needs: a connection, by name. */
+interface ConnectionSource {
+	connection(name?: string): unknown;
+}
+
+/**
+ * Read a member without assuming how the object answers.
+ *
+ * Two shapes have to work, and they disagree about `in`. Quasar's accessor is
+ * a Proxy over an empty null-prototype object with only a `get` trap, so
+ * `"connection" in manager` is FALSE while reading it returns the function —
+ * gating on `in` rejected the real manager. And a module namespace under a
+ * test double RAISES for an export it does not have, rather than answering
+ * undefined, so a bare read fails on the mock. Reading through a catch is what
+ * satisfies both.
+ */
+function readMember(value: unknown, name: string): unknown {
+	if (typeof value !== "object" || value === null) return undefined;
+	try {
+		return Reflect.get(value, name);
+	} catch {
+		return undefined;
+	}
+}
+
+function isConnectionSource(value: unknown): value is ConnectionSource {
+	return typeof readMember(value, "connection") === "function";
+}
+
+export interface QuasarConnectionRequest {
+	/** The package asking. It prefixes every message this can raise. */
+	pkg: string;
+	/**
+	 * How this package builds an error.
+	 *
+	 * Not optional, and not `new Error` by default: a package with its own
+	 * error type carries codes (`E_<PKG>_<REASON>`) that a caller catches on,
+	 * and a shared helper throwing a bare Error would silently drop them. The
+	 * two reasons are distinguished so the codes can be too.
+	 */
+	raise: (
+		reason: "quasar-missing" | "incomplete-connection",
+		message: string,
+		cause?: unknown,
+	) => Error;
+	/** Connection name, or `undefined` for quasar's default. */
+	name?: string;
+	/** The commands the caller will actually issue. */
+	required: readonly string[];
+	/** What the caller does with them, for the message that names a gap. */
+	what: string;
+	/**
+	 * A second way out, when this package has one.
+	 *
+	 * Several of them accept a client object directly, so "pass a client
+	 * instead of a connection name" is actionable — and it was in each
+	 * package's own message before this was shared. Dropping it to unify the
+	 * wording would have made the error strictly less useful.
+	 */
+	alternative?: string;
+}
+
+/**
+ * The named connection, checked for the commands the caller needs BEFORE it is
+ * handed over — a connection missing one would otherwise fail on the first
+ * command, far from the line that asked for it.
+ */
+export async function quasarConnection<T>(
+	request: QuasarConnectionRequest,
+): Promise<T> {
+	const { pkg, name, required, what, raise, alternative } = request;
+	const specifier = "@c9up/quasar/services/main";
+	let loaded: unknown;
+	try {
+		loaded = await import(/* @vite-ignore */ specifier);
+	} catch (cause) {
+		throw raise(
+			"quasar-missing",
+			`[${pkg}] ${what} asks for the quasar connection "${name ?? "default"}", but @c9up/quasar is not installed.\n` +
+				`  pnpm add @c9up/quasar${alternative ? `, ${alternative}` : ""}`,
+			cause,
+		);
+	}
+
+	const manager = isConnectionSource(loaded)
+		? loaded
+		: Reflect.get(Object(loaded), "default");
+	if (!isConnectionSource(manager)) {
+		throw raise(
+			"quasar-missing",
+			`[${pkg}] @c9up/quasar/services/main did not expose a connection() manager`,
+		);
+	}
+
+	const connection = manager.connection(name);
+	const missing = required.filter(
+		(command) => typeof readMember(connection, command) !== "function",
+	);
+	if (missing.length > 0) {
+		throw raise(
+			"incomplete-connection",
+			`[${pkg}] the quasar connection${name ? ` '${name}'` : ""} is missing ${missing.join(", ")}, which ${what} issues`,
+		);
+	}
+	// Load-bearing: every member of `required` has just been checked to be a
+	// function on this object. The caller names the type it needs because only
+	// the caller knows which commands it asked for.
+	return connection as T;
+}

package/dist/nodeEnv.d.ts

@@ -1,16 +0,0 @@
-/**
- * Reading `NODE_ENV`, with the aliases people actually set.
- *
- * `NODE_ENV=prod` is ordinary in a Dockerfile or a platform dashboard. Read
- * verbatim it answers "not production" — and here that decides whether a queue
- * silently accepts a delivery guarantee weaker than the one it advertises.
- *
- * Duplicated rather than imported: bay depends on no other package in this
- * workspace, and a safety decision that only holds when an optional peer is
- * installed is not a decision.
- */
-/** The canonical name for whatever `NODE_ENV` holds. */
-export declare function normalizeNodeEnv(value: string | undefined): string;
-/** Whether this process is running in production, under any spelling. */
-export declare function inProduction(): boolean;
-//# sourceMappingURL=nodeEnv.d.ts.map

package/dist/nodeEnv.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeEnv.d.ts","sourceRoot":"","sources":["../src/nodeEnv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAOlE;AAED,yEAAyE;AACzE,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}

package/dist/nodeEnv.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeEnv.js","sourceRoot":"","sources":["../src/nodeEnv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;AACnD,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AACzC,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEtC,wDAAwD;AACxD,MAAM,UAAU,gBAAgB,CAAC,KAAyB;IACzD,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAC1D,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IAChC,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,aAAa,CAAC;IACjD,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,YAAY,CAAC;IACjD,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,MAAM,CAAC;IAC3C,OAAO,GAAG,CAAC;AACZ,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,YAAY;IAC3B,OAAO,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,YAAY,CAAC;AAChE,CAAC"}

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,
-			});
-	},
-};