@shivaedev/effect-pg-boss 0.14.0 → 0.15.1

package/src/server/internal/testingIdle.ts

@@ -0,0 +1,52 @@
+import { Effect, Schema } from "effect";
+import type { PgBoss } from "pg-boss";
+import type { PgBossTestingError } from "#error.ts";
+import { quotedSchema } from "#internal/storedRows.ts";
+import { testingOperation } from "#internal/testingReadout.ts";
+
+export interface TestingBatch {
+	readonly name: string;
+	settled: boolean;
+}
+
+export interface TestingWork {
+	readonly batches: Set<TestingBatch>;
+	readonly queues: Set<string>;
+}
+
+const Busy = Schema.Struct({ busy: Schema.Boolean });
+
+export function testingIdle(
+	client: () => PgBoss,
+	schema: () => string,
+	work: TestingWork,
+	signal: { readonly revision: Effect.Effect<number>; readonly waitForChange: (after: number) => Effect.Effect<number> },
+): Effect.Effect<void, PgBossTestingError> {
+	const busy = testingOperation("waitForIdle", async () => {
+		const quoted = quotedSchema(schema());
+		const { rows } = await client()
+			.getDb()
+			.executeSql(
+				`/* effect-pg-boss testing idle */ SELECT EXISTS (
+					SELECT 1 FROM ${quoted}.job
+					WHERE name = ANY($1::text[]) AND (
+						(state < 'active' AND NOT blocked AND start_after <= ${quoted}.job_now())
+						OR state = 'active'
+					)
+				) AS busy`,
+				[[...work.queues]],
+			);
+		return (await Schema.decodeUnknownPromise(Busy)(rows[0])).busy;
+	});
+	return Effect.gen(function* () {
+		while (true) {
+			const revision = yield* signal.revision;
+			// A batch with no settlement since its fetch still holds active jobs, so it is busy without a read.
+			const unsettled = [...work.batches].some((batch) => !batch.settled);
+			if (work.queues.size === 0 || !(unsettled || (yield* busy))) {
+				return;
+			}
+			yield* signal.waitForChange(revision);
+		}
+	});
+}

package/src/server/internal/testingReadout.ts

@@ -1,8 +1,8 @@
-import { Effect, Redacted, Schema } from "effect";
+import { Effect, Redacted } from "effect";
 import type { FindJobsOptions, PgBoss } from "pg-boss";
 import type { JobPayloadSchema, QueueDefinition } from "#definition.ts";
-import { PgBossPayloadError, PgBossTestingError } from "#error.ts";
-import { payloadOf } from "#internal/tracing.ts";
+import { PgBossTestingError } from "#error.ts";
+import { decodeStoredData } from "#internal/storedRows.ts";
 
 export function testingOperation<A>(operation: string, run: () => Promise<A>, queue?: string) {
 	return Effect.tryPromise({
@@ -14,13 +14,6 @@ export function testingOperation<A>(operation: string, run: () => Promise<A>, qu
 export function testingReadout(client: () => PgBoss) {
 	return <TName extends string, TPayload extends JobPayloadSchema>(queue: QueueDefinition<TName, TPayload>, options?: FindJobsOptions) =>
 		testingOperation("jobs", () => client().findJobs<unknown>(queue.name, options), queue.name).pipe(
-			Effect.flatMap((jobs) =>
-				Effect.forEach(jobs, (job) =>
-					Schema.decodeUnknownEffect(queue.schema)(payloadOf(job.data)).pipe(
-						Effect.mapError((original) => new PgBossPayloadError({ direction: "decode", original: Redacted.make(original), queue: queue.name })),
-						Effect.map((data) => ({ ...job, data })),
-					),
-				),
-			),
+			Effect.flatMap((jobs) => Effect.forEach(jobs, (job) => decodeStoredData(queue, job.data).pipe(Effect.map((data) => ({ ...job, data }))))),
 		);
 }

package/src/server/internal/testingSignal.ts

@@ -6,10 +6,12 @@ export function testingSignal() {
 	return {
 		changed() {
 			revision += 1;
-			for (const listener of listeners) {
+			// A resumed waiter can wait again synchronously; it must wait for the next change, not this one.
+			const waiting = [...listeners];
+			listeners.clear();
+			for (const listener of waiting) {
 				listener(revision);
 			}
-			listeners.clear();
 		},
 		revision: Effect.sync(() => revision),
 		waitForChange: (after: number): Effect.Effect<number> =>

package/src/server/internal/testingSnapshot.ts

@@ -0,0 +1,53 @@
+import { Effect, Schema } from "effect";
+import type { PgBoss } from "pg-boss";
+import type { PgBossPayloadError, PgBossTestingError } from "#error.ts";
+import { decodeStoredData, quotedSchema } from "#internal/storedRows.ts";
+import { testingOperation } from "#internal/testingReadout.ts";
+import type { SnapshotQueue, UnfinishedJob } from "#testing.ts";
+
+const Rows = Schema.Array(
+	Schema.Struct({
+		data: Schema.Unknown,
+		id: Schema.String,
+		queue: Schema.String,
+		startAfter: Schema.DateTimeUtcFromDate,
+		state: Schema.Literals(["created", "retry", "active", "failed"]),
+	}),
+);
+
+export function testingSnapshot(client: () => PgBoss, schema: () => string) {
+	return <const TQueues extends readonly SnapshotQueue[]>(
+		queues: TQueues,
+	): Effect.Effect<
+		readonly UnfinishedJob<TQueues[number]>[],
+		PgBossPayloadError | PgBossTestingError,
+		TQueues[number]["schema"]["DecodingServices"]
+	> => {
+		const byName = new Map<string, TQueues[number]>(queues.map((queue) => [queue.name, queue]));
+		return testingOperation("snapshot", async () => {
+			const quoted = quotedSchema(schema());
+			const { rows } = await client()
+				.getDb()
+				.executeSql(
+					`SELECT id, name AS queue, state, data, start_after AS "startAfter"
+					FROM ${quoted}.job
+					WHERE name = ANY($1::text[]) AND state IN ('created', 'retry', 'active', 'failed')
+					ORDER BY created_on, id`,
+					[[...byName.keys()]],
+				);
+			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/testing.ts

@@ -1,12 +1,25 @@
-import { Effect, Redacted } from "effect";
-import { PgBoss } from "pg-boss";
+import { type DateTime, Effect, Redacted } from "effect";
+import type { PgBoss } from "pg-boss";
 import type { PgBossClientFactory } from "#client.ts";
-import type { QueueDefinition } from "#definition.ts";
+import type { JobPayloadSchema, QueueDefinition } from "#definition.ts";
 import { PgBossTestingError } from "#error.ts";
+import { nativeClient } from "#internal/nativeClient.ts";
 import { testingClient } from "#internal/testingClient.ts";
 import { testingDeferrals } from "#internal/testingDeferrals.ts";
+import { type TestingWork, testingIdle } from "#internal/testingIdle.ts";
 import { testingOperation, testingReadout } from "#internal/testingReadout.ts";
 import { testingSignal } from "#internal/testingSignal.ts";
+import { testingSnapshot } from "#internal/testingSnapshot.ts";
+
+export type SnapshotQueue = Pick<QueueDefinition<string, JobPayloadSchema>, "name" | "schema">;
+
+export interface UnfinishedJob<TQueue extends SnapshotQueue> {
+	readonly data: TQueue["schema"]["Type"];
+	readonly id: string;
+	readonly queue: TQueue["name"];
+	readonly startAfter: DateTime.Utc;
+	readonly state: "active" | "created" | "failed" | "retry";
+}
 
 export const testRetryPolicy = Object.freeze({ retryBackoff: false, retryDelay: 0 });
 
@@ -18,11 +31,13 @@ export function makePgBossTesting(options: PgBossTestingOptions = {}) {
 	let current: PgBoss | undefined;
 	let schema = "pgboss";
 	const signal = testingSignal();
+	const work: TestingWork = { batches: new Set(), queues: new Set() };
 	const controls = {
 		changed: signal.changed,
 		expirations: new Map<string, number>(),
 		failures: new Set<string>(),
 		retryPolicy: options.retryPolicy ?? {},
+		work,
 	};
 	function client(): PgBoss {
 		if (current === undefined) {
@@ -35,7 +50,7 @@ export function makePgBossTesting(options: PgBossTestingOptions = {}) {
 			throw new Error("A testing controller owns one jobs client; create a controller per runtime");
 		}
 		schema = clientOptions.schema ?? "pgboss";
-		current = new PgBoss({ ...clientOptions, "__test__enableSpies": true });
+		current = nativeClient({ ...clientOptions, "__test__enableSpies": true });
 		return testingClient(current, clientOptions.schema ?? "pgboss", controls);
 	};
 	return {
@@ -82,7 +97,9 @@ export function makePgBossTesting(options: PgBossTestingOptions = {}) {
 		jobs: testingReadout(client),
 		revision: signal.revision,
 		schemaVersion: testingOperation("schemaVersion", () => client().schemaVersion()),
+		snapshot: testingSnapshot(client, () => schema),
 		waitForChange: signal.waitForChange,
+		waitForIdle: testingIdle(client, () => schema, work, signal),
 	};
 }