@shivaedev/jobs 0.25.0 → 0.27.0

package/src/server/internal/register.ts

@@ -1,10 +1,9 @@
 import { type Context, Effect, type Scope } from "effect";
+import { registerWorker } from "#adapters/registerWorker.ts";
 import type { PgBossClient } from "#client.ts";
 import type { JobRegistration, QueueDefinition, QueueWorker, ScheduleDefinition, ScheduledWorker } from "#definition.ts";
 import { PgBossQueueOptionsError, toPgBossError } from "#error.ts";
-import type { PgBossRunner } from "#internal/batchHandler.ts";
 import { ensureQueue } from "#internal/ensureQueue.ts";
-import { registerWorker } from "#internal/registerWorker.ts";
 import { runQueueWorker } from "#internal/runQueueWorker.ts";
 
 function isQueueWorker(registration: JobRegistration): registration is QueueWorker {
@@ -62,7 +61,6 @@ const registerQueue = Effect.fnUntraced(function* (
 	context: Context.Context<unknown>,
 	scope: Scope.Scope,
 	schema: string,
-	execute: PgBossRunner,
 	graceful: boolean,
 ) {
 	const queue = registration._tag === "QueueWorker" ? registration.queue : registration;
@@ -78,10 +76,8 @@ const registerQueue = Effect.fnUntraced(function* (
 		scope,
 		schema,
 		queue.maxDeferrals,
-		context,
-		execute,
 		graceful,
-	);
+	).pipe(Effect.provide(context));
 });
 
 const registerSchedule = Effect.fnUntraced(function* (
@@ -90,21 +86,11 @@ const registerSchedule = Effect.fnUntraced(function* (
 	context: Context.Context<unknown>,
 	scope: Scope.Scope,
 	schema: string,
-	execute: PgBossRunner,
 	graceful: boolean,
 ) {
 	const { schedule } = worker;
-	yield* registerWorker(
-		client,
-		schedule.name,
-		schedule.workerOptions,
-		() => worker.effect,
-		scope,
-		schema,
-		schedule.maxDeferrals,
-		context,
-		execute,
-		graceful,
+	yield* registerWorker(client, schedule.name, schedule.workerOptions, () => worker.effect, scope, schema, schedule.maxDeferrals, graceful).pipe(
+		Effect.provide(context),
 	);
 	yield* Effect.tryPromise({
 		catch: (error) => toPgBossError("register", error, schedule.name),
@@ -125,7 +111,6 @@ export const registerJobs = Effect.fnUntraced(function* <R>(
 	registrations: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
-	execute: PgBossRunner,
 	schema = "pgboss",
 	startWorkers = true,
 	graceful = true,
@@ -139,9 +124,9 @@ export const registerJobs = Effect.fnUntraced(function* <R>(
 	const provided = workerContext(context);
 	for (const registration of registrations) {
 		if (isQueueWorker(registration) || isQueueDefinition(registration)) {
-			yield* registerQueue(client, registration, provided, scope, schema, execute, graceful);
+			yield* registerQueue(client, registration, provided, scope, schema, graceful);
 		} else if (isScheduledWorker(registration)) {
-			yield* registerSchedule(client, registration, provided, scope, schema, execute, graceful);
+			yield* registerSchedule(client, registration, provided, scope, schema, graceful);
 		}
 	}
 });

package/src/server/internal/registerReleasedJobs.ts

@@ -1,9 +1,9 @@
 import { type Context, Effect, Option, Scope } from "effect";
 import { WorkerRelease } from "@shivaedev/sql/WorkerRelease.ts";
+import { retireJobs } from "#adapters/retireJobs.ts";
 import type { PgBossClient } from "#client.ts";
 import type { JobRegistration } from "#definition.ts";
 import { toPgBossError } from "#error.ts";
-import type { PgBossRunner } from "#internal/batchHandler.ts";
 import { registerJobs, registrationName } from "./register.ts";
 
 export const registerReleasedJobs = Effect.fnUntraced(function* <R>(
@@ -11,20 +11,21 @@ export const registerReleasedJobs = Effect.fnUntraced(function* <R>(
 	jobs: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
-	execute: PgBossRunner,
 	schema: string | undefined,
 	graceful: boolean,
+	retired: readonly string[] = [],
 ) {
 	const signal = yield* Effect.serviceOption(WorkerRelease);
 	const workers = jobs.filter((job) => job._tag !== "QueueDefinition");
 	const scope = yield* Effect.scope;
-	const register = registerJobs(client, jobs, context, replaceWorkers, execute, schema, true, graceful).pipe(
+	const register = retireJobs(client, jobs, retired).pipe(
+		Effect.andThen(registerJobs(client, jobs, context, replaceWorkers, schema, true, graceful)),
 		Effect.provideService(Scope.Scope, scope),
 	);
-	if (Option.isNone(signal) || workers.length === 0) {
+	if (Option.isNone(signal) || (workers.length === 0 && retired.length === 0)) {
 		return yield* register;
 	}
-	yield* registerJobs(client, jobs, context, replaceWorkers, execute, schema, false, graceful);
+	yield* registerJobs(client, jobs, context, replaceWorkers, schema, false, graceful);
 	let working = replaceWorkers;
 	let paused = false;
 	yield* signal.value.register((active) =>

package/src/server/internal/runQueueWorker.ts

@@ -1,11 +1,12 @@
 import { Effect, Redacted, Schema } from "effect";
 import type { Job } from "pg-boss";
+import { workerDiagnostics } from "#adapters/workerDiagnostics.ts";
 import { jobContext, type QueueWorker } from "#definition.ts";
 import { PgBossPayloadError } from "#error.ts";
 import { payloadOf } from "#internal/tracing.ts";
 
 export function runQueueWorker(worker: QueueWorker, job: Job<unknown>, deadline: number) {
-	return Schema.decodeUnknownEffect(worker.queue.schema)(payloadOf(job.data)).pipe(
+	return Schema.decodeUnknownEffect(Schema.toCodecJson(worker.queue.schema))(payloadOf(job.data)).pipe(
 		Effect.mapError(
 			(error) =>
 				new PgBossPayloadError({
@@ -15,5 +16,6 @@ export function runQueueWorker(worker: QueueWorker, job: Job<unknown>, deadline:
 				}),
 		),
 		Effect.flatMap((payload) => worker.handler(payload, jobContext(job, deadline))),
+		workerDiagnostics,
 	);
 }

package/src/server/internal/storedRows.ts

@@ -11,7 +11,7 @@ export function decodeStoredData<const TName extends string, const TPayload exte
 	queue: { readonly name: TName; readonly schema: TPayload },
 	data: unknown,
 ): Effect.Effect<TPayload["Type"], PgBossPayloadError, TPayload["DecodingServices"]> {
-	return Schema.decodeUnknownEffect(queue.schema)(payloadOf(data)).pipe(
+	return Schema.decodeUnknownEffect(Schema.toCodecJson(queue.schema))(payloadOf(data)).pipe(
 		Effect.mapError((error) => new PgBossPayloadError({ direction: "decode", original: Redacted.make(error), queue: queue.name })),
 	);
 }

package/src/server/internal/testingClient.ts

@@ -1,9 +1,9 @@
 import type { Job, PgBoss, SendOptions, UpdateOptions, UpdateRequest, UpdateResponse } from "pg-boss";
+import { testingExpirations } from "#adapters/testingExpirations.ts";
 import type { PgBossClient } from "#client.ts";
 import { deferralObservers } from "#internal/deferral.ts";
 import { expireAttempt } from "#internal/expireAttempt.ts";
 import { observeTestingSettlements } from "#internal/observeTestingSettlements.ts";
-import { testingExpirations } from "#internal/testingExpirations.ts";
 import type { TestingBatch, TestingWork } from "#internal/testingIdle.ts";
 
 export interface TestingControls {

package/src/server/internal/testingWaits.ts

@@ -0,0 +1,98 @@
+import { Clock, Duration, Effect, Option, Redacted } from "effect";
+import type { JobWithMetadata, PgBoss } from "pg-boss";
+import type { JobPayloadSchema, QueueDefinition } from "#definition.ts";
+import { type PgBossPayloadError, PgBossTestingError, PgBossWaitError } from "#error.ts";
+import type { TestingFetches } from "#internal/adapters/testingFetches.ts";
+import { decodeStoredData } from "#internal/storedRows.ts";
+import { testingOperation } from "#internal/testingReadout.ts";
+import type { PgBossTestingWaitOptions } from "#testing.ts";
+
+interface Reading<A> {
+	readonly arrived: Option.Option<A>;
+	readonly seen: string;
+}
+
+interface Signal {
+	readonly revision: Effect.Effect<number>;
+	readonly waitForChange: (after: number) => Effect.Effect<number>;
+}
+
+function waitUntil<A, E, R>(
+	signal: Signal,
+	waitingFor: string,
+	read: Effect.Effect<Reading<A>, E, R>,
+	options: PgBossTestingWaitOptions | undefined,
+) {
+	const within = Duration.fromInputUnsafe(options?.within ?? "20 seconds");
+	return Effect.suspend(() => {
+		let lastSeen = "nothing yet";
+		const wait = Effect.gen(function* () {
+			while (true) {
+				const revision = yield* signal.revision;
+				const { arrived, seen } = yield* read;
+				lastSeen = seen;
+				if (Option.isSome(arrived)) {
+					return arrived.value;
+				}
+				yield* signal.waitForChange(revision);
+			}
+		});
+		return wait.pipe(
+			Effect.timeoutOrElse({ duration: within, orElse: () => Effect.fail(new PgBossWaitError({ lastSeen, waitingFor, within })) }),
+			// The budget is wall time, so a story's TestClock neither ends the wait early nor holds it open.
+			Effect.provideService(Clock.Clock, Clock.Clock.defaultValue()),
+		);
+	});
+}
+
+function fetchesRefused(queue: Pick<QueueDefinition, "name">, original: Error) {
+	return new PgBossTestingError({ operation: "fetchesPass", original: Redacted.make(original), queue: queue.name });
+}
+
+export function testingWaits(client: () => PgBoss, fetches: () => TestingFetches | undefined, signal: Signal) {
+	return {
+		fetchesPass: (queue: Pick<QueueDefinition, "name">, count: number, options?: PgBossTestingWaitOptions) =>
+			Effect.gen(function* () {
+				if (!Number.isSafeInteger(count) || count < 1) {
+					return yield* fetchesRefused(queue, new RangeError("Fetch count must be a positive integer"));
+				}
+				const observed = fetches();
+				if (observed === undefined) {
+					return yield* fetchesRefused(queue, new Error("Provide the testing clientFactory to a jobs Layer first"));
+				}
+				const begun = observed.begun(queue.name);
+				const fetchesHave = count === 1 ? "fetch that began after the wait has" : "fetches that began after the wait have";
+				return yield* waitUntil(
+					signal,
+					`${count} ${queue.name} ${fetchesHave} finished`,
+					Effect.sync(() => {
+						const passed = observed.passedSince(queue.name, begun);
+						return { arrived: passed >= count ? Option.some(undefined) : Option.none(), seen: `${passed} finished` };
+					}),
+					options,
+				);
+			}),
+		untilJob: <TName extends string, TPayload extends JobPayloadSchema>(
+			queue: Pick<QueueDefinition<TName, TPayload>, "name" | "schema">,
+			id: string,
+			state: JobWithMetadata["state"],
+			options?: PgBossTestingWaitOptions,
+		) =>
+			waitUntil(
+				signal,
+				`job ${id} in ${queue.name} is ${state}`,
+				testingOperation("untilJob", () => client().getJobById<unknown>(queue.name, id), queue.name).pipe(
+					Effect.flatMap((job): Effect.Effect<Reading<JobWithMetadata<TPayload["Type"]>>, PgBossPayloadError, TPayload["DecodingServices"]> => {
+						if (job === null) {
+							return Effect.succeed({ arrived: Option.none(), seen: "no such job" });
+						}
+						if (job.state !== state) {
+							return Effect.succeed({ arrived: Option.none(), seen: job.state });
+						}
+						return Effect.map(decodeStoredData(queue, job.data), (data) => ({ arrived: Option.some({ ...job, data }), seen: job.state }));
+					}),
+				),
+				options,
+			),
+	};
+}

package/src/server/schema.ts

@@ -1,79 +1,23 @@
 import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/sql";
-import type { Connection } from "effect/sql/SqlConnection";
-import { getConstructionPlans, getMigrationPlans, PgBoss } from "pg-boss";
 import pgBossPackage from "pg-boss/package.json" with { type: "json" };
 import type { SchemaComponent } from "@shivaedev/sql/SchemaComponent.ts";
+import { installSchema } from "#adapters/installSchema.ts";
 import { type PgBossError, toPgBossError } from "#error.ts";
-import { deferralStorePlan } from "#internal/deferralStorePlan.ts";
-import { runSchemaPlan } from "#internal/runSchemaPlan.ts";
-import { resumeSchemaIndexes } from "#internal/schemaIndexBuilds.ts";
 
-const Partitions = Schema.Array(
-	Schema.Struct({
-		policy: Schema.String,
-		tableName: Schema.String,
-	}),
-);
 const InstalledSchema = Schema.Array(Schema.Struct({ name: Schema.NullOr(Schema.String) }));
 const InstalledVersion = Schema.Array(Schema.Struct({ version: Schema.Number }));
+const InstalledResolution = Schema.Array(Schema.Struct({ installed: Schema.Boolean }));
 
 export interface PgBossSchemaOptions {
 	readonly schema?: string;
 }
 
-async function installSchema(
-	connection: Connection,
-	options: PgBossSchemaOptions,
-	run: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>,
-): Promise<void> {
-	const schema = options.schema ?? "pgboss";
-	const construction = getConstructionPlans(schema);
-	const client = new PgBoss({
-		db: { executeSql: async (text, values = []) => ({ rows: Array.from(await run(connection.executeUnprepared(text, values, undefined))) }) },
-		schema,
-	});
-	if (!(await client.isInstalled())) {
-		await runSchemaPlan(connection, construction, run);
-		return;
-	}
-	const version = await client.schemaVersion();
-	if (version === null) {
-		throw new Error("The pg-boss version table is empty");
-	}
-	if (version > pgBossPackage.pgboss.schema) {
-		return;
-	}
-	if (version >= 27) {
-		await resumeSchemaIndexes(client, schema);
-	}
-	if (version < pgBossPackage.pgboss.schema) {
-		const partitionTables = Schema.decodeUnknownSync(Partitions)(
-			await run(connection.executeUnprepared(`SELECT table_name AS "tableName", policy FROM ${schema}.queue WHERE partition = true`, [], undefined)),
-		);
-		await runSchemaPlan(connection, getMigrationPlans(schema, version, { partitionTables: Array.from(partitionTables) }), run, {
-			schema,
-			version: pgBossPackage.pgboss.schema,
-		});
-		await resumeSchemaIndexes(client, schema);
-	}
-}
-
 export function installPgBossSchema(options: PgBossSchemaOptions = {}): Effect.Effect<void, PgBossError, SqlClient.SqlClient> {
-	return Effect.scoped(
-		Effect.gen(function* () {
-			const sql = yield* SqlClient.SqlClient;
-			const connection = yield* sql.reserve;
-			const run = Effect.runPromiseWith(yield* Effect.context<never>());
-			yield* Effect.tryPromise({
-				catch: (error) => error,
-				try: async () => {
-					await installSchema(connection, options, run);
-					await run(connection.executeRaw(deferralStorePlan(options.schema ?? "pgboss"), []));
-				},
-			});
-		}).pipe(Effect.mapError((error) => toPgBossError("install", error))),
-	).pipe(Effect.uninterruptible);
+	return Effect.scoped(installSchema(options)).pipe(
+		Effect.mapError((error) => toPgBossError("install", error)),
+		Effect.uninterruptible,
+	);
 }
 
 export function pgBossSchema(options: PgBossSchemaOptions = {}): SchemaComponent {
@@ -92,9 +36,14 @@ export function pgBossSchema(options: PgBossSchemaOptions = {}): SchemaComponent
 					? []
 					: yield* sql`select version from ${table}`.withoutTransform.pipe(Effect.flatMap(Schema.decodeUnknownEffect(InstalledVersion)));
 			const required = pgBossPackage.pgboss.schema;
-			return row === undefined || row.version < required
-				? `schema ${schema}, installed version ${row?.version ?? "missing"}, required version ${required}`
-				: undefined;
+			if (row === undefined || row.version < required) {
+				return `schema ${schema}, installed version ${row?.version ?? "missing"}, required version ${required}`;
+			}
+			const job = sql`${sql(schema)}.${sql("job")}`;
+			const [resolution] = yield* sql`SELECT EXISTS (
+				SELECT 1 FROM pg_trigger WHERE tgrelid = to_regclass(${job.compile()[0]}) AND tgname = 'effect_dead_letter_resolution'
+			) AS installed`.withoutTransform.pipe(Effect.flatMap(Schema.decodeUnknownEffect(InstalledResolution)));
+			return resolution?.installed ? undefined : `schema ${schema}, missing dead-letter resolution trigger`;
 		}),
 	};
 }

package/src/server/service.ts

@@ -2,6 +2,7 @@ import { Context, Effect, Exit, Layer, type Option, Redacted, type Schema, Scope
 import type { ConstructorOptions, JobWithMetadata, SendOptions, StopOptions } from "pg-boss";
 import { defineService } from "@shivaedev/service/defineService.ts";
 import { genericMethod } from "@shivaedev/service/genericMethod.ts";
+import { clientErrorReporter } from "#adapters/clientErrorReporter.ts";
 import type { PgBossClientFactory } from "#client.ts";
 import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "#definition.ts";
 import type { PgBossClientOptionsError, PgBossError, PgBossPayloadError, PgBossQueueNamesError, PgBossQueueOptionsError } from "#error.ts";
@@ -19,7 +20,7 @@ export interface PgBossService {
 	readonly deadLetteredJobs: <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 		queue: { readonly name: TName; readonly schema: TPayload },
 		options: JobPageOptions,
-	) => Effect.Effect<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]>;
+	) => Effect.Effect<JobPage<DeadLetteredJob<unknown>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]>;
 	readonly enqueue: <const TName extends string, const TPayload extends JobPayloadSchema, const TQueue extends QueueDefinition<TName, TPayload>>(
 		queue: QueueDefinition<TName, TPayload> & TQueue,
 		payload: NoInfer<Schema.Schema.Type<TPayload>>,
@@ -28,12 +29,12 @@ export interface PgBossService {
 	readonly failedJobs: <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 		queue: { readonly name: TName; readonly schema: TPayload },
 		options: JobPageOptions,
-	) => Effect.Effect<JobPage<ListedJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]>;
+	) => Effect.Effect<JobPage<ListedJob<unknown>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]>;
 	readonly getJob: <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 		queue: { readonly name: TName; readonly schema: TPayload },
 		id: string,
-	) => Effect.Effect<Option.Option<JobWithMetadata<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
-	readonly health: () => Effect.Effect<JobsHealth, PgBossError>;
+	) => Effect.Effect<Option.Option<JobWithMetadata<unknown>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
+	readonly health: (queues?: readonly Pick<QueueDefinition, "name">[]) => Effect.Effect<JobsHealth, PgBossError>;
 	readonly retry: (queue: Pick<QueueDefinition, "name">, id: string) => Effect.Effect<void, PgBossError>;
 }
 
@@ -49,8 +50,7 @@ export function pgBossLayer(options: PgBossOptions): Layer.Layer<PgBoss, PgBossE
 	return Layer.effect(
 		PgBoss,
 		Effect.gen(function* () {
-			const dependencies = yield* Effect.context<never>();
-			const execute = Effect.runPromiseWith(dependencies);
+			const report = yield* clientErrorReporter(logClientError);
 			const acquired = yield* Effect.acquireRelease(
 				acquireClient(
 					{
@@ -61,9 +61,7 @@ export function pgBossLayer(options: PgBossOptions): Layer.Layer<PgBoss, PgBossE
 							...(connectionString === undefined ? {} : { connectionString: Redacted.value(connectionString) }),
 						},
 					},
-					(error) => {
-						void execute(logClientError(error));
-					},
+					report,
 				),
 				(client) => releaseClient(client, stop),
 			);
@@ -75,6 +73,7 @@ export function pgBossLayer(options: PgBossOptions): Layer.Layer<PgBoss, PgBossE
 export interface PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> {
 	readonly jobs: TRegistrations;
 	readonly onError?: (error: Error) => Effect.Effect<unknown, never, TErrorRequirements>;
+	readonly retired?: readonly string[];
 }
 
 export interface PgBossDefinition<TIdentifier extends string = string> extends Context.Service<TIdentifier, PgBossService> {
@@ -94,23 +93,21 @@ export function makePgBoss<const TIdentifier extends string>(identifier: TIdenti
 			initialize: Effect.gen(function* () {
 				yield* validateQueueNames(options.jobs, queueNames);
 				const acquired = yield* PgBoss;
-				const execute = Effect.runPromiseWith(dependencies);
 				const workerScope = yield* Scope.make();
 				const service = makeService(acquired.client, options.jobs.map(registrationName), acquired.schema);
 				const context = Context.add(dependencies, Service, service);
 				const reportError = options.onError ?? logClientError;
-				const unsubscribe = subscribeClientErrors(acquired.client, (error) => {
-					void execute(Effect.exit(Effect.provide(reportError(error), context)));
-				});
+				const report = yield* clientErrorReporter(reportError).pipe(Effect.provide(context));
+				const unsubscribe = subscribeClientErrors(acquired.client, report);
 				yield* Effect.addFinalizer(() => Scope.close(workerScope, Exit.void).pipe(Effect.ensuring(Effect.sync(unsubscribe))));
 				yield* registerReleasedJobs(
 					acquired.client,
 					options.jobs,
 					context,
 					acquired.reused,
-					(effect) => execute(effect),
 					acquired.schema,
 					acquired.stop?.graceful !== false,
+					options.retired,
 				).pipe(Effect.provideService(Scope.Scope, workerScope), Effect.provide(dependencies));
 				return service;
 			}),

package/src/server/testing.ts

@@ -1,9 +1,10 @@
 import { type DateTime, Duration, Effect, Redacted } from "effect";
 import type { PgBoss } from "pg-boss";
 import type { PgBossClientFactory } from "#client.ts";
+import { defaultClientFactory } from "#defaultClientFactory.ts";
 import type { JobPayloadSchema, QueueDefinition } from "#definition.ts";
 import { PgBossTestingError } from "#error.ts";
-import { nativeClient } from "#internal/nativeClient.ts";
+import { type TestingFetches, testingFetches } from "#internal/adapters/testingFetches.ts";
 import { testingClient } from "#internal/testingClient.ts";
 import { testingDeferrals } from "#internal/testingDeferrals.ts";
 import { type TestingWork, testingIdle } from "#internal/testingIdle.ts";
@@ -11,6 +12,7 @@ import { testingOperation, testingReadout } from "#internal/testingReadout.ts";
 import { testingSchedules } from "#internal/testingSchedules.ts";
 import { testingSignal } from "#internal/testingSignal.ts";
 import { testingSnapshot } from "#internal/testingSnapshot.ts";
+import { testingWaits } from "#internal/testingWaits.ts";
 
 export type SnapshotQueue = Pick<QueueDefinition<string, JobPayloadSchema>, "name" | "schema">;
 
@@ -22,6 +24,10 @@ export interface UnfinishedJob<TQueue extends SnapshotQueue> {
 	readonly state: "active" | "created" | "failed" | "retry";
 }
 
+export interface PgBossTestingWaitOptions {
+	readonly within?: Duration.Input;
+}
+
 export const testRetryPolicy = Object.freeze({ retryBackoff: false, retryDelay: 0 });
 
 export interface PgBossTestingOptions {
@@ -30,6 +36,7 @@ export interface PgBossTestingOptions {
 
 export function makePgBossTesting(options: PgBossTestingOptions = {}) {
 	let current: PgBoss | undefined;
+	let fetches: TestingFetches | undefined;
 	let schema = "pgboss";
 	const signal = testingSignal();
 	const work: TestingWork = { batches: new Set(), queues: new Set() };
@@ -52,12 +59,14 @@ export function makePgBossTesting(options: PgBossTestingOptions = {}) {
 			throw new Error("A testing controller owns one jobs client; create a controller per runtime");
 		}
 		schema = clientOptions.schema ?? "pgboss";
-		current = nativeClient({ ...clientOptions, "__test__enableSpies": true });
+		current = defaultClientFactory({ ...clientOptions, "__test__enableSpies": true });
+		fetches = testingFetches(current.getDb(), signal.changed);
 		return testingClient(current, clientOptions.schema ?? "pgboss", controls);
 	};
 	return {
 		...testingDeferrals(client, () => schema, signal.changed),
 		...testingSchedules(client, signal.changed),
+		...testingWaits(client, () => fetches, signal),
 		checkBatchWindow: (queue: Pick<QueueDefinition, "name" | "workerOptions">, millisecondsPerJob: number) =>
 			testingOperation(
 				"checkBatchWindow",

package/dist/server/internal/nativeClient.d.ts

@@ -1,3 +0,0 @@
-import { type ConstructorOptions, PgBoss } from "pg-boss";
-export declare function nativeClient(options: ConstructorOptions): PgBoss;
-//# sourceMappingURL=nativeClient.d.ts.map

package/dist/server/internal/nativeClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nativeClient.d.ts","sourceRoot":"","sources":["../../../src/server/internal/nativeClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1D,wBAAgB,YAAY,CAAC,OAAO,EAAE,kBAAkB,UA0BvD"}

package/dist/server/internal/nativeClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nativeClient.js","sourceRoot":"","sources":["../../../src/server/internal/nativeClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAA2B,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1D,MAAM,UAAU,YAAY,CAAC,OAA2B;IACvD,MAAM,YAAY,GAAG,IAAI,GAAG,EAAiB,CAAC;IAC9C,MAAM,MAAM,GAAG;QACd,GAAG,OAAO;QACV,MAAM,EAAE,GAAG,EAAE;YACZ,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAC5C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE;gBACzB,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC5B,OAAO,EAAE,CAAC;YACX,CAAC,CAAC,CACF,CAAC;YACF,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACzB,OAAO,MAAM,CAAC;QACf,CAAC;KACD,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,CAAC,IAAI,GAAG,KAAK,EAAE,WAAW,EAAE,EAAE;QACnC,MAAM,IAAI,CAAC,WAAW,CAAC,CAAC;QACxB,0EAA0E;QAC1E,IAAI,WAAW,EAAE,KAAK,KAAK,KAAK,EAAE,CAAC;YAClC,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;QACtC,CAAC;IACF,CAAC,CAAC;IACF,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/server/internal/registerWorker.d.ts

@@ -1,6 +0,0 @@
-import { type Context, Effect, Scope } from "effect";
-import type { Job, WorkOptions } from "pg-boss";
-import type { PgBossClient } from "#client.ts";
-import { type PgBossRunner } from "#internal/batchHandler.ts";
-export declare const registerWorker: (client: PgBossClient, name: string, options: WorkOptions, run: (job: Job<unknown>, deadline: number) => Effect.Effect<unknown, unknown, unknown>, scope: Scope.Scope, schema: string, maxDeferrals: number, context: Context.Context<unknown>, execute: PgBossRunner, graceful: boolean) => Effect.Effect<string, import("#error.ts").PgBossError, never>;
-//# sourceMappingURL=registerWorker.d.ts.map

package/dist/server/internal/registerWorker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerWorker.d.ts","sourceRoot":"","sources":["../../../src/server/internal/registerWorker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,EAAS,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC5D,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAK5E,eAAO,MAAM,cAAc,wEAIf,GAAG,CAAC,OAAO,CAAC,YAAY,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,yMAmCrF,CAAC"}

package/dist/server/internal/registerWorker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerWorker.js","sourceRoot":"","sources":["../../../src/server/internal/registerWorker.ts"],"names":[],"mappings":"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"}

package/dist/server/internal/scheduleDefinition.d.ts

@@ -1,3 +0,0 @@
-import type { DefineScheduleOptions, ScheduleDefinition } from "#definition.ts";
-export declare function scheduleDefinition<const TName extends string>(options: DefineScheduleOptions<TName>): ScheduleDefinition<TName>;
-//# sourceMappingURL=scheduleDefinition.d.ts.map

package/dist/server/internal/scheduleDefinition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduleDefinition.d.ts","sourceRoot":"","sources":["../../../src/server/internal/scheduleDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGhF,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAiB/H"}

package/dist/server/internal/scheduleDefinition.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduleDefinition.js","sourceRoot":"","sources":["../../../src/server/internal/scheduleDefinition.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAElF,MAAM,UAAU,kBAAkB,CAA6B,OAAqC;IACnG,MAAM,UAAU,GAA8B;QAC7C,IAAI,EAAE,oBAAoB;QAC1B,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,YAAY,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC;QACzC,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC;QAC/C,GAAG,EAAE,CAAC,MAAM,EAAE,EAAE,CACf,MAAM,CAAC,MAAM,CAAC;YACb,IAAI,EAAE,iBAA0B;YAChC,MAAM;YACN,QAAQ,EAAE,UAAU;SACpB,CAAC;QACH,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;QAClE,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;KAC5F,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AAClC,CAAC"}