@shivaedev/effect-pg-boss 0.8.0 → 0.9.0

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(

package/src/server/testing.ts

@@ -0,0 +1,85 @@
+import { Effect, Redacted } from "effect";
+import { PgBoss } from "pg-boss";
+import type { PgBossClientFactory } from "#client.ts";
+import type { QueueDefinition } from "#definition.ts";
+import { PgBossTestingError } from "#error.ts";
+import { testingClient } from "#internal/testingClient.ts";
+import { testingOperation, testingReadout } from "#internal/testingReadout.ts";
+import { testingSignal } from "#internal/testingSignal.ts";
+
+export const testRetryPolicy = Object.freeze({ retryBackoff: false, retryDelay: 0 });
+
+export interface PgBossTestingOptions {
+	readonly retryPolicy?: typeof testRetryPolicy;
+}
+
+export function makePgBossTesting(options: PgBossTestingOptions = {}) {
+	let current: PgBoss | undefined;
+	const signal = testingSignal();
+	const controls = {
+		changed: signal.changed,
+		expirations: new Map<string, number>(),
+		failures: new Set<string>(),
+		retryPolicy: options.retryPolicy ?? {},
+	};
+	function client(): PgBoss {
+		if (current === undefined) {
+			throw new Error("Provide the testing clientFactory to a jobs Layer first");
+		}
+		return current;
+	}
+	const clientFactory: PgBossClientFactory = (clientOptions) => {
+		if (current !== undefined) {
+			throw new Error("A testing controller owns one jobs client; create a controller per runtime");
+		}
+		current = new PgBoss({ ...clientOptions, "__test__enableSpies": true });
+		return testingClient(current, clientOptions.schema ?? "pgboss", controls);
+	};
+	return {
+		checkBatchWindow: (queue: QueueDefinition, millisecondsPerJob: number) =>
+			testingOperation(
+				"checkBatchWindow",
+				async () => {
+					const stored = await client().getQueue(queue.name);
+					if (stored === null) {
+						throw new Error("Queue is not registered");
+					}
+					if (stored.expireInSeconds === undefined) {
+						throw new Error("Queue has no expiry window");
+					}
+					if (!Number.isFinite(millisecondsPerJob) || millisecondsPerJob < 0) {
+						throw new RangeError("Job duration must be nonnegative and finite");
+					}
+					const required = (queue.workerOptions.batchSize ?? 10) * millisecondsPerJob;
+					if (required >= stored.expireInSeconds * 1000) {
+						throw new Error("Sequential batch work must fit within the queue expiry window");
+					}
+				},
+				queue.name,
+			),
+		checkSchemaVersion: (expected: number) =>
+			testingOperation("checkSchemaVersion", async () => {
+				if ((await client().schemaVersion()) !== expected) {
+					throw new Error(`Expected pg-boss schema version ${expected}`);
+				}
+			}),
+		clientFactory,
+		expireAfter: (queue: QueueDefinition, attempts: number) =>
+			Effect.try({
+				catch: (original) => new PgBossTestingError({ operation: "expireAfter", original: Redacted.make(original), queue: queue.name }),
+				try: () => {
+					if (!Number.isSafeInteger(attempts) || attempts < 1) {
+						throw new RangeError("Attempts must be a positive integer");
+					}
+					controls.expirations.set(queue.name, attempts);
+				},
+			}),
+		failNextSend: (queue: QueueDefinition) => Effect.sync(() => controls.failures.add(queue.name)).pipe(Effect.asVoid),
+		jobs: testingReadout(client),
+		revision: signal.revision,
+		schemaVersion: testingOperation("schemaVersion", () => client().schemaVersion()),
+		waitForChange: signal.waitForChange,
+	};
+}
+
+export type PgBossTesting = ReturnType<typeof makePgBossTesting>;