@shivaedev/effect-pg-boss 0.7.1 → 0.8.1

package/src/server/internal/lifecycle.ts

@@ -2,30 +2,8 @@ import { Effect } from "effect";
 import type { ConstructorOptions, StopOptions } from "pg-boss";
 import { defaultClientFactory, type PgBossClient, type PgBossClientFactory } from "#client.ts";
 import { toPgBossError } from "#error.ts";
-
-interface CachedClient {
-	readonly client: Promise<PgBossClient>;
-	references: number;
-}
-
-const CacheKey = Symbol.for("@shivaedev/effect-pg-boss/client-cache");
-const sharedCache: unknown = Reflect.get(globalThis, CacheKey);
-const clientCache: Map<string | symbol, unknown> = sharedCache instanceof Map ? sharedCache : new Map<string | symbol, unknown>();
-Reflect.set(globalThis, CacheKey, clientCache);
-
-function isCachedClient(value: unknown): value is CachedClient {
-	return (
-		typeof value === "object"
-		&& value !== null
-		&& Reflect.get(value, "client") instanceof Promise
-		&& typeof Reflect.get(value, "references") === "number"
-	);
-}
-
-function cachedClient(key: string | symbol): CachedClient | undefined {
-	const entry = clientCache.get(key);
-	return isCachedClient(entry) ? entry : undefined;
-}
+import { acquireCachedClient, releaseCachedClient } from "./clientCache.ts";
+import { logClientError, observeClientErrors } from "./clientErrors.ts";
 
 export interface AcquireClientOptions {
 	readonly clientCacheKey?: string | symbol | undefined;
@@ -39,86 +17,48 @@ export interface AcquiredClient {
 	readonly reused: boolean;
 }
 
-function startClient(options: AcquireClientOptions): Promise<PgBossClient> {
+async function startClient(options: AcquireClientOptions, report: (error: Error) => void): Promise<PgBossClient> {
 	const client = (options.clientFactory ?? defaultClientFactory)(options.constructor);
-	return client.start().then(
-		() => client,
-		async (error) => {
-			try {
-				await client.stop();
-			} catch {
-				// Preserve the startup failure; stop is best effort on failed acquisition.
-			}
-			throw error;
-		},
-	);
+	observeClientErrors(client, report);
+	try {
+		await client.start();
+		return client;
+	} catch (error) {
+		try {
+			await client.stop();
+		} catch {
+			// Preserve the startup failure; stop is best effort on failed acquisition.
+		}
+		throw error;
+	}
 }
 
-export const acquireClient = (options: AcquireClientOptions): Effect.Effect<AcquiredClient, import("#error.ts").PgBossError> =>
-	Effect.tryPromise({
-		catch: (error) => toPgBossError("start", error),
-		try: async () => {
-			const cacheKey = options.clientCacheKey;
-			if (cacheKey === undefined) {
-				return {
-					client: await startClient(options),
-					reused: false,
-				};
-			}
-
-			const existing = cachedClient(cacheKey);
-			if (existing !== undefined) {
-				existing.references += 1;
-				try {
-					return {
-						cacheKey,
-						client: await existing.client,
-						reused: true,
-					};
-				} catch (error) {
-					existing.references -= 1;
-					throw error;
-				}
-			}
-
-			const entry: CachedClient = {
-				client: startClient(options),
-				references: 1,
-			};
-			clientCache.set(cacheKey, entry);
-			try {
-				return {
-					cacheKey,
-					client: await entry.client,
-					reused: false,
-				};
-			} catch (error) {
-				if (clientCache.get(cacheKey) === entry) {
-					clientCache.delete(cacheKey);
-				}
-				throw error;
-			}
-		},
+export function acquireClient(options: AcquireClientOptions): Effect.Effect<AcquiredClient, import("#error.ts").PgBossError> {
+	return Effect.contextWith((context) => {
+		const run = Effect.runForkWith(context);
+		function report(error: Error) {
+			run(logClientError(error));
+		}
+		return Effect.tryPromise({
+			catch: (error) => toPgBossError("start", error),
+			try: async () => {
+				const cacheKey = options.clientCacheKey;
+				return cacheKey === undefined
+					? { client: await startClient(options, report), reused: false }
+					: { cacheKey, ...(await acquireCachedClient(cacheKey, () => startClient(options, report))) };
+			},
+		});
 	});
+}
 
-export const releaseClient = (acquired: AcquiredClient, stopOptions?: StopOptions): Effect.Effect<void> =>
-	Effect.tryPromise({
+export function releaseClient(acquired: AcquiredClient, stopOptions?: StopOptions): Effect.Effect<void> {
+	return Effect.tryPromise({
 		catch: (error) => toPgBossError("stop", error),
 		try: async () => {
-			if (acquired.cacheKey === undefined) {
-				await acquired.client.stop(stopOptions);
-				return;
-			}
-
-			const entry = cachedClient(acquired.cacheKey);
-			if (entry === undefined) {
-				return;
+			const client = acquired.cacheKey === undefined ? acquired.client : await releaseCachedClient(acquired.cacheKey);
+			if (client !== undefined) {
+				await client.stop(stopOptions);
 			}
-			entry.references -= 1;
-			if (entry.references > 0) {
-				return;
-			}
-			clientCache.delete(acquired.cacheKey);
-			await acquired.client.stop(stopOptions);
 		},
 	}).pipe(Effect.catch((error) => Effect.logError(error)));
+}

package/src/server/internal/register.ts

@@ -9,7 +9,7 @@ import {
 	type ScheduleDefinition,
 	type ScheduledWorker,
 } from "#definition.ts";
-import { PgBossPayloadError, PgBossQueueOptionsError, toPgBossError } from "#error.ts";
+import { PgBossError, PgBossPayloadError, PgBossQueueOptionsError, toPgBossError } from "#error.ts";
 import { batchHandler } from "#internal/batchHandler.ts";
 import { ensureQueue } from "#internal/ensureQueue.ts";
 import { payloadOf, traceJob } from "#internal/tracing.ts";
@@ -51,7 +51,11 @@ async function prepareQueues(client: PgBossClient, registrations: readonly JobRe
 	}
 	for (const registration of registrations) {
 		const definition = registrationDefinition(registration);
-		await ensureQueue(client, definition.name, definition.queueOptions);
+		try {
+			await ensureQueue(client, definition.name, definition.queueOptions);
+		} catch (error) {
+			throw error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error, definition.name);
+		}
 	}
 }
 
@@ -85,7 +89,7 @@ async function registerQueue(client: PgBossClient, registration: QueueWorker | Q
 	}
 	await client.work(
 		name,
-		queue.workerOptions,
+		{ ...queue.workerOptions, includeMetadata: true },
 		batchHandler(client, name, (job) => runQueueWorker(registration, job, context)),
 	);
 }
@@ -94,7 +98,7 @@ async function registerSchedule(client: PgBossClient, worker: ScheduledWorker, c
 	const { schedule } = worker;
 	await client.work(
 		schedule.name,
-		schedule.workerOptions,
+		{ ...schedule.workerOptions, includeMetadata: true },
 		batchHandler(client, schedule.name, (job) => Effect.provide(traceJob(worker.effect, job, schedule.name), context)),
 	);
 	await client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions);
@@ -113,9 +117,9 @@ export const registerJobs = <R>(
 	registrations: readonly JobRegistration[],
 	context: Context.Context<R>,
 	replaceWorkers: boolean,
-): Effect.Effect<void, import("#error.ts").PgBossError | PgBossQueueOptionsError> =>
+): Effect.Effect<void, PgBossError | PgBossQueueOptionsError> =>
 	Effect.tryPromise({
-		catch: (error) => (error instanceof PgBossQueueOptionsError ? error : toPgBossError("register", error)),
+		catch: (error) => (error instanceof PgBossQueueOptionsError || error instanceof PgBossError ? error : toPgBossError("register", error)),
 		try: async () => {
 			registrationNames(registrations);
 			await prepareQueues(client, registrations, replaceWorkers);

package/src/server/service.ts

@@ -4,6 +4,7 @@ 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 { logClientError, subscribeClientErrors } from "#internal/clientErrors.ts";
 import { acquireClient, releaseClient } from "#internal/lifecycle.ts";
 import { registerJobs, registrationName } from "#internal/register.ts";
 import { makeService } from "#internal/service.ts";
@@ -42,10 +43,6 @@ export interface PgBossDefinition<TIdentifier extends string = string> extends C
 	>;
 }
 
-function logClientError(error: Error): Effect.Effect<void> {
-	return Effect.logError({ event: "pg_boss_error", message: error.message });
-}
-
 export const makePgBoss = <const TIdentifier extends string>(identifier: TIdentifier): PgBossDefinition<TIdentifier> => {
 	const Service = Context.Service<TIdentifier, PgBossService>(identifier);
 
@@ -74,20 +71,14 @@ export const makePgBoss = <const TIdentifier extends string>(identifier: TIdenti
 				const errorListener = (error: Error) => {
 					void Effect.runPromise(Effect.exit(Effect.provide(reportError(error), context)));
 				};
-				acquired.client.on("error", errorListener);
+				const unsubscribe = subscribeClientErrors(acquired.client, errorListener);
 				const registration = registerJobs(acquired.client, jobs, context, acquired.reused);
 				return yield* registration.pipe(
-					Effect.as({ acquired, errorListener, service }),
-					Effect.onError(() => {
-						acquired.client.off("error", errorListener);
-						return releaseClient(acquired, stop);
-					}),
+					Effect.as({ acquired, service, unsubscribe }),
+					Effect.onError(() => releaseClient(acquired, stop).pipe(Effect.ensuring(Effect.sync(unsubscribe)))),
 				);
 			}),
-			(resource) => {
-				resource.acquired.client.off("error", resource.errorListener);
-				return releaseClient(resource.acquired, stop);
-			},
+			(resource) => releaseClient(resource.acquired, stop).pipe(Effect.ensuring(Effect.sync(resource.unsubscribe))),
 		);
 
 		return Layer.effect(