bunqueue 2.8.60 → 2.9.0

package/dist/infrastructure/persistence/postgres/mutations.js

@@ -0,0 +1,171 @@
+import { MAX_TIMELINE_ENTRIES } from '../../../domain/types/job';
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+import { updatedPostgresJobData } from './jobData';
+import { updatePostgresRepeatSuccessorData } from './repeatMutations';
+async function lockJob(tx, ctx, id) {
+    const rows = await tx `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    FOR UPDATE
+  `;
+    return rows[0] ?? null;
+}
+function pendingState(job, now) {
+    if (job.dependsOn.length > 0)
+        return 'waiting-children';
+    if (job.runAt > now)
+        return 'delayed';
+    return job.priority > 0 ? 'prioritized' : 'waiting';
+}
+async function saveJob(tx, ctx, input) {
+    const { job, state, eventType, now } = input;
+    const rows = await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(job)}, state = ${state}, priority = ${job.priority},
+        lifo = ${job.lifo}, run_at = ${job.runAt}, started_at = ${job.startedAt},
+        completed_at = ${job.completedAt}, attempts = ${job.attempts},
+        lease_owner = CASE WHEN ${state} = 'active' THEN lease_owner ELSE NULL END,
+        lease_broker_id = CASE WHEN ${state} = 'active' THEN lease_broker_id ELSE NULL END,
+        lease_broker_session_id = CASE
+          WHEN ${state} = 'active' THEN lease_broker_session_id ELSE NULL
+        END,
+        lease_token = CASE WHEN ${state} = 'active' THEN lease_token ELSE NULL END,
+        lease_until = CASE WHEN ${state} = 'active' THEN lease_until ELSE NULL END,
+        version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(job.id)}
+    RETURNING *
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: eventType,
+        jobId: job.id,
+        occurredAt: now,
+        job,
+        state,
+    });
+    return decodePostgresJob(rows[0]);
+}
+export async function updatePostgresJobData(ctx, id, data) {
+    return await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (!row || row.state === 'completed' || row.state === 'failed') {
+            return await updatePostgresRepeatSuccessorData(tx, ctx, id, data);
+        }
+        const stored = decodePostgresJob(row);
+        const job = { ...stored.job, data: updatedPostgresJobData(stored.job, data) };
+        const now = await databaseNow(tx);
+        await saveJob(tx, ctx, {
+            job,
+            state: stored.state,
+            eventType: 'updated',
+            now,
+        });
+        return true;
+    });
+}
+export async function updatePostgresProgress(ctx, id, progress, message) {
+    return await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (row?.state !== 'active')
+            return false;
+        const stored = decodePostgresJob(row);
+        const now = await databaseNow(tx);
+        stored.job.progress = Math.max(0, Math.min(100, progress));
+        stored.job.progressMessage = message === undefined ? stored.job.progressMessage : message;
+        stored.job.lastHeartbeat = now;
+        await saveJob(tx, ctx, {
+            job: stored.job,
+            state: stored.state,
+            eventType: 'progress',
+            now,
+        });
+        return true;
+    });
+}
+export async function changePostgresPriority(ctx, id, priority, lifo) {
+    return await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (!row || !['waiting', 'prioritized', 'delayed'].includes(row.state))
+            return false;
+        const stored = decodePostgresJob(row);
+        const job = { ...stored.job, priority, lifo: lifo ?? stored.job.lifo };
+        const now = await databaseNow(tx);
+        const state = pendingState(job, now);
+        await saveJob(tx, ctx, { job, state, eventType: 'priority', now });
+        return true;
+    });
+}
+export async function changePostgresDelay(ctx, id, runAt, token) {
+    return await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (!row || !['waiting', 'prioritized', 'delayed', 'active'].includes(row.state))
+            return false;
+        const now = await databaseNow(tx);
+        if (row.state === 'active' &&
+            (row.lease_token !== token || Number(row.lease_until ?? 0) <= now)) {
+            return false;
+        }
+        const stored = decodePostgresJob(row);
+        stored.job.runAt = runAt;
+        stored.job.startedAt = null;
+        const state = pendingState(stored.job, now);
+        if (stored.job.timeline.length < MAX_TIMELINE_ENTRIES) {
+            stored.job.timeline.push({ state, timestamp: now });
+        }
+        await saveJob(tx, ctx, { job: stored.job, state, eventType: 'delayed', now });
+        return true;
+    });
+}
+export async function promotePostgresJob(ctx, id) {
+    return await changePostgresDelay(ctx, id, await databaseNow(ctx.sql));
+}
+export async function movePostgresJobToWaitingChildren(ctx, id, token) {
+    return await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (!row || !['waiting', 'prioritized', 'delayed', 'active'].includes(row.state))
+            return false;
+        const now = await databaseNow(tx);
+        if (row.state === 'active' &&
+            (row.lease_token !== token || Number(row.lease_until ?? 0) <= now)) {
+            return false;
+        }
+        const job = decodePostgresJob(row).job;
+        job.startedAt = null;
+        if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+            job.timeline.push({ state: 'waiting-children', timestamp: now });
+        }
+        await saveJob(tx, ctx, {
+            job,
+            state: 'waiting-children',
+            eventType: 'waiting-children',
+            now,
+        });
+        return true;
+    });
+}
+export async function clearPostgresJobUniqueKey(ctx, id) {
+    return await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (!row?.unique_key)
+            return false;
+        const job = decodePostgresJob(row).job;
+        const updated = { ...job, uniqueKey: null };
+        const now = await databaseNow(tx);
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(updated)}, unique_key = NULL,
+          unique_expires_at = NULL, version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    `;
+        await recordPostgresEvent(tx, ctx, {
+            queue: job.queue,
+            type: 'updated',
+            jobId: id,
+            occurredAt: now,
+            job: updated,
+            state: row.state,
+        });
+        return true;
+    });
+}

package/dist/infrastructure/persistence/postgres/outcomes.d.ts

@@ -0,0 +1,4 @@
+import { type PostgresContext } from './context';
+import type { PostgresFailureInput, PostgresTransitionResult } from './types';
+export { completePostgresJob } from './completionOutcome';
+export declare function failPostgresJob(ctx: PostgresContext, input: PostgresFailureInput): Promise<PostgresTransitionResult>;

package/dist/infrastructure/persistence/postgres/outcomes.js

@@ -0,0 +1,194 @@
+import { calculateBackoff, canRetry, MAX_TIMELINE_ENTRIES, normalizeStacktrace, } from '../../../domain/types/job';
+import { createDlqEntry, getDlqRetryState, recordJobFailureAttempt, } from '../../../domain/types/dlq';
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent, runPostgresPostCommitMaintenance, } from './context';
+import { applyPostgresFlowFailure, clearPostgresParentFlowFailures, lockPostgresJobFlowParent, } from './flowFailures';
+import { enforcePostgresDlqLimit } from './dlqLifecycle';
+import { getPostgresQueuePolicies } from './policies';
+import { partitionPostgresDestructionCandidates } from './dependencyDestruction';
+import { runPostgresTransactionWithRetry } from './transactionRetry';
+export { completePostgresJob } from './completionOutcome';
+async function lockActiveJob(tx, ctx, id) {
+    const rows = await tx `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    FOR UPDATE
+  `;
+    return rows[0] ?? null;
+}
+function notApplied(row) {
+    return {
+        applied: false,
+        alreadyFinalized: row?.state === 'completed' || row?.state === 'failed',
+        job: row ? decodePostgresJob(row).job : null,
+        state: row?.state ?? null,
+    };
+}
+function assertToken(row, token, now) {
+    return row.state === 'active' && row.lease_token === token && Number(row.lease_until ?? 0) > now;
+}
+async function deleteLiveJob(tx, ctx, id) {
+    await tx `
+    DELETE FROM bunqueue_job_logs
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+  `;
+    await tx `
+    DELETE FROM bunqueue_dependencies
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+  `;
+    await tx `
+    DELETE FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+  `;
+}
+function failureReason(value, terminal) {
+    switch (value) {
+        case "explicit_fail" /* FailureReason.ExplicitFail */:
+        case "max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */:
+        case "timeout" /* FailureReason.Timeout */:
+        case "stalled" /* FailureReason.Stalled */:
+        case "ttl_expired" /* FailureReason.TtlExpired */:
+        case "worker_lost" /* FailureReason.WorkerLost */:
+        case "unknown" /* FailureReason.Unknown */:
+            return value;
+    }
+    return terminal ? "max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */ : "explicit_fail" /* FailureReason.ExplicitFail */;
+}
+async function persistRetry(tx, ctx, job, now) {
+    job.runAt = now + calculateBackoff(job);
+    job.startedAt = null;
+    const state = job.runAt > now ? 'delayed' : job.priority > 0 ? 'prioritized' : 'waiting';
+    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+        job.timeline.push({ state, timestamp: now, attempt: job.attempts + 1 });
+    }
+    await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(job)}, state = ${state}, attempts = ${job.attempts},
+        run_at = ${job.runAt}, started_at = NULL, lease_owner = NULL, lease_token = NULL,
+        lease_broker_id = NULL, lease_broker_session_id = NULL,
+        lease_until = NULL, error = NULL, failure_reason = NULL,
+        dlq_entry = NULL,
+        dlq_retry_state = ${encodePostgresValue(getDlqRetryState(job))},
+        version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(job.id)}
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: 'retried',
+        jobId: job.id,
+        occurredAt: now,
+        job,
+        state,
+        dlqEntry: null,
+        dlqRetryState: getDlqRetryState(job),
+    });
+    return state;
+}
+async function persistTerminalFailure(tx, ctx, input) {
+    const { job, reason, error, now, remove } = input;
+    const { dlq } = await getPostgresQueuePolicies(tx, ctx, job.queue);
+    const entry = createDlqEntry(job, reason, error ?? null, dlq, now);
+    const { protectedIds } = remove
+        ? await partitionPostgresDestructionCandidates(tx, ctx, [job.id], [job.id])
+        : { protectedIds: [] };
+    const removed = remove && protectedIds.length === 0;
+    if (removed) {
+        await deleteLiveJob(tx, ctx, job.id);
+    }
+    else {
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(job)}, state = 'failed', attempts = ${job.attempts},
+          completed_at = ${now}, lease_owner = NULL, lease_token = NULL, lease_until = NULL,
+          lease_broker_id = NULL, lease_broker_session_id = NULL,
+          error = ${error ?? null}, failure_reason = ${reason},
+          dlq_entry = ${encodePostgresValue(entry)}, dlq_retry_state = NULL,
+          version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(job.id)}
+    `;
+    }
+    return {
+        dlqEntry: removed ? null : entry,
+        maxEntries: removed ? null : dlq.maxEntries,
+        removed,
+    };
+}
+export async function failPostgresJob(ctx, input) {
+    const result = await runPostgresTransactionWithRetry(ctx, async (tx) => {
+        await lockPostgresJobFlowParent(tx, ctx, input.id);
+        const row = await lockActiveJob(tx, ctx, input.id);
+        const now = await databaseNow(tx);
+        if (!row || !assertToken(row, input.token, now)) {
+            return { transition: notApplied(row), dlqLimits: new Map() };
+        }
+        const job = decodePostgresJob(row).job;
+        job.attempts++;
+        job.stacktrace = normalizeStacktrace(input.stack, job.stackTraceLimit);
+        const willRetry = !input.unrecoverable && canRetry(job);
+        const reason = failureReason(input.failureReason, !willRetry);
+        let nextState = 'failed';
+        let dlqEntry = null;
+        let dlqMaxEntries = null;
+        let removed = false;
+        if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+            job.timeline.push({
+                state: 'failed',
+                timestamp: now,
+                error: input.error,
+                attempt: job.attempts,
+            });
+        }
+        if (willRetry) {
+            recordJobFailureAttempt(job, reason, input.error ?? null, now);
+            nextState = await persistRetry(tx, ctx, job, now);
+        }
+        else {
+            job.completedAt = now;
+            const persisted = await persistTerminalFailure(tx, ctx, {
+                job,
+                reason,
+                error: input.error,
+                now,
+                remove: job.removeOnFail || input.removeOnFail === true,
+            });
+            dlqEntry = persisted.dlqEntry;
+            dlqMaxEntries = persisted.maxEntries;
+            removed = persisted.removed;
+        }
+        await recordPostgresEvent(tx, ctx, {
+            queue: job.queue,
+            type: 'failed',
+            jobId: job.id,
+            occurredAt: now,
+            job,
+            state: nextState,
+            error: input.error,
+            removed,
+            dlqEntry,
+            dlqRetryState: willRetry ? getDlqRetryState(job) : null,
+        });
+        const dlqLimits = new Map();
+        if (!willRetry) {
+            await clearPostgresParentFlowFailures(tx, ctx, job.id);
+            const request = await applyPostgresFlowFailure(tx, ctx, job, input.error, now);
+            if (request)
+                dlqLimits.set(request.queue, request.maxEntries);
+        }
+        if (dlqMaxEntries !== null) {
+            dlqLimits.set(job.queue, dlqMaxEntries);
+        }
+        return {
+            transition: {
+                applied: true,
+                alreadyFinalized: false,
+                job,
+                state: nextState,
+            },
+            dlqLimits,
+        };
+    });
+    for (const [queue, maxEntries] of [...result.dlqLimits].sort(([left], [right]) => left.localeCompare(right))) {
+        await runPostgresPostCommitMaintenance(ctx, `dlq-limit:${queue}`, () => enforcePostgresDlqLimit(ctx, queue, maxEntries));
+    }
+    return result.transition;
+}

package/dist/infrastructure/persistence/postgres/policies.d.ts

@@ -0,0 +1,11 @@
+import type { SQL, TransactionSQL } from 'bun';
+import { type DlqConfig } from '../../../domain/types/dlq';
+import { type StallConfig } from '../../../domain/types/stall';
+import type { PostgresContext } from './context';
+export interface PostgresQueuePolicies {
+    readonly stall: StallConfig;
+    readonly dlq: DlqConfig;
+}
+export declare function decodePostgresDlqConfig(queue: string, value: Uint8Array | null): DlqConfig;
+/** Read effective queue policies inside an existing transaction when supplied. */
+export declare function getPostgresQueuePolicies(sql: SQL | TransactionSQL, ctx: PostgresContext, queue: string): Promise<PostgresQueuePolicies>;

package/dist/infrastructure/persistence/postgres/policies.js

@@ -0,0 +1,18 @@
+import { DEFAULT_DLQ_CONFIG } from '../../../domain/types/dlq';
+import { DEFAULT_STALL_CONFIG } from '../../../domain/types/stall';
+import { decodePostgresValue } from './codec';
+export function decodePostgresDlqConfig(queue, value) {
+    return decodePostgresValue(value, DEFAULT_DLQ_CONFIG, `dlqConfig:${queue}`);
+}
+/** Read effective queue policies inside an existing transaction when supplied. */
+export async function getPostgresQueuePolicies(sql, ctx, queue) {
+    const rows = await sql `
+    SELECT stall_config, dlq_config
+    FROM bunqueue_queue_state
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+  `;
+    return {
+        stall: decodePostgresValue(rows[0]?.stall_config ?? null, DEFAULT_STALL_CONFIG, `stallConfig:${queue}`),
+        dlq: decodePostgresDlqConfig(queue, rows[0]?.dlq_config ?? null),
+    };
+}

package/dist/infrastructure/persistence/postgres/postCommitMaintenance.d.ts

@@ -0,0 +1,17 @@
+type MaintenanceReporter = (subsystem: string, error: unknown) => void;
+/** Coalesce, serialize, and retry idempotent work after a committed transition. */
+export declare class PostgresPostCommitMaintenance {
+    private readonly report;
+    private readonly retryDelayMs;
+    private readonly flights;
+    private timer;
+    private closed;
+    constructor(report: MaintenanceReporter, retryDelayMs: number);
+    run(subsystem: string, operation: () => Promise<unknown>): Promise<void>;
+    close(): void;
+    drain(): Promise<void>;
+    private startFlight;
+    private runLoop;
+    private scheduleRetry;
+}
+export {};

package/dist/infrastructure/persistence/postgres/postCommitMaintenance.js

@@ -0,0 +1,117 @@
+/** Coalesce, serialize, and retry idempotent work after a committed transition. */
+export class PostgresPostCommitMaintenance {
+    report;
+    retryDelayMs;
+    flights = new Map();
+    timer = null;
+    closed = false;
+    constructor(report, retryDelayMs) {
+        this.report = report;
+        this.retryDelayMs = retryDelayMs;
+    }
+    run(subsystem, operation) {
+        if (this.closed)
+            return Promise.resolve();
+        let resolve;
+        const result = new Promise((accept) => {
+            resolve = accept;
+        });
+        const existing = this.flights.get(subsystem);
+        if (existing) {
+            if (existing.pending) {
+                existing.pending.operation = operation;
+                existing.pending.retry = false;
+                existing.pending.waiters.push(resolve);
+            }
+            else {
+                existing.pending = { operation, waiters: [resolve], retry: false };
+            }
+            this.startFlight(subsystem, existing);
+            return result;
+        }
+        const flight = {
+            pending: { operation, waiters: [resolve], retry: false },
+            running: false,
+            loop: null,
+        };
+        this.flights.set(subsystem, flight);
+        this.startFlight(subsystem, flight);
+        return result;
+    }
+    close() {
+        this.closed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        for (const [subsystem, flight] of this.flights) {
+            if (flight.pending?.retry)
+                flight.pending = null;
+            if (flight.pending)
+                this.startFlight(subsystem, flight);
+            else if (!flight.running)
+                this.flights.delete(subsystem);
+        }
+    }
+    async drain() {
+        while (this.flights.size > 0) {
+            const loops = [...this.flights.values()].flatMap(({ loop }) => (loop ? [loop] : []));
+            if (loops.length === 0)
+                return;
+            await Promise.all(loops);
+        }
+    }
+    startFlight(subsystem, flight) {
+        if (flight.running || !flight.pending)
+            return;
+        flight.running = true;
+        const loop = this.runLoop(subsystem, flight).finally(() => {
+            flight.running = false;
+            flight.loop = null;
+            if (flight.pending && (!this.closed || !flight.pending.retry)) {
+                this.startFlight(subsystem, flight);
+            }
+            else if (!flight.pending && this.flights.get(subsystem) === flight) {
+                this.flights.delete(subsystem);
+            }
+        });
+        flight.loop = loop;
+    }
+    async runLoop(subsystem, flight) {
+        while (flight.pending) {
+            const current = flight.pending;
+            flight.pending = null;
+            let failure = null;
+            try {
+                await current.operation();
+            }
+            catch (error) {
+                failure = error;
+            }
+            for (const resolve of current.waiters)
+                resolve();
+            const superseded = flight.pending !== null;
+            if (this.closed)
+                continue;
+            if (failure === null) {
+                if (!superseded)
+                    this.report(subsystem, null);
+                continue;
+            }
+            if (superseded)
+                continue;
+            this.report(subsystem, failure);
+            flight.pending = { operation: current.operation, waiters: [], retry: true };
+            this.scheduleRetry();
+            return;
+        }
+    }
+    scheduleRetry() {
+        if (this.closed || this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            for (const [subsystem, flight] of this.flights)
+                this.startFlight(subsystem, flight);
+        }, this.retryDelayMs);
+    }
+}

package/dist/infrastructure/persistence/postgres/promotion.d.ts

@@ -0,0 +1,3 @@
+import { type JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+export declare function promotePostgresJobs(ctx: PostgresContext, queue: string, count?: number): Promise<JobId[]>;

package/dist/infrastructure/persistence/postgres/promotion.js

@@ -0,0 +1,43 @@
+import { jobId, MAX_TIMELINE_ENTRIES } from '../../../domain/types/job';
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+export async function promotePostgresJobs(ctx, queue, count) {
+    const limit = count === undefined ? 2_147_483_647 : Math.max(0, count);
+    if (limit === 0)
+        return [];
+    return await ctx.sql.begin(async (tx) => {
+        const now = await databaseNow(tx);
+        const rows = await tx `
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND queue = ${queue}
+        AND state = 'delayed'
+      ORDER BY created_at, id
+      LIMIT ${limit}
+      FOR UPDATE SKIP LOCKED
+    `;
+        for (const row of rows) {
+            const job = decodePostgresJob(row).job;
+            job.runAt = now;
+            const state = job.priority > 0 ? 'prioritized' : 'waiting';
+            if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+                job.timeline.push({ state, timestamp: now });
+            }
+            await tx `
+        UPDATE bunqueue_jobs
+        SET payload = ${encodePostgresValue(job)}, run_at = ${now}, state = ${state},
+            version = version + 1
+        WHERE namespace = ${ctx.config.namespace} AND id = ${row.id}
+      `;
+            await recordPostgresEvent(tx, ctx, {
+                queue,
+                type: 'retried',
+                jobId: job.id,
+                occurredAt: now,
+                job,
+                state,
+            });
+        }
+        return rows.map((row) => jobId(row.id));
+    });
+}

package/dist/infrastructure/persistence/postgres/queries.d.ts

@@ -0,0 +1,22 @@
+import type { DlqEntry } from '../../../domain/types/dlq';
+import type { Job, JobId } from '../../../domain/types/job';
+import type { PostgresContext } from './context';
+import type { PostgresReadSql } from './context';
+import type { PostgresCounts, PostgresJobState, PostgresStoredJob } from './types';
+export declare function getPostgresJob(ctx: PostgresContext, id: JobId): Promise<PostgresStoredJob | null>;
+export declare function getPostgresJobs(ctx: PostgresContext, ids: readonly JobId[], sql?: PostgresReadSql): Promise<PostgresStoredJob[]>;
+/** Return dependency ids that have neither a job row nor durable completion evidence. */
+export declare function findMissingPostgresDependencies(ctx: PostgresContext, ids: readonly JobId[]): Promise<JobId[]>;
+export interface ListPostgresJobsOptions {
+    readonly states?: readonly PostgresJobState[];
+    readonly offset?: number;
+    readonly limit?: number;
+    readonly asc?: boolean;
+}
+export declare function listPostgresJobs(ctx: PostgresContext, queue: string, options?: ListPostgresJobsOptions, sql?: PostgresReadSql): Promise<PostgresStoredJob[]>;
+export declare function loadAllPostgresJobs(ctx: PostgresContext, sql?: PostgresReadSql): Promise<PostgresStoredJob[]>;
+export declare function getPostgresCounts(ctx: PostgresContext, queue?: string): Promise<PostgresCounts>;
+export declare function listPostgresQueues(ctx: PostgresContext, sql?: PostgresReadSql): Promise<string[]>;
+export declare function listPostgresDlq(ctx: PostgresContext, queue: string, limit?: number): Promise<DlqEntry[]>;
+export declare function latestPostgresEventId(ctx: PostgresContext): Promise<number>;
+export declare function jobsOnly(rows: readonly PostgresStoredJob[]): Job[];