@shivaedev/jobs 0.22.0 → 0.23.0

package/src/server/internal/lifecycle.ts

@@ -4,7 +4,7 @@ import { defaultClientFactory, type PgBossClient, type PgBossClientFactory } fro
 import { PgBossClientOptionsError, type PgBossError, toPgBossError } from "#error.ts";
 import { deferralStorePlan } from "#internal/deferralStorePlan.ts";
 import { acquireCachedClient, releaseCachedClient } from "./clientCache.ts";
-import { logClientError, observeClientErrors } from "./clientErrors.ts";
+import { observeClientErrors } from "./clientErrors.ts";
 
 export interface AcquireClientOptions {
 	readonly clientCacheKey?: string | symbol | undefined;
@@ -37,21 +37,18 @@ async function startClient(options: AcquireClientOptions, report: (error: Error)
 	}
 }
 
-export function acquireClient(options: AcquireClientOptions): Effect.Effect<AcquiredClient, PgBossError | PgBossClientOptionsError> {
-	return Effect.contextWith((context) => {
-		const run = Effect.runForkWith(context);
-		function report(error: Error) {
-			run(logClientError(error));
-		}
-		return Effect.tryPromise({
-			catch: (error) => (error instanceof PgBossClientOptionsError ? error : toPgBossError("start", error)),
-			try: async () => {
-				const cacheKey = options.clientCacheKey;
-				return cacheKey === undefined
-					? { client: await startClient(options, report), reused: false }
-					: { cacheKey, ...(await acquireCachedClient(cacheKey, options.constructor, () => startClient(options, report))) };
-			},
-		});
+export function acquireClient(
+	options: AcquireClientOptions,
+	report: (error: Error) => void,
+): Effect.Effect<AcquiredClient, PgBossError | PgBossClientOptionsError> {
+	return Effect.tryPromise({
+		catch: (error) => (error instanceof PgBossClientOptionsError ? error : toPgBossError("start", error)),
+		try: async () => {
+			const cacheKey = options.clientCacheKey;
+			return cacheKey === undefined
+				? { client: await startClient(options, report), reused: false }
+				: { cacheKey, ...(await acquireCachedClient(cacheKey, options.constructor, () => startClient(options, report))) };
+		},
 	});
 }
 

package/src/server/internal/listJobs.ts

@@ -1,12 +1,26 @@
-import { Effect, Option, Schema } from "effect";
+import { Effect, Option, Redacted, Schema } from "effect";
 import type { PgBossClient } from "#client.ts";
 import type { JobPayloadSchema } from "#definition.ts";
-import { type PgBossError, type PgBossPayloadError, toPgBossError } from "#error.ts";
+import { type PgBossError, PgBossPayloadError, toPgBossError } from "#error.ts";
 import { type DeadLetteredJob, deadLetterQueueName, type JobPage, type JobPageOptions } from "#health.ts";
 import { decodeStoredData, quotedSchema } from "#internal/storedRows.ts";
+import { JobFailure } from "#JobFailure.ts";
 import type { PgBossService } from "#service.ts";
 
-const Cursor = Schema.StringFromBase64Url.pipe(Schema.decodeTo(Schema.fromJsonString(Schema.Tuple([Schema.String, Schema.String]))));
+const Cursor = Schema.StringFromBase64Url.pipe(
+	Schema.decodeTo(
+		Schema.fromJsonString(
+			Schema.Tuple([
+				Schema.String.check(Schema.makeFilter((value) => Option.isSome(Schema.decodeUnknownOption(Schema.DateTimeUtcFromString)(value)))),
+				Schema.String.check(Schema.isUUID()),
+			]),
+		),
+	),
+);
+const PageOptions = Schema.Struct({
+	cursor: Schema.optionalKey(Schema.UndefinedOr(Cursor)),
+	limit: Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0)),
+});
 
 const Row = Schema.Struct({
 	completedOn: Schema.OptionFromNullOr(Schema.DateTimeUtcFromDate),
@@ -14,12 +28,12 @@ const Row = Schema.Struct({
 	cursorAt: Schema.String,
 	data: Schema.Unknown,
 	id: Schema.String,
-	output: Schema.Unknown,
+	output: Schema.NullOr(JobFailure),
 	queue: Schema.String,
 	retryCount: Schema.Number,
 	retryLimit: Schema.Number,
 	sourceId: Schema.OptionFromNullOr(Schema.String),
-	sourceOutput: Schema.Unknown,
+	sourceOutput: Schema.NullOr(JobFailure),
 	startedOn: Schema.OptionFromNullOr(Schema.DateTimeUtcFromDate),
 	state: Schema.Literals(["created", "retry", "active", "completed", "cancelled", "failed"]),
 });
@@ -39,60 +53,56 @@ export function deadLetteredJobsFor(client: PgBossClient, schema: string): PgBos
 	return (queue, options) => listJobs(client, schema, "deadLetteredJobs", queue, options);
 }
 
-function listJobs<const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
+const listJobs = Effect.fnUntraced(function* <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 	client: PgBossClient,
 	schema: string,
 	listing: Listing,
 	queue: { readonly name: TName; readonly schema: TPayload },
 	options: JobPageOptions,
-): Effect.Effect<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]> {
-	return Effect.tryPromise({
+): Effect.fn.Return<JobPage<DeadLetteredJob<TPayload["Type"]>>, 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),
 		try: async () => {
 			if (client.getDb === undefined) {
 				throw new TypeError("This pg-boss client does not support getDb");
 			}
-			if (!Number.isSafeInteger(options.limit) || options.limit < 1) {
-				throw new RangeError("The page limit must be a positive integer");
-			}
-			const after = options.cursor === undefined ? undefined : await Schema.decodeUnknownPromise(Cursor)(options.cursor);
 			const quoted = quotedSchema(schema);
-			const { rows } = await client.getDb().executeSql(
+			const { rows: storedRows } = await client.getDb().executeSql(
 				`SELECT
-						id,
-						name AS queue,
-						state,
-						retry_count AS "retryCount",
-						retry_limit AS "retryLimit",
-						created_on AS "createdOn",
-						started_on AS "startedOn",
-						completed_on AS "completedOn",
-						output,
-						data,
-						source_id AS "sourceId",
-						source_output AS "sourceOutput",
-						to_json(created_on) #>> '{}' AS "cursorAt"
-					FROM ${quoted}.job
-					WHERE name = $1
-						${listing === "failedJobs" ? "AND state = 'failed'" : ""}
-						AND ($2::timestamptz IS NULL OR (created_on, id) < ($2::timestamptz, $3::uuid))
-					ORDER BY created_on DESC, id DESC
-					LIMIT $4`,
-				[listing === "failedJobs" ? queue.name : deadLetterQueueName(queue.name), after?.[0] ?? null, after?.[1] ?? null, options.limit + 1],
+					id,
+					name AS queue,
+					state,
+					retry_count AS "retryCount",
+					retry_limit AS "retryLimit",
+					created_on AS "createdOn",
+					started_on AS "startedOn",
+					completed_on AS "completedOn",
+					output,
+					data,
+					source_id AS "sourceId",
+					source_output AS "sourceOutput",
+					to_json(created_on) #>> '{}' AS "cursorAt"
+				FROM ${quoted}.job
+				WHERE name = $1
+					${listing === "failedJobs" ? "AND state = 'failed'" : ""}
+					AND ($2::timestamptz IS NULL OR (created_on, id) < ($2::timestamptz, $3::uuid))
+				ORDER BY created_on DESC, id DESC
+				LIMIT $4`,
+				[listing === "failedJobs" ? queue.name : deadLetterQueueName(queue.name), after?.[0] ?? null, after?.[1] ?? null, limit + 1],
 			);
-			return Schema.decodeUnknownPromise(Rows)(rows);
+			return storedRows;
 		},
-	}).pipe(
-		Effect.flatMap((rows) => {
-			const page = rows.slice(0, options.limit);
-			const last = page.at(-1);
-			const next =
-				rows.length > options.limit && last !== undefined ? Option.some(Schema.encodeSync(Cursor)([last.cursorAt, last.id])) : Option.none();
-			return 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 })),
-				),
-			).pipe(Effect.map((jobs) => ({ jobs, next })));
-		}),
+	});
+	const decodedRows = yield* Schema.decodeUnknownEffect(Rows)(rows).pipe(
+		Effect.mapError((error) => new PgBossPayloadError({ direction: "decode", original: Redacted.make(error), queue: queue.name })),
 	);
-}
+	const page = decodedRows.slice(0, limit);
+	const last = page.at(-1);
+	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 })),
+		),
+	).pipe(Effect.map((jobs) => ({ jobs, next })));
+});

package/src/server/internal/makeService.ts

@@ -13,7 +13,7 @@ export function makeService(client: PgBossClient, names: readonly string[], sche
 		enqueue: enqueueFor(client),
 		failedJobs: failedJobsFor(client, schema),
 		getJob: getJobFor(client),
-		health: healthFor(client, names),
+		health: () => healthFor(client, names),
 		retry: retryFor(client),
 	};
 }

package/src/server/internal/register.ts

@@ -1,18 +1,11 @@
-import { type Context, Effect, Redacted, Schema, type Scope } from "effect";
-import type { Job } from "pg-boss";
+import { type Context, Effect, type Scope } from "effect";
 import type { PgBossClient } from "#client.ts";
-import {
-	type JobRegistration,
-	jobContext,
-	type QueueDefinition,
-	type QueueWorker,
-	type ScheduleDefinition,
-	type ScheduledWorker,
-} from "#definition.ts";
-import { PgBossError, PgBossPayloadError, PgBossQueueOptionsError, toPgBossError } from "#error.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 { payloadOf } from "#internal/tracing.ts";
+import { runQueueWorker } from "#internal/runQueueWorker.ts";
 
 function isQueueWorker(registration: JobRegistration): registration is QueueWorker {
 	return registration._tag === "QueueWorker";
@@ -43,21 +36,19 @@ export function registrationName(registration: JobRegistration): string {
 	return registrationDefinition(registration).name;
 }
 
-async function prepareQueues(client: PgBossClient, registrations: readonly JobRegistration[], replaceWorkers: boolean): Promise<void> {
+const prepareQueues = Effect.fnUntraced(function* (client: PgBossClient, registrations: readonly JobRegistration[], replaceWorkers: boolean) {
 	for (const registration of registrations) {
 		if (replaceWorkers && !isQueueDefinition(registration)) {
-			await client.offWork(registrationName(registration));
+			yield* Effect.tryPromise({ catch: (error) => toPgBossError("register", error), try: () => client.offWork(registrationName(registration)) });
 		}
 	}
 	for (const registration of registrations) {
 		const definition = registrationDefinition(registration);
-		try {
-			await ensureQueue(client, definition.name, definition.queueOptions);
-		} catch (error) {
-			throw error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error, definition.name);
-		}
+		yield* ensureQueue(client, definition.name, definition.queueOptions).pipe(
+			Effect.mapError((error) => (error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error, definition.name))),
+		);
 	}
-}
+});
 
 // The layer requires RegistrationRequirements of its jobs, so its context provides every registered worker.
 function workerContext<R>(context: Context.Context<R>): Context.Context<unknown>;
@@ -65,46 +56,61 @@ function workerContext(context: unknown): unknown {
 	return context;
 }
 
-function runQueueWorker(worker: QueueWorker, job: Job<unknown>) {
-	return Schema.decodeUnknownEffect(worker.queue.schema)(payloadOf(job.data)).pipe(
-		Effect.mapError(
-			(error) =>
-				new PgBossPayloadError({
-					direction: "decode",
-					original: Redacted.make(error),
-					queue: worker.queue.name,
-				}),
-		),
-		Effect.flatMap((payload) => worker.handler(payload, jobContext(job))),
-	);
-}
-
-async function registerQueue(
+const registerQueue = Effect.fnUntraced(function* (
 	client: PgBossClient,
 	registration: QueueWorker | QueueDefinition,
 	context: Context.Context<unknown>,
 	scope: Scope.Scope,
 	schema: string,
-): Promise<void> {
+	execute: PgBossRunner,
+	graceful: boolean,
+) {
 	const queue = registration._tag === "QueueWorker" ? registration.queue : registration;
 	const name = queue.name;
 	if (registration._tag === "QueueDefinition") {
 		return;
 	}
-	await registerWorker(client, name, queue.workerOptions, (job) => runQueueWorker(registration, job), scope, schema, queue.maxDeferrals, context);
-}
+	yield* registerWorker(
+		client,
+		name,
+		queue.workerOptions,
+		(job) => runQueueWorker(registration, job),
+		scope,
+		schema,
+		queue.maxDeferrals,
+		context,
+		execute,
+		graceful,
+	);
+});
 
-async function registerSchedule(
+const registerSchedule = Effect.fnUntraced(function* (
 	client: PgBossClient,
 	worker: ScheduledWorker,
 	context: Context.Context<unknown>,
 	scope: Scope.Scope,
 	schema: string,
-): Promise<void> {
+	execute: PgBossRunner,
+	graceful: boolean,
+) {
 	const { schedule } = worker;
-	await registerWorker(client, schedule.name, schedule.workerOptions, () => worker.effect, scope, schema, schedule.maxDeferrals, context);
-	await client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions);
-}
+	yield* registerWorker(
+		client,
+		schedule.name,
+		schedule.workerOptions,
+		() => worker.effect,
+		scope,
+		schema,
+		schedule.maxDeferrals,
+		context,
+		execute,
+		graceful,
+	);
+	yield* Effect.tryPromise({
+		catch: (error) => toPgBossError("register", error, schedule.name),
+		try: () => client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions),
+	});
+});
 
 export function registrationNames(registrations: readonly JobRegistration[]): readonly string[] {
 	const names = registrations.map(registrationName);
@@ -114,32 +120,28 @@ export function registrationNames(registrations: readonly JobRegistration[]): re
 	return names;
 }
 
-export function registerJobs<R>(
+export const registerJobs = Effect.fnUntraced(function* <R>(
 	client: PgBossClient,
 	registrations: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
+	execute: PgBossRunner,
 	schema = "pgboss",
 	startWorkers = true,
-): Effect.Effect<void, PgBossError | PgBossQueueOptionsError, Scope.Scope> {
-	return Effect.flatMap(Effect.scope, (scope) =>
-		Effect.tryPromise({
-			catch: (error) => (error instanceof PgBossQueueOptionsError || error instanceof PgBossError ? error : toPgBossError("register", error)),
-			try: async () => {
-				registrationNames(registrations);
-				await prepareQueues(client, registrations, replaceWorkers);
-				if (!startWorkers) {
-					return;
-				}
-				const provided = workerContext(context);
-				for (const registration of registrations) {
-					if (isQueueWorker(registration) || isQueueDefinition(registration)) {
-						await registerQueue(client, registration, provided, scope, schema);
-					} else if (isScheduledWorker(registration)) {
-						await registerSchedule(client, registration, provided, scope, schema);
-					}
-				}
-			},
-		}),
-	);
-}
+	graceful = true,
+) {
+	const scope = yield* Effect.scope;
+	yield* Effect.try({ catch: (error) => toPgBossError("register", error), try: () => registrationNames(registrations) });
+	yield* prepareQueues(client, registrations, replaceWorkers);
+	if (!startWorkers) {
+		return;
+	}
+	const provided = workerContext(context);
+	for (const registration of registrations) {
+		if (isQueueWorker(registration) || isQueueDefinition(registration)) {
+			yield* registerQueue(client, registration, provided, scope, schema, execute, graceful);
+		} else if (isScheduledWorker(registration)) {
+			yield* registerSchedule(client, registration, provided, scope, schema, execute, graceful);
+		}
+	}
+});

package/src/server/internal/registerReleasedJobs.ts

@@ -3,6 +3,7 @@ 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>(
@@ -10,16 +11,20 @@ export const registerReleasedJobs = Effect.fnUntraced(function* <R>(
 	jobs: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
-	schema?: string,
+	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, schema).pipe(Effect.provideService(Scope.Scope, scope));
+	const register = registerJobs(client, jobs, context, replaceWorkers, execute, 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, schema, false);
+	yield* registerJobs(client, jobs, context, replaceWorkers, execute, schema, false, graceful);
 	let working = replaceWorkers;
 	let paused = false;
 	yield* signal.value.register((active) =>

package/src/server/internal/registerWorker.ts

@@ -1,11 +1,13 @@
-import { Clock, type Context, Effect, type Scope } from "effect";
+import { type Context, Effect, Fiber, Scope } from "effect";
 import type { Job, WorkOptions } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
-import { batchHandler } from "#internal/batchHandler.ts";
+import { toPgBossError } from "#error.ts";
+import { batchHandler, type PgBossRunner } from "#internal/batchHandler.ts";
 import { deferrableAttempt } from "#internal/deferrableAttempt.ts";
+import { retryWake } from "#internal/retryWake.ts";
 import { traceJob } from "#internal/tracing.ts";
 
-export function registerWorker(
+export const registerWorker = Effect.fnUntraced(function* (
 	client: PgBossClient,
 	name: string,
 	options: WorkOptions,
@@ -14,47 +16,34 @@ export function registerWorker(
 	schema: string,
 	maxDeferrals: number,
 	context: Context.Context<unknown>,
-): Promise<string> {
-	const registration = client.work(
-		name,
-		{ ...options, includeMetadata: true },
-		batchHandler(
-			client,
-			name,
-			(job) => {
-				const attempt = traceJob(deferrableAttempt(run(job), client, schema, job, maxDeferrals), job, name);
-				return Effect.provide(attempt, context);
-			},
-			async (attempt) => {
-				if (client.findJobs === undefined || client.notifyWorker === undefined) {
-					return;
-				}
-				const job = (await client.findJobs(name, { id: attempt.id }))[0];
-				if (job?.state !== "retry") {
-					return;
-				}
-				const workId = await registration;
-				await Effect.runPromise(
-					Effect.gen(function* () {
-						// Host timers can fire early; PostgreSQL also retains precision that Date drops.
-						const deadline = job.startAfter.getTime() + 1;
-						let remaining = deadline - (yield* Clock.currentTimeMillis);
-						while (remaining > 0) {
-							yield* Effect.sleep(remaining);
-							remaining = deadline - (yield* Clock.currentTimeMillis);
-						}
-						const workerIds = client
-							.getWipData?.()
-							.filter((worker) => worker.workId === workId)
-							.map((worker) => worker.id) ?? [workId];
-						for (const workerId of workerIds) {
-							client.notifyWorker?.(workerId);
-						}
-					}).pipe(Effect.forkIn(scope)),
-				);
-			},
-			Effect.runPromiseWith(context),
-		),
+	execute: PgBossRunner,
+	graceful: boolean,
+) {
+	const fibers = yield* Scope.fork(scope);
+	function runJob(job: Job<unknown>) {
+		return Effect.provide(traceJob(deferrableAttempt(run(job), client, schema, job, maxDeferrals), job, name), context);
+	}
+	function afterFailure(attempt: Job<unknown>) {
+		return retryWake(client, name, attempt.id, registration).pipe(Effect.forkIn(fibers), Effect.asVoid);
+	}
+	const handle = yield* Effect.try({
+		catch: (error) => toPgBossError("register", error, name),
+		try: () => batchHandler(client, name, runJob, afterFailure),
+	});
+	const registration: Promise<string> = yield* Effect.try({
+		catch: (error) => toPgBossError("register", error, name),
+		try: () =>
+			client.work(name, { ...options, includeMetadata: true }, (jobs) =>
+				execute(handle(jobs).pipe(Effect.forkIn(fibers), Effect.flatMap(Fiber.join))),
+			),
+	});
+	const id = yield* Effect.tryPromise({ catch: (error) => toPgBossError("register", error, name), try: () => registration });
+	yield* Scope.addFinalizer(
+		scope,
+		Effect.tryPromise({
+			catch: (error) => toPgBossError("stop", error, name),
+			try: () => client.offWork(name, { id, wait: graceful }),
+		}).pipe(Effect.catch(Effect.logError)),
 	);
-	return registration;
-}
+	return id;
+});

package/src/server/internal/retryWake.ts

@@ -0,0 +1,33 @@
+import { Clock, Effect } from "effect";
+import { redactDiagnosticCause } from "@shivaedev/errors/redactCause.ts";
+import type { PgBossClient } from "#client.ts";
+import { toPgBossError } from "#error.ts";
+
+export function retryWake(client: PgBossClient, name: string, id: string, registration: Promise<string>): Effect.Effect<void> {
+	return Effect.gen(function* () {
+		const findJobs = client.findJobs?.bind(client);
+		if (findJobs === undefined || client.notifyWorker === undefined) {
+			return;
+		}
+		const jobs = yield* Effect.tryPromise({ catch: (error) => toPgBossError("settle", error, name), try: () => findJobs(name, { id }) });
+		const job = jobs[0];
+		if (job?.state !== "retry") {
+			return;
+		}
+		const workId = yield* Effect.tryPromise({ catch: (error) => toPgBossError("register", error, name), try: () => registration });
+		// Host timers can fire early; PostgreSQL retains precision that Date drops.
+		const deadline = job.startAfter.getTime() + 1;
+		let remaining = deadline - (yield* Clock.currentTimeMillis);
+		while (remaining > 0) {
+			yield* Effect.sleep(remaining);
+			remaining = deadline - (yield* Clock.currentTimeMillis);
+		}
+		const workerIds = client
+			.getWipData?.()
+			.filter((worker) => worker.workId === workId)
+			.map((worker) => worker.id) ?? [workId];
+		for (const workerId of workerIds) {
+			client.notifyWorker(workerId);
+		}
+	}).pipe(Effect.catchCause((cause) => Effect.logError(redactDiagnosticCause(cause))));
+}

package/src/server/internal/runQueueWorker.ts

@@ -0,0 +1,19 @@
+import { Effect, Redacted, Schema } from "effect";
+import type { Job } from "pg-boss";
+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(
+		Effect.mapError(
+			(error) =>
+				new PgBossPayloadError({
+					direction: "decode",
+					original: Redacted.make(error),
+					queue: worker.queue.name,
+				}),
+		),
+		Effect.flatMap((payload) => worker.handler(payload, jobContext(job))),
+	);
+}

package/src/server/internal/schemaIndexBuilds.ts

@@ -1,5 +1,9 @@
+import { Schema } from "effect";
 import type { PgBoss } from "pg-boss";
 
+const IndexBuilds = Schema.Array(Schema.Struct({ command: Schema.String, id: Schema.String }));
+const IndexValidity = Schema.Array(Schema.Struct({ invalid: Schema.Boolean }));
+
 const BUILD_PREFIX = "effect-pg-boss-schema:";
 
 function indexName(command: string): string {
@@ -30,11 +34,11 @@ export async function resumeSchemaIndexes(client: PgBoss, schema: string): Promi
 		`SELECT id, command FROM ${schema}.bam WHERE starts_with(name, $1) AND status <> 'completed' ORDER BY created_on, name`,
 		[BUILD_PREFIX],
 	);
-	for (const row of rows) {
+	for (const row of Schema.decodeUnknownSync(IndexBuilds)(rows)) {
 		const name = indexName(row.command);
 		if (/^\s*CREATE /mu.test(row.command)) {
 			const probe = await db.executeSql("SELECT NOT indisvalid AS invalid FROM pg_index WHERE indexrelid = to_regclass($1)", [`${schema}.${name}`]);
-			if (probe.rows[0]?.invalid === true) {
+			if (Schema.decodeUnknownSync(IndexValidity)(probe.rows)[0]?.invalid === true) {
 				await db.executeSql(`DROP INDEX CONCURRENTLY IF EXISTS ${schema}."${name}"`);
 			}
 		}

package/src/server/schema.ts

@@ -1,7 +1,7 @@
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/sql";
 import type { Connection } from "effect/sql/SqlConnection";
-import { getConstructionPlans, getMigrationPlans, type MigrationPartition, PgBoss } from "pg-boss";
+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 { type PgBossError, toPgBossError } from "#error.ts";
@@ -9,6 +9,15 @@ 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 }));
+
 export interface PgBossSchemaOptions {
 	readonly schema?: string;
 }
@@ -39,10 +48,13 @@ async function installSchema(
 		await resumeSchemaIndexes(client, schema);
 	}
 	if (version < pgBossPackage.pgboss.schema) {
-		const partitionTables: MigrationPartition[] = Array.from(
+		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 }), run, { schema, version: pgBossPackage.pgboss.schema });
+		await runSchemaPlan(connection, getMigrationPlans(schema, version, { partitionTables: Array.from(partitionTables) }), run, {
+			schema,
+			version: pgBossPackage.pgboss.schema,
+		});
 		await resumeSchemaIndexes(client, schema);
 	}
 }
@@ -72,9 +84,13 @@ export function pgBossSchema(options: PgBossSchemaOptions = {}): SchemaComponent
 		pending: Effect.gen(function* () {
 			const sql = yield* SqlClient.SqlClient;
 			const table = sql`${sql(schema)}.${sql("version")}`;
-			const [installed] = yield* sql<{ name: string | null }>`select to_regclass(${table.compile()[0]})::text as name`.withoutTransform;
+			const [installed] = yield* sql`select to_regclass(${table.compile()[0]})::text as name`.withoutTransform.pipe(
+				Effect.flatMap(Schema.decodeUnknownEffect(InstalledSchema)),
+			);
 			const [row] =
-				installed === undefined || installed.name === null ? [] : yield* sql<{ version: number }>`select version from ${table}`.withoutTransform;
+				installed === undefined || installed.name === null
+					? []
+					: 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}`