@shivaedev/effect-pg-boss 0.4.0 → 0.6.0

package/dist/{internal → server/internal}/service.d.ts

@@ -1,4 +1,4 @@
 import type { PgBossClient } from "#client.ts";
 import type { PgBossService } from "#service.ts";
-export declare const makeService: (client: PgBossClient, names: readonly string[]) => PgBossService;
+export declare const makeService: (client: PgBossClient, names: readonly string[], schema?: string) => PgBossService;
 //# sourceMappingURL=service.d.ts.map

package/dist/server/internal/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/server/internal/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,WAAW,WAAY,YAAY,SAAS,SAAS,MAAM,EAAE,sBAAsB,aA+B9F,CAAC"}

package/dist/{internal → server/internal}/service.js

@@ -1,7 +1,10 @@
 import { Effect, Option, Redacted, Schema } from "effect";
 import { PgBossPayloadError, toPgBossError } from "#error.ts";
-import { healthFor } from "./health.js";
-export const makeService = (client, names) => ({
+import { countsFor } from "#internal/countsFor.ts";
+import { healthFor } from "#internal/health.ts";
+import { getJobFor, retryFor } from "#internal/jobControl.ts";
+export const makeService = (client, names, schema = "pgboss") => ({
+    counts: (queue) => countsFor(client, schema, queue.name),
     enqueue: (queue, payload, options) => Schema.encodeUnknownEffect(queue.schema)(payload).pipe(Effect.mapError((error) => new PgBossPayloadError({
         direction: "encode",
         original: Redacted.make(error),
@@ -19,6 +22,8 @@ export const makeService = (client, names) => ({
             try: () => client.send(queue.name, encoded, options),
         }).pipe(Effect.map(Option.fromNullishOr));
     })),
+    getJob: getJobFor(client),
     health: healthFor(client, names),
+    retry: retryFor(client),
 });
 //# sourceMappingURL=service.js.map

package/dist/server/internal/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../src/server/internal/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE1D,OAAO,EAAoB,kBAAkB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAG9D,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAAoB,EAAE,KAAwB,EAAE,MAAM,GAAG,QAAQ,EAAiB,EAAE,CAAC,CAAC;IACjH,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;IACxD,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CACpC,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CACrD,MAAM,CAAC,QAAQ,CACd,CAAC,KAAK,EAAE,EAAE,CACT,IAAI,kBAAkB,CAAC;QACtB,SAAS,EAAE,QAAQ;QACnB,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;QAC9B,KAAK,EAAE,KAAK,CAAC,IAAI;KACjB,CAAC,CACH,EACD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,EAA0E,EAAE;QAClG,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrD,OAAO,MAAM,CAAC,IAAI,CACjB,IAAI,kBAAkB,CAAC;gBACtB,SAAS,EAAE,QAAQ;gBACnB,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAC;gBACjF,KAAK,EAAE,KAAK,CAAC,IAAI;aACjB,CAAC,CACF,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC,UAAU,CAAC;YACxB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC;YAC7D,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC;SACpD,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;IAC3C,CAAC,CAAC,CACF;IACF,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;IACzB,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;IAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvB,CAAC,CAAC"}

package/dist/{service.d.ts → server/service.d.ts}

@@ -1,12 +1,15 @@
 import { Context, Effect, Layer, type Option, type Schema } from "effect";
-import type { ConstructorOptions, SendOptions, StopOptions } from "pg-boss";
+import type { ConstructorOptions, JobWithMetadata, SendOptions, StopOptions } from "pg-boss";
 import type { PgBossClientFactory } from "#client.ts";
-import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "./definition.ts";
-import type { PgBossError, PgBossPayloadError } from "./error.ts";
-import type { JobsHealth } from "./health.ts";
+import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "#definition.ts";
+import type { PgBossError, PgBossPayloadError, PgBossQueueOptionsError } from "#error.ts";
+import type { JobsHealth, QueueCounts } from "#health.ts";
 export interface PgBossService {
+    readonly counts: (queue: QueueDefinition) => Effect.Effect<QueueCounts, PgBossError>;
     readonly enqueue: <const TName extends string, const TPayload extends JobPayloadSchema>(queue: QueueDefinition<TName, TPayload>, payload: Schema.Schema.Type<TPayload>, options?: SendOptions) => Effect.Effect<Option.Option<string>, PgBossError | PgBossPayloadError, TPayload["EncodingServices"]>;
+    readonly getJob: <const TName extends string, const TPayload extends JobPayloadSchema>(queue: QueueDefinition<TName, TPayload>, id: string) => Effect.Effect<Option.Option<JobWithMetadata<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
     readonly health: Effect.Effect<JobsHealth, PgBossError>;
+    readonly retry: (queue: QueueDefinition, id: string) => Effect.Effect<void, PgBossError>;
 }
 export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> = ConstructorOptions & {
     readonly clientFactory?: PgBossClientFactory;
@@ -16,7 +19,7 @@ export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[]
     readonly stop?: StopOptions;
 };
 export interface PgBossDefinition<TIdentifier extends string = string> extends Context.Service<TIdentifier, PgBossService> {
-    readonly layer: <const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(options: PgBossLayerOptions<TRegistrations, TErrorRequirements>) => Layer.Layer<TIdentifier, PgBossError, RegistrationRequirements<TRegistrations> | TErrorRequirements>;
+    readonly layer: <const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(options: PgBossLayerOptions<TRegistrations, TErrorRequirements>) => Layer.Layer<TIdentifier, PgBossError | PgBossQueueOptionsError, RegistrationRequirements<TRegistrations> | TErrorRequirements>;
 }
 export declare const makePgBoss: <const TIdentifier extends string>(identifier: TIdentifier) => PgBossDefinition<TIdentifier>;
 //# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/server/service.ts"],"names":[],"mappings":"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"}

package/dist/{service.js → server/service.js}

@@ -31,7 +31,7 @@ export const makePgBoss = (identifier) => {
             resource.acquired.client.off("error", resource.errorListener);
             return releaseClient(resource.acquired, stop);
         });
-        return Layer.effect(Service, Effect.map(acquire, ({ acquired }) => makeService(acquired.client, names)));
+        return Layer.effect(Service, Effect.map(acquire, ({ acquired }) => makeService(acquired.client, names, constructorOptions.schema)));
     };
     return Object.assign(Service, { layer });
 };

package/dist/server/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../src/server/service.ts"],"names":[],"mappings":"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"}

package/docs/north-star.md

@@ -43,6 +43,6 @@ An application that needs only queueing should not import a repository framework
 - Domain workers, authorization rules, external-provider interfaces and application logging or health policy.
 - Another general service declaration system; native Context and Layer stay available, and general declaration ergonomics belong to `effect-service`.
 - Application repositories or migration ownership; those belong to `effect-sql`.
-- An implicit link between enqueueing and an application's database transaction. Transaction and outbox policy remain application decisions; after-commit changes have their own path through `effect-changes`.
+- Transactional enqueueing: jobs use a separate connection from application SQL transactions. Applications own any required outbox policy; after-commit changes have their own path through `effect-changes`.
 - A promise of exactly-once domain side effects or provider idempotency. Those need application-specific decisions and evidence.
 - Browser, device or offline synchronization behavior. A PostgreSQL queue boundary cannot establish those product contracts.

package/docs/roadmap.md

@@ -8,9 +8,13 @@ This file owns the package's implementation inventory and open API choices. The
 - [x] Object payload Schema definitions, decoded enqueue types and queue workers. Type tests reject primitive schemas, missing fields and encoded values passed as decoded payloads.
 - [x] Encoding at enqueue and decoding before the handler. The PostgreSQL test round-trips a transformed payload and checks that malformed stored data reaches the dead-letter queue without calling the domain handler.
 - [x] Queue and schedule registration, with dead-letter queues, default retry settings and UTC schedule registration. Fake-client tests verify the supplied settings and a retry-limit override.
+- [x] Producer-only queue definitions create queues and dead-letter queues through `Jobs.layer({ jobs: [Queue] })`, without starting a consumer. The [PostgreSQL producer test](../src/server/producerPostgres.spec.ts) enqueues a transformed payload and observes worker retry exhaustion and dead-letter delivery. The [starter producer](../../../examples/starter/src/server/noteProducer.ts) uses this API.
 - [x] Worker and scheduled Effect service capture. Runtime and packed-consumer type tests preserve handler requirements.
 - [x] Scoped startup and shutdown, including cleanup when startup or registration fails.
 - [x] Explicit keyed client reuse and unkeyed per-build acquisition. Lifecycle tests cover two builds sharing one client and replacing the registered worker.
+- [x] Full pg-boss queue creation options, excluding the adapter's name and dead-letter setup. [PostgreSQL evidence](../src/server/notifyPostgres.spec.ts) verifies notification delivery to a waiting worker and immediate live counts after completion; [type tests](../src/server/service.typecheck.test.ts) enforce option ownership.
+- [x] Schema-decoded lookup by job ID and retry under the same ID for failed or retry-waiting jobs. [PostgreSQL evidence](../src/server/jobControlPostgres.spec.ts) verifies both states complete after a manual retry.
+- [x] Startup reconciles declared mutable queue settings and rejects immutable policy or partition changes with a typed error. [PostgreSQL restart evidence](../src/server/queueOptionsPostgres.spec.ts) checks expiry and retry-limit changes on an existing queue.
 - [x] Queue health totals for active, failed, queued, ready and dead-lettered counts, verified with a populated fake queue.
 - [x] Public defining-module imports and an installed-package type fixture.
 
@@ -18,9 +22,11 @@ This file owns the package's implementation inventory and open API choices. The
 
 No further package API expansion is selected. Let the framework's jobs integration work identify the next package change, and preserve the existing payload and lifecycle contracts while it does. That integration's status stays in the framework roadmap.
 
+## Decisions
+
+Enqueueing is separate from application SQL transactions. The package supplies no transactional enqueue adapter. Applications use transactions for database invariants and handle queue errors without failing those transactions. The starter enqueues after its note write transaction and logs queue failures; its [PostgreSQL queue-failure story](../../../examples/starter/src/server/queueFailure.spec.ts) proves that rejected enqueueing leaves create and edit writes saved. Its [rollback story](../../../examples/starter/src/server/committedJobs.spec.ts) also proves that an independently enqueued job survives an outer application rollback.
+
 ## Open questions
 
-- Which application boundary should choose how a database write becomes a durable job: an explicit after-commit action, an outbox, or another demonstrated approach? The enqueue API is independent of application SQL; no transaction coupling is selected.
 - Should a shared client key be checked against constructor settings and registration changes? The lifecycle fixture uses the same Layer twice; it does not settle incompatible configurations under one key.
-- Which public hooks need dedicated regression coverage before the guide makes stronger claims? Error-event reporting, cancellation through a job's AbortSignal, a declined send result, multi-queue health and actual cron/retry execution are implemented boundaries or engine behaviors without focused evidence here.
-- Should the package grow only when an application's integration needs a helper, or is a wider jobs API intended? The package has no in-repo application consumer to settle that question.
+- Which public hooks need dedicated regression coverage before the guide makes stronger claims? Error-event reporting, cancellation through a job's AbortSignal, a declined send result, multi-queue health and actual cron execution are implemented boundaries or engine behaviors without focused evidence here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-pg-boss",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Effect-native jobs and lifecycle management for pg-boss",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-pg-boss#readme",
   "bugs": {
@@ -17,17 +17,17 @@
   "imports": {
     "#test/*": "./src/test-support/*",
     "#*.ts": {
-      "source": "./src/*.ts",
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
+      "source": "./src/server/*.ts",
+      "types": "./dist/server/*.d.ts",
+      "default": "./dist/server/*.js"
     }
   },
   "exports": {
     "./*.ts": {
-      "types": "./dist/*.d.ts",
-      "source": "./src/*.ts",
-      "import": "./dist/*.js",
-      "default": "./dist/*.js"
+      "types": "./dist/server/*.d.ts",
+      "source": "./src/server/*.ts",
+      "import": "./dist/server/*.js",
+      "default": "./dist/server/*.js"
     },
     "./internal/*": null,
     "./package.json": "./package.json"
@@ -43,17 +43,17 @@
     "README.md"
   ],
   "devDependencies": {
-    "@shivaedev/quality": "0.19.0",
+    "@shivaedev/quality": "0.22.0",
     "@types/node": "24.19.1",
     "@typescript/native": "npm:typescript@7.0.2",
-    "effect": "4.0.0-rc.112",
-    "pg-boss": "12.36.0",
+    "effect": "4.0.4",
+    "pg-boss": "12.37.0",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.112",
-    "pg-boss": "12.36.0"
+    "effect": "4.0.4",
+    "pg-boss": "12.37.0"
   },
   "engines": {
     "node": ">=24"

package/src/{client.ts → server/client.ts}

@@ -1,16 +1,32 @@
-import type { ConstructorOptions, Job, Queue, QueueResult, ScheduleOptions, SendOptions, StopOptions, WorkOptions } from "pg-boss";
+import type {
+	ConstructorOptions,
+	FindJobsOptions,
+	Job,
+	JobWithMetadata,
+	Queue,
+	QueueResult,
+	ScheduleOptions,
+	SendOptions,
+	StopOptions,
+	WorkOptions,
+} from "pg-boss";
 import { PgBoss } from "pg-boss";
 
 export interface PgBossClient {
 	readonly createQueue: (name: string, options?: Omit<Queue, "name">) => Promise<void>;
+	readonly findJobs?: (name: string, options?: FindJobsOptions) => Promise<readonly JobWithMetadata<unknown>[]>;
+	readonly getDb?: PgBoss["getDb"];
 	readonly getQueue: (name: string) => Promise<QueueResult | null>;
 	readonly off: (event: "error", listener: (error: Error) => void) => unknown;
 	readonly offWork: (name: string) => Promise<void>;
 	readonly on: (event: "error", listener: (error: Error) => void) => unknown;
+	readonly retry?: PgBoss["retry"];
 	readonly schedule: (name: string, cron: string, data?: object | null, options?: ScheduleOptions) => Promise<void>;
 	readonly send: (name: string, data?: object | null, options?: SendOptions) => Promise<string | null>;
 	readonly start: () => Promise<unknown>;
 	readonly stop: (options?: StopOptions) => Promise<void>;
+	readonly update?: PgBoss["update"];
+	readonly updateQueue?: PgBoss["updateQueue"];
 	readonly work: (name: string, options: WorkOptions, handler: (jobs: readonly Job<unknown>[]) => Promise<unknown>) => Promise<string>;
 }
 

package/src/{definition.ts → server/definition.ts}

@@ -1,5 +1,5 @@
 import type { Effect, Schema } from "effect";
-import type { Job, QueueOptions, ScheduleOptions, WorkOptions } from "pg-boss";
+import type { Job, Queue, ScheduleOptions, WorkOptions } from "pg-boss";
 
 export interface JobPayloadSchema extends Schema.Top {
 	readonly Encoded: object;
@@ -20,7 +20,7 @@ export interface QueueDefinition<Name extends string = string, Payload extends J
 		handler: (payload: Schema.Schema.Type<Payload>, job: JobContext) => Effect.Effect<unknown, E, R>,
 	) => QueueWorker<Payload, R>;
 	readonly name: Name;
-	readonly queueOptions: Omit<QueueOptions, "deadLetter">;
+	readonly queueOptions: Omit<Queue, "name" | "deadLetter">;
 	readonly schema: Payload;
 	readonly workerOptions: WorkOptions;
 }
@@ -32,14 +32,14 @@ export interface QueueWorker<Payload extends JobPayloadSchema = JobPayloadSchema
 }
 
 export interface JobRegistration {
-	readonly _tag: "QueueWorker" | "ScheduledWorker";
+	readonly _tag: "QueueDefinition" | "QueueWorker" | "ScheduledWorker";
 }
 
 export interface ScheduleDefinition<Name extends string = string> {
 	readonly _tag: "ScheduleDefinition";
 	readonly cron: string;
 	readonly name: Name;
-	readonly queueOptions: Omit<QueueOptions, "deadLetter">;
+	readonly queueOptions: Omit<Queue, "name" | "deadLetter">;
 	readonly run: <E, R>(effect: Effect.Effect<unknown, E, R>) => ScheduledWorker<R>;
 	readonly scheduleOptions: ScheduleOptions;
 	readonly workerOptions: WorkOptions;
@@ -61,7 +61,7 @@ export type RegistrationRequirements<Registrations extends readonly JobRegistrat
 
 export interface DefineQueueOptions<Name extends string, Payload extends JobPayloadSchema> {
 	readonly name: Name;
-	readonly queue?: Omit<QueueOptions, "deadLetter">;
+	readonly queue?: Omit<Queue, "name" | "deadLetter">;
 	readonly schema: Payload;
 	readonly worker?: WorkOptions;
 }
@@ -88,7 +88,7 @@ export const defineQueue = <const Name extends string, const Payload extends Job
 export interface DefineScheduleOptions<Name extends string> {
 	readonly cron: string;
 	readonly name: Name;
-	readonly queue?: Omit<QueueOptions, "deadLetter">;
+	readonly queue?: Omit<Queue, "name" | "deadLetter">;
 	readonly schedule?: ScheduleOptions;
 	readonly worker?: WorkOptions;
 }

package/src/{error.ts → server/error.ts}

@@ -1,6 +1,6 @@
 import { Data, Redacted } from "effect";
 
-export type PgBossOperation = "enqueue" | "health" | "register" | "start" | "stop";
+export type PgBossOperation = "counts" | "enqueue" | "getJob" | "health" | "register" | "retry" | "start" | "stop";
 
 export class PgBossError extends Data.TaggedError("PgBossError")<{
 	readonly operation: PgBossOperation;
@@ -8,6 +8,15 @@ export class PgBossError extends Data.TaggedError("PgBossError")<{
 	readonly original: Redacted.Redacted<unknown>;
 }> {}
 
+export class PgBossQueueOptionsError extends Data.TaggedError("PgBossQueueOptionsError")<{
+	readonly queue: string;
+	readonly options: readonly ("partition" | "policy")[];
+}> {
+	override get message(): string {
+		return `Queue ${this.queue} cannot change options after creation: ${this.options.join(", ")}`;
+	}
+}
+
 export class PgBossPayloadError extends Data.TaggedError("PgBossPayloadError")<{
 	readonly direction: "decode" | "encode";
 	readonly queue: string;

package/src/{health.ts → server/health.ts}

@@ -1,3 +1,10 @@
+export interface QueueCounts {
+	readonly activeCount: number;
+	readonly failedCount: number;
+	readonly queuedCount: number;
+	readonly totalCount: number;
+}
+
 export interface QueueHealth {
 	readonly activeCount: number;
 	readonly deadLetteredCount: number;

package/src/server/internal/countsFor.ts

@@ -0,0 +1,33 @@
+import { Effect, Schema } from "effect";
+import type { PgBossClient } from "#client.ts";
+import { toPgBossError } from "#error.ts";
+import type { QueueCounts } from "#health.ts";
+
+const Counts = Schema.Struct({
+	activeCount: Schema.Number,
+	failedCount: Schema.Number,
+	queuedCount: Schema.Number,
+	totalCount: Schema.Number,
+});
+
+export function countsFor(client: PgBossClient, schema: string, name: string): Effect.Effect<QueueCounts, import("#error.ts").PgBossError> {
+	return Effect.tryPromise({
+		catch: (error) => toPgBossError("counts", error, name),
+		try: async () => {
+			if (client.getDb === undefined) {
+				throw new TypeError("This pg-boss client does not support getDb");
+			}
+			const quotedSchema = `"${schema.replaceAll('"', '""')}"`;
+			const { rows } = await client.getDb().executeSql(
+				`SELECT
+					count(*) FILTER (WHERE state = 'active')::int AS "activeCount",
+					count(*) FILTER (WHERE state = 'failed')::int AS "failedCount",
+					count(*) FILTER (WHERE state IN ('created', 'retry'))::int AS "queuedCount",
+					count(*)::int AS "totalCount"
+				FROM ${quotedSchema}.job WHERE name = $1`,
+				[name],
+			);
+			return Schema.decodeUnknownPromise(Counts)(rows[0]);
+		},
+	});
+}

package/src/server/internal/ensureQueue.ts

@@ -0,0 +1,29 @@
+import type { Queue } from "pg-boss";
+import type { PgBossClient } from "#client.ts";
+import { PgBossQueueOptionsError } from "#error.ts";
+import { deadLetterQueueName } from "#health.ts";
+
+export async function ensureQueue(client: PgBossClient, name: string, options: Omit<Queue, "name" | "deadLetter">): Promise<void> {
+	const deadLetter = deadLetterQueueName(name);
+	const desired = { retryBackoff: true, retryLimit: 3, ...options, deadLetter };
+	await client.createQueue(deadLetter);
+	await client.createQueue(name, desired);
+	const existing = await client.getQueue(name);
+	if (existing === null) {
+		return;
+	}
+	const immutable = (["partition", "policy"] as const).filter((key) => desired[key] !== undefined && desired[key] !== existing[key]);
+	if (immutable.length > 0) {
+		throw new PgBossQueueOptionsError({ options: immutable, queue: name });
+	}
+	const { partition: _partition, policy: _policy, ...mutable } = desired;
+	const changed = Object.entries(mutable).some(([key, value]) => value !== undefined && value !== Reflect.get(existing, key));
+	if (!changed) {
+		return;
+	}
+	if (client.updateQueue === undefined) {
+		throw new TypeError("This pg-boss client does not support updateQueue");
+	}
+	// pg-boss validates retryDelayMax against retryBackoff in the same update.
+	await client.updateQueue(name, mutable);
+}

package/src/server/internal/jobControl.ts

@@ -0,0 +1,46 @@
+import { Effect, Option, Redacted, Schema } from "effect";
+import type { PgBossClient } from "#client.ts";
+import { PgBossPayloadError, toPgBossError } from "#error.ts";
+import type { PgBossService } from "#service.ts";
+
+export function getJobFor(client: PgBossClient): PgBossService["getJob"] {
+	return (queue, id) =>
+		Effect.tryPromise({
+			catch: (error) => toPgBossError("getJob", error, queue.name),
+			try: async () => {
+				if (client.findJobs === undefined) {
+					throw new TypeError("This pg-boss client does not support findJobs");
+				}
+				return (await client.findJobs(queue.name, { id }))[0];
+			},
+		}).pipe(
+			Effect.flatMap((job) =>
+				job === undefined
+					? Effect.succeed(Option.none())
+					: Schema.decodeUnknownEffect(queue.schema)(job.data).pipe(
+							Effect.mapError((error) => new PgBossPayloadError({ direction: "decode", original: Redacted.make(error), queue: queue.name })),
+							Effect.map((data) => Option.some({ ...job, data })),
+						),
+			),
+		);
+}
+
+export function retryFor(client: PgBossClient): PgBossService["retry"] {
+	return (queue, id) =>
+		Effect.tryPromise({
+			catch: (error) => toPgBossError("retry", error, queue.name),
+			try: async () => {
+				if (client.findJobs === undefined || client.retry === undefined || client.update === undefined) {
+					throw new TypeError("This pg-boss client does not support findJobs, retry and update");
+				}
+				const job = (await client.findJobs(queue.name, { id }))[0];
+				if (job?.state !== "failed" && job?.state !== "retry") {
+					return;
+				}
+				if (job.state === "failed") {
+					await client.retry(queue.name, id);
+				}
+				await client.update(queue.name, undefined, { id, startAfter: 0 });
+			},
+		});
+}

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

@@ -1,17 +1,9 @@
 import { type Context, Effect, Redacted, Schema } from "effect";
 import type { Job } from "pg-boss";
 import type { PgBossClient } from "#client.ts";
-import { type JobRegistration, jobContext, type QueueWorker, type ScheduledWorker } from "#definition.ts";
-import { PgBossPayloadError, toPgBossError } from "#error.ts";
-import { deadLetterQueueName } from "#health.ts";
-
-function queueOptions(options: Readonly<Record<string, unknown>>) {
-	return {
-		retryBackoff: true,
-		retryLimit: 3,
-		...options,
-	};
-}
+import { type JobRegistration, jobContext, type QueueDefinition, type QueueWorker, type ScheduledWorker } from "#definition.ts";
+import { PgBossPayloadError, PgBossQueueOptionsError, toPgBossError } from "#error.ts";
+import { ensureQueue } from "#internal/ensureQueue.ts";
 
 function isQueueWorker(registration: JobRegistration): registration is QueueWorker {
 	return registration._tag === "QueueWorker";
@@ -21,7 +13,14 @@ function isScheduledWorker(registration: JobRegistration): registration is Sched
 	return registration._tag === "ScheduledWorker";
 }
 
+function isQueueDefinition(registration: JobRegistration): registration is QueueDefinition {
+	return registration._tag === "QueueDefinition";
+}
+
 export const registrationName = (registration: JobRegistration): string => {
+	if (isQueueDefinition(registration)) {
+		return registration.name;
+	}
 	if (isQueueWorker(registration)) {
 		return registration.queue.name;
 	}
@@ -55,20 +54,24 @@ function runQueueWorker(worker: QueueWorker, job: Job<unknown>, context: Context
 	);
 }
 
-async function registerQueue(client: PgBossClient, worker: QueueWorker, context: Context.Context<unknown>, replaceWorker: boolean): Promise<void> {
-	const name = worker.queue.name;
-	const deadLetter = deadLetterQueueName(name);
-	if (replaceWorker) {
+async function registerQueue(
+	client: PgBossClient,
+	registration: QueueWorker | QueueDefinition,
+	context: Context.Context<unknown>,
+	replaceWorker: boolean,
+): Promise<void> {
+	const queue = registration._tag === "QueueWorker" ? registration.queue : registration;
+	const name = queue.name;
+	if (replaceWorker && registration._tag === "QueueWorker") {
 		await client.offWork(name);
 	}
-	await client.createQueue(deadLetter);
-	await client.createQueue(name, {
-		...queueOptions(worker.queue.queueOptions),
-		deadLetter,
-	});
-	await client.work(name, worker.queue.workerOptions, async (jobs) => {
+	await ensureQueue(client, name, queue.queueOptions);
+	if (registration._tag === "QueueDefinition") {
+		return;
+	}
+	await client.work(name, queue.workerOptions, async (jobs) => {
 		for (const job of jobs) {
-			await runQueueWorker(worker, job, context);
+			await runQueueWorker(registration, job, context);
 		}
 	});
 }
@@ -80,15 +83,10 @@ async function registerSchedule(
 	replaceWorker: boolean,
 ): Promise<void> {
 	const { schedule } = worker;
-	const deadLetter = deadLetterQueueName(schedule.name);
 	if (replaceWorker) {
 		await client.offWork(schedule.name);
 	}
-	await client.createQueue(deadLetter);
-	await client.createQueue(schedule.name, {
-		...queueOptions(schedule.queueOptions),
-		deadLetter,
-	});
+	await ensureQueue(client, schedule.name, schedule.queueOptions);
 	await client.work(schedule.name, schedule.workerOptions, async (jobs: readonly Job<unknown>[]) => {
 		for (const job of jobs) {
 			await Effect.runPromise(Effect.provide(worker.effect, context), {
@@ -112,14 +110,14 @@ export const registerJobs = <R>(
 	registrations: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
-): Effect.Effect<void, import("#error.ts").PgBossError> =>
+): Effect.Effect<void, import("#error.ts").PgBossError | PgBossQueueOptionsError> =>
 	Effect.tryPromise({
-		catch: (error) => toPgBossError("register", error),
+		catch: (error) => (error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error)),
 		try: async () => {
 			registrationNames(registrations);
 			const provided = workerContext(context);
 			for (const registration of registrations) {
-				if (isQueueWorker(registration)) {
+				if (isQueueWorker(registration) || isQueueDefinition(registration)) {
 					await registerQueue(client, registration, provided, replaceWorkers);
 				} else if (isScheduledWorker(registration)) {
 					await registerSchedule(client, registration, provided, replaceWorkers);

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

@@ -1,10 +1,13 @@
 import { Effect, Option, Redacted, Schema } from "effect";
 import type { PgBossClient } from "#client.ts";
 import { type PgBossError, PgBossPayloadError, toPgBossError } from "#error.ts";
+import { countsFor } from "#internal/countsFor.ts";
+import { healthFor } from "#internal/health.ts";
+import { getJobFor, retryFor } from "#internal/jobControl.ts";
 import type { PgBossService } from "#service.ts";
-import { healthFor } from "./health.ts";
 
-export const makeService = (client: PgBossClient, names: readonly string[]): PgBossService => ({
+export const makeService = (client: PgBossClient, names: readonly string[], schema = "pgboss"): PgBossService => ({
+	counts: (queue) => countsFor(client, schema, queue.name),
 	enqueue: (queue, payload, options) =>
 		Schema.encodeUnknownEffect(queue.schema)(payload).pipe(
 			Effect.mapError(
@@ -31,5 +34,7 @@ export const makeService = (client: PgBossClient, names: readonly string[]): PgB
 				}).pipe(Effect.map(Option.fromNullishOr));
 			}),
 		),
+	getJob: getJobFor(client),
 	health: healthFor(client, names),
+	retry: retryFor(client),
 });

package/src/{service.ts → server/service.ts}

@@ -1,20 +1,26 @@
 import { Context, Effect, Layer, type Option, type Schema } from "effect";
-import type { ConstructorOptions, SendOptions, StopOptions } from "pg-boss";
+import type { ConstructorOptions, JobWithMetadata, SendOptions, StopOptions } from "pg-boss";
 import type { PgBossClientFactory } from "#client.ts";
+import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "#definition.ts";
+import type { PgBossError, PgBossPayloadError, PgBossQueueOptionsError } from "#error.ts";
+import type { JobsHealth, QueueCounts } from "#health.ts";
 import { acquireClient, releaseClient } from "#internal/lifecycle.ts";
 import { registerJobs, registrationName } from "#internal/register.ts";
 import { makeService } from "#internal/service.ts";
-import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "./definition.ts";
-import type { PgBossError, PgBossPayloadError } from "./error.ts";
-import type { JobsHealth } from "./health.ts";
 
 export interface PgBossService {
+	readonly counts: (queue: QueueDefinition) => Effect.Effect<QueueCounts, PgBossError>;
 	readonly enqueue: <const TName extends string, const TPayload extends JobPayloadSchema>(
 		queue: QueueDefinition<TName, TPayload>,
 		payload: Schema.Schema.Type<TPayload>,
 		options?: SendOptions,
 	) => Effect.Effect<Option.Option<string>, PgBossError | PgBossPayloadError, TPayload["EncodingServices"]>;
+	readonly getJob: <const TName extends string, const TPayload extends JobPayloadSchema>(
+		queue: QueueDefinition<TName, TPayload>,
+		id: string,
+	) => Effect.Effect<Option.Option<JobWithMetadata<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
 	readonly health: Effect.Effect<JobsHealth, PgBossError>;
+	readonly retry: (queue: QueueDefinition, id: string) => Effect.Effect<void, PgBossError>;
 }
 
 export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> = ConstructorOptions & {
@@ -29,7 +35,7 @@ export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[]
 export interface PgBossDefinition<TIdentifier extends string = string> extends Context.Service<TIdentifier, PgBossService> {
 	readonly layer: <const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(
 		options: PgBossLayerOptions<TRegistrations, TErrorRequirements>,
-	) => Layer.Layer<TIdentifier, PgBossError, RegistrationRequirements<TRegistrations> | TErrorRequirements>;
+	) => Layer.Layer<TIdentifier, PgBossError | PgBossQueueOptionsError, RegistrationRequirements<TRegistrations> | TErrorRequirements>;
 }
 
 function logClientError(error: Error): Effect.Effect<void> {
@@ -41,7 +47,7 @@ export const makePgBoss = <const TIdentifier extends string>(identifier: TIdenti
 
 	const layer = <const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(
 		options: PgBossLayerOptions<TRegistrations, TErrorRequirements>,
-	): Layer.Layer<TIdentifier, PgBossError, RegistrationRequirements<TRegistrations> | TErrorRequirements> => {
+	): Layer.Layer<TIdentifier, PgBossError | PgBossQueueOptionsError, RegistrationRequirements<TRegistrations> | TErrorRequirements> => {
 		type Requirements = RegistrationRequirements<TRegistrations> | TErrorRequirements;
 		const names = options.jobs.map(registrationName);
 		const { clientFactory, clientCacheKey, jobs, onError, stop, ...constructorOptions } = options;
@@ -76,7 +82,7 @@ export const makePgBoss = <const TIdentifier extends string>(identifier: TIdenti
 
 		return Layer.effect(
 			Service,
-			Effect.map(acquire, ({ acquired }) => makeService(acquired.client, names)),
+			Effect.map(acquire, ({ acquired }) => makeService(acquired.client, names, constructorOptions.schema)),
 		);
 	};
 

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGnI,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACjE,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,OAAO,CAAC;IAC5E,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,QAAQ,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,OAAO,CAAC;IAC3E,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClH,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrG,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACrI;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,kBAAkB,KAAK,YAAY,CAAC;AAEhF,eAAO,MAAM,oBAAoB,EAAE,mBAAsD,CAAC"}

package/dist/client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAiBjC,MAAM,CAAC,MAAM,oBAAoB,GAAwB,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC"}