bunqueue 2.8.59 → 2.9.0

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

@@ -0,0 +1,136 @@
+import { claimPostgresJobs } from './claims';
+import { getPostgresQueueState, setPostgresConcurrency, setPostgresDlqConfig, setPostgresPaused, setPostgresRateLimit, setPostgresStallConfig, } from './control';
+import { drainPostgresQueue, obliteratePostgresQueue } from './queueDestruction';
+import { promotePostgresJobs } from './promotion';
+import { changePostgresDelay, changePostgresPriority, clearPostgresJobUniqueKey, movePostgresJobToWaitingChildren, promotePostgresJob, updatePostgresJobData, updatePostgresProgress, } from './mutations';
+import { removePostgresJob, retryPostgresTerminalJob } from './destructiveMutations';
+import { completePostgresJob } from './completionOutcome';
+import { failPostgresJob } from './outcomes';
+import { renewPostgresLease } from './leaseRenewal';
+import { getPostgresCounts, getPostgresJob, getPostgresJobs, findMissingPostgresDependencies, latestPostgresEventId, listPostgresDlq, listPostgresJobs, listPostgresQueues, loadAllPostgresJobs, } from './queries';
+import { getPostgresChildrenValues, getPostgresCompletionResult, loadPostgresCompletionResults, } from './completionQueries';
+import { recoverExpiredPostgresLeases } from './recovery';
+import { getPostgresFlowFailureValues } from './flowFailures';
+import { PostgresAdmissionStore } from './admissionStore';
+import { cleanPostgresQueue, purgePostgresDlq } from './maintenance';
+import { maintainPostgresDlq } from './dlqLifecycle';
+import { addPostgresJobLog, clearPostgresJobLogs, getPostgresJobLogs } from './logs';
+import { getPostgresCron, listPostgresCrons, processPostgresCrons, removePostgresCron, upsertPostgresCron, } from './crons';
+import { heartbeatPostgresWorker, listPostgresWorkers, removePostgresClientWorkers, removePostgresWorker, savePostgresWorker, } from './workers';
+import { getPostgresQueueMetrics, trimPostgresQueueEvents } from './telemetry';
+import { releasePostgresClientLease } from './leaseRelease';
+import { removePostgresChildDependency, updatePostgresJobParent } from './relationships';
+import { cancelPostgresJob, discardPostgresJob, removePostgresDlqJob } from './terminal';
+import { databaseNow, runPostgresPostCommitMaintenance } from './context';
+import { completePostgresJobs } from './batchCompletion';
+import { prunePostgresCompletionTombstones } from './completionLifecycle';
+import { loadPostgresLifetimeMetrics } from './lifetimeMetrics';
+import { finalizePostgresLifetimeMetrics } from './lifetimeMetricsFinalizer';
+import { loadPostgresCloudReadModel } from './cloudReadModel';
+import { removePostgresUnprocessedChildren } from './removeUnprocessedChildren';
+import { loadPostgresJobProjections, loadPostgresManagerSnapshot, loadPostgresQueueReadModel, } from './readModels';
+/** Database-authoritative PostgreSQL queue store safe for concurrent brokers. */
+export class PostgresQueueStore extends PostgresAdmissionStore {
+    async now() {
+        await this.initialize();
+        return await databaseNow(this.context.sql);
+    }
+    async claim(queue, count, owner = this.config.brokerId, leaseDurationMs = this.config.leaseDurationMs) {
+        await this.initialize();
+        return await claimPostgresJobs(this.context, queue, count, owner, leaseDurationMs);
+    }
+    async complete(id, token, result, remove = false) {
+        await this.initialize();
+        const transition = await completePostgresJob(this.context, id, token, result, remove);
+        if (transition.applied && (remove || transition.job?.removeOnComplete)) {
+            await runPostgresPostCommitMaintenance(this.context, 'completion-retention', () => prunePostgresCompletionTombstones(this.context));
+        }
+        return transition;
+    }
+    async completeMany(items) {
+        await this.initialize();
+        const transitions = await completePostgresJobs(this.context, items);
+        if (transitions.some((transition) => transition.applied && transition.removed)) {
+            await runPostgresPostCommitMaintenance(this.context, 'completion-retention', () => prunePostgresCompletionTombstones(this.context));
+        }
+        return transitions;
+    }
+    async fail(input) {
+        await this.initialize();
+        return await failPostgresJob(this.context, input);
+    }
+    async renew(id, token, durationMs) {
+        await this.initialize();
+        return await renewPostgresLease(this.context, id, token, durationMs);
+    }
+    async recoverExpired(limit) {
+        await this.initialize();
+        return await recoverExpiredPostgresLeases(this.context, limit);
+    }
+    async maintainDlq(limit) {
+        await this.initialize();
+        return await maintainPostgresDlq(this.context, limit);
+    }
+    addCron = (input) => upsertPostgresCron(this.context, input);
+    getCron = (name) => getPostgresCron(this.context, name);
+    listCrons = () => listPostgresCrons(this.context);
+    removeCron = (name) => removePostgresCron(this.context, name);
+    processCrons = (limit) => processPostgresCrons(this.context, limit);
+    saveWorker = (worker) => savePostgresWorker(this.context, worker);
+    heartbeatWorker = (id, stats, clientId) => heartbeatPostgresWorker(this.context, id, stats, clientId);
+    removeWorker = (id, clientId) => removePostgresWorker(this.context, id, clientId);
+    removeClientWorkers = (clientId) => removePostgresClientWorkers(this.context, clientId);
+    listWorkers = () => listPostgresWorkers(this.context);
+    getQueueMetrics = (queue, type, start, end) => getPostgresQueueMetrics(this.context, queue, type, start, end);
+    trimQueueEvents = (queue, maxLength) => trimPostgresQueueEvents(this.context, queue, maxLength);
+    releaseClientLease = (id, token) => releasePostgresClientLease(this.context, id, token);
+    getJob = (id) => getPostgresJob(this.context, id);
+    getJobs = (ids) => getPostgresJobs(this.context, ids);
+    findMissingDependencies = (ids) => findMissingPostgresDependencies(this.context, ids);
+    getResult = (id) => getPostgresCompletionResult(this.context, id);
+    getCounts = (queue) => getPostgresCounts(this.context, queue);
+    getQueues = () => listPostgresQueues(this.context);
+    getDlq = (queue, limit) => listPostgresDlq(this.context, queue, limit);
+    getChildrenValues = (id) => getPostgresChildrenValues(this.context, id);
+    getFailedChildrenValues = (id) => getPostgresFlowFailureValues(this.context, id, 'continue');
+    getIgnoredChildrenFailures = (id) => getPostgresFlowFailureValues(this.context, id, 'ignore');
+    addLog = (id, message, level) => addPostgresJobLog(this.context, id, message, level);
+    getLogs = (id) => getPostgresJobLogs(this.context, id);
+    clearLogs = (id, keepLogs) => clearPostgresJobLogs(this.context, id, keepLogs);
+    getQueueState = (queue) => getPostgresQueueState(this.context, queue);
+    list = (queue, options) => listPostgresJobs(this.context, queue, options);
+    loadAll = () => loadAllPostgresJobs(this.context);
+    loadResults = (queue) => loadPostgresCompletionResults(this.context, queue);
+    latestEventId = () => latestPostgresEventId(this.context);
+    loadLifetimeMetrics = () => loadPostgresLifetimeMetrics(this.context);
+    finalizeLifetimeMetrics = (apply) => finalizePostgresLifetimeMetrics(this.context, apply);
+    loadCloudReadModel = () => loadPostgresCloudReadModel(this.context);
+    loadManagerSnapshot = () => loadPostgresManagerSnapshot(this.context);
+    loadQueueReadModel = (queue) => loadPostgresQueueReadModel(this.context, queue);
+    loadJobProjections = (requests) => loadPostgresJobProjections(this.context, requests);
+    updateData = (id, data) => updatePostgresJobData(this.context, id, data);
+    updateProgress = (id, value, message) => updatePostgresProgress(this.context, id, value, message);
+    changePriority = (id, priority, lifo) => changePostgresPriority(this.context, id, priority, lifo);
+    changeDelay = (id, runAt, token) => changePostgresDelay(this.context, id, runAt, token);
+    moveToWaitingChildren = (id, token) => movePostgresJobToWaitingChildren(this.context, id, token);
+    clearUniqueKey = (id) => clearPostgresJobUniqueKey(this.context, id);
+    removeDependency = (id) => removePostgresChildDependency(this.context, id);
+    removeUnprocessedChildren = (parentId) => removePostgresUnprocessedChildren(this.context, parentId);
+    updateParent = (childId, parentId) => updatePostgresJobParent(this.context, childId, parentId);
+    promote = (id) => promotePostgresJob(this.context, id);
+    cancel = (id) => cancelPostgresJob(this.context, id);
+    discard = (id, token) => discardPostgresJob(this.context, id, token);
+    remove = (id, token) => removePostgresJob(this.context, id, token);
+    removeDlq = (queue, id) => removePostgresDlqJob(this.context, queue, id);
+    purgeDlq = (queue) => purgePostgresDlq(this.context, queue);
+    clean = (queue, graceMs, state, limit) => cleanPostgresQueue(this.context, queue, graceMs, state, limit);
+    retry = (id, timestamp) => retryPostgresTerminalJob(this.context, id, timestamp);
+    pause = (queue, paused) => setPostgresPaused(this.context, queue, paused);
+    setRateLimit = (queue, limit, durationMs, ttlMs) => setPostgresRateLimit(this.context, queue, limit, durationMs, ttlMs);
+    setConcurrency = (queue, limit) => setPostgresConcurrency(this.context, queue, limit);
+    setStallConfig = (queue, config) => setPostgresStallConfig(this.context, queue, config);
+    setDlqConfig = (queue, config) => setPostgresDlqConfig(this.context, queue, config);
+    drain = (queue) => drainPostgresQueue(this.context, queue);
+    obliterate = (queue) => obliteratePostgresQueue(this.context, queue);
+    promoteMany = (queue, count) => promotePostgresJobs(this.context, queue, count);
+}

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

@@ -0,0 +1,6 @@
+import type { QueueMetrics, QueueMetricType } from '../../../domain/types/metrics';
+import type { PostgresContext } from './context';
+export declare function getPostgresQueueMetrics(ctx: PostgresContext, queue: string, type: QueueMetricType, start?: number, end?: number): Promise<QueueMetrics>;
+export declare function trimPostgresQueueEvents(ctx: PostgresContext, queue: string, maxLength: number): Promise<number>;
+/** Converge retained windows after missed notifications or an unclean broker exit. */
+export declare function sweepPostgresEventRetention(ctx: PostgresContext): Promise<number>;

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

@@ -0,0 +1,88 @@
+import { recordPostgresEventPruneWatermarks, summarizePostgresPrunedEvents, } from './eventPruneWatermarks';
+import { lockPostgresEventRetention, prunePostgresQueueEvents } from './eventRetention';
+import { POSTGRES_EVENT_CHANNEL } from './schema';
+function assertNonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+}
+export async function getPostgresQueueMetrics(ctx, queue, type, start = 0, end = -1) {
+    assertNonNegativeInteger(start, 'start');
+    if (end !== -1)
+        assertNonNegativeInteger(end, 'end');
+    const [metaRows, buckets] = await Promise.all([
+        ctx.sql `
+      SELECT total_count, prev_ts, prev_count
+      FROM bunqueue_metric_totals
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND metric_type = ${type}
+    `,
+        ctx.sql `
+      SELECT minute, count FROM bunqueue_metric_buckets
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND metric_type = ${type}
+      ORDER BY minute DESC
+      LIMIT ${ctx.config.maxMetricDataPoints}
+    `,
+    ]);
+    const data = [];
+    if (buckets.length > 0) {
+        const newest = Number(buckets[0].minute);
+        const oldest = Math.max(Number(buckets.at(-1).minute), newest - ctx.config.maxMetricDataPoints + 1);
+        data.push(...new Array(newest - oldest + 1).fill(0));
+        for (const bucket of buckets)
+            data[newest - Number(bucket.minute)] = bucket.count;
+    }
+    const count = data.length;
+    const exclusiveEnd = end === -1 ? count : Math.min(count, end + 1);
+    const meta = metaRows[0];
+    return {
+        meta: {
+            count: Number(meta?.total_count ?? 0),
+            prevTS: Number(meta?.prev_ts ?? 0),
+            prevCount: meta?.prev_count ?? 0,
+        },
+        data: start >= exclusiveEnd ? [] : data.slice(start, exclusiveEnd),
+        count,
+    };
+}
+export async function trimPostgresQueueEvents(ctx, queue, maxLength) {
+    assertNonNegativeInteger(maxLength, 'maxLength');
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresEventRetention(tx, ctx, queue);
+        const rows = await prunePostgresQueueEvents(tx, ctx, queue, maxLength);
+        const prune = summarizePostgresPrunedEvents(rows);
+        const { prunedThrough } = prune;
+        if (prunedThrough > 0) {
+            await recordPostgresEventPruneWatermarks(tx, ctx, [
+                {
+                    queue,
+                    sourceEventId: prunedThrough,
+                    ...prune,
+                    prunesCurrentTransaction: false,
+                },
+            ]);
+            await tx.notify(POSTGRES_EVENT_CHANNEL, JSON.stringify({
+                namespace: ctx.config.namespace,
+                queue,
+                brokerId: ctx.config.brokerId,
+                prunedThrough,
+            }));
+        }
+        return rows.length;
+    });
+}
+/** Converge retained windows after missed notifications or an unclean broker exit. */
+export async function sweepPostgresEventRetention(ctx) {
+    const queues = await ctx.sql `
+    SELECT queue
+    FROM bunqueue_events
+    WHERE namespace = ${ctx.config.namespace}
+    GROUP BY queue
+    HAVING COUNT(*) > ${ctx.config.maxQueueEvents}
+    ORDER BY queue
+  `;
+    let removed = 0;
+    for (const { queue } of queues) {
+        removed += await trimPostgresQueueEvents(ctx, queue, ctx.config.maxQueueEvents);
+    }
+    return removed;
+}

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

@@ -0,0 +1,8 @@
+import type { JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+/** Cancel only a pending job, matching the existing QueueManager contract. */
+export declare function cancelPostgresJob(ctx: PostgresContext, id: JobId): Promise<boolean>;
+/** Move a runnable pending or actively leased job to the DLQ. */
+export declare function discardPostgresJob(ctx: PostgresContext, id: JobId, token?: string): Promise<boolean>;
+/** Permanently remove exactly one failed job from its queue. */
+export declare function removePostgresDlqJob(ctx: PostgresContext, queue: string, id: JobId): Promise<boolean>;

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

@@ -0,0 +1,137 @@
+import { createDlqEntry } from '../../../domain/types/dlq';
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent, runPostgresPostCommitMaintenance, } from './context';
+import { enforcePostgresDlqLimit } from './dlqLifecycle';
+import { getPostgresQueuePolicies } from './policies';
+import { lockPostgresDestructionCandidates, partitionPostgresDestructionCandidates, } from './dependencyDestruction';
+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;
+}
+async function deleteJobDependencies(tx, ctx, id) {
+    await tx `
+    DELETE FROM bunqueue_dependencies
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+  `;
+}
+async function deleteParentFailureValues(tx, ctx, id) {
+    await tx `
+    DELETE FROM bunqueue_flow_failures
+    WHERE namespace = ${ctx.config.namespace} AND parent_id = ${String(id)}
+  `;
+}
+/** Cancel only a pending job, matching the existing QueueManager contract. */
+export async function cancelPostgresJob(ctx, id) {
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresDestructionCandidates(tx, ctx, [id]);
+        const row = await lockJob(tx, ctx, id);
+        if (!row || !['waiting', 'prioritized', 'delayed', 'waiting-children'].includes(row.state)) {
+            return false;
+        }
+        const { protectedIds } = await partitionPostgresDestructionCandidates(tx, ctx, [id], [id]);
+        if (protectedIds.length > 0)
+            return false;
+        const job = decodePostgresJob(row).job;
+        await deleteJobDependencies(tx, ctx, id);
+        await tx `
+      DELETE FROM bunqueue_job_logs
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+    `;
+        await deleteParentFailureValues(tx, ctx, id);
+        await tx `
+      DELETE FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    `;
+        await recordPostgresEvent(tx, ctx, {
+            queue: job.queue,
+            type: 'removed',
+            jobId: id,
+            occurredAt: await databaseNow(tx),
+            job,
+            state: row.state,
+            removed: true,
+        });
+        return true;
+    });
+}
+/** Move a runnable pending or actively leased job to the DLQ. */
+export async function discardPostgresJob(ctx, id, token) {
+    const request = await ctx.sql.begin(async (tx) => {
+        const row = await lockJob(tx, ctx, id);
+        if (!row || !['waiting', 'prioritized', 'delayed', 'active'].includes(row.state))
+            return null;
+        const now = await databaseNow(tx);
+        if (row.state === 'active' &&
+            (row.lease_token !== token || Number(row.lease_until ?? 0) <= now)) {
+            return null;
+        }
+        const job = decodePostgresJob(row).job;
+        job.completedAt = now;
+        const { dlq } = await getPostgresQueuePolicies(tx, ctx, job.queue);
+        const entry = createDlqEntry(job, "unknown" /* FailureReason.Unknown */, null, dlq, now);
+        await deleteJobDependencies(tx, ctx, id);
+        await deleteParentFailureValues(tx, ctx, id);
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(job)}, state = 'failed', completed_at = ${now},
+          lease_owner = NULL, lease_broker_id = NULL, lease_broker_session_id = NULL,
+          lease_token = NULL, lease_until = NULL,
+          error = NULL, failure_reason = ${"unknown" /* FailureReason.Unknown */},
+          dlq_entry = ${encodePostgresValue(entry)}, dlq_retry_state = NULL,
+          version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    `;
+        await recordPostgresEvent(tx, ctx, {
+            queue: job.queue,
+            type: 'failed',
+            jobId: id,
+            occurredAt: now,
+            job,
+            state: 'failed',
+            dlqEntry: entry,
+            dlqRetryState: null,
+        });
+        return { queue: job.queue, maxEntries: dlq.maxEntries };
+    });
+    if (!request)
+        return false;
+    await runPostgresPostCommitMaintenance(ctx, `dlq-limit:${request.queue}`, () => enforcePostgresDlqLimit(ctx, request.queue, request.maxEntries));
+    return true;
+}
+/** Permanently remove exactly one failed job from its queue. */
+export async function removePostgresDlqJob(ctx, queue, id) {
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresDestructionCandidates(tx, ctx, [id]);
+        const row = await lockJob(tx, ctx, id);
+        if (!row || row.queue !== queue || row.state !== 'failed')
+            return false;
+        const { protectedIds } = await partitionPostgresDestructionCandidates(tx, ctx, [id], [id]);
+        if (protectedIds.length > 0)
+            return false;
+        const job = decodePostgresJob(row).job;
+        await deleteJobDependencies(tx, ctx, id);
+        await tx `
+      DELETE FROM bunqueue_job_logs
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+    `;
+        await deleteParentFailureValues(tx, ctx, id);
+        await tx `
+      DELETE FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    `;
+        await recordPostgresEvent(tx, ctx, {
+            queue,
+            type: 'removed',
+            jobId: id,
+            occurredAt: await databaseNow(tx),
+            job,
+            state: 'failed',
+            removed: true,
+        });
+        return true;
+    });
+}

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

@@ -0,0 +1,6 @@
+import type { TransactionSQL } from 'bun';
+import type { PostgresContext } from './context';
+/** Retry only PostgreSQL failures that guarantee the current transaction was aborted. */
+export declare function isRetryablePostgresTransactionError(error: unknown): boolean;
+/** Replay the complete callback after rollback-certain contention, never after ambiguous I/O. */
+export declare function runPostgresTransactionWithRetry<T>(ctx: PostgresContext, operation: (tx: TransactionSQL) => Promise<T>): Promise<T>;

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

@@ -0,0 +1,42 @@
+import { storageLog } from '../../../shared/logger';
+const MAX_TRANSACTION_ATTEMPTS = 2;
+const RETRYABLE_SQL_STATES = new Set(['40001', '40P01', '55P03']);
+function sqlState(error) {
+    if (typeof error !== 'object' || error === null)
+        return null;
+    const record = error;
+    for (const field of ['errno', 'sqlState', 'code']) {
+        const value = record[field];
+        if (typeof value === 'string' && /^[0-9A-Z]{5}$/.test(value))
+            return value;
+    }
+    return null;
+}
+/** Retry only PostgreSQL failures that guarantee the current transaction was aborted. */
+export function isRetryablePostgresTransactionError(error) {
+    const state = sqlState(error);
+    return state !== null && RETRYABLE_SQL_STATES.has(state);
+}
+function retryDelayMs(failedAttempt) {
+    const base = 10 * 2 ** (failedAttempt - 1);
+    return base + Math.floor(Math.random() * base);
+}
+/** Replay the complete callback after rollback-certain contention, never after ambiguous I/O. */
+export async function runPostgresTransactionWithRetry(ctx, operation) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await ctx.sql.begin(operation);
+        }
+        catch (error) {
+            if (attempt >= MAX_TRANSACTION_ATTEMPTS || !isRetryablePostgresTransactionError(error)) {
+                throw error;
+            }
+            storageLog.warn('Retrying PostgreSQL transaction after rollback', {
+                failedAttempt: attempt,
+                maxAttempts: MAX_TRANSACTION_ATTEMPTS,
+                sqlState: sqlState(error),
+            });
+            await Bun.sleep(retryDelayMs(attempt));
+        }
+    }
+}

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

@@ -0,0 +1,175 @@
+import type { DlqConfig, DlqEntry, DlqRetryState } from '../../../domain/types/dlq';
+import type { Job, JobId } from '../../../domain/types/job';
+import type { StallConfig } from '../../../domain/types/stall';
+export type PostgresJobState = 'waiting' | 'prioritized' | 'delayed' | 'waiting-children' | 'active' | 'completed' | 'failed';
+export interface PostgresStorageConfig {
+    readonly url: string;
+    readonly namespace?: string;
+    readonly brokerId?: string;
+    readonly poolSize?: number;
+    readonly leaseDurationMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly statementTimeoutMs?: number;
+    readonly lockTimeoutMs?: number;
+    readonly idleTransactionTimeoutMs?: number;
+    readonly maxConcurrentOperations?: number;
+    readonly maxQueuedOperations?: number;
+    readonly maxSnapshotJobs?: number;
+    readonly maxSnapshotPayloadBytes?: number;
+    readonly maxQueueEvents?: number;
+    readonly maxMetricDataPoints?: number;
+    readonly maxCompletedJobs?: number;
+    readonly maxJobResults?: number;
+}
+export interface ResolvedPostgresStorageConfig {
+    readonly url: string;
+    readonly namespace: string;
+    readonly brokerId: string;
+    readonly brokerSessionId: string;
+    readonly poolSize: number;
+    readonly leaseDurationMs: number;
+    readonly pollIntervalMs: number;
+    readonly statementTimeoutMs: number;
+    readonly lockTimeoutMs: number;
+    readonly idleTransactionTimeoutMs: number;
+    readonly maxConcurrentOperations: number;
+    readonly maxQueuedOperations: number;
+    readonly maxSnapshotJobs: number;
+    readonly maxSnapshotPayloadBytes: number;
+    readonly maxQueueEvents: number;
+    readonly maxMetricDataPoints: number;
+    readonly maxCompletedJobs: number;
+    readonly maxJobResults: number;
+}
+export interface PostgresJobRow {
+    namespace: string;
+    id: string;
+    queue: string;
+    payload: Uint8Array;
+    state: PostgresJobState;
+    priority: number;
+    lifo: boolean;
+    run_at: number | string | bigint;
+    created_at: number | string | bigint;
+    started_at: number | string | bigint | null;
+    completed_at: number | string | bigint | null;
+    attempts: number;
+    max_attempts: number;
+    ttl: number | string | bigint | null;
+    timeout: number | string | bigint | null;
+    unique_key: string | null;
+    unique_expires_at: number | string | bigint | null;
+    custom_id: string | null;
+    group_id: string | null;
+    parent_id: string | null;
+    lease_owner: string | null;
+    lease_broker_id: string | null;
+    lease_broker_session_id: string | null;
+    lease_token: string | null;
+    lease_until: number | string | bigint | null;
+    lease_renewals: number;
+    result: Uint8Array | null;
+    dlq_entry: Uint8Array | null;
+    dlq_retry_state: Uint8Array | null;
+    error: string | null;
+    failure_reason: string | null;
+    version: number | string | bigint;
+}
+export interface ClaimedPostgresJob {
+    readonly job: Job;
+    readonly token: string;
+    readonly owner: string;
+    readonly brokerId: string;
+    readonly leaseUntil: number;
+}
+export interface PostgresStoredJob {
+    readonly job: Job;
+    readonly state: PostgresJobState;
+    readonly result: unknown;
+    readonly error: string | null;
+    readonly dlqEntry: DlqEntry | null;
+    readonly dlqRetryState: DlqRetryState | null;
+    readonly token: string | null;
+    readonly leaseOwner: string | null;
+    readonly leaseBrokerId: string | null;
+    readonly leaseUntil: number | null;
+    readonly leaseRenewals: number;
+    readonly version: number;
+}
+export interface PostgresCompletionResult {
+    readonly jobId: JobId;
+    readonly queue: string;
+    readonly result: unknown;
+    readonly pinned: boolean;
+}
+export interface PostgresQueueState {
+    readonly queue: string;
+    readonly paused: boolean;
+    readonly rateLimit: number | null;
+    readonly rateDurationMs: number | null;
+    readonly rateWindowStartedAt: number | null;
+    readonly rateExpiresAt: number | null;
+    readonly rateCount: number;
+    readonly concurrencyLimit: number | null;
+    readonly stallConfig: StallConfig;
+    readonly dlqConfig: DlqConfig;
+}
+export interface PostgresCounts {
+    readonly waiting: number;
+    readonly active: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly delayed: number;
+    readonly prioritized: number;
+    readonly waitingChildren: number;
+}
+export interface PostgresTransitionResult {
+    readonly applied: boolean;
+    readonly alreadyFinalized: boolean;
+    readonly job: Job | null;
+    readonly state: PostgresJobState | null;
+}
+export interface PostgresCompletionInput {
+    readonly id: JobId;
+    readonly token: string;
+    readonly result?: unknown;
+    readonly removeOnComplete?: boolean;
+}
+export interface PostgresBatchCompletionResult extends PostgresTransitionResult {
+    readonly removed: boolean;
+}
+export interface PostgresFailureInput {
+    readonly id: JobId;
+    readonly token: string;
+    readonly error?: string;
+    readonly stack?: string[];
+    readonly unrecoverable?: boolean;
+    readonly removeOnFail?: boolean;
+    readonly failureReason?: string;
+}
+export interface PostgresStoreEvent {
+    readonly id: number;
+    readonly queue: string;
+    readonly type: string;
+    readonly jobId: JobId;
+    readonly occurredAt: number;
+    readonly job: Job | null;
+    readonly state: PostgresJobState | null;
+    readonly result?: unknown;
+    readonly error?: string;
+    readonly removed?: boolean;
+    readonly dlqEntry?: DlqEntry | null;
+    readonly dlqRetryState?: DlqRetryState | null;
+}
+/** Event delivered from the durable journal after its transaction commit is sequenced. */
+export interface PostgresDeliveredStoreEvent extends PostgresStoreEvent {
+    readonly commitSeq: number;
+}
+export interface PostgresStorageHealth {
+    readonly ok: boolean;
+    readonly error: string | null;
+    readonly since: number | null;
+    readonly backend: 'postgres';
+    readonly brokerId: string;
+    readonly namespace: string;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+import type { SQL, TransactionSQL } from 'bun';
+import type { Worker } from '../../../domain/types/worker';
+import type { PostgresContext } from './context';
+export declare function savePostgresWorker(ctx: PostgresContext, worker: Worker): Promise<void>;
+export declare function removePostgresWorker(ctx: PostgresContext, id: string, clientId?: string): Promise<boolean>;
+export declare function heartbeatPostgresWorker(ctx: PostgresContext, id: string, stats?: {
+    activeJobs?: number;
+    processed?: number;
+    failed?: number;
+}, clientId?: string): Promise<boolean>;
+export declare function removePostgresClientWorkers(ctx: PostgresContext, clientId: string): Promise<number>;
+export declare function removePostgresBrokerWorkers(ctx: PostgresContext): Promise<number>;
+export declare function listPostgresWorkers(ctx: PostgresContext): Promise<Worker[]>;
+export declare function hasActivePostgresWorker(sql: SQL | TransactionSQL, ctx: PostgresContext, queue: string, now: number, timeoutMs?: number): Promise<boolean>;
+export declare function purgeStalePostgresWorkers(ctx: PostgresContext, requestedNow?: number, staleMs?: number): Promise<number>;