@shivaedev/jobs 0.35.0 → 0.36.0

package/src/server/adapters/testingController.ts

@@ -1,137 +0,0 @@
-import { Duration, Effect, Redacted, type Schema } from "effect";
-import { TestClock as PgBossTestClock } from "pg-boss";
-import { defaultClientFactory } from "#server/adapters/defaultClientFactory.ts";
-import { testingClient } from "#server/adapters/testingClient.ts";
-import { testingDueNow } from "#server/adapters/testingDueNow.ts";
-import { testingTime } from "#server/adapters/testingTime.ts";
-import type { JobReadOptions, PgBossClientFactory } from "#server/client.ts";
-import type { JobPayloadSchema, QueueDefinition } from "#server/definition.ts";
-import type { EngineClient } from "#server/engineClient.ts";
-import { PgBossTestingError } from "#server/error.ts";
-import type { PgBossInspectionService, SnapshotQueue } from "#server/inspection.ts";
-import { type TestingFetches, testingFetches } from "#server/internal/adapters/testingFetches.ts";
-import { type TestingWork, testingIdle } from "#server/internal/testingIdle.ts";
-import { testingInspection, testingOperation } from "#server/internal/testingOperation.ts";
-import { testingSchedules } from "#server/internal/testingSchedules.ts";
-import { testingWaits } from "#server/internal/testingWaits.ts";
-import type { PgBossTestingOptions } from "#server/testing.ts";
-import { queueSignal } from "./queueSignal.ts";
-import { testingInspectionClient } from "./testingInspectionClient.ts";
-export function testingController(settings: PgBossTestingOptions = {}) {
-	const clock = settings.clock === undefined ? undefined : new PgBossTestClock(settings.clock.currentTimeMillisUnsafe());
-	let current: EngineClient | undefined;
-	let fetches: TestingFetches | undefined;
-	let schema = "pgboss";
-	const signal = queueSignal();
-	let observed: PgBossInspectionService | undefined;
-	const work: TestingWork = { batches: new Set(), queues: new Set() };
-	const controls = {
-		changed: signal.changed,
-		expirations: new Map<string, number>(),
-		expirySeconds: new Map<string, number>(),
-		failures: new Set<string>(),
-		retryPolicy: settings.retryPolicy ?? {},
-		work,
-	};
-	function client(): EngineClient {
-		if (current === undefined) {
-			throw new Error("Provide the testing clientFactory to a jobs Layer first");
-		}
-		return current;
-	}
-	function inspection(): PgBossInspectionService {
-		if (observed === undefined) {
-			throw new Error("Provide the testing clientFactory to a jobs Layer first");
-		}
-		return observed;
-	}
-	const clientFactory: PgBossClientFactory = (clientOptions) => {
-		if (current !== undefined) {
-			throw new Error("A testing controller owns one jobs client; create a controller per runtime");
-		}
-		schema = clientOptions.schema ?? "pgboss";
-		current = defaultClientFactory({ ...clientOptions, ...(clock === undefined ? {} : { clock }) });
-		fetches = testingFetches(current.getDb(), signal.changed);
-		current = testingClient(current, schema, controls);
-		return testingInspectionClient(current, schema, work, signal.changed, (reads) => {
-			observed = reads;
-		});
-	};
-	const wake = Effect.sync(() => {
-		if (clock !== undefined) {
-			for (const worker of client().getWipData()) {
-				client().notifyWorker(worker.id);
-			}
-		}
-	});
-	const idle = testingIdle(inspection, work, signal, wake);
-	return {
-		deferred: (queue: Pick<QueueDefinition, "name">) => Effect.suspend(() => testingInspection("deferred", inspection().deferred(queue), queue.name)),
-		...testingDueNow(client, () => schema, signal.changed),
-		...testingSchedules(client, inspection),
-		...testingWaits(inspection, () => fetches, signal),
-		checkBatchWindow: (queue: Pick<QueueDefinition, "name" | "workerOptions">, millisecondsPerJob: number) =>
-			testingOperation(
-				"checkBatchWindow",
-				async () => {
-					const stored = await Effect.runPromise(inspection().queue(queue));
-					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 Effect.runPromise(inspection().schemaVersion())) !== expected) {
-					throw new Error(`Expected pg-boss schema version ${expected}`);
-				}
-			}),
-		clientFactory,
-		expireAfter: (queue: Pick<QueueDefinition, "name">, 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);
-				},
-			}),
-		expireIn: (queue: Pick<QueueDefinition, "name">, duration: Duration.Input) =>
-			Effect.try({
-				catch: (original) => new PgBossTestingError({ operation: "expireIn", original: Redacted.make(original), queue: queue.name }),
-				try: () => {
-					const milliseconds = Duration.toMillis(Duration.fromInputUnsafe(duration));
-					if (!Number.isFinite(milliseconds) || milliseconds < 1000) {
-						throw new RangeError("Expiry must be finite and at least one second");
-					}
-					controls.expirySeconds.set(queue.name, Math.ceil(milliseconds / 1000));
-				},
-			}),
-		failNextSend: (queue: Pick<QueueDefinition, "name">) => Effect.sync(() => controls.failures.add(queue.name)).pipe(Effect.asVoid),
-		jobs: <TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(
-			queue: { readonly name: TName; readonly schema: TPayload },
-			readOptions?: JobReadOptions,
-		) => Effect.suspend(() => testingInspection("jobs", inspection().jobs(queue, readOptions), queue.name)),
-		refreshQueueStats: (queue?: Pick<QueueDefinition, "name">) =>
-			testingOperation("refreshQueueStats", () => client().supervise(queue?.name), queue?.name),
-		revision: signal.revision,
-		schemaVersion: Effect.suspend(() => testingInspection("schemaVersion", inspection().schemaVersion())),
-		snapshot: <const TQueues extends readonly SnapshotQueue[]>(queues: TQueues) =>
-			Effect.suspend(() => testingInspection("snapshot", inspection().snapshot(queues))),
-		waitForChange: signal.waitForChange,
-		waitForIdle: idle,
-		...testingTime(settings.clock, clock, idle),
-	};
-}

package/src/server/adapters/testingDueNow.ts

@@ -1,32 +0,0 @@
-import type { QueueDefinition } from "#server/definition.ts";
-import type { EngineClient } from "#server/engineClient.ts";
-import { quotedSchema } from "#server/internal/storedRows.ts";
-import { testingOperation } from "#server/internal/testingOperation.ts";
-
-export function testingDueNow(client: () => EngineClient, schema: () => string, changed: () => void) {
-	function makeDue(queue: Pick<QueueDefinition, "name">, deferredOnly: boolean) {
-		return testingOperation(
-			deferredOnly ? "runDeferredNow" : "runDueNow",
-			async () => {
-				const quoted = quotedSchema(schema());
-				const condition = deferredOnly
-					? "state = 'retry' AND output ? 'jobDeferral' AND started_on IS NULL"
-					: `state IN ('created', 'retry') AND start_after > ${quoted}.job_now()`;
-				await client()
-					.getDb()
-					.executeSql(`UPDATE ${quoted}.job SET start_after = ${quoted}.job_now() WHERE name = $1 AND ${condition}`, [queue.name]);
-				changed();
-				for (const worker of client()
-					.getWipData()
-					.filter((candidate) => candidate.name === queue.name)) {
-					client().notifyWorker(worker.id);
-				}
-			},
-			queue.name,
-		);
-	}
-	return {
-		runDeferredNow: (queue: Pick<QueueDefinition, "name">) => makeDue(queue, true),
-		runDueNow: (queue: Pick<QueueDefinition, "name">) => makeDue(queue, false),
-	};
-}

package/src/server/adapters/testingEngine.ts

@@ -1,15 +0,0 @@
-import { type Context, Effect, Redacted } from "effect";
-import type { EngineClient } from "#server/engineClient.ts";
-import { PgBossTestingError } from "#server/error.ts";
-import type { TestingEngine } from "#server/internal/engine.ts";
-import { expireAttempt } from "./expireAttempt.ts";
-
-export function testingEngine(client: EngineClient, schema: string): Context.Service.Shape<typeof TestingEngine> {
-	return {
-		expireAttempt: (job, cause) =>
-			Effect.tryPromise({
-				catch: (original) => new PgBossTestingError({ operation: "expireAttempt", original: Redacted.make(original), queue: job.name }),
-				try: () => expireAttempt(client, schema, job, cause),
-			}),
-	};
-}

package/src/server/adapters/testingExpirations.ts

@@ -1,33 +0,0 @@
-import type { EngineClient } from "#server/engineClient.ts";
-import type { EnqueueOptions } from "#server/enqueueOptions.ts";
-import type { WorkerJob } from "#server/job.ts";
-
-export function testingExpirations(client: EngineClient) {
-	const snapshots = new Map<string, Promise<number | undefined>>();
-	return {
-		attemptsFor: (job: WorkerJob<unknown>) => snapshots.get(`${job.name}:${job.id}`),
-		send(name: string, data: object | null | undefined, options: EnqueueOptions, attempts: number | undefined) {
-			if (attempts === undefined && options.id === undefined) {
-				return client.send(name, data, options);
-			}
-			const id = options.id ?? crypto.randomUUID();
-			const key = `${name}:${id}`;
-			const previous = snapshots.get(key);
-			const sending = client.send(name, data, { ...options, id });
-			// A worker may claim the row before send returns. Wait for its result before applying the snapshot.
-			const snapshot = sending
-				.then(
-					(sent) => (sent === id ? attempts : previous),
-					() => previous,
-				)
-				.then((value) => {
-					if (value === undefined && snapshots.get(key) === snapshot) {
-						snapshots.delete(key);
-					}
-					return value;
-				});
-			snapshots.set(key, snapshot);
-			return sending;
-		},
-	};
-}

package/src/server/adapters/testingInspectionClient.ts

@@ -1,70 +0,0 @@
-import { Context, Effect, Exit, Layer, Scope } from "effect";
-import type { EngineClient } from "#server/engineClient.ts";
-import { PgBossInspection, type PgBossInspectionService } from "#server/inspection.ts";
-import type { TestingWork } from "#server/internal/testingIdle.ts";
-import { PgBoss } from "#server/PgBoss.ts";
-
-const settleBatches = Effect.fnUntraced(function* (inspection: PgBossInspectionService, work: TestingWork) {
-	for (const batch of work.batches) {
-		if (batch.settled) {
-			continue;
-		}
-		const stored = yield* inspection.storedJobs({ name: batch.name });
-		batch.settled = !stored.some((job) => job.state === "active" && batch.jobs.get(job.id) === job.retryCount);
-	}
-});
-
-export function testingInspectionClient(
-	source: EngineClient,
-	schema: string,
-	work: TestingWork,
-	changed: () => void,
-	observe: (inspection: PgBossInspectionService) => void,
-): EngineClient {
-	const scope = Effect.runSync(Scope.make());
-	const start = source.start.bind(source);
-	const stop = source.stop.bind(source);
-	async function startObserved() {
-		const result = await start();
-		const context = await Effect.runPromise(
-			Layer.buildWithScope(
-				PgBossInspection.layer.pipe(Layer.provide(Layer.succeed(PgBoss, { client: source, reused: false, schema, stop: undefined }))),
-				scope,
-			),
-		);
-		const inspection = Context.get(context, PgBossInspection);
-		observe(inspection);
-		await Effect.runPromise(
-			Effect.gen(function* () {
-				const changes = yield* inspection.changes();
-				const from = yield* changes.revision;
-				yield* Effect.forkScoped(
-					Effect.gen(function* () {
-						let revision = from;
-						while (true) {
-							revision = yield* changes.waitForChange(revision);
-							yield* settleBatches(inspection, work);
-							changed();
-						}
-					}),
-				);
-			}).pipe(Effect.provideService(Scope.Scope, scope)),
-		);
-		return result;
-	}
-	const stopObserved: EngineClient["stop"] = async (options) => {
-		await Promise.all([Effect.runPromise(Scope.close(scope, Exit.void)), stop(options)]);
-	};
-	return new Proxy(source, {
-		get(target, property) {
-			if (property === "start") {
-				return startObserved;
-			}
-			if (property === "stop") {
-				return stopObserved;
-			}
-			const value: unknown = Reflect.get(target, property);
-			return typeof value === "function" ? value.bind(target) : value;
-		},
-	});
-}

package/src/server/adapters/testingTime.ts

@@ -1,25 +0,0 @@
-import { Duration, Effect } from "effect";
-import type { TestClock } from "effect/testing";
-import type { PgBossTestingError } from "#server/error.ts";
-import { testingOperation } from "#server/internal/testingOperation.ts";
-
-export function testingTime(
-	clock: TestClock.TestClock | undefined,
-	jobs: { readonly setTime: (time: number) => Promise<void>; readonly tick: (milliseconds: number) => Promise<void> } | undefined,
-	idle: Effect.Effect<void, PgBossTestingError>,
-) {
-	return {
-		timePasses: (duration: Duration.Input) =>
-			Effect.gen(function* () {
-				if (clock === undefined || jobs === undefined) {
-					return yield* Effect.die(new Error("Provide the story's TestClock to makePgBossTesting before passing time"));
-				}
-				yield* idle;
-				const next = clock.currentTimeMillisUnsafe() + Duration.toMillis(Duration.fromInputUnsafe(duration));
-				yield* testingOperation("timePasses", () => jobs.setTime(next));
-				yield* clock.adjust(duration);
-				yield* testingOperation("timePasses", () => jobs.tick(0));
-				yield* idle;
-			}),
-	};
-}

package/src/server/internal/adapters/deferralChanges.ts

@@ -1,3 +0,0 @@
-import type { ClientDatabase } from "#server/ClientDatabase.ts";
-
-export const deferralChanges = new WeakMap<ClientDatabase, () => void>();

package/src/server/internal/adapters/testingFetches.ts

@@ -1,36 +0,0 @@
-import type { ClientDatabase } from "#server/ClientDatabase.ts";
-
-// pg-boss offers no hook for a worker fetch that finds nothing, so the controller recognizes its claim statement on the client's database.
-const claim = /UPDATE\s+\S+\s+j\s+SET\s+state\s*=\s*'active'/u;
-const claimedQueue = /\bj\.name\s*=\s*'(?<queue>[^']+)'/u;
-
-export interface TestingFetches {
-	readonly begun: (queue: string) => number;
-	readonly passedSince: (queue: string, begun: number) => number;
-}
-
-export function testingFetches(db: ClientDatabase, changed: () => void): TestingFetches {
-	const begun = new Map<string, number>();
-	const passed = new Map<string, number[]>();
-	const executeSql = db.executeSql.bind(db);
-	db.executeSql = async (text: string, values?: unknown[]) => {
-		const queue = claim.test(text) ? claimedQueue.exec(text)?.groups?.queue : undefined;
-		if (queue === undefined) {
-			return executeSql(text, values);
-		}
-		const ordinal = (begun.get(queue) ?? 0) + 1;
-		begun.set(queue, ordinal);
-		try {
-			return await executeSql(text, values);
-		} finally {
-			const ordinals = passed.get(queue) ?? [];
-			ordinals.push(ordinal);
-			passed.set(queue, ordinals);
-			changed();
-		}
-	};
-	return {
-		begun: (queue) => begun.get(queue) ?? 0,
-		passedSince: (queue, mark) => (passed.get(queue) ?? []).filter((ordinal) => ordinal > mark).length,
-	};
-}

package/src/server/internal/testingIdle.ts

@@ -1,36 +0,0 @@
-import { Effect } from "effect";
-import type { PgBossTestingError } from "#server/error.ts";
-import type { PgBossInspectionService } from "#server/inspection.ts";
-import { testingInspection } from "#server/internal/testingOperation.ts";
-
-export interface TestingBatch {
-	readonly jobs: ReadonlyMap<string, number>;
-	readonly name: string;
-	settled: boolean;
-}
-
-export interface TestingWork {
-	readonly batches: Set<TestingBatch>;
-	readonly queues: Set<string>;
-}
-
-export function testingIdle(
-	inspection: () => PgBossInspectionService,
-	work: TestingWork,
-	signal: { readonly revision: Effect.Effect<number>; readonly waitForChange: (after: number) => Effect.Effect<number> },
-	wake: Effect.Effect<void> = Effect.void,
-): Effect.Effect<void, PgBossTestingError> {
-	const busy = Effect.suspend(() => testingInspection("waitForIdle", inspection().busy([...work.queues].map((name) => ({ name })))));
-	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* wake;
-			yield* signal.waitForChange(revision);
-		}
-	});
-}

package/src/server/internal/testingOperation.ts

@@ -1,18 +0,0 @@
-import { Effect, Redacted } from "effect";
-import { PgBossError, PgBossTestingError } from "#server/error.ts";
-
-export function testingOperation<A>(operation: string, run: () => Promise<A>, queue?: string) {
-	return Effect.tryPromise({
-		catch: (original) => new PgBossTestingError({ operation, original: Redacted.make(original), queue }),
-		try: run,
-	});
-}
-
-export function testingInspection<A, E, R>(operation: string, effect: Effect.Effect<A, E | PgBossError, R>, queue?: string) {
-	return effect.pipe(
-		Effect.catchIf(
-			(error): error is PgBossError => error instanceof PgBossError,
-			(error) => Effect.fail(new PgBossTestingError({ operation, original: error.original, queue: queue ?? error.queue })),
-		),
-	);
-}

package/src/server/internal/testingSchedules.ts

@@ -1,35 +0,0 @@
-import { Effect, Redacted } from "effect";
-import type { PgBossClient } from "#server/client.ts";
-import type { ScheduleDefinition } from "#server/definition.ts";
-import { PgBossTestingError } from "#server/error.ts";
-import type { PgBossInspectionService } from "#server/inspection.ts";
-import { testingInspection, testingOperation } from "#server/internal/testingOperation.ts";
-
-export function testingSchedules(client: () => PgBossClient, inspection: () => PgBossInspectionService) {
-	return {
-		schedules: () =>
-			Effect.suspend(() => testingInspection("schedules", inspection().schedules())).pipe(
-				Effect.map((schedules) => schedules.map(({ name, cron, timezone }) => ({ cron, name, timezone }))),
-			),
-		trigger: (schedule: Pick<ScheduleDefinition, "name" | "scheduleOptions">) =>
-			Effect.gen(function* () {
-				const [registered] = yield* testingInspection(
-					"trigger",
-					inspection().schedules(schedule.name, schedule.scheduleOptions.key ?? ""),
-					schedule.name,
-				);
-				if (registered === undefined) {
-					return yield* new PgBossTestingError({
-						operation: "trigger",
-						original: Redacted.make(new Error("Schedule is not registered")),
-						queue: schedule.name,
-					});
-				}
-				return yield* testingOperation(
-					"trigger",
-					() => client().send(registered.name, registered.data, { ...registered.options, startAfter: 0 }),
-					schedule.name,
-				);
-			}),
-	};
-}

package/src/server/internal/testingWaits.ts

@@ -1,94 +0,0 @@
-import { Duration, Effect, Option, Redacted, type Schema } from "effect";
-import type { JobPayloadSchema, QueueDefinition } from "#server/definition.ts";
-import { type PgBossPayloadError, PgBossTestingError, PgBossWaitError } from "#server/error.ts";
-import type { PgBossInspectionService } from "#server/inspection.ts";
-import type { TestingFetches } from "#server/internal/adapters/testingFetches.ts";
-import { testingInspection } from "#server/internal/testingOperation.ts";
-import type { Job, JobState } from "#server/job.ts";
-import type { PgBossTestingWaitOptions } from "#server/testing.ts";
-
-interface Reading<A> {
-	readonly arrived: Option.Option<A>;
-	readonly seen: string;
-}
-
-interface Signal {
-	readonly revision: Effect.Effect<number>;
-	readonly waitForChange: (after: number) => Effect.Effect<number>;
-}
-
-function waitUntil<A, E, R>(
-	signal: Signal,
-	waitingFor: string,
-	read: Effect.Effect<Reading<A>, E, R>,
-	options: PgBossTestingWaitOptions | undefined,
-) {
-	const within = Duration.fromInputUnsafe(options?.within ?? "20 seconds");
-	return Effect.suspend(() => {
-		let lastSeen = "nothing yet";
-		const wait = Effect.gen(function* () {
-			while (true) {
-				const revision = yield* signal.revision;
-				const { arrived, seen } = yield* read;
-				lastSeen = seen;
-				if (Option.isSome(arrived)) {
-					return arrived.value;
-				}
-				yield* signal.waitForChange(revision);
-			}
-		});
-		return wait.pipe(Effect.timeoutOrElse({ duration: within, orElse: () => Effect.fail(new PgBossWaitError({ lastSeen, waitingFor, within })) }));
-	});
-}
-
-function fetchesRefused(queue: Pick<QueueDefinition, "name">, original: Error) {
-	return new PgBossTestingError({ operation: "fetchesPass", original: Redacted.make(original), queue: queue.name });
-}
-
-export function testingWaits(inspection: () => PgBossInspectionService, fetches: () => TestingFetches | undefined, signal: Signal) {
-	return {
-		fetchesPass: (queue: Pick<QueueDefinition, "name">, count: number, options?: PgBossTestingWaitOptions) =>
-			Effect.gen(function* () {
-				if (!Number.isSafeInteger(count) || count < 1) {
-					return yield* fetchesRefused(queue, new RangeError("Fetch count must be a positive integer"));
-				}
-				const observed = fetches();
-				if (observed === undefined) {
-					return yield* fetchesRefused(queue, new Error("Provide the testing clientFactory to a jobs Layer first"));
-				}
-				const begun = observed.begun(queue.name);
-				const fetchesHave = count === 1 ? "fetch that began after the wait has" : "fetches that began after the wait have";
-				return yield* waitUntil(
-					signal,
-					`${count} ${queue.name} ${fetchesHave} finished`,
-					Effect.sync(() => {
-						const passed = observed.passedSince(queue.name, begun);
-						return { arrived: passed >= count ? Option.some(undefined) : Option.none(), seen: `${passed} finished` };
-					}),
-					options,
-				);
-			}),
-		untilJob: <TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(
-			queue: { readonly name: TName; readonly schema: TPayload },
-			id: string,
-			state: JobState,
-			options?: PgBossTestingWaitOptions,
-		) =>
-			waitUntil(
-				signal,
-				`job ${id} in ${queue.name} is ${state}`,
-				Effect.suspend(() => testingInspection("untilJob", inspection().jobs(queue, { id }), queue.name)).pipe(
-					Effect.flatMap(([job]): Effect.Effect<Reading<Job<TPayload["Type"]>>, PgBossPayloadError, TPayload["DecodingServices"]> => {
-						if (job === undefined) {
-							return Effect.succeed({ arrived: Option.none(), seen: "no such job" });
-						}
-						if (job.state !== state) {
-							return Effect.succeed({ arrived: Option.none(), seen: job.state });
-						}
-						return Effect.succeed({ arrived: Option.some(job), seen: job.state });
-					}),
-				),
-				options,
-			),
-	};
-}

package/src/server/testing.ts

@@ -1,31 +0,0 @@
-import { type Duration, Effect, type Tracer } from "effect";
-import type { TestClock } from "effect/testing";
-import { testingController } from "#server/adapters/testingController.ts";
-
-export function makePgBossTesting(options: PgBossTestingOptions = {}) {
-	return testingController(options);
-}
-
-export interface PgBossTestingWaitOptions {
-	readonly within?: Duration.Input;
-}
-
-export const testRetryPolicy = Object.freeze({ retryBackoff: false, retryDelay: 0 });
-
-export interface PgBossTestingOptions {
-	readonly clock?: TestClock.TestClock;
-	readonly retryPolicy?: typeof testRetryPolicy;
-}
-
-export function linkedWorkerSpans(sender: Pick<Tracer.AnySpan, "spanId" | "traceId">, spans: readonly Tracer.Span[]) {
-	return Effect.sync(() =>
-		spans.filter(
-			(span) =>
-				span.kind === "consumer"
-				&& span.attributes.get("messaging.system") === "pg-boss"
-				&& span.links.some((link) => link.span.spanId === sender.spanId && link.span.traceId === sender.traceId),
-		),
-	);
-}
-
-export type PgBossTesting = ReturnType<typeof makePgBossTesting>;