@shivaedev/jobs 0.39.0 → 0.40.0

package/dist/server/services/operations/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../src/server/services/operations/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,MAAM,CAAC,MAAM,gBAAgB,GAAG,aAAa,CAAC;IAC7C,EAAE,EAAE,kCAAkC;IACtC,UAAU,EAAE,MAAM,CAAC,IAAI;IACvB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IACjH,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC;CACxC,CAAC,CAAC"}

package/dist/server/services/operations/unschedule.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+export declare const unschedule: (schedule: Pick<import("../../definition.ts").ScheduleDefinition<string>, "name" | "scheduleOptions">) => Effect.Effect<void, import("../../error.ts").PgBossError | import("../../error.ts").PgBossNotFoundError, JobEngine>;
+//# sourceMappingURL=unschedule.d.ts.map

package/dist/server/services/operations/unschedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unschedule.d.ts","sourceRoot":"","sources":["../../../../src/server/services/operations/unschedule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,eAAO,MAAM,UAAU,+NAGrB,CAAC"}

package/dist/server/services/operations/unschedule.js

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { JobEngine } from "#server/engine.ts";
+export const unschedule = Effect.fn("PgBossOperations.unschedule")(function* (...args) {
+    const engine = yield* JobEngine;
+    return yield* engine.unschedule(...args);
+});
+//# sourceMappingURL=unschedule.js.map

package/dist/server/services/operations/unschedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unschedule.js","sourceRoot":"","sources":["../../../../src/server/services/operations/unschedule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC,6BAA6B,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,IAA6C;IAC7H,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC;IAChC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;AAC1C,CAAC,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"validateQueueNames.d.ts","sourceRoot":"","sources":["../../src/server/validateQueueNames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,eAAO,MAAM,kBAAkB,uIAW7B,CAAC"}
+{"version":3,"file":"validateQueueNames.d.ts","sourceRoot":"","sources":["../../src/server/validateQueueNames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,eAAO,MAAM,kBAAkB,uIAW7B,CAAC"}

package/dist/server/validateQueueNames.js

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
+import { registrationName } from "#server/adapters/register.ts";
 import { PgBossQueueNamesError } from "#server/error.ts";
-import { registrationName } from "./register.js";
 export const validateQueueNames = Effect.fnUntraced(function* (jobs, declared) {
     if (declared === undefined) {
         return;

package/dist/server/validateQueueNames.js.map

@@ -1 +1 @@
-{"version":3,"file":"validateQueueNames.js","sourceRoot":"","sources":["../../src/server/validateQueueNames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,IAAgC,EAAE,QAAuC;IACvI,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,OAAO,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACtE,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACzE,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjD,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAC/E,CAAC;AACF,CAAC,CAAC,CAAC"}
+{"version":3,"file":"validateQueueNames.js","sourceRoot":"","sources":["../../src/server/validateQueueNames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,IAAgC,EAAE,QAAuC;IACvI,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,OAAO,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACtE,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACzE,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjD,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAC/E,CAAC;AACF,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/jobs",
-  "version": "0.39.0",
+  "version": "0.40.0",
   "description": "Effect-native jobs and lifecycle management for pg-boss",
   "keywords": [
     "effect"
@@ -45,15 +45,15 @@
   "dependencies": {
     "@shivaedev/errors": "0.10.0",
     "@shivaedev/service": "0.8.0",
-    "@shivaedev/sql": "0.42.0"
+    "@shivaedev/sql": "0.43.0"
   },
   "devDependencies": {
     "@effect/sql-pg": "4.1.0",
     "@shivaedev/http": "0.8.0",
-    "@shivaedev/quality": "0.65.0",
-    "@shivaedev/test-kits": "0.8.0",
-    "@shivaedev/test-sql": "0.24.0",
-    "@shivaedev/test-story": "0.42.0",
+    "@shivaedev/quality": "0.66.0",
+    "@shivaedev/test-kits": "0.8.1",
+    "@shivaedev/test-sql": "0.24.1",
+    "@shivaedev/test-story": "0.42.1",
     "@types/node": "24.19.2",
     "effect": "4.1.0",
     "pg-boss": "12.38.0",

package/src/server/InspectionEngine.ts

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+import type { inspectionReads } from "#server/adapters/inspectionReads.ts";
+export class InspectionEngine extends Context.Service<InspectionEngine, ReturnType<typeof inspectionReads>>()("@shivaedev/jobs/InspectionEngine") {}

package/src/server/JobQueues.ts

@@ -0,0 +1,2 @@
+import { Context } from "effect";
+export class JobQueues extends Context.Service<JobQueues, readonly string[]>()("@shivaedev/jobs/JobQueues") {}

package/src/server/SchemaConnection.ts

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+import type { Connection } from "effect/sql/SqlConnection";
+export class SchemaConnection extends Context.Service<SchemaConnection, Connection>()("@shivaedev/jobs/SchemaConnection") {}

package/src/server/adapters/inspection.ts

@@ -1,31 +1,26 @@
-import { Effect } from "effect";
-import { jobEngine } from "#server/adapters/jobEngine.ts";
-import type { PgBossClient } from "#server/client.ts";
-import { countsFor } from "#server/countsFor.ts";
-import { JobEngine } from "#server/engine.ts";
-import { healthFor } from "#server/healthFor.ts";
+import { Context, Effect } from "effect";
+import { getJob } from "#server/getJob.ts";
 import type { PgBossInspectionService } from "#server/inspection.ts";
-import { jobControl } from "#server/jobControl.ts";
-import { jobListings } from "#server/jobListings.ts";
-import { inspectionChanges } from "./inspectionChanges.ts";
-import { inspectionReads } from "./inspectionReads.ts";
+import { inspectionJobs } from "#server/inspectionJobs.ts";
+import { inspectionSnapshot } from "#server/inspectionSnapshot.ts";
+import { deadLetteredJobs, failedJobs } from "#server/jobListings.ts";
+import { PgBossInspectionReads } from "#server/services/inspection/service.ts";
+import { PgBossOperations } from "#server/services/operations/service.ts";
 
-export function inspection(client: PgBossClient, schema = "pgboss"): Effect.Effect<PgBossInspectionService> {
-	const engine = jobEngine(client, schema);
-	return Effect.gen(function* () {
-		const listings = yield* jobListings;
-		const { getJob } = yield* jobControl;
-		return {
-			...inspectionReads(client, schema),
-			...listings,
-			changes: (queue?: { readonly name: string }) => inspectionChanges(client, schema, queue?.name),
-			counts: (queue: { readonly name: string }) => countsFor(client, schema, queue.name),
-			getJob,
-			health: (queues: readonly { readonly name: string }[]) =>
-				healthFor(
-					client,
-					queues.map((queue) => queue.name),
-				),
-		};
-	}).pipe(Effect.provideService(JobEngine, engine));
-}
+export const inspection = Effect.fnUntraced(function* (): Effect.fn.Return<
+	PgBossInspectionService,
+	never,
+	"@shivaedev/jobs/PgBossInspectionReads" | "@shivaedev/jobs/PgBossOperations"
+> {
+	const ambient = yield* Effect.context<"@shivaedev/jobs/PgBossInspectionReads" | "@shivaedev/jobs/PgBossOperations">();
+	const context = Context.pick(PgBossOperations, PgBossInspectionReads)(ambient);
+	const reads = yield* PgBossInspectionReads;
+	return {
+		...reads,
+		deadLetteredJobs: (queue, options) => deadLetteredJobs(queue, 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)),
+		jobs: (queue, options) => inspectionJobs(queue, options).pipe(Effect.provide(context)),
+		snapshot: (queues) => inspectionSnapshot(queues).pipe(Effect.provide(context)),
+	};
+});

package/src/server/adapters/inspectionJobs.ts

@@ -1,8 +1,6 @@
-import { Effect, type Schema } from "effect";
+import { Effect } from "effect";
 import type { JobReadOptions, PgBossClient } from "#server/client.ts";
-import type { JobPayloadSchema } from "#server/definition.ts";
 import { toPgBossError } from "#server/error.ts";
-import { decodeStoredData } from "#server/storedRows.ts";
 
 export function inspectionJobs(client: PgBossClient) {
 	function storedJobs(queue: { readonly name: string }, options?: JobReadOptions) {
@@ -16,13 +14,5 @@ export function inspectionJobs(client: PgBossClient) {
 			},
 		});
 	}
-	function jobs<TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(
-		queue: { readonly name: TName; readonly schema: TPayload },
-		options?: JobReadOptions,
-	) {
-		return storedJobs(queue, options).pipe(
-			Effect.flatMap((rows) => Effect.forEach(rows, (job) => decodeStoredData(queue, job.data).pipe(Effect.map((data) => ({ ...job, data }))))),
-		);
-	}
-	return { jobs, storedJobs };
+	return { storedJobs };
 }

package/src/server/adapters/inspectionLayer.ts

@@ -0,0 +1,7 @@
+import { type Context, Layer } from "effect";
+import type { PgBossInspectionService } from "#server/inspection.ts";
+import { inspection } from "./inspection.ts";
+import { operationsLayer } from "./operationsLayer.ts";
+export function inspectionLayer<TIdentifier extends string>(service: Context.Service<TIdentifier, PgBossInspectionService>) {
+	return Layer.effect(service, inspection()).pipe(Layer.provide(operationsLayer([])));
+}

package/src/server/adapters/inspectionReads.ts

@@ -31,7 +31,6 @@ export function inspectionReads(client: PgBossClient, schema: string) {
 				);
 				return Schema.decodeUnknownSync(Busy)(rows[0]).busy;
 			}),
-		...inspectionJobs(client),
 		queue: (queue: Pick<QueueDefinition, "name">) => inspectionOperation(() => client.getQueue(queue.name), queue.name),
 		schedules: (name?: string, key?: string) =>
 			inspectionOperation(() => {
@@ -47,9 +46,7 @@ export function inspectionReads(client: PgBossClient, schema: string) {
 				}
 				return client.schemaVersion();
 			}),
-		snapshot: inspectionSnapshot(
-			() => client,
-			() => schema,
-		),
+		snapshot: inspectionSnapshot(client, schema),
+		storedJobs: inspectionJobs(client).storedJobs,
 	};
 }

package/src/server/adapters/inspectionSnapshot.ts

@@ -1,9 +1,7 @@
-import { Effect, Schema } from "effect";
+import { Schema } from "effect";
 import { inspectionOperation } from "#server/adapters/inspectionOperation.ts";
 import type { PgBossClient } from "#server/client.ts";
-import type { PgBossError, PgBossPayloadError } from "#server/error.ts";
-import type { SnapshotQueue, UnfinishedJob } from "#server/inspection.ts";
-import { decodeStoredData, quotedSchema } from "#server/storedRows.ts";
+import { quotedSchema } from "#server/storedRows.ts";
 
 const Rows = Schema.Array(
 	Schema.Struct({
@@ -15,40 +13,24 @@ const Rows = Schema.Array(
 	}),
 );
 
-export function inspectionSnapshot(client: () => PgBossClient, schema: () => string) {
-	return <const TQueues extends readonly SnapshotQueue[]>(
-		queues: TQueues,
-	): Effect.Effect<readonly UnfinishedJob<TQueues[number]>[], PgBossPayloadError | PgBossError, TQueues[number]["schema"]["DecodingServices"]> => {
-		const byName = new Map<string, TQueues[number]>(queues.map((queue) => [queue.name, queue]));
-		return inspectionOperation(async () => {
-			const quoted = quotedSchema(schema());
-			const db = client().getDb?.();
+export function inspectionSnapshot(client: PgBossClient, schema: string) {
+	return (queues: readonly { readonly name: string }[]) =>
+		inspectionOperation(async () => {
+			const quoted = quotedSchema(schema);
+			const db = client.getDb?.();
 			if (db === undefined) {
 				throw new TypeError("This pg-boss client does not support getDb");
 			}
 			const { rows } = await db.executeSql(
 				`SELECT id, name AS queue, data, start_after AS "startAfter",
-					CASE WHEN state = 'retry' AND started_on IS NULL AND start_after > ${quoted}.job_now()
-						AND output ? 'jobDeferral'
-					THEN 'deferred' ELSE state::text END AS state
-					FROM ${quoted}.job
-					WHERE name = ANY($1::text[]) AND state IN ('created', 'retry', 'active', 'failed')
-					ORDER BY created_on, id`,
-				[[...byName.keys()]],
+    CASE WHEN state = 'retry' AND started_on IS NULL AND start_after > ${quoted}.job_now()
+     AND output ? 'jobDeferral'
+    THEN 'deferred' ELSE state::text END AS state
+    FROM ${quoted}.job
+    WHERE name = ANY($1::text[]) AND state IN ('created', 'retry', 'active', 'failed')
+    ORDER BY created_on, id`,
+				[queues.map(({ name }) => name)],
 			);
 			return Schema.decodeUnknownPromise(Rows)(rows);
-		}).pipe(
-			Effect.flatMap((rows) =>
-				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/adapters/installSchema.ts

@@ -4,6 +4,7 @@ import type { Connection } from "effect/sql/SqlConnection";
 import { getConstructionPlans, getMigrationPlans, PgBoss } from "pg-boss";
 import pgBossPackage from "pg-boss/package.json" with { type: "json" };
 import { jobStorePlans } from "#server/jobStorePlans.ts";
+import { SchemaConnection } from "#server/SchemaConnection.ts";
 import type { PgBossSchemaOptions } from "#server/schema.ts";
 import { runSchemaPlan } from "./runSchemaPlan.ts";
 import { resumeSchemaIndexes } from "./schemaIndexBuilds.ts";
@@ -26,7 +27,7 @@ async function installNativeSchema(
 		schema,
 	});
 	if (!(await client.isInstalled())) {
-		await runSchemaPlan(connection, construction, run);
+		await run(runSchemaPlan(construction).pipe(Effect.provideService(SchemaConnection, connection)));
 		return;
 	}
 	const version = await client.schemaVersion();
@@ -43,10 +44,12 @@ async function installNativeSchema(
 		const partitionTables = Schema.decodeUnknownSync(Partitions)(
 			await run(connection.executeUnprepared(`SELECT table_name AS "tableName", policy FROM ${schema}.queue WHERE partition = true`, [], undefined)),
 		);
-		await runSchemaPlan(connection, getMigrationPlans(schema, version, { partitionTables: Array.from(partitionTables) }), run, {
-			schema,
-			version: pgBossPackage.pgboss.schema,
-		});
+		await run(
+			runSchemaPlan(getMigrationPlans(schema, version, { partitionTables: Array.from(partitionTables) }), {
+				schema,
+				version: pgBossPackage.pgboss.schema,
+			}).pipe(Effect.provideService(SchemaConnection, connection)),
+		);
 		await resumeSchemaIndexes(client, schema);
 	}
 }

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/{pgBossDefinitionLayer.ts → 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/{register.ts → 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 { ensureQueue } from "#server/ensureQueue.ts";
 import { PgBossQueueOptionsError, toPgBossError } from "#server/error.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/{registerReleasedJobs.ts → 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

@@ -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/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, []);
 		}
 	}
-}
+});