@shivaedev/jobs 0.39.0 → 0.40.1

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/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/initializeInspection.ts";
-import { busy } from "#server/operations/busy.ts";
-import { changes } from "#server/operations/changes.ts";
-import { counts } from "#server/operations/counts.ts";
-import { deadLetteredJobs } from "#server/operations/deadLetteredJobs.ts";
-import { deferred } from "#server/operations/deferred.ts";
-import { failedJobs } from "#server/operations/failedJobs.ts";
-import { getJob } from "#server/operations/getJob.ts";
-import { inspectionHealth } from "#server/operations/inspectionHealth.ts";
-import { jobs } from "#server/operations/jobs.ts";
-import { queue } from "#server/operations/queue.ts";
-import { schedules } from "#server/operations/schedules.ts";
-import { schemaVersion } from "#server/operations/schemaVersion.ts";
-import { snapshot } from "#server/operations/snapshot.ts";
-import { storedJobs } from "#server/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/jobListings.ts

@@ -1,12 +1,12 @@
-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 { JobEngine, type Listing } from "#server/engine.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 { 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(
@@ -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/runQueueWorker.ts

@@ -1,20 +1,19 @@
 import { Effect, Redacted, Schema } from "effect";
 import { deferralCount } from "#server/adapters/deferralCount.ts";
 import { workerDiagnostics } from "#server/adapters/workerDiagnostics.ts";
-import type { PgBossClient } from "#server/client.ts";
 import { type JobPayloadSchema, jobContext, type QueueWorker } from "#server/definition.ts";
 import { PgBossPayloadError } from "#server/error.ts";
 import type { WorkerJob } from "#server/job.ts";
+import { PgBoss } from "#server/PgBoss.ts";
 import { payloadOf } from "#server/tracing.ts";
 
-export function runQueueWorker<R>(
+export const runQueueWorker = Effect.fnUntraced(function* <R>(
 	worker: QueueWorker<JobPayloadSchema & { readonly DecodingServices: R }, R>,
 	job: WorkerJob<unknown>,
 	deadline: number,
-	client: PgBossClient,
-	schema: string,
 ) {
-	return Schema.decodeUnknownEffect(Schema.toCodecJson(worker.queue.schema))(payloadOf(job.data)).pipe(
+	const { client, schema = "pgboss" } = yield* PgBoss;
+	return yield* Schema.decodeUnknownEffect(Schema.toCodecJson(worker.queue.schema))(payloadOf(job.data)).pipe(
 		Effect.mapError(
 			(error) =>
 				new PgBossPayloadError({
@@ -28,4 +27,4 @@ export function runQueueWorker<R>(
 		),
 		workerDiagnostics,
 	);
-}
+});

package/src/server/service.ts

@@ -1,6 +1,7 @@
 import { Context, type Effect, Layer, type Option, type Redacted, type Schema } from "effect";
 import { acquireClient } from "#server/acquireClient.ts";
 import { clientEngine } from "#server/adapters/lifecycle.ts";
+import { pgBossDefinitionLayer } from "#server/adapters/pgBossDefinitionLayer.ts";
 import type { PgBossClientFactory } from "#server/client.ts";
 import type { ClientOptions, StopOptions } from "#server/clientOptions.ts";
 import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements, ScheduleDefinition } from "#server/definition.ts";
@@ -18,7 +19,6 @@ import type { PgBossInspectionService } from "#server/inspection.ts";
 import type { Job } from "#server/job.ts";
 import { ClientEngine } from "#server/lifecycle.ts";
 import { PgBoss } from "#server/PgBoss.ts";
-import { pgBossDefinitionLayer } from "#server/pgBossDefinitionLayer.ts";
 
 export interface PgBossService {
 	readonly counts: (queue: Pick<QueueDefinition, "name">) => Effect.Effect<QueueCounts, PgBossError>;

package/src/server/services/inspection/busy.ts

@@ -0,0 +1,6 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const busy = Effect.fn("PgBossInspectionReads.busy")(function* (...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["busy"]>) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.busy(...args);
+});

package/src/server/services/inspection/changes.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { inspectionChanges } from "#server/adapters/inspectionChanges.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+export const changes = Effect.fn("PgBossInspectionReads.changes")(function* (queue?: { readonly name: string }) {
+	const { client, schema } = yield* PgBoss;
+	return yield* inspectionChanges(client, schema ?? "pgboss", queue?.name);
+});

package/src/server/services/inspection/counts.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { countsFor } from "#server/adapters/countsFor.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+export const counts = Effect.fn("PgBossInspectionReads.counts")(function* (queue: { readonly name: string }) {
+	const { client, schema } = yield* PgBoss;
+	return yield* countsFor(client, schema ?? "pgboss", queue.name);
+});

package/src/server/services/inspection/deferred.ts

@@ -0,0 +1,8 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const deferred = Effect.fn("PgBossInspectionReads.deferred")(function* (
+	...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["deferred"]>
+) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.deferred(...args);
+});

package/src/server/services/inspection/health.ts

@@ -0,0 +1,10 @@
+import { Effect } from "effect";
+import { healthFor } from "#server/adapters/healthFor.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+export const health = Effect.fn("PgBossInspectionReads.health")(function* (queues: readonly { readonly name: string }[]) {
+	const { client } = yield* PgBoss;
+	return yield* healthFor(
+		client,
+		queues.map(({ name }) => name),
+	);
+});

package/src/server/services/inspection/queue.ts

@@ -0,0 +1,8 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const queue = Effect.fn("PgBossInspectionReads.queue")(function* (
+	...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["queue"]>
+) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.queue(...args);
+});

package/src/server/services/inspection/schedules.ts

@@ -0,0 +1,8 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const schedules = Effect.fn("PgBossInspectionReads.schedules")(function* (
+	...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["schedules"]>
+) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.schedules(...args);
+});

package/src/server/services/inspection/schemaVersion.ts

@@ -0,0 +1,8 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const schemaVersion = Effect.fn("PgBossInspectionReads.schemaVersion")(function* (
+	...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["schemaVersion"]>
+) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.schemaVersion(...args);
+});

package/src/server/services/inspection/service.ts

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+import { busy } from "./busy.ts";
+import { changes } from "./changes.ts";
+import { counts } from "./counts.ts";
+import { deferred } from "./deferred.ts";
+import { health } from "./health.ts";
+import { queue } from "./queue.ts";
+import { schedules } from "./schedules.ts";
+import { schemaVersion } from "./schemaVersion.ts";
+import { snapshot } from "./snapshot.ts";
+import { storedJobs } from "./storedJobs.ts";
+export const PgBossInspectionReads = defineService({
+	id: "@shivaedev/jobs/PgBossInspectionReads",
+	initialize: Effect.void,
+	methods: () => ({ busy, changes, counts, deferred, health, queue, schedules, schemaVersion, snapshot, storedJobs }),
+	requires: [PgBoss, InspectionEngine],
+});

package/src/server/services/inspection/snapshot.ts

@@ -0,0 +1,8 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const snapshot = Effect.fn("PgBossInspectionReads.snapshot")(function* (
+	...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["snapshot"]>
+) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.snapshot(...args);
+});

package/src/server/services/inspection/storedJobs.ts

@@ -0,0 +1,8 @@
+import { type Context, Effect } from "effect";
+import { InspectionEngine } from "#server/InspectionEngine.ts";
+export const storedJobs = Effect.fn("PgBossInspectionReads.storedJobs")(function* (
+	...args: Parameters<Context.Service.Shape<typeof InspectionEngine>["storedJobs"]>
+) {
+	const engine = yield* InspectionEngine;
+	return yield* engine.storedJobs(...args);
+});

package/src/server/services/operations/counts.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { countsFor } from "#server/adapters/countsFor.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+export const counts = Effect.fn("PgBossOperations.counts")(function* (queue: { readonly name: string }) {
+	const { client, schema } = yield* PgBoss;
+	return yield* countsFor(client, schema ?? "pgboss", queue.name);
+});

package/src/server/services/operations/deleteQueue.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+import type { PgBossService } from "#server/service.ts";
+export const deleteQueue = Effect.fn("PgBossOperations.deleteQueue")(function* (...args: Parameters<PgBossService["deleteQueue"]>) {
+	const engine = yield* JobEngine;
+	return yield* engine.deleteQueue(...args);
+});

package/src/server/services/operations/enqueue.ts

@@ -0,0 +1,12 @@
+import { Effect, Option } from "effect";
+import { transactionDb } from "#server/adapters/transactionDb.ts";
+import type { EnqueueOptions } from "#server/enqueueOptions.ts";
+import { toPgBossError } from "#server/error.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+export const enqueue = Effect.fn("PgBossOperations.enqueue")(function* (name: string, data: object, options?: EnqueueOptions) {
+	const { client } = yield* PgBoss;
+	const db = yield* transactionDb;
+	const sendOptions = db === undefined ? options : { ...options, db };
+	const send = Effect.tryPromise({ catch: (error) => toPgBossError("enqueue", error, name), try: () => client.send(name, data, sendOptions) });
+	return Option.fromNullishOr(yield* db === undefined ? send : Effect.uninterruptible(send));
+});

package/src/server/services/operations/getJob.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+export const getJob = Effect.fn("PgBossOperations.getJob")(function* (queue: string, id: string) {
+	const engine = yield* JobEngine;
+	return yield* engine.getJob(queue, id);
+});

package/src/server/services/operations/health.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { healthFor } from "#server/adapters/healthFor.ts";
+import { JobQueues } from "#server/JobQueues.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+export const health = Effect.fn("PgBossOperations.health")(function* (queues?: readonly { readonly name: string }[]) {
+	const { client } = yield* PgBoss;
+	const names = yield* JobQueues;
+	return yield* healthFor(client, queues?.map(({ name }) => name) ?? names);
+});

package/src/server/services/operations/listJobs.ts

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import type { KeysetPageQuery } from "@shivaedev/sql/keysetPage.ts";
+import type { Listing } from "#server/engine.ts";
+import { JobEngine } from "#server/engine.ts";
+export const listJobs = Effect.fn("PgBossOperations.listJobs")(function* (listing: Listing, queue: string, query: KeysetPageQuery) {
+	const engine = yield* JobEngine;
+	return yield* engine.listJobs(listing, queue, query);
+});

package/src/server/services/operations/refreshQueueStats.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+import type { PgBossService } from "#server/service.ts";
+export const refreshQueueStats = Effect.fn("PgBossOperations.refreshQueueStats")(function* (...args: Parameters<PgBossService["refreshQueueStats"]>) {
+	const engine = yield* JobEngine;
+	return yield* engine.refreshQueueStats(...args);
+});

package/src/server/services/operations/retry.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+export const retry = Effect.fn("PgBossOperations.retry")(function* (queue: string, id: string) {
+	const engine = yield* JobEngine;
+	return yield* engine.retry(queue, id);
+});

package/src/server/services/operations/service.ts

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { JobEngine } from "#server/engine.ts";
+import { JobQueues } from "#server/JobQueues.ts";
+import { PgBoss } from "#server/PgBoss.ts";
+import { counts } from "./counts.ts";
+import { deleteQueue } from "./deleteQueue.ts";
+import { enqueue } from "./enqueue.ts";
+import { getJob } from "./getJob.ts";
+import { health } from "./health.ts";
+import { listJobs } from "./listJobs.ts";
+import { refreshQueueStats } from "./refreshQueueStats.ts";
+import { retry } from "./retry.ts";
+import { unschedule } from "./unschedule.ts";
+export const PgBossOperations = defineService({
+	id: "@shivaedev/jobs/PgBossOperations",
+	initialize: Effect.void,
+	methods: () => ({ counts, deleteQueue, enqueue, getJob, health, listJobs, refreshQueueStats, retry, unschedule }),
+	requires: [PgBoss, JobEngine, JobQueues],
+});

package/src/server/services/operations/unschedule.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+import type { PgBossService } from "#server/service.ts";
+export const unschedule = Effect.fn("PgBossOperations.unschedule")(function* (...args: Parameters<PgBossService["unschedule"]>) {
+	const engine = yield* JobEngine;
+	return yield* engine.unschedule(...args);
+});

package/src/server/validateQueueNames.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
+import { registrationName } from "#server/adapters/register.ts";
 import type { JobRegistration } from "#server/definition.ts";
 import { PgBossQueueNamesError } from "#server/error.ts";
-import { registrationName } from "./register.ts";
 
 export const validateQueueNames = Effect.fnUntraced(function* (jobs: readonly JobRegistration[], declared: readonly string[] | undefined) {
 	if (declared === undefined) {

package/dist/server/PgBossInitialization.d.ts

@@ -1,9 +0,0 @@
-import { Context, type Effect, type Scope } from "effect";
-import type { PgBossError, PgBossQueueNamesError, PgBossQueueOptionsError } from "#server/error.ts";
-import type { PgBoss } from "#server/PgBoss.ts";
-import type { PgBossService } from "#server/service.ts";
-declare const PgBossInitialization_base: Context.ServiceClass<PgBossInitialization, "@shivaedev/jobs/PgBossInitialization", Effect.Effect<PgBossService, PgBossError | PgBossQueueNamesError | PgBossQueueOptionsError, PgBoss | Scope.Scope>>;
-export declare class PgBossInitialization extends PgBossInitialization_base {
-}
-export {};
-//# sourceMappingURL=PgBossInitialization.d.ts.map

package/dist/server/PgBossInitialization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PgBossInitialization.d.ts","sourceRoot":"","sources":["../../src/server/PgBossInitialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AACpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;;AAExD,qBAAa,oBAAqB,SAAQ,yBAGC;CAAG"}

package/dist/server/PgBossInitialization.js

@@ -1,4 +0,0 @@
-import { Context } from "effect";
-export class PgBossInitialization extends Context.Service()("@shivaedev/jobs/PgBossInitialization") {
-}
-//# sourceMappingURL=PgBossInitialization.js.map

package/dist/server/PgBossInitialization.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PgBossInitialization.js","sourceRoot":"","sources":["../../src/server/PgBossInitialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA2B,MAAM,QAAQ,CAAC;AAK1D,MAAM,OAAO,oBAAqB,SAAQ,OAAO,CAAC,OAAO,EAGtD,CAAC,sCAAsC,CAAC;CAAG"}

package/dist/server/PgBossOperations.d.ts

@@ -1,27 +0,0 @@
-import { PgBoss } from "#server/PgBoss.ts";
-import { PgBossInitialization } from "./PgBossInitialization.ts";
-export declare const PgBossOperations: import("effect/Context").Service<"@shivaedev/jobs/PgBossOperations", Readonly<{
-    readonly counts: (queue: Pick<import("./definition.ts").QueueDefinition<string, import("./definition.ts").JobPayloadSchema>, "name">) => import("effect/Effect").Effect<import("./health.ts").QueueCounts, import("./error.ts").PgBossError, never>;
-    readonly deadLetteredJobs: <const TName extends string, const TPayload extends import("./definition.ts").JobPayloadSchema | typeof import("effect/Schema").Null>(queue: {
-        readonly name: TName;
-        readonly schema: TPayload;
-    }, options: import("./health.ts").JobPageOptions) => import("effect/Effect").Effect<import("./health.ts").JobPage<import("./health.ts").DeadLetteredJob<unknown>>, import("./error.ts").PgBossError | import("./error.ts").PgBossPayloadError | import("effect/Schema").SchemaError, TPayload["DecodingServices"]>;
-    readonly deleteQueue: (queue: Pick<import("./definition.ts").QueueDefinition<string, import("./definition.ts").JobPayloadSchema>, "name">) => import("effect/Effect").Effect<void, import("./error.ts").PgBossError | import("./error.ts").PgBossNotFoundError, never>;
-    readonly enqueue: <const TName extends string, const TPayload extends import("./definition.ts").JobPayloadSchema, const TQueue extends import("./definition.ts").QueueDefinition<TName, TPayload>>(queue: import("./definition.ts").QueueDefinition<TName, TPayload> & TQueue, payload: NoInfer<import("effect/Schema").Schema.Type<TPayload>>, options?: NoInfer<import("./enqueueOptions.ts").QueueEnqueueOptions<TQueue>>) => import("effect/Effect").Effect<import("effect/Option").Option<string>, import("./error.ts").PgBossError | import("./error.ts").PgBossPayloadError, TPayload["EncodingServices"]>;
-    readonly failedJobs: <const TName extends string, const TPayload extends import("./definition.ts").JobPayloadSchema | typeof import("effect/Schema").Null>(queue: {
-        readonly name: TName;
-        readonly schema: TPayload;
-    }, options: import("./health.ts").JobPageOptions) => import("effect/Effect").Effect<import("./health.ts").JobPage<import("./health.ts").ListedJob<unknown>>, import("./error.ts").PgBossError | import("./error.ts").PgBossPayloadError | import("effect/Schema").SchemaError, TPayload["DecodingServices"]>;
-    readonly getJob: <const TName extends string, const TPayload extends import("./definition.ts").JobPayloadSchema | typeof import("effect/Schema").Null>(queue: {
-        readonly name: TName;
-        readonly schema: TPayload;
-    }, id: string) => import("effect/Effect").Effect<import("effect/Option").Option<import("./job.ts").Job<unknown>>, import("./error.ts").PgBossError | import("./error.ts").PgBossPayloadError, TPayload["DecodingServices"]>;
-    readonly health: (queues?: readonly Pick<import("./definition.ts").QueueDefinition<string, import("./definition.ts").JobPayloadSchema>, "name">[] | undefined) => import("effect/Effect").Effect<import("./health.ts").JobsHealth, import("./error.ts").PgBossError, never>;
-    readonly inspection: () => import("effect/Effect").Effect<import("./inspection.ts").PgBossInspectionService, never, never>;
-    readonly refreshQueueStats: (queue?: Pick<import("./definition.ts").QueueDefinition<string, import("./definition.ts").JobPayloadSchema>, "name"> | undefined) => import("effect/Effect").Effect<void, import("./error.ts").PgBossError, never>;
-    readonly retry: (queue: Pick<import("./definition.ts").QueueDefinition<string, import("./definition.ts").JobPayloadSchema>, "name">, id: string) => import("effect/Effect").Effect<void, import("./error.ts").PgBossError, never>;
-    readonly unschedule: (schedule: Pick<import("./definition.ts").ScheduleDefinition<string>, "name" | "scheduleOptions">) => import("effect/Effect").Effect<void, import("./error.ts").PgBossError | import("./error.ts").PgBossNotFoundError, never>;
-}>> & {
-    readonly layer: import("effect/Layer").Layer<"@shivaedev/jobs/PgBossOperations", import("./error.ts").PgBossError | import("./error.ts").PgBossQueueNamesError | import("./error.ts").PgBossQueueOptionsError, PgBoss | PgBossInitialization>;
-};
-//# sourceMappingURL=PgBossOperations.d.ts.map

package/dist/server/PgBossOperations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PgBossOperations.d.ts","sourceRoot":"","sources":["../../src/server/PgBossOperations.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;CAiB3B,CAAC"}