@shivaedev/effect-pg-boss 0.1.2 → 0.2.0

package/src/definition.ts

@@ -14,33 +14,21 @@ export interface JobContext {
 	readonly heartbeatSeconds: number | null;
 }
 
-export interface QueueDefinition<
-	Name extends string = string,
-	Payload extends JobPayloadSchema = JobPayloadSchema,
-> {
+export interface QueueDefinition<Name extends string = string, Payload extends JobPayloadSchema = JobPayloadSchema> {
 	readonly _tag: "QueueDefinition";
 	readonly name: Name;
 	readonly schema: Payload;
 	readonly queueOptions: Omit<QueueOptions, "deadLetter">;
 	readonly workerOptions: WorkOptions;
 	readonly handle: <E, R>(
-		handler: (
-			payload: Schema.Schema.Type<Payload>,
-			job: JobContext,
-		) => Effect.Effect<unknown, E, R>,
+		handler: (payload: Schema.Schema.Type<Payload>, job: JobContext) => Effect.Effect<unknown, E, R>,
 	) => QueueWorker<Payload, R>;
 }
 
-export interface QueueWorker<
-	Payload extends JobPayloadSchema = JobPayloadSchema,
-	Requirements = unknown,
-> {
+export interface QueueWorker<Payload extends JobPayloadSchema = JobPayloadSchema, Requirements = unknown> {
 	readonly _tag: "QueueWorker";
 	readonly queue: QueueDefinition<string, Payload>;
-	readonly handler: (
-		payload: Schema.Schema.Type<Payload>,
-		job: JobContext,
-	) => Effect.Effect<unknown, unknown, Requirements>;
+	readonly handler: (payload: Schema.Schema.Type<Payload>, job: JobContext) => Effect.Effect<unknown, unknown, Requirements>;
 }
 
 export interface JobRegistration {
@@ -54,9 +42,7 @@ export interface ScheduleDefinition<Name extends string = string> {
 	readonly queueOptions: Omit<QueueOptions, "deadLetter">;
 	readonly scheduleOptions: ScheduleOptions;
 	readonly workerOptions: WorkOptions;
-	readonly run: <E, R>(
-		effect: Effect.Effect<unknown, E, R>,
-	) => ScheduledWorker<R>;
+	readonly run: <E, R>(effect: Effect.Effect<unknown, E, R>) => ScheduledWorker<R>;
 }
 
 export interface ScheduledWorker<Requirements = unknown> {
@@ -65,9 +51,7 @@ export interface ScheduledWorker<Requirements = unknown> {
 	readonly effect: Effect.Effect<unknown, unknown, Requirements>;
 }
 
-export type RegistrationRequirements<
-	Registrations extends readonly JobRegistration[],
-> = Registrations[number] extends infer Registration
+export type RegistrationRequirements<Registrations extends readonly JobRegistration[]> = Registrations[number] extends infer Registration
 	? Registration extends QueueWorker<infer Payload, infer Requirements>
 		? Requirements | Payload["DecodingServices"]
 		: Registration extends ScheduledWorker<infer Requirements>
@@ -75,20 +59,14 @@ export type RegistrationRequirements<
 			: never
 	: never;
 
-export interface DefineQueueOptions<
-	Name extends string,
-	Payload extends JobPayloadSchema,
-> {
+export interface DefineQueueOptions<Name extends string, Payload extends JobPayloadSchema> {
 	readonly name: Name;
 	readonly schema: Payload;
 	readonly queue?: Omit<QueueOptions, "deadLetter">;
 	readonly worker?: WorkOptions;
 }
 
-export const defineQueue = <
-	const Name extends string,
-	const Payload extends JobPayloadSchema,
->(
+export const defineQueue = <const Name extends string, const Payload extends JobPayloadSchema>(
 	options: DefineQueueOptions<Name, Payload>,
 ): QueueDefinition<Name, Payload> => {
 	const definition: QueueDefinition<Name, Payload> = {
@@ -115,9 +93,7 @@ export interface DefineScheduleOptions<Name extends string> {
 	readonly worker?: WorkOptions;
 }
 
-export const defineSchedule = <const Name extends string>(
-	options: DefineScheduleOptions<Name>,
-): ScheduleDefinition<Name> => {
+export const defineSchedule = <const Name extends string>(options: DefineScheduleOptions<Name>): ScheduleDefinition<Name> => {
 	const definition: ScheduleDefinition<Name> = {
 		_tag: "ScheduleDefinition",
 		cron: options.cron,

package/src/error.ts

@@ -1,15 +1,10 @@
 import { Data, Redacted } from "effect";
 
-export type PgBossOperation =
-	| "enqueue"
-	| "health"
-	| "register"
-	| "start"
-	| "stop";
+export type PgBossOperation = "enqueue" | "health" | "register" | "start" | "stop";
 
 export class PgBossError extends Data.TaggedError("PgBossError")<{
 	readonly operation: PgBossOperation;
-	readonly queue?: string;
+	readonly queue?: string | undefined;
 	readonly original: Redacted.Redacted<unknown>;
 }> {}
 
@@ -19,11 +14,7 @@ export class PgBossPayloadError extends Data.TaggedError("PgBossPayloadError")<{
 	readonly original: Redacted.Redacted<unknown>;
 }> {}
 
-export const toPgBossError = (
-	operation: PgBossOperation,
-	error: unknown,
-	queue?: string,
-): PgBossError =>
+export const toPgBossError = (operation: PgBossOperation, error: unknown, queue?: string): PgBossError =>
 	new PgBossError({
 		operation,
 		queue,

package/src/health.ts

@@ -16,5 +16,4 @@ export interface JobsHealth {
 	readonly readyTotal: number;
 }
 
-export const deadLetterQueueName = (queueName: string): string =>
-	`${queueName}-dlq`;
+export const deadLetterQueueName = (queueName: string): string => `${queueName}-dlq`;

package/src/index.ts

@@ -10,24 +10,24 @@ export {
 	type QueueWorker,
 	type ScheduleDefinition,
 	type ScheduledWorker,
-} from "./definition.js";
+} from "./definition.ts";
 export {
 	PgBossError,
 	type PgBossOperation,
 	PgBossPayloadError,
-} from "./error.js";
+} from "./error.ts";
 export {
 	deadLetterQueueName,
 	type JobsHealth,
 	type QueueHealth,
-} from "./health.js";
+} from "./health.ts";
 export type {
 	PgBossClient,
 	PgBossClientFactory,
-} from "./internal/client.js";
+} from "./internal/client.ts";
 export {
 	makePgBoss,
 	type PgBossDefinition,
 	type PgBossLayerOptions,
 	type PgBossService,
-} from "./service.js";
+} from "./service.ts";

package/src/internal/client.ts

@@ -1,45 +1,19 @@
-import type {
-	ConstructorOptions,
-	Job,
-	Queue,
-	QueueResult,
-	ScheduleOptions,
-	SendOptions,
-	StopOptions,
-	WorkOptions,
-} from "pg-boss";
+import type { ConstructorOptions, Job, 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 createQueue: (name: string, options?: Omit<Queue, "name">) => Promise<void>;
 	readonly getQueue: (name: string) => Promise<QueueResult | null>;
 	readonly offWork: (name: string) => Promise<void>;
 	readonly on: (event: "error", listener: (error: Error) => void) => unknown;
 	readonly off: (event: "error", listener: (error: Error) => void) => unknown;
-	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 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 work: <Payload>(
-		name: string,
-		options: WorkOptions,
-		handler: (jobs: readonly Job<Payload>[]) => Promise<unknown>,
-	) => Promise<string>;
+	readonly work: (name: string, options: WorkOptions, handler: (jobs: readonly Job<unknown>[]) => Promise<unknown>) => Promise<string>;
 }
 
 export type PgBossClientFactory = (options: ConstructorOptions) => PgBossClient;
 
-export const defaultClientFactory: PgBossClientFactory = (options) =>
-	new PgBoss(options);
+export const defaultClientFactory: PgBossClientFactory = (options) => new PgBoss(options);

package/src/internal/health.ts

@@ -1,25 +1,15 @@
 import { Effect } from "effect";
-import { toPgBossError } from "../error.js";
-import {
-	deadLetterQueueName,
-	type JobsHealth,
-	type QueueHealth,
-} from "../health.js";
-import type { PgBossClient } from "./client.js";
+import { toPgBossError } from "../error.ts";
+import { deadLetterQueueName, type JobsHealth, type QueueHealth } from "../health.ts";
+import type { PgBossClient } from "./client.ts";
 
-export const healthFor = (
-	client: PgBossClient,
-	names: readonly string[],
-): Effect.Effect<JobsHealth, import("../error.js").PgBossError> =>
+export const healthFor = (client: PgBossClient, names: readonly string[]): Effect.Effect<JobsHealth, import("../error.ts").PgBossError> =>
 	Effect.forEach(
 		names,
 		(name) =>
 			Effect.tryPromise({
 				try: async (): Promise<QueueHealth> => {
-					const [queue, deadLetter] = await Promise.all([
-						client.getQueue(name),
-						client.getQueue(deadLetterQueueName(name)),
-					]);
+					const [queue, deadLetter] = await Promise.all([client.getQueue(name), client.getQueue(deadLetterQueueName(name))]);
 					return {
 						activeCount: queue?.activeCount ?? 0,
 						deadLetteredCount: deadLetter?.queuedCount ?? 0,
@@ -35,10 +25,7 @@ export const healthFor = (
 	).pipe(
 		Effect.map((jobs) => ({
 			activeTotal: jobs.reduce((sum, job) => sum + job.activeCount, 0),
-			deadLetteredTotal: jobs.reduce(
-				(sum, job) => sum + job.deadLetteredCount,
-				0,
-			),
+			deadLetteredTotal: jobs.reduce((sum, job) => sum + job.deadLetteredCount, 0),
 			failedTotal: jobs.reduce((sum, job) => sum + job.failedCount, 0),
 			jobs,
 			queuedTotal: jobs.reduce((sum, job) => sum + job.queuedCount, 0),

package/src/internal/lifecycle.ts

@@ -1,11 +1,7 @@
 import { Effect } from "effect";
 import type { ConstructorOptions, StopOptions } from "pg-boss";
-import { toPgBossError } from "../error.js";
-import {
-	defaultClientFactory,
-	type PgBossClient,
-	type PgBossClientFactory,
-} from "./client.js";
+import { toPgBossError } from "../error.ts";
+import { defaultClientFactory, type PgBossClient, type PgBossClientFactory } from "./client.ts";
 
 interface CachedClient {
 	readonly client: Promise<PgBossClient>;
@@ -13,17 +9,25 @@ interface CachedClient {
 }
 
 const CacheKey = Symbol.for("@shivaedev/effect-pg-boss/client-cache");
-const globalCache = globalThis as typeof globalThis & {
-	[CacheKey]?: Map<string | symbol, CachedClient>;
+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);
+
+const isCachedClient = (value: unknown): value is CachedClient =>
+	typeof value === "object" &&
+	value !== null &&
+	Reflect.get(value, "client") instanceof Promise &&
+	typeof Reflect.get(value, "references") === "number";
+
+const cachedClient = (key: string | symbol): CachedClient | undefined => {
+	const entry = clientCache.get(key);
+	return isCachedClient(entry) ? entry : undefined;
 };
-const clientCache =
-	globalCache[CacheKey] ?? new Map<string | symbol, CachedClient>();
-globalCache[CacheKey] = clientCache;
 
 export interface AcquireClientOptions {
-	readonly clientFactory?: PgBossClientFactory;
+	readonly clientFactory?: PgBossClientFactory | undefined;
 	readonly constructor: ConstructorOptions;
-	readonly developmentCacheKey?: string | symbol;
+	readonly clientCacheKey?: string | symbol | undefined;
 }
 
 export interface AcquiredClient {
@@ -33,9 +37,7 @@ export interface AcquiredClient {
 }
 
 const startClient = (options: AcquireClientOptions): Promise<PgBossClient> => {
-	const client = (options.clientFactory ?? defaultClientFactory)(
-		options.constructor,
-	);
+	const client = (options.clientFactory ?? defaultClientFactory)(options.constructor);
 	return client.start().then(
 		() => client,
 		async (error) => {
@@ -49,15 +51,10 @@ const startClient = (options: AcquireClientOptions): Promise<PgBossClient> => {
 	);
 };
 
-export const acquireClient = (
-	options: AcquireClientOptions,
-): Effect.Effect<AcquiredClient, import("../error.js").PgBossError> =>
+export const acquireClient = (options: AcquireClientOptions): Effect.Effect<AcquiredClient, import("../error.ts").PgBossError> =>
 	Effect.tryPromise({
 		try: async () => {
-			const cacheKey =
-				process.env.NODE_ENV === "production"
-					? undefined
-					: options.developmentCacheKey;
+			const cacheKey = options.clientCacheKey;
 			if (cacheKey === undefined) {
 				return {
 					client: await startClient(options),
@@ -65,7 +62,7 @@ export const acquireClient = (
 				};
 			}
 
-			const existing = clientCache.get(cacheKey);
+			const existing = cachedClient(cacheKey);
 			if (existing !== undefined) {
 				existing.references += 1;
 				try {
@@ -99,10 +96,7 @@ export const acquireClient = (
 		catch: (error) => toPgBossError("start", error),
 	});
 
-export const releaseClient = (
-	acquired: AcquiredClient,
-	stopOptions?: StopOptions,
-): Effect.Effect<void> =>
+export const releaseClient = (acquired: AcquiredClient, stopOptions?: StopOptions): Effect.Effect<void> =>
 	Effect.tryPromise({
 		try: async () => {
 			if (acquired.cacheKey === undefined) {
@@ -110,7 +104,7 @@ export const releaseClient = (
 				return;
 			}
 
-			const entry = clientCache.get(acquired.cacheKey);
+			const entry = cachedClient(acquired.cacheKey);
 			if (entry === undefined) return;
 			entry.references -= 1;
 			if (entry.references > 0) return;

package/src/internal/register.ts

@@ -1,15 +1,9 @@
-import { Effect, Redacted, Schema } from "effect";
+import { type Context, Effect, Redacted, Schema } from "effect";
 import type { Job } from "pg-boss";
-import {
-	type JobPayloadSchema,
-	type JobRegistration,
-	jobContext,
-	type QueueWorker,
-	type ScheduledWorker,
-} from "../definition.js";
-import { PgBossPayloadError, toPgBossError } from "../error.js";
-import { deadLetterQueueName } from "../health.js";
-import type { PgBossClient } from "./client.js";
+import { type JobRegistration, jobContext, type QueueWorker, type ScheduledWorker } from "../definition.ts";
+import { PgBossPayloadError, toPgBossError } from "../error.ts";
+import { deadLetterQueueName } from "../health.ts";
+import type { PgBossClient } from "./client.ts";
 
 const queueOptions = (options: Readonly<Record<string, unknown>>) => ({
 	retryBackoff: true,
@@ -17,11 +11,23 @@ const queueOptions = (options: Readonly<Record<string, unknown>>) => ({
 	...options,
 });
 
-const runQueueWorker = <R>(
-	worker: QueueWorker<JobPayloadSchema, R>,
-	job: Job<unknown>,
-	context: import("effect").Context.Context<R>,
-): Promise<unknown> =>
+const isQueueWorker = (registration: JobRegistration): registration is QueueWorker => registration._tag === "QueueWorker";
+
+const isScheduledWorker = (registration: JobRegistration): registration is ScheduledWorker => registration._tag === "ScheduledWorker";
+
+export const registrationName = (registration: JobRegistration): string => {
+	if (isQueueWorker(registration)) return registration.queue.name;
+	if (isScheduledWorker(registration)) return registration.schedule.name;
+	throw new TypeError(`Unknown pg-boss registration: ${registration._tag}`);
+};
+
+// The layer requires RegistrationRequirements of its jobs, so its context provides every registered worker.
+function workerContext<R>(context: Context.Context<R>): Context.Context<unknown>;
+function workerContext(context: unknown): unknown {
+	return context;
+}
+
+const runQueueWorker = (worker: QueueWorker, job: Job<unknown>, context: Context.Context<unknown>): Promise<unknown> =>
 	Effect.runPromise(
 		Schema.decodeUnknownEffect(worker.queue.schema)(job.data).pipe(
 			Effect.mapError(
@@ -34,16 +40,11 @@ const runQueueWorker = <R>(
 			),
 			Effect.flatMap((payload) => worker.handler(payload, jobContext(job))),
 			Effect.provide(context),
-		) as Effect.Effect<unknown, unknown>,
+		),
 		{ signal: job.signal },
 	);
 
-const registerQueue = async <R>(
-	client: PgBossClient,
-	worker: QueueWorker<JobPayloadSchema, R>,
-	context: import("effect").Context.Context<R>,
-	replaceWorker: boolean,
-): Promise<void> => {
+const registerQueue = async (client: PgBossClient, worker: QueueWorker, context: Context.Context<unknown>, replaceWorker: boolean): Promise<void> => {
 	const name = worker.queue.name;
 	const deadLetter = deadLetterQueueName(name);
 	if (replaceWorker) await client.offWork(name);
@@ -57,10 +58,10 @@ const registerQueue = async <R>(
 	});
 };
 
-const registerSchedule = async <R>(
+const registerSchedule = async (
 	client: PgBossClient,
-	worker: ScheduledWorker<R>,
-	context: import("effect").Context.Context<R>,
+	worker: ScheduledWorker,
+	context: Context.Context<unknown>,
 	replaceWorker: boolean,
 ): Promise<void> => {
 	const { schedule } = worker;
@@ -71,33 +72,18 @@ const registerSchedule = async <R>(
 		...queueOptions(schedule.queueOptions),
 		deadLetter,
 	});
-	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), {
-					signal: job.signal,
-				});
-			}
-		},
-	);
-	await client.schedule(
-		schedule.name,
-		schedule.cron,
-		null,
-		schedule.scheduleOptions,
-	);
+	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), {
+				signal: job.signal,
+			});
+		}
+	});
+	await client.schedule(schedule.name, schedule.cron, null, schedule.scheduleOptions);
 };
 
-export const registrationNames = (
-	registrations: readonly JobRegistration[],
-): readonly string[] => {
-	const names = registrations.map((registration) =>
-		registration._tag === "QueueWorker"
-			? (registration as QueueWorker).queue.name
-			: (registration as ScheduledWorker).schedule.name,
-	);
+export const registrationNames = (registrations: readonly JobRegistration[]): readonly string[] => {
+	const names = registrations.map(registrationName);
 	if (new Set(names).size !== names.length) {
 		throw new TypeError("pg-boss job names must be unique");
 	}
@@ -107,27 +93,18 @@ export const registrationNames = (
 export const registerJobs = <R>(
 	client: PgBossClient,
 	registrations: readonly JobRegistration[],
-	context: import("effect").Context.Context<R>,
+	context: Context.Context<R>,
 	replaceWorkers: boolean,
-): Effect.Effect<void, import("../error.js").PgBossError> =>
+): Effect.Effect<void, import("../error.ts").PgBossError> =>
 	Effect.tryPromise({
 		try: async () => {
 			registrationNames(registrations);
+			const provided = workerContext(context);
 			for (const registration of registrations) {
-				if (registration._tag === "QueueWorker") {
-					await registerQueue(
-						client,
-						registration as QueueWorker<JobPayloadSchema, R>,
-						context,
-						replaceWorkers,
-					);
-				} else {
-					await registerSchedule(
-						client,
-						registration as ScheduledWorker<R>,
-						context,
-						replaceWorkers,
-					);
+				if (isQueueWorker(registration)) {
+					await registerQueue(client, registration, provided, replaceWorkers);
+				} else if (isScheduledWorker(registration)) {
+					await registerSchedule(client, registration, provided, replaceWorkers);
 				}
 			}
 		},

package/src/internal/service.ts

@@ -1,17 +1,10 @@
 import { Effect, Option, Redacted, Schema } from "effect";
-import {
-	type PgBossError,
-	PgBossPayloadError,
-	toPgBossError,
-} from "../error.js";
-import type { PgBossService } from "../service.js";
-import type { PgBossClient } from "./client.js";
-import { healthFor } from "./health.js";
+import { type PgBossError, PgBossPayloadError, toPgBossError } from "../error.ts";
+import type { PgBossService } from "../service.ts";
+import type { PgBossClient } from "./client.ts";
+import { healthFor } from "./health.ts";
 
-export const makeService = (
-	client: PgBossClient,
-	names: readonly string[],
-): PgBossService => ({
+export const makeService = (client: PgBossClient, names: readonly string[]): PgBossService => ({
 	enqueue: (queue, payload, options) =>
 		Schema.encodeUnknownEffect(queue.schema)(payload).pipe(
 			Effect.mapError(
@@ -22,30 +15,21 @@ export const makeService = (
 						queue: queue.name,
 					}),
 			),
-			Effect.flatMap(
-				(
-					encoded,
-				): Effect.Effect<
-					Option.Option<string>,
-					PgBossError | PgBossPayloadError
-				> => {
-					if (typeof encoded !== "object" || encoded === null) {
-						return Effect.fail(
-							new PgBossPayloadError({
-								direction: "encode",
-								original: Redacted.make(
-									new TypeError("pg-boss payloads must encode to objects"),
-								),
-								queue: queue.name,
-							}),
-						);
-					}
-					return Effect.tryPromise({
-						try: () => client.send(queue.name, encoded, options),
-						catch: (error) => toPgBossError("enqueue", error, queue.name),
-					}).pipe(Effect.map(Option.fromNullishOr));
-				},
-			),
+			Effect.flatMap((encoded): Effect.Effect<Option.Option<string>, PgBossError | PgBossPayloadError> => {
+				if (typeof encoded !== "object" || encoded === null) {
+					return Effect.fail(
+						new PgBossPayloadError({
+							direction: "encode",
+							original: Redacted.make(new TypeError("pg-boss payloads must encode to objects")),
+							queue: queue.name,
+						}),
+					);
+				}
+				return Effect.tryPromise({
+					try: () => client.send(queue.name, encoded, options),
+					catch: (error) => toPgBossError("enqueue", error, queue.name),
+				}).pipe(Effect.map(Option.fromNullishOr));
+			}),
 		),
 	health: healthFor(client, names),
 });