@shivaedev/jobs 0.37.1 → 0.40.0

package/src/server/adapters/makeService.ts

@@ -0,0 +1,31 @@
+import { Context, Effect } from "effect";
+import { inspection } from "#server/adapters/inspection.ts";
+import { enqueuePayload } from "#server/enqueuePayload.ts";
+import { getJob } from "#server/getJob.ts";
+import { deadLetteredJobs, failedJobs } from "#server/jobListings.ts";
+import type { PgBossService } from "#server/service.ts";
+import { PgBossOperations } from "#server/services/operations/service.ts";
+
+export const makeService = Effect.fnUntraced(function* (): Effect.fn.Return<
+	PgBossService,
+	never,
+	"@shivaedev/jobs/PgBossOperations" | "@shivaedev/jobs/PgBossInspectionReads"
+> {
+	const ambient = yield* Effect.context<"@shivaedev/jobs/PgBossOperations">();
+	const context = Context.pick(PgBossOperations)(ambient);
+	const operations = yield* PgBossOperations;
+	const reads = yield* inspection();
+	return {
+		counts: operations.counts,
+		deadLetteredJobs: (queue, options) => deadLetteredJobs(queue, options).pipe(Effect.provide(context)),
+		deleteQueue: operations.deleteQueue,
+		enqueue: (queue, payload, options) => enqueuePayload(queue, payload, options).pipe(Effect.provide(context)),
+		failedJobs: (queue, options) => failedJobs(queue, options).pipe(Effect.provide(context)),
+		getJob: (queue, id) => getJob(queue, id).pipe(Effect.provide(context)),
+		health: operations.health,
+		inspection: () => Effect.succeed(reads),
+		refreshQueueStats: operations.refreshQueueStats,
+		retry: (queue, id) => operations.retry(queue.name, id),
+		unschedule: operations.unschedule,
+	};
+});

package/src/server/adapters/operationsLayer.ts

@@ -0,0 +1,23 @@
+import { Effect, Layer } from "effect";
+import { JobEngine } from "#server/engine.ts";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+import { JobQueues } from "#server/JobQueues.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+import { PgBossInspectionReads } from "#server/services/inspection/service.ts";
+import { PgBossOperations } from "#server/services/operations/service.ts";
+import { inspectionReads } from "./inspectionReads.ts";
+import { jobEngine } from "./jobEngine.ts";
+export function operationsLayer(names: readonly string[]) {
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const acquired = yield* PgBoss;
+			const ports = Layer.mergeAll(
+				Layer.succeed(JobEngine, jobEngine(acquired.client, acquired.schema)),
+				Layer.succeed(InspectionEngine, inspectionReads(acquired.client, acquired.schema ?? "pgboss")),
+				Layer.succeed(JobQueues, names),
+				Layer.succeed(PgBoss, acquired),
+			);
+			return Layer.mergeAll(Layer.fresh(PgBossOperations.layer), Layer.fresh(PgBossInspectionReads.layer)).pipe(Layer.provide(ports));
+		}),
+	);
+}

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

@@ -1,19 +1,16 @@
 import { type Context, Effect, Exit, Layer, Scope } from "effect";
 import { clientErrorReporter } from "#server/adapters/clientErrorReporter.ts";
 import { clientErrorSubscription } from "#server/adapters/clientErrorSubscription.ts";
-import { jobEngine } from "#server/adapters/jobEngine.ts";
+import { logClientError } from "#server/clientErrors.ts";
 import type { JobRegistration, RegistrationRequirements } from "#server/definition.ts";
 import type { PgBossError, PgBossQueueNamesError, PgBossQueueOptionsError } from "#server/error.ts";
 import { PgBoss } from "#server/PgBoss.ts";
 import type { PgBossLayerOptions, PgBossService } from "#server/service.ts";
-import { logClientError } from "./clientErrors.ts";
-import { JobEngine } from "./engine.ts";
+import { validateQueueNames } from "#server/validateQueueNames.ts";
 import { makeService } from "./makeService.ts";
-import { PgBossInitialization } from "./PgBossInitialization.ts";
-import { PgBossOperations } from "./PgBossOperations.ts";
+import { operationsLayer } from "./operationsLayer.ts";
 import { registrationName } from "./register.ts";
 import { registerReleasedJobs } from "./registerReleasedJobs.ts";
-import { validateQueueNames } from "./validateQueueNames.ts";
 
 export function pgBossDefinitionLayer<TIdentifier extends string, const TRegistrations extends readonly JobRegistration[], E>(
 	Service: Context.Service<TIdentifier, PgBossService>,
@@ -31,10 +28,7 @@ export function pgBossDefinitionLayer<TIdentifier extends string, R, E>(
 ) {
 	return Layer.unwrap(
 		Effect.map(Effect.context<Exclude<R, TIdentifier> | E>(), (dependencies) =>
-			Layer.effect(Service, PgBossOperations).pipe(
-				Layer.provide(Layer.fresh(PgBossOperations.layer)),
-				Layer.provide(Layer.succeed(PgBossInitialization, initializePgBoss(Service, options, dependencies, queueNames))),
-			),
+			Layer.effect(Service, initializePgBoss(Service, options, dependencies, queueNames)),
 		),
 	);
 }
@@ -48,16 +42,15 @@ const initializePgBoss = Effect.fnUntraced(function* <TIdentifier extends string
 	yield* validateQueueNames(options.jobs, queueNames);
 	const acquired = yield* PgBoss;
 	const workerScope = yield* Scope.make();
-	const service = yield* makeService(acquired.client, options.jobs.map(registrationName), acquired.schema).pipe(
-		Effect.provideService(JobEngine, jobEngine(acquired.client, acquired.schema)),
-	);
+	const services = yield* Layer.build(operationsLayer(options.jobs.map(registrationName)));
+	const service = yield* makeService().pipe(Effect.provide(services));
 	yield* Effect.gen(function* () {
 		const context = yield* Effect.context<R | E>();
 		const reportError = options.onError ?? logClientError;
 		const report = yield* clientErrorReporter(reportError).pipe(Effect.provide(context));
 		const unsubscribe = yield* clientErrorSubscription(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, acquired.schema, acquired.stop, options.retired).pipe(
+		yield* registerReleasedJobs(acquired.client, options.jobs, acquired.reused, acquired.schema, acquired.stop, options.retired).pipe(
 			Effect.provideService(Scope.Scope, workerScope),
 		);
 	}).pipe(Effect.provideService(Service, service), Effect.provide(dependencies));

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

@@ -1,12 +1,12 @@
-import { type Context, Effect, Scope } from "effect";
+import { Effect, Scope } from "effect";
 import { registerWorker } from "#server/adapters/registerWorker.ts";
 import { workerDiagnostics } from "#server/adapters/workerDiagnostics.ts";
 import type { PgBossClient } from "#server/client.ts";
 import type { StopOptions } from "#server/clientOptions.ts";
 import type { JobPayloadSchema, JobRegistration, QueueDefinition, QueueWorker, ScheduleDefinition, ScheduledWorker } from "#server/definition.ts";
 import { PgBossQueueOptionsError, toPgBossError } from "#server/error.ts";
-import { ensureQueue } from "#server/internal/ensureQueue.ts";
-import { runQueueWorker } from "#server/internal/runQueueWorker.ts";
+import { runQueueWorker } from "#server/runQueueWorker.ts";
+import { ensureQueue } from "./ensureQueue.ts";
 
 function registrationDefinition(registration: JobRegistration): QueueDefinition | ScheduleDefinition {
 	if (registration._tag === "QueueDefinition") {
@@ -39,8 +39,6 @@ const prepareQueues = Effect.fnUntraced(function* (client: PgBossClient, registr
 const registerQueue = Effect.fnUntraced(function* <R>(
 	client: PgBossClient,
 	registration: QueueWorker<JobPayloadSchema & { readonly DecodingServices: R }, R> | QueueDefinition,
-	context: Context.Context<R>,
-	scope: Scope.Scope,
 	schema: string,
 	stop: StopOptions | undefined,
 ) {
@@ -53,33 +51,21 @@ const registerQueue = Effect.fnUntraced(function* <R>(
 		client,
 		name,
 		queue.workerOptions,
-		(job, deadline) => runQueueWorker(registration, job, deadline, client, schema),
-		scope,
+		(job, deadline) => runQueueWorker(registration, job, deadline),
 		schema,
 		queue.maxDeferrals,
 		stop,
-	).pipe(Effect.provide(context));
+	);
 });
 
 const registerSchedule = Effect.fnUntraced(function* <R>(
 	client: PgBossClient,
 	worker: ScheduledWorker<R>,
-	context: Context.Context<R>,
-	scope: Scope.Scope,
 	schema: string,
 	stop: StopOptions | undefined,
 ) {
 	const { schedule } = worker;
-	yield* registerWorker(
-		client,
-		schedule.name,
-		schedule.workerOptions,
-		() => workerDiagnostics(worker.effect),
-		scope,
-		schema,
-		schedule.maxDeferrals,
-		stop,
-	).pipe(Effect.provide(context));
+	yield* registerWorker(client, schedule.name, schedule.workerOptions, () => workerDiagnostics(worker.effect), schema, schedule.maxDeferrals, stop);
 	yield* Effect.tryPromise({
 		catch: (error) => toPgBossError("register", error, schedule.name),
 		try: () => client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions),
@@ -97,7 +83,6 @@ export function registrationNames(registrations: readonly JobRegistration[]): re
 export const registerJobs = Effect.fnUntraced(function* <R>(
 	client: PgBossClient,
 	registrations: readonly JobRegistration<R>[],
-	context: Context.Context<R>,
 	replaceWorkers: boolean,
 	schema = "pgboss",
 	startWorkers = true,
@@ -111,9 +96,9 @@ export const registerJobs = Effect.fnUntraced(function* <R>(
 	}
 	for (const registration of registrations) {
 		if (registration._tag === "QueueWorker" || registration._tag === "QueueDefinition") {
-			yield* registerQueue(client, registration, context, scope, schema, stop);
+			yield* registerQueue(client, registration, schema, stop).pipe(Effect.provideService(Scope.Scope, scope));
 		} else {
-			yield* registerSchedule(client, registration, context, scope, schema, stop);
+			yield* registerSchedule(client, registration, schema, stop).pipe(Effect.provideService(Scope.Scope, scope));
 		}
 	}
 });

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

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

package/src/server/adapters/registerWorker.ts

@@ -2,12 +2,12 @@ import { Effect, Fiber, Scope } from "effect";
 import { batchHandler } from "#server/adapters/batchHandler.ts";
 import type { PgBossClient } from "#server/client.ts";
 import type { StopOptions } from "#server/clientOptions.ts";
+import { deferrableAttempt } from "#server/deferrableAttempt.ts";
+import { JobEngine } from "#server/engine.ts";
 import { toPgBossError } from "#server/error.ts";
-import { deferrableAttempt } from "#server/internal/deferrableAttempt.ts";
-import { JobEngine } from "#server/internal/engine.ts";
-import { retryWake } from "#server/internal/retryWake.ts";
-import { traceJob } from "#server/internal/tracing.ts";
 import type { WorkerJob } from "#server/job.ts";
+import { retryWake } from "#server/retryWake.ts";
+import { traceJob } from "#server/tracing.ts";
 import type { WorkerOptions } from "#server/workerOptions.ts";
 import { jobEngine } from "./jobEngine.ts";
 
@@ -16,11 +16,11 @@ export const registerWorker = Effect.fnUntraced(function* <R>(
 	name: string,
 	options: WorkerOptions,
 	run: (job: WorkerJob<unknown>, deadline: number) => Effect.Effect<unknown, unknown, R>,
-	scope: Scope.Scope,
 	schema: string,
 	maxDeferrals: number,
 	stop?: StopOptions,
 ) {
+	const scope = yield* Effect.scope;
 	const execute = Effect.runPromiseWith(yield* Effect.context<R>());
 	const workerScope = yield* Scope.fork(scope);
 	const fibers = yield* Scope.fork(workerScope);

package/src/server/adapters/retireJobs.ts

@@ -1,9 +1,9 @@
 import { Effect } from "effect";
+import { registrationNames } from "#server/adapters/register.ts";
 import type { PgBossClient } from "#server/client.ts";
 import type { JobRegistration } from "#server/definition.ts";
 import { toPgBossError } from "#server/error.ts";
 import { deadLetterQueueName } from "#server/health.ts";
-import { registrationNames } from "#server/internal/register.ts";
 
 export const retireJobs = Effect.fnUntraced(function* (client: PgBossClient, jobs: readonly JobRegistration[], retired: readonly string[]) {
 	yield* Effect.try({

package/src/server/adapters/runSchemaPlan.ts

@@ -1,13 +1,9 @@
-import type { Effect } from "effect";
-import type { Connection } from "effect/sql/SqlConnection";
+import { Effect } from "effect";
+import { SchemaConnection } from "#server/SchemaConnection.ts";
 import { pendingIndexInserts } from "./schemaIndexBuilds.ts";
 
-export async function runSchemaPlan(
-	connection: Connection,
-	plan: string,
-	run: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>,
-	upgrade?: { readonly schema: string; readonly version: number },
-): Promise<void> {
+export const runSchemaPlan = Effect.fnUntraced(function* (plan: string, upgrade?: { readonly schema: string; readonly version: number }) {
+	const connection = yield* SchemaConnection;
 	// Native exported plans append concurrent index DDL after the migration transaction.
 	const parts = /^\s*BEGIN;(?<body>[\s\S]*)\n {4}COMMIT;(?<concurrent>[\s\S]*)$/u.exec(plan);
 	if (parts?.groups === undefined) {
@@ -23,10 +19,10 @@ export async function runSchemaPlan(
 		.filter((statement) => statement.trim() !== "");
 	const pending = upgrade === undefined ? "" : pendingIndexInserts(upgrade.schema, upgrade.version, commands, quote);
 	// Effect SQL uses the extended protocol, which accepts one statement per command.
-	await run(connection.executeRaw(`DO ${quote(`BEGIN EXECUTE ${quote(`${body}\n${pending}`)}; END`)}`, []));
+	yield* connection.executeRaw(`DO ${quote(`BEGIN EXECUTE ${quote(`${body}\n${pending}`)}; END`)}`, []);
 	if (upgrade === undefined) {
 		for (const statement of commands) {
-			await run(connection.executeRaw(statement, []));
+			yield* connection.executeRaw(statement, []);
 		}
 	}
-}
+});

package/src/server/adapters/settleDeferral.ts

@@ -1,8 +1,8 @@
 import { Schema } from "effect";
 import type { PgBossClient } from "#server/client.ts";
-import { STATELY_DEFERRAL_POLICY } from "#server/internal/deferral.ts";
-import type { JobAttempt } from "#server/internal/engine.ts";
-import { quotedSchema } from "#server/internal/storedRows.ts";
+import { STATELY_DEFERRAL_POLICY } from "#server/deferral.ts";
+import type { JobAttempt } from "#server/engine.ts";
+import { quotedSchema } from "#server/storedRows.ts";
 import { localInspectionChanges } from "./localInspectionChanges.ts";
 
 const Settlement = Schema.Struct({ claimed: Schema.Boolean, deferred: Schema.Boolean });

package/src/server/{internal/deadLetterResolutionPlan.ts → deadLetterResolutionPlan.ts}

@@ -1,4 +1,4 @@
-import { quotedSchema } from "#server/internal/storedRows.ts";
+import { quotedSchema } from "#server/storedRows.ts";
 
 export function deadLetterResolutionPlan(schema: string): string {
 	const quoted = quotedSchema(schema);

package/src/server/{internal/deferrableAttempt.ts → deferrableAttempt.ts}

@@ -1,7 +1,7 @@
 import { Clock, DateTime, Effect, Schema } from "effect";
+import { deferredAttempt } from "#server/deferral.ts";
 import { RetryAt } from "#server/definition.ts";
-import { deferredAttempt } from "#server/internal/deferral.ts";
-import { type JobAttempt, JobEngine } from "#server/internal/engine.ts";
+import { type JobAttempt, JobEngine } from "#server/engine.ts";
 
 const recordDeferral = Effect.fnUntraced(function* (at: string, reason: string) {
 	const span = yield* Effect.currentSpan.pipe(Effect.orDie);

package/src/server/{internal/deferralStorePlan.ts → deferralStorePlan.ts}

@@ -1,5 +1,5 @@
-import { STATELY_DEFERRAL_POLICY } from "#server/internal/deferral.ts";
-import { quotedSchema } from "#server/internal/storedRows.ts";
+import { STATELY_DEFERRAL_POLICY } from "#server/deferral.ts";
+import { quotedSchema } from "#server/storedRows.ts";
 
 export function deferralStorePlan(schema: string): string {
 	const quoted = quotedSchema(schema);

package/src/server/defineSchedule.ts

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

package/src/server/definition.ts

@@ -1,7 +1,7 @@
 import { Clock, Duration, Effect, Schema } from "effect";
 import type { QueueDisplay, SubjectColumn } from "#display.ts";
+import { maxDeferrals, nativeQueueOptions } from "#server/definitionOptions.ts";
 import type { ScheduleOptions } from "#server/enqueueOptions.ts";
-import { maxDeferrals, nativeQueueOptions } from "#server/internal/definitionOptions.ts";
 import type { WorkerJob } from "#server/job.ts";
 import type { QueueOptions, QueuePolicy } from "#server/queueOptions.ts";
 import type { WorkerOptions } from "#server/workerOptions.ts";

package/src/server/enqueuePayload.ts

@@ -0,0 +1,38 @@
+import { Effect, Redacted, Schema } from "effect";
+import { payloadJobId, payloadKey } from "#server/adapters/payloadIdentity.ts";
+import type { JobPayloadSchema, QueueDefinition } from "#server/definition.ts";
+import type { EnqueueOptions, QueueEnqueueOptions } from "#server/enqueueOptions.ts";
+import { PgBossPayloadError } from "#server/error.ts";
+import { PgBossOperations } from "#server/services/operations/service.ts";
+import { capturePayload } from "#server/tracing.ts";
+
+function identityOptions(queue: Pick<QueueDefinition, "id" | "key" | "name">, payload: object, options?: EnqueueOptions) {
+	return queue.id === undefined && queue.key === undefined
+		? options
+		: {
+				...options,
+				...(queue.id === undefined ? {} : { id: payloadJobId(queue.name, queue.id, payload) }),
+				...(queue.key === undefined ? {} : { singletonKey: payloadKey(queue.key, payload) }),
+			};
+}
+
+export const enqueuePayload = Effect.fnUntraced(function* <
+	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>>, options?: NoInfer<QueueEnqueueOptions<TQueue>>) {
+	const operations = yield* PgBossOperations;
+	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) {
+		return yield* new PgBossPayloadError({
+			direction: "encode",
+			original: Redacted.make(new TypeError("pg-boss payloads must encode to objects")),
+			queue: queue.name,
+		});
+	}
+	const data = yield* capturePayload(encoded);
+	const sendOptions = identityOptions(queue, payload, options);
+	return yield* operations.enqueue(queue.name, data, sendOptions);
+});

package/src/server/error.ts

@@ -1,5 +1,5 @@
 import { Cause, Data, Redacted } from "effect";
-import { failureOutput } from "#server/internal/failureOutput.ts";
+import { failureOutput } from "#server/failureOutput.ts";
 
 export type PgBossOperation =
 	| "counts"

package/src/server/getJob.ts

@@ -0,0 +1,28 @@
+import type { Schema } from "effect";
+import { Effect, Option } from "effect";
+import { redact } from "@shivaedev/errors/redact.ts";
+import { deferralOf } from "#server/deferral.ts";
+import type { JobPayloadSchema } from "#server/definition.ts";
+import { readJobFailure } from "#server/readJobFailure.ts";
+import { PgBossOperations } from "#server/services/operations/service.ts";
+import { decodeStoredData } from "#server/storedRows.ts";
+
+export const getJob = Effect.fnUntraced(function* <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
+	queue: { readonly name: TName; readonly schema: TPayload },
+	id: string,
+) {
+	const engine = yield* PgBossOperations;
+	return yield* engine.getJob(queue.name, id).pipe(
+		Effect.flatMap(
+			Effect.fnUntraced(function* (job) {
+				if (job === undefined) {
+					return Option.none();
+				}
+				const data = yield* decodeStoredData(queue, job.data);
+				const output = deferralOf(job) === undefined ? yield* readJobFailure(queue.name, job.output) : job.output;
+				const sourceOutput = yield* readJobFailure(queue.name, job.sourceOutput);
+				return Option.some({ ...job, data: redact(data), output, sourceOutput });
+			}),
+		),
+	);
+});

package/src/server/inspection.ts

@@ -1,25 +1,12 @@
-import type { DateTime } from "effect";
-import { defineService } from "@shivaedev/service/defineService.ts";
-import { genericMethod } from "@shivaedev/service/genericMethod.ts";
+import type { DateTime, Effect, Schema } from "effect";
+import { Context } from "effect";
 import type { inspectionChanges } from "#server/adapters/inspectionChanges.ts";
+import { inspectionLayer } from "#server/adapters/inspectionLayer.ts";
 import type { inspectionReads } from "#server/adapters/inspectionReads.ts";
+import type { JobReadOptions } from "#server/client.ts";
 import type { JobPayloadSchema, QueueDefinition } from "#server/definition.ts";
-import { initializeInspection } from "#server/internal/initializeInspection.ts";
-import { busy } from "#server/internal/operations/busy.ts";
-import { changes } from "#server/internal/operations/changes.ts";
-import { counts } from "#server/internal/operations/counts.ts";
-import { deadLetteredJobs } from "#server/internal/operations/deadLetteredJobs.ts";
-import { deferred } from "#server/internal/operations/deferred.ts";
-import { failedJobs } from "#server/internal/operations/failedJobs.ts";
-import { getJob } from "#server/internal/operations/getJob.ts";
-import { inspectionHealth } from "#server/internal/operations/inspectionHealth.ts";
-import { jobs } from "#server/internal/operations/jobs.ts";
-import { queue } from "#server/internal/operations/queue.ts";
-import { schedules } from "#server/internal/operations/schedules.ts";
-import { schemaVersion } from "#server/internal/operations/schemaVersion.ts";
-import { snapshot } from "#server/internal/operations/snapshot.ts";
-import { storedJobs } from "#server/internal/operations/storedJobs.ts";
-import { PgBoss } from "#server/PgBoss.ts";
+import type { PgBossError, PgBossPayloadError } from "#server/error.ts";
+import type { Job } from "#server/job.ts";
 import type { PgBossService } from "#server/service.ts";
 
 export type SnapshotQueue = Pick<QueueDefinition<string, JobPayloadSchema>, "name" | "schema">;
@@ -32,30 +19,18 @@ export interface UnfinishedJob<TQueue extends SnapshotQueue> {
 	readonly state: "active" | "created" | "deferred" | "failed" | "retry";
 }
 
-export const PgBossInspection = defineService({
-	id: "@shivaedev/jobs/PgBossInspection",
-	initialize: initializeInspection,
-	methods: (service) => ({
-		busy: busy(service),
-		changes: changes(service),
-		counts: counts(service),
-		deadLetteredJobs: genericMethod(deadLetteredJobs(service)),
-		deferred: deferred(service),
-		failedJobs: genericMethod(failedJobs(service)),
-		getJob: genericMethod(getJob(service)),
-		health: inspectionHealth(service),
-		jobs: genericMethod(jobs(service)),
-		queue: queue(service),
-		schedules: schedules(service),
-		schemaVersion: schemaVersion(service),
-		snapshot: genericMethod(snapshot(service)),
-		storedJobs: storedJobs(service),
-	}),
-	requires: [PgBoss] as const,
-});
-
-export type PgBossInspectionService = ReturnType<typeof inspectionReads> &
-	Pick<PgBossService, "counts" | "deadLetteredJobs" | "failedJobs" | "getJob"> & {
+export type PgBossInspectionService = Omit<ReturnType<typeof inspectionReads>, "snapshot"> & {
+	readonly jobs: <TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(
+		queue: { readonly name: TName; readonly schema: TPayload },
+		options?: JobReadOptions,
+	) => Effect.Effect<Job<TPayload["Type"]>[], PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
+	readonly snapshot: <const TQueues extends readonly SnapshotQueue[]>(
+		queues: TQueues,
+	) => Effect.Effect<readonly UnfinishedJob<TQueues[number]>[], PgBossPayloadError | PgBossError, TQueues[number]["schema"]["DecodingServices"]>;
+} & Pick<PgBossService, "counts" | "deadLetteredJobs" | "failedJobs" | "getJob"> & {
 		readonly health: (queues: readonly { readonly name: string }[]) => ReturnType<PgBossService["health"]>;
 		readonly changes: (queue?: { readonly name: string }) => ReturnType<typeof inspectionChanges>;
 	};
+
+const Inspection = Context.Service<"@shivaedev/jobs/PgBossInspection", PgBossInspectionService>("@shivaedev/jobs/PgBossInspection");
+export const PgBossInspection = Object.assign(Inspection, { layer: inspectionLayer(Inspection) });

package/src/server/inspectionJobs.ts

@@ -0,0 +1,13 @@
+import { Effect, type Schema } from "effect";
+import type { JobReadOptions } from "#server/client.ts";
+import type { JobPayloadSchema } from "#server/definition.ts";
+import { PgBossInspectionReads } from "#server/services/inspection/service.ts";
+import { decodeStoredData } from "#server/storedRows.ts";
+export const inspectionJobs = Effect.fnUntraced(function* <TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(
+	queue: { readonly name: TName; readonly schema: TPayload },
+	options?: JobReadOptions,
+) {
+	const inspection = yield* PgBossInspectionReads;
+	const rows = yield* inspection.storedJobs(queue, options);
+	return yield* Effect.forEach(rows, (job) => decodeStoredData(queue, job.data).pipe(Effect.map((data) => ({ ...job, data }))));
+});

package/src/server/inspectionSnapshot.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import type { SnapshotQueue, UnfinishedJob } from "#server/inspection.ts";
+import { PgBossInspectionReads } from "#server/services/inspection/service.ts";
+import { decodeStoredData } from "#server/storedRows.ts";
+export const inspectionSnapshot = Effect.fnUntraced(function* <const TQueues extends readonly SnapshotQueue[]>(queues: TQueues) {
+	const inspection = yield* PgBossInspectionReads;
+	const byName = new Map<string, TQueues[number]>(queues.map((queue) => [queue.name, queue]));
+	const rows = yield* inspection.snapshot(queues);
+	return yield* Effect.forEach(rows, ({ data, queue: name, ...row }) => {
+		const queue = byName.get(name);
+		if (queue === undefined) {
+			return Effect.die(new Error(`The snapshot returned a job of an unrequested queue ${name}`));
+		}
+		return decodeStoredData<TQueues[number]["name"], TQueues[number]["schema"]>(queue, data).pipe(
+			Effect.map((decoded): UnfinishedJob<TQueues[number]> => ({ ...row, data: decoded, queue: queue.name })),
+		);
+	});
+});

package/src/server/{internal/jobListings.ts → jobListings.ts}

@@ -1,13 +1,13 @@
-import { type Context, Effect, Option, Redacted, Schema } from "effect";
+import { Effect, Option, Redacted, Schema } from "effect";
 import { redact } from "@shivaedev/errors/redact.ts";
 import { keysetPage } from "@shivaedev/sql/keysetPage.ts";
 import type { JobPayloadSchema } from "#server/definition.ts";
+import type { Listing } from "#server/engine.ts";
 import { type PgBossError, PgBossPayloadError } from "#server/error.ts";
 import type { DeadLetteredJob, JobPage, JobPageOptions } from "#server/health.ts";
-import { JobEngine, type Listing } from "#server/internal/engine.ts";
-import { decodeStoredData } from "#server/internal/storedRows.ts";
 import { readJobFailure } from "#server/readJobFailure.ts";
-import type { PgBossService } from "#server/service.ts";
+import { PgBossOperations } from "#server/services/operations/service.ts";
+import { decodeStoredData } from "#server/storedRows.ts";
 
 const Cursor = Schema.StringFromBase64Url.pipe(
 	Schema.decodeTo(
@@ -42,29 +42,33 @@ const Row = Schema.Struct({
 
 const Rows = Schema.Array(Row);
 
-export const jobListings = Effect.gen(function* () {
-	const engine = yield* JobEngine;
-	const failedJobs: PgBossService["failedJobs"] = (queue, options) =>
-		listJobs(engine, "failedJobs", queue, options).pipe(
-			Effect.map(({ jobs, next }) => ({ jobs: jobs.map(({ sourceId: _id, sourceOutput: _output, ...job }) => job), next })),
-		);
-	const deadLetteredJobs: PgBossService["deadLetteredJobs"] = (queue, options) =>
-		listJobs(engine, "deadLetteredJobs", queue, options).pipe(
-			Effect.map(({ jobs, next }) => ({ jobs: jobs.map((job) => ({ ...job, sourceQueue: queue.name })), next })),
-		);
-	return { deadLetteredJobs, failedJobs };
+export const failedJobs = Effect.fnUntraced(function* <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
+	queue: { readonly name: TName; readonly schema: TPayload },
+	options: JobPageOptions,
+) {
+	return yield* listJobs("failedJobs", queue, options).pipe(
+		Effect.map(({ jobs, next }) => ({ jobs: jobs.map(({ sourceId: _id, sourceOutput: _output, ...job }) => job), next })),
+	);
+});
+export const deadLetteredJobs = Effect.fnUntraced(function* <
+	const TName extends string,
+	const TPayload extends JobPayloadSchema | typeof Schema.Null,
+>(queue: { readonly name: TName; readonly schema: TPayload }, options: JobPageOptions) {
+	return yield* listJobs("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>(
-	engine: Context.Service.Shape<typeof JobEngine>,
 	listing: Listing,
 	queue: { readonly name: TName; readonly schema: TPayload },
 	options: JobPageOptions,
 ): Effect.fn.Return<
 	JobPage<Omit<DeadLetteredJob<unknown>, "sourceQueue">>,
 	PgBossError | PgBossPayloadError | Schema.SchemaError,
-	TPayload["DecodingServices"]
+	TPayload["DecodingServices"] | "@shivaedev/jobs/PgBossOperations"
 > {
+	const engine = yield* PgBossOperations;
 	const { cursor: after, limit } = yield* Schema.decodeUnknownEffect(PageOptions)(options);
 	const page = yield* keysetPage({
 		after,

package/src/server/{internal/jobStorePlans.ts → jobStorePlans.ts}

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