@shivaedev/jobs 0.24.0 → 0.26.0

package/src/server/internal/enqueueFor.ts

@@ -1,14 +1,14 @@
 import { Effect, Option, Redacted, Schema } from "effect";
+import { transactionDb } from "#adapters/transactionDb.ts";
 import type { PgBossClient } from "#client.ts";
 import { PgBossPayloadError, toPgBossError } from "#error.ts";
 import { capturePayload } from "#internal/tracing.ts";
-import { transactionDb } from "#internal/transactionDb.ts";
 import type { PgBossService } from "#service.ts";
 
 export function enqueueFor(client: PgBossClient): PgBossService["enqueue"] {
 	return (queue, payload, options) =>
 		Effect.gen(function* () {
-			const encoded = yield* Schema.encodeUnknownEffect(queue.schema)(payload).pipe(
+			const encoded = yield* Schema.encodeUnknownEffect(Schema.toCodecJson(queue.schema))(payload).pipe(
 				Effect.mapError((error) => new PgBossPayloadError({ direction: "encode", original: Redacted.make(error), queue: queue.name })),
 			);
 			if (typeof encoded !== "object" || encoded === null) {

package/src/server/internal/jobControl.ts

@@ -1,4 +1,5 @@
 import { Effect, Option } from "effect";
+import { redact } from "@shivaedev/errors/redact.ts";
 import type { PgBossClient } from "#client.ts";
 import { toPgBossError } from "#error.ts";
 import { decodeStoredData } from "#internal/storedRows.ts";
@@ -18,7 +19,7 @@ export function getJobFor(client: PgBossClient): PgBossService["getJob"] {
 			Effect.flatMap((job) =>
 				job === undefined
 					? Effect.succeed(Option.none())
-					: decodeStoredData(queue, job.data).pipe(Effect.map((data) => Option.some({ ...job, data }))),
+					: decodeStoredData(queue, job.data).pipe(Effect.map((data) => Option.some({ ...job, data: redact(data) }))),
 			),
 		);
 }

package/src/server/internal/jobStorePlans.ts

@@ -0,0 +1,6 @@
+import { deadLetterResolutionPlan } from "#internal/deadLetterResolutionPlan.ts";
+import { deferralStorePlan } from "#internal/deferralStorePlan.ts";
+
+export function jobStorePlans(schema: string): readonly string[] {
+	return [deferralStorePlan(schema), deadLetterResolutionPlan(schema)];
+}

package/src/server/internal/lifecycle.ts

@@ -1,8 +1,9 @@
 import { Effect } from "effect";
 import type { ConstructorOptions, StopOptions } from "pg-boss";
-import { defaultClientFactory, type PgBossClient, type PgBossClientFactory } from "#client.ts";
+import type { PgBossClient, PgBossClientFactory } from "#client.ts";
+import { defaultClientFactory } from "#defaultClientFactory.ts";
 import { PgBossClientOptionsError, type PgBossError, toPgBossError } from "#error.ts";
-import { deferralStorePlan } from "#internal/deferralStorePlan.ts";
+import { jobStorePlans } from "#internal/jobStorePlans.ts";
 import { acquireCachedClient, releaseCachedClient } from "./clientCache.ts";
 import { observeClientErrors } from "./clientErrors.ts";
 
@@ -24,7 +25,9 @@ async function startClient(options: AcquireClientOptions, report: (error: Error)
 	try {
 		await client.start();
 		if (options.constructor.migrate !== false && client.getDb !== undefined) {
-			await client.getDb().executeSql(deferralStorePlan(options.constructor.schema ?? "pgboss"));
+			for (const plan of jobStorePlans(options.constructor.schema ?? "pgboss")) {
+				await client.getDb().executeSql(plan);
+			}
 		}
 		return client;
 	} catch (error) {

package/src/server/internal/listJobs.ts

@@ -1,4 +1,5 @@
 import { Effect, Option, Redacted, Schema } from "effect";
+import { redact } from "@shivaedev/errors/redact.ts";
 import type { PgBossClient } from "#client.ts";
 import type { JobPayloadSchema } from "#definition.ts";
 import { type PgBossError, PgBossPayloadError, toPgBossError } from "#error.ts";
@@ -50,7 +51,10 @@ export function failedJobsFor(client: PgBossClient, schema: string): PgBossServi
 }
 
 export function deadLetteredJobsFor(client: PgBossClient, schema: string): PgBossService["deadLetteredJobs"] {
-	return (queue, options) => listJobs(client, schema, "deadLetteredJobs", queue, options);
+	return (queue, options) =>
+		listJobs(client, schema, "deadLetteredJobs", queue, options).pipe(
+			Effect.map(({ jobs, next }) => ({ jobs: jobs.map((job) => ({ ...job, sourceQueue: queue.name })), next })),
+		);
 }
 
 const listJobs = Effect.fnUntraced(function* <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
@@ -59,7 +63,11 @@ const listJobs = Effect.fnUntraced(function* <const TName extends string, const
 	listing: Listing,
 	queue: { readonly name: TName; readonly schema: TPayload },
 	options: JobPageOptions,
-): Effect.fn.Return<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]> {
+): Effect.fn.Return<
+	JobPage<Omit<DeadLetteredJob<unknown>, "sourceQueue">>,
+	PgBossError | PgBossPayloadError | Schema.SchemaError,
+	TPayload["DecodingServices"]
+> {
 	const { cursor: after, limit } = yield* Schema.decodeUnknownEffect(PageOptions)(options);
 	const rows = yield* Effect.tryPromise({
 		catch: (error) => toPgBossError(listing, error, queue.name),
@@ -102,7 +110,7 @@ const listJobs = Effect.fnUntraced(function* <const TName extends string, const
 	const next = decodedRows.length > limit && last !== undefined ? Option.some(Schema.encodeSync(Cursor)([last.cursorAt, last.id])) : Option.none();
 	return yield* Effect.forEach(page, ({ cursorAt: _, data, ...row }) =>
 		decodeStoredData(queue, data).pipe(
-			Effect.map((decoded) => ({ ...row, attempt: Option.isSome(row.startedOn) ? row.retryCount + 1 : 0, data: decoded })),
+			Effect.map((decoded) => ({ ...row, attempt: Option.isSome(row.startedOn) ? row.retryCount + 1 : 0, data: redact(decoded) })),
 		),
 	).pipe(Effect.map((jobs) => ({ jobs, next })));
 });

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;
@@ -74,14 +72,12 @@ const registerQueue = Effect.fnUntraced(function* (
 		client,
 		name,
 		queue.workerOptions,
-		(job) => runQueueWorker(registration, job),
+		(job, deadline) => runQueueWorker(registration, job, deadline),
 		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

@@ -3,7 +3,6 @@ import { WorkerRelease } from "@shivaedev/sql/WorkerRelease.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 +10,17 @@ export const registerReleasedJobs = Effect.fnUntraced(function* <R>(
 	jobs: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
-	execute: PgBossRunner,
 	schema: string | undefined,
 	graceful: boolean,
 ) {
 	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(
-		Effect.provideService(Scope.Scope, scope),
-	);
+	const register = registerJobs(client, jobs, context, replaceWorkers, schema, true, graceful).pipe(Effect.provideService(Scope.Scope, scope));
 	if (Option.isNone(signal) || workers.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>) {
-	return Schema.decodeUnknownEffect(worker.queue.schema)(payloadOf(job.data)).pipe(
+export function runQueueWorker(worker: QueueWorker, job: Job<unknown>, deadline: number) {
+	return Schema.decodeUnknownEffect(Schema.toCodecJson(worker.queue.schema))(payloadOf(job.data)).pipe(
 		Effect.mapError(
 			(error) =>
 				new PgBossPayloadError({
@@ -14,6 +15,7 @@ export function runQueueWorker(worker: QueueWorker, job: Job<unknown>) {
 					queue: worker.queue.name,
 				}),
 		),
-		Effect.flatMap((payload) => worker.handler(payload, jobContext(job))),
+		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/internal/waitForBatchExpiry.ts

@@ -2,15 +2,18 @@ import { Clock, Effect } from "effect";
 import type { Job } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
 import { type PgBossError, toPgBossError } from "#error.ts";
-import { deadlineOf } from "#internal/deadlineOf.ts";
 
-export function waitForBatchExpiry(client: PgBossClient, name: string, jobs: readonly Job<unknown>[]): Effect.Effect<void, PgBossError> {
+export function waitForBatchExpiry(
+	client: PgBossClient,
+	name: string,
+	jobs: readonly Job<unknown>[],
+	deadline: number,
+): Effect.Effect<void, PgBossError> {
 	return Effect.gen(function* () {
 		const findJobs = client.findJobs?.bind(client);
 		if (findJobs === undefined) {
 			return yield* Effect.fail(new TypeError("This pg-boss client does not support reading interrupted claims"));
 		}
-		const deadline = Math.max(0, ...jobs.map(deadlineOf)) + 1000;
 		let delay = 25;
 		const poll = Effect.gen(function* () {
 			for (const job of jobs) {
@@ -25,6 +28,6 @@ export function waitForBatchExpiry(client: PgBossClient, name: string, jobs: rea
 				}
 			}
 		});
-		return yield* poll.pipe(Effect.timeout(Math.max(0, deadline - (yield* Clock.currentTimeMillis))));
+		return yield* poll.pipe(Effect.timeout(Math.max(0, deadline + 1000 - (yield* Clock.currentTimeMillis))));
 	}).pipe(Effect.mapError((error) => toPgBossError("settle", error, name)));
 }

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,11 +29,11 @@ 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"]>;
+	) => Effect.Effect<Option.Option<JobWithMetadata<unknown>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
 	readonly health: () => 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),
 			);
@@ -94,24 +92,17 @@ 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,
-				).pipe(Effect.provideService(Scope.Scope, workerScope), Effect.provide(dependencies));
+				yield* registerReleasedJobs(acquired.client, options.jobs, context, acquired.reused, acquired.schema, acquired.stop?.graceful !== false).pipe(
+					Effect.provideService(Scope.Scope, workerScope),
+					Effect.provide(dependencies),
+				);
 				return service;
 			}),
 			methods: (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>) => 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