@shivaedev/jobs 0.25.0 → 0.26.0

package/src/server/adapters/installSchema.ts

@@ -0,0 +1,68 @@
+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 { jobStorePlans } from "#internal/jobStorePlans.ts";
+import type { PgBossSchemaOptions } from "#schema.ts";
+import { runSchemaPlan } from "./runSchemaPlan.ts";
+import { resumeSchemaIndexes } from "./schemaIndexBuilds.ts";
+
+const Partitions = Schema.Array(
+	Schema.Struct({
+		policy: Schema.String,
+		tableName: Schema.String,
+	}),
+);
+async function installNativeSchema(
+	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 const installSchema = Effect.fnUntraced(function* (options: PgBossSchemaOptions) {
+	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 (signal) => {
+			const execute: typeof run = (effect) => run(effect, { signal });
+			await installNativeSchema(connection, options, execute);
+		},
+	});
+	for (const plan of jobStorePlans(options.schema ?? "pgboss")) {
+		yield* connection.executeRaw(plan, []);
+	}
+});

package/src/server/{internal → adapters}/registerWorker.ts

@@ -1,27 +1,26 @@
-import { type Context, Effect, Fiber, Scope } from "effect";
+import { Effect, Fiber, Scope } from "effect";
 import type { Job, WorkOptions } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
 import { toPgBossError } from "#error.ts";
-import { batchHandler, type PgBossRunner } from "#internal/batchHandler.ts";
+import { batchHandler } from "#internal/batchHandler.ts";
 import { deferrableAttempt } from "#internal/deferrableAttempt.ts";
 import { retryWake } from "#internal/retryWake.ts";
 import { traceJob } from "#internal/tracing.ts";
 
-export const registerWorker = Effect.fnUntraced(function* (
+export const registerWorker = Effect.fnUntraced(function* <R>(
 	client: PgBossClient,
 	name: string,
 	options: WorkOptions,
-	run: (job: Job<unknown>, deadline: number) => Effect.Effect<unknown, unknown, unknown>,
+	run: (job: Job<unknown>, deadline: number) => Effect.Effect<unknown, unknown, R>,
 	scope: Scope.Scope,
 	schema: string,
 	maxDeferrals: number,
-	context: Context.Context<unknown>,
-	execute: PgBossRunner,
 	graceful: boolean,
 ) {
+	const execute = Effect.runPromiseWith(yield* Effect.context<R>());
 	const fibers = yield* Scope.fork(scope);
 	function runJob(job: Job<unknown>, deadline: number) {
-		return Effect.provide(traceJob(deferrableAttempt(run(job, deadline), client, schema, job, maxDeferrals), job, name), context);
+		return traceJob(deferrableAttempt(run(job, deadline), client, schema, job, maxDeferrals), job, name);
 	}
 	function afterFailure(attempt: Job<unknown>) {
 		return retryWake(client, name, attempt.id, registration).pipe(Effect.forkIn(fibers), Effect.asVoid);

package/src/server/adapters/workerDiagnostics.ts

@@ -0,0 +1,28 @@
+import { Context, Effect, Logger, References } from "effect";
+import { redact } from "@shivaedev/errors/redact.ts";
+import { redactDiagnosticCause } from "@shivaedev/errors/redactCause.ts";
+import { isSensitiveKey, REDACTED } from "@shivaedev/errors/sensitive.ts";
+
+function maskedLogger(logger: Logger.Logger<unknown, unknown>) {
+	return Logger.make((options) => {
+		const context = options.fiber.context;
+		const annotations = Object.fromEntries(
+			Object.entries(options.fiber.getRef(References.CurrentLogAnnotations)).map(([key, value]) => [
+				key,
+				isSensitiveKey(key) ? REDACTED : redact(value),
+			]),
+		);
+		options.fiber.setContext(Context.add(context, References.CurrentLogAnnotations, annotations));
+		try {
+			return logger.log({ ...options, cause: redactDiagnosticCause(options.cause), message: redact(options.message) });
+		} finally {
+			options.fiber.setContext(context);
+		}
+	});
+}
+
+export function workerDiagnostics<A, E, R>(effect: Effect.Effect<A, E, R>) {
+	return Effect.flatMap(Logger.CurrentLoggers, (loggers) =>
+		Effect.provideService(effect, Logger.CurrentLoggers, new Set([...loggers].map(maskedLogger))),
+	);
+}

package/src/server/client.ts

@@ -11,7 +11,6 @@ import type {
 	StopOptions,
 	WorkOptions,
 } from "pg-boss";
-import { nativeClient } from "#internal/nativeClient.ts";
 
 export interface PgBossClient {
 	readonly complete?: PgBoss["complete"];
@@ -36,5 +35,3 @@ export interface PgBossClient {
 }
 
 export type PgBossClientFactory = (options: ConstructorOptions) => PgBossClient;
-
-export const defaultClientFactory: PgBossClientFactory = nativeClient;

package/src/server/{internal/nativeClient.ts → defaultClientFactory.ts}

@@ -1,7 +1,7 @@
 import { Socket } from "node:net";
 import { type ConstructorOptions, PgBoss } from "pg-boss";
 
-export function nativeClient(options: ConstructorOptions) {
+export function defaultClientFactory(options: ConstructorOptions) {
 	const disconnected = new Set<Promise<void>>();
 	const config = {
 		...options,

package/src/server/{internal/scheduleDefinition.ts → defineSchedule.ts}

@@ -1,7 +1,7 @@
 import type { DefineScheduleOptions, ScheduleDefinition } from "#definition.ts";
 import { maxDeferrals, nativeQueueOptions } from "#internal/definitionOptions.ts";
 
-export function scheduleDefinition<const TName extends string>(options: DefineScheduleOptions<TName>): ScheduleDefinition<TName> {
+export function defineSchedule<const TName extends string>(options: DefineScheduleOptions<TName>): ScheduleDefinition<TName> {
 	const definition: ScheduleDefinition<TName> = {
 		_tag: "ScheduleDefinition",
 		cron: options.cron,

package/src/server/definition.ts

@@ -1,7 +1,6 @@
 import { Clock, Duration, Effect, Schema } from "effect";
 import type { Job, policies, Queue, ScheduleOptions, WorkOptions } from "pg-boss";
 import { maxDeferrals, nativeQueueOptions } from "#internal/definitionOptions.ts";
-import { scheduleDefinition } from "#internal/scheduleDefinition.ts";
 
 export class RetryAt extends Schema.TaggedError<RetryAt>()("RetryAt", {
 	at: Schema.DateTimeUtc,
@@ -123,10 +122,6 @@ export interface DefineScheduleOptions<TName extends string> {
 	readonly worker?: WorkOptions;
 }
 
-export function defineSchedule<const TName extends string>(options: DefineScheduleOptions<TName>): ScheduleDefinition<TName> {
-	return scheduleDefinition(options);
-}
-
 export function jobContext(job: Job<unknown>, deadline: number): JobContext {
 	return {
 		expireInSeconds: job.expireInSeconds,

package/src/server/error.ts

@@ -1,4 +1,4 @@
-import { Cause, Data, Redacted } from "effect";
+import { Cause, Data, Duration, Redacted } from "effect";
 import { failureOutput } from "#internal/failureOutput.ts";
 
 export type PgBossOperation =
@@ -76,6 +76,16 @@ export class PgBossTestingError extends Data.TaggedError("PgBossTestingError")<{
 	readonly queue?: string | undefined;
 }> {}
 
+export class PgBossWaitError extends Data.TaggedError("PgBossWaitError")<{
+	readonly lastSeen: string;
+	readonly waitingFor: string;
+	readonly within: Duration.Duration;
+}> {
+	override get message(): string {
+		return `Gave up after ${Duration.format(this.within)} waiting until ${this.waitingFor}; last seen: ${this.lastSeen}`;
+	}
+}
+
 export function toPgBossError(operation: PgBossOperation, error: unknown, queue?: string): PgBossError {
 	return new PgBossError({
 		operation,

package/src/server/health.ts

@@ -48,6 +48,7 @@ export interface ListedJob<TData> {
 export interface DeadLetteredJob<TData> extends ListedJob<TData> {
 	readonly sourceId: Option.Option<string>;
 	readonly sourceOutput: JobFailure | null;
+	readonly sourceQueue: string;
 }
 
 export interface JobPageOptions {

package/src/server/internal/adapters/testingFetches.ts

@@ -0,0 +1,36 @@
+import type { PgBoss } from "pg-boss";
+
+// pg-boss offers no hook for a worker fetch that finds nothing, so the controller recognizes its claim statement on the client's database.
+const claim = /UPDATE\s+\S+\s+j\s+SET\s+state\s*=\s*'active'/u;
+const claimedQueue = /\bj\.name\s*=\s*'(?<queue>[^']+)'/u;
+
+export interface TestingFetches {
+	readonly begun: (queue: string) => number;
+	readonly passedSince: (queue: string, begun: number) => number;
+}
+
+export function testingFetches(db: ReturnType<PgBoss["getDb"]>, changed: () => void): TestingFetches {
+	const begun = new Map<string, number>();
+	const passed = new Map<string, number[]>();
+	const executeSql = db.executeSql.bind(db);
+	db.executeSql = async (text: string, values?: unknown[]) => {
+		const queue = claim.test(text) ? claimedQueue.exec(text)?.groups?.queue : undefined;
+		if (queue === undefined) {
+			return executeSql(text, values);
+		}
+		const ordinal = (begun.get(queue) ?? 0) + 1;
+		begun.set(queue, ordinal);
+		try {
+			return await executeSql(text, values);
+		} finally {
+			const ordinals = passed.get(queue) ?? [];
+			ordinals.push(ordinal);
+			passed.set(queue, ordinals);
+			changed();
+		}
+	};
+	return {
+		begun: (queue) => begun.get(queue) ?? 0,
+		passedSince: (queue, mark) => (passed.get(queue) ?? []).filter((ordinal) => ordinal > mark).length,
+	};
+}

package/src/server/internal/batchHandler.ts

@@ -24,7 +24,14 @@ function settleAttempt(
 	});
 }
 
-export type PgBossRunner = <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
+const interruptAt = Effect.fnUntraced(function* (deadline: number) {
+	let remaining = deadline - (yield* Clock.currentTimeMillis);
+	while (remaining > 0) {
+		yield* Effect.sleep(remaining);
+		remaining = deadline - (yield* Clock.currentTimeMillis);
+	}
+	return yield* Effect.interrupt;
+});
 
 function aborted(signal: AbortSignal) {
 	return Effect.callback<never>((resume) => {
@@ -40,11 +47,11 @@ function aborted(signal: AbortSignal) {
 	});
 }
 
-export function batchHandler(
+export function batchHandler<R>(
 	client: PgBossClient,
 	name: string,
 	schema: string,
-	run: (job: Job<unknown>, deadline: number) => Effect.Effect<unknown, unknown>,
+	run: (job: Job<unknown>, deadline: number) => Effect.Effect<unknown, unknown, R>,
 	afterFailure: (job: Job<unknown>) => Effect.Effect<void, unknown> = () => Effect.void,
 ) {
 	const complete = client.complete?.bind(client);
@@ -61,11 +68,7 @@ export function batchHandler(
 		if (remaining <= 0) {
 			return "expired";
 		}
-		const exit = yield* run(job, deadline).pipe(
-			Effect.timeoutOrElse({ duration: remaining, orElse: () => Effect.interrupt }),
-			Effect.raceFirst(aborted(job.signal)),
-			Effect.exit,
-		);
+		const exit = yield* run(job, deadline).pipe(Effect.raceFirst(interruptAt(deadline)), Effect.raceFirst(aborted(job.signal)), Effect.exit);
 		if (job.signal.aborted || (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause))) {
 			return "interrupted";
 		}

package/src/server/internal/deadLetterResolutionPlan.ts

@@ -0,0 +1,28 @@
+import { quotedSchema } from "#internal/storedRows.ts";
+
+export function deadLetterResolutionPlan(schema: string): string {
+	const quoted = quotedSchema(schema);
+	const jobTable = `${quoted}.job`.replaceAll("'", "''");
+	const body = `BEGIN
+		PERFORM pg_advisory_xact_lock(hashtextextended('${jobTable}.effect_dead_letter_resolution', 0));
+		CREATE OR REPLACE FUNCTION ${quoted}.effect_dead_letter_resolution() RETURNS trigger LANGUAGE plpgsql AS $resolve$
+		BEGIN
+			DELETE FROM ${quoted}.job
+			WHERE name = NEW.name || '-dlq' AND source_name = NEW.name AND source_id = NEW.id
+				AND source_created_on = NEW.created_on;
+			RETURN NEW;
+		END
+		$resolve$;
+		IF NOT EXISTS (
+			SELECT 1 FROM pg_trigger WHERE tgrelid = '${jobTable}'::regclass AND tgname = 'effect_dead_letter_resolution'
+		) THEN
+			CREATE TRIGGER effect_dead_letter_resolution AFTER UPDATE OF state ON ${quoted}.job
+			FOR EACH ROW WHEN (NEW.state = 'completed' AND OLD.state IS DISTINCT FROM NEW.state)
+			EXECUTE FUNCTION ${quoted}.effect_dead_letter_resolution();
+			DELETE FROM ${quoted}.job AS copy USING ${quoted}.job AS source
+			WHERE source.state = 'completed' AND copy.name = source.name || '-dlq'
+				AND copy.source_name = source.name AND copy.source_id = source.id AND copy.source_created_on = source.created_on;
+		END IF;
+	END`;
+	return `DO '${body.replaceAll("'", "''")}'`;
+}

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;
@@ -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

@@ -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>, 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 {