@shivaedev/jobs 0.22.0 → 0.23.0

package/src/server/service.ts

@@ -1,5 +1,7 @@
-import { Context, Effect, Layer, type Option, type Schema } from "effect";
+import { Context, Effect, Exit, Layer, type Option, Redacted, type Schema, Scope } from "effect";
 import type { ConstructorOptions, JobWithMetadata, SendOptions, StopOptions } from "pg-boss";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { genericMethod } from "@shivaedev/service/genericMethod.ts";
 import type { PgBossClientFactory } from "#client.ts";
 import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "#definition.ts";
 import type { PgBossClientOptionsError, PgBossError, PgBossPayloadError, PgBossQueueOptionsError } from "#error.ts";
@@ -9,13 +11,14 @@ import { acquireClient, releaseClient } from "#internal/lifecycle.ts";
 import { makeService } from "#internal/makeService.ts";
 import { registrationName } from "#internal/register.ts";
 import { registerReleasedJobs } from "#internal/registerReleasedJobs.ts";
+import { PgBoss } from "#PgBoss.ts";
 
 export interface PgBossService {
 	readonly counts: (queue: Pick<QueueDefinition, "name">) => Effect.Effect<QueueCounts, PgBossError>;
 	readonly deadLetteredJobs: <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 		queue: { readonly name: TName; readonly schema: TPayload },
 		options: JobPageOptions,
-	) => Effect.Effect<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
+	) => Effect.Effect<JobPage<DeadLetteredJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]>;
 	readonly enqueue: <const TName extends string, const TPayload extends JobPayloadSchema, const TQueue extends QueueDefinition<TName, TPayload>>(
 		queue: QueueDefinition<TName, TPayload> & TQueue,
 		payload: NoInfer<Schema.Schema.Type<TPayload>>,
@@ -24,77 +27,109 @@ export interface PgBossService {
 	readonly failedJobs: <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 		queue: { readonly name: TName; readonly schema: TPayload },
 		options: JobPageOptions,
-	) => Effect.Effect<JobPage<ListedJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
+	) => Effect.Effect<JobPage<ListedJob<TPayload["Type"]>>, PgBossError | PgBossPayloadError | Schema.SchemaError, TPayload["DecodingServices"]>;
 	readonly getJob: <const TName extends string, const TPayload extends JobPayloadSchema | typeof Schema.Null>(
 		queue: { readonly name: TName; readonly schema: TPayload },
 		id: string,
 	) => Effect.Effect<Option.Option<JobWithMetadata<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
-	readonly health: Effect.Effect<JobsHealth, PgBossError>;
+	readonly health: () => Effect.Effect<JobsHealth, PgBossError>;
 	readonly retry: (queue: Pick<QueueDefinition, "name">, id: string) => Effect.Effect<void, PgBossError>;
 }
 
-export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> = ConstructorOptions & {
+export type PgBossOptions = Omit<ConstructorOptions, "connectionString"> & {
+	readonly connectionString?: Redacted.Redacted<string>;
 	readonly clientFactory?: PgBossClientFactory;
-	// One started client is reference-counted per key, so development module reloads reuse it instead of starting another.
 	readonly clientCacheKey?: string | symbol | undefined;
-	readonly jobs: TRegistrations;
-	readonly onError?: (error: Error) => Effect.Effect<unknown, never, TErrorRequirements>;
 	readonly stop?: StopOptions;
 };
 
+export function pgBossLayer(options: PgBossOptions): Layer.Layer<PgBoss, PgBossError | PgBossClientOptionsError> {
+	const { connectionString, clientFactory, clientCacheKey, stop, ...settings } = options;
+	return Layer.effect(
+		PgBoss,
+		Effect.gen(function* () {
+			const dependencies = yield* Effect.context<never>();
+			const execute = Effect.runPromiseWith(dependencies);
+			const acquired = yield* Effect.acquireRelease(
+				acquireClient(
+					{
+						clientCacheKey,
+						clientFactory,
+						constructor: {
+							...settings,
+							...(connectionString === undefined ? {} : { connectionString: Redacted.value(connectionString) }),
+						},
+					},
+					(error) => {
+						void execute(logClientError(error));
+					},
+				),
+				(client) => releaseClient(client, stop),
+			);
+			return { ...acquired, schema: settings.schema, stop };
+		}),
+	);
+}
+
+export interface PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> {
+	readonly jobs: TRegistrations;
+	readonly onError?: (error: Error) => Effect.Effect<unknown, never, TErrorRequirements>;
+}
+
 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 | PgBossQueueOptionsError | PgBossClientOptionsError,
-		Exclude<RegistrationRequirements<TRegistrations>, TIdentifier> | TErrorRequirements
+		PgBossError | PgBossQueueOptionsError,
+		PgBoss | Exclude<RegistrationRequirements<TRegistrations>, TIdentifier> | TErrorRequirements
 	>;
 }
 
 export function makePgBoss<const TIdentifier extends string>(identifier: TIdentifier): PgBossDefinition<TIdentifier> {
-	const Service = Context.Service<TIdentifier, PgBossService>(identifier);
-
+	function definition<R>(options: PgBossLayerOptions<readonly JobRegistration[], R>, dependencies: Context.Context<R>) {
+		return defineService({
+			id: identifier,
+			initialize: Effect.gen(function* () {
+				const acquired = yield* PgBoss;
+				const execute = Effect.runPromiseWith(dependencies);
+				const workerScope = yield* Scope.make();
+				const service = makeService(acquired.client, options.jobs.map(registrationName), acquired.schema);
+				const context = Context.add(dependencies, Service, service);
+				const reportError = options.onError ?? logClientError;
+				const unsubscribe = subscribeClientErrors(acquired.client, (error) => {
+					void execute(Effect.exit(Effect.provide(reportError(error), context)));
+				});
+				yield* Effect.addFinalizer(() => Scope.close(workerScope, Exit.void).pipe(Effect.ensuring(Effect.sync(unsubscribe))));
+				yield* registerReleasedJobs(
+					acquired.client,
+					options.jobs,
+					context,
+					acquired.reused,
+					(effect) => execute(effect),
+					acquired.schema,
+					acquired.stop?.graceful !== false,
+				).pipe(Effect.provideService(Scope.Scope, workerScope), Effect.provide(dependencies));
+				return service;
+			}),
+			methods: (service) => ({
+				counts: service.counts,
+				deadLetteredJobs: genericMethod(service.deadLetteredJobs),
+				enqueue: genericMethod(service.enqueue),
+				failedJobs: genericMethod(service.failedJobs),
+				getJob: genericMethod(service.getJob),
+				health: service.health,
+				retry: service.retry,
+			}),
+			requires: [PgBoss],
+		});
+	}
+	const Service: Context.Service<TIdentifier, PgBossService> = definition({ jobs: [] }, Context.empty());
 	function layer<const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(
 		options: PgBossLayerOptions<TRegistrations, TErrorRequirements>,
-	): Layer.Layer<
-		TIdentifier,
-		PgBossError | PgBossQueueOptionsError | PgBossClientOptionsError,
-		Exclude<RegistrationRequirements<TRegistrations>, TIdentifier> | TErrorRequirements
-	> {
+	) {
 		type Requirements = Exclude<RegistrationRequirements<TRegistrations>, TIdentifier> | TErrorRequirements;
-		const names = options.jobs.map(registrationName);
-		const { clientFactory, clientCacheKey, jobs, onError, stop, ...constructorOptions } = options;
-
-		const acquire = Effect.acquireRelease(
-			Effect.gen(function* () {
-				const dependencies = yield* Effect.context<Requirements>();
-				const acquired = yield* acquireClient({
-					clientCacheKey,
-					clientFactory,
-					constructor: constructorOptions,
-				});
-				const service = makeService(acquired.client, names, constructorOptions.schema);
-				const context = Context.add(dependencies, Service, service);
-				const reportError: (error: Error) => Effect.Effect<unknown, never, Requirements | TIdentifier> = onError ?? logClientError;
-				function errorListener(error: Error): void {
-					void Effect.runPromise(Effect.exit(Effect.provide(reportError(error), context)));
-				}
-				const unsubscribe = subscribeClientErrors(acquired.client, errorListener);
-				const registration = registerReleasedJobs(acquired.client, jobs, context, acquired.reused, constructorOptions.schema);
-				return yield* registration.pipe(
-					Effect.as({ acquired, service, unsubscribe }),
-					Effect.onError(() => releaseClient(acquired, stop).pipe(Effect.ensuring(Effect.sync(unsubscribe)))),
-				);
-			}),
-			(resource) => releaseClient(resource.acquired, stop).pipe(Effect.ensuring(Effect.sync(resource.unsubscribe))),
-		);
-
-		return Layer.effect(
-			Service,
-			Effect.map(acquire, ({ service }) => service),
-		);
+		return Layer.unwrap(Effect.map(Effect.context<Requirements>(), (dependencies) => definition(options, dependencies).layer));
 	}
-
 	return Object.assign(Service, { layer });
 }