bunqueue 2.8.60 → 2.9.0

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

@@ -0,0 +1,120 @@
+import { jobId } from '../../../domain/types/job';
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+import { lockPostgresDestructionIdentities, partitionPostgresDestructionCandidates, } from './dependencyDestruction';
+import { lockPostgresBrokerSession } from './brokerSessions';
+function isProtectedCron(row) {
+    return decodePostgresJob(row).job.uniqueKey?.startsWith('cron:') === true;
+}
+export async function discardPostgresProtectedCronLease(tx, ctx, row, now) {
+    if (!isProtectedCron(row))
+        return false;
+    const id = jobId(row.id);
+    const { protectedIds } = await partitionPostgresDestructionCandidates(tx, ctx, [id], [id]);
+    if (protectedIds.length > 0)
+        return false;
+    const job = decodePostgresJob(row).job;
+    await tx `
+    DELETE FROM bunqueue_job_logs
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${row.id}
+  `;
+    await tx `
+    DELETE FROM bunqueue_flow_failures
+    WHERE namespace = ${ctx.config.namespace} AND parent_id = ${row.id}
+  `;
+    await tx `
+    DELETE FROM bunqueue_dependencies
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${row.id}
+  `;
+    await tx `
+    DELETE FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${row.id}
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: 'removed',
+        jobId: job.id,
+        occurredAt: now,
+        job,
+        state: 'active',
+        removed: true,
+    });
+    return true;
+}
+async function releaseLeaseRow(tx, ctx, row, now) {
+    if (await discardPostgresProtectedCronLease(tx, ctx, row, now))
+        return;
+    const job = decodePostgresJob(row).job;
+    job.startedAt = null;
+    job.runAt = Math.min(job.runAt, now);
+    const state = job.priority > 0 ? 'prioritized' : 'waiting';
+    await tx `
+    UPDATE bunqueue_jobs
+    SET payload = ${encodePostgresValue(job)}, state = ${state}, run_at = ${job.runAt},
+        started_at = NULL, lease_owner = NULL, lease_token = NULL, lease_until = NULL,
+        lease_broker_id = NULL, lease_broker_session_id = NULL,
+        lease_renewals = 0, version = version + 1
+    WHERE namespace = ${ctx.config.namespace} AND id = ${row.id}
+  `;
+    await recordPostgresEvent(tx, ctx, {
+        queue: job.queue,
+        type: 'retried',
+        jobId: job.id,
+        occurredAt: now,
+        job,
+        state,
+    });
+}
+/** Release a never-renewed connection lease without racing pooled heartbeats. */
+export async function releasePostgresClientLease(ctx, id, token) {
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresBrokerSession(tx, ctx);
+        await lockPostgresDestructionIdentities(tx, ctx, [id]);
+        const now = await databaseNow(tx);
+        const rows = await tx `
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+      FOR UPDATE
+    `;
+        const row = rows[0];
+        if (row?.state !== 'active' ||
+            row.lease_token !== token ||
+            Number(row.lease_until ?? 0) <= now ||
+            row.lease_renewals > 0) {
+            return false;
+        }
+        await releaseLeaseRow(tx, ctx, row, now);
+        return true;
+    });
+}
+/** Return or discard every active lease currently coordinated by this broker. */
+export async function releasePostgresBrokerLeases(ctx) {
+    return await ctx.sql.begin(async (tx) => {
+        const now = await databaseNow(tx);
+        const candidates = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND state = 'active'
+        AND lease_broker_id = ${ctx.config.brokerId}
+        AND lease_broker_session_id = ${ctx.config.brokerSessionId}
+      ORDER BY id
+    `;
+        const ids = candidates.map((row) => jobId(row.id));
+        if (ids.length === 0)
+            return 0;
+        await lockPostgresDestructionIdentities(tx, ctx, ids);
+        const rows = await tx `
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND state = 'active'
+        AND lease_broker_id = ${ctx.config.brokerId}
+        AND lease_broker_session_id = ${ctx.config.brokerSessionId}
+        AND id = ANY(${tx.array(ids.map(String), 'TEXT')})
+      ORDER BY id
+      FOR UPDATE
+    `;
+        for (const row of rows)
+            await releaseLeaseRow(tx, ctx, row, now);
+        return rows.length;
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+/** Renew one fenced lease and transfer its broker responsibility atomically. */
+export declare function renewPostgresLease(ctx: PostgresContext, id: JobId, token: string, durationMs: number): Promise<number | null>;

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

@@ -0,0 +1,35 @@
+import { decodePostgresJob, encodePostgresValue } from './codec';
+import { databaseNow } from './context';
+import { lockPostgresBrokerSession } from './brokerSessions';
+/** Renew one fenced lease and transfer its broker responsibility atomically. */
+export async function renewPostgresLease(ctx, id, token, durationMs) {
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresBrokerSession(tx, ctx);
+        const now = await databaseNow(tx);
+        const rows = await tx `
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+        AND state = 'active' AND lease_token = ${token} AND lease_until > ${now}
+      FOR UPDATE
+    `;
+        const row = rows[0];
+        if (!row)
+            return null;
+        const job = decodePostgresJob(row).job;
+        job.lastHeartbeat = now;
+        const requestedLeaseUntil = now + Math.max(1, durationMs);
+        const leaseUntil = row.timeout === null
+            ? requestedLeaseUntil
+            : Math.min(requestedLeaseUntil, Number(row.started_at ?? now) + Number(row.timeout));
+        await tx `
+      UPDATE bunqueue_jobs
+      SET payload = ${encodePostgresValue(job)}, lease_until = ${leaseUntil},
+          lease_broker_id = ${ctx.config.brokerId},
+          lease_broker_session_id = ${ctx.config.brokerSessionId},
+          lease_renewals = lease_renewals + 1,
+          version = version + 1
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+    `;
+        return leaseUntil;
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { PostgresContext, PostgresReadSql } from './context';
+export interface PostgresQueueLifetimeTotals {
+    readonly queue: string;
+    readonly totalCompleted: bigint;
+    readonly totalFailed: bigint;
+}
+export interface PostgresLifetimeMetricsSnapshot {
+    readonly baselineEventId: number;
+    readonly baselineCommitSeq: number;
+    readonly totalCompleted: bigint;
+    readonly totalFailed: bigint;
+    readonly queues: readonly PostgresQueueLifetimeTotals[];
+}
+/** Load terminal lifetime counters and their matching event boundary atomically. */
+export declare function loadPostgresLifetimeMetrics(ctx: PostgresContext, sql?: PostgresReadSql): Promise<PostgresLifetimeMetricsSnapshot>;

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

@@ -0,0 +1,46 @@
+/** Load terminal lifetime counters and their matching event boundary atomically. */
+export async function loadPostgresLifetimeMetrics(ctx, sql) {
+    const load = async (readSql) => {
+        const [[baseline], rows] = await Promise.all([
+            readSql `
+        SELECT
+          (SELECT MAX(id) FROM bunqueue_events
+           WHERE namespace = ${ctx.config.namespace}) AS event_id,
+          (SELECT MAX(commit_seq) FROM bunqueue_event_commits
+           WHERE namespace = ${ctx.config.namespace}) AS commit_seq
+      `,
+            readSql `
+        SELECT queue, metric_type, total_count
+        FROM bunqueue_metric_totals
+        WHERE namespace = ${ctx.config.namespace}
+        ORDER BY queue, metric_type
+      `,
+        ]);
+        const queues = new Map();
+        let totalCompleted = 0n;
+        let totalFailed = 0n;
+        for (const row of rows) {
+            const count = BigInt(row.total_count);
+            const totals = queues.get(row.queue) ?? { totalCompleted: 0n, totalFailed: 0n };
+            if (row.metric_type === 'completed') {
+                totals.totalCompleted = count;
+                totalCompleted += count;
+            }
+            else {
+                totals.totalFailed = count;
+                totalFailed += count;
+            }
+            queues.set(row.queue, totals);
+        }
+        return {
+            baselineEventId: Number(baseline.event_id ?? 0),
+            baselineCommitSeq: Number(baseline.commit_seq ?? 0),
+            totalCompleted,
+            totalFailed,
+            queues: [...queues].map(([queue, totals]) => ({ queue, ...totals })),
+        };
+    };
+    if (sql)
+        return await load(sql);
+    return await ctx.sql.begin('isolation level repeatable read read only', load);
+}

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

@@ -0,0 +1,4 @@
+import type { PostgresContext } from './context';
+import { type PostgresLifetimeMetricsSnapshot } from './lifetimeMetrics';
+/** Fence terminal counters against the same commit sequencer used by journal writers. */
+export declare function finalizePostgresLifetimeMetrics(ctx: PostgresContext, apply: (snapshot: PostgresLifetimeMetricsSnapshot) => void): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { postgresAdvisoryLockName } from './advisoryLocks';
+import { loadPostgresLifetimeMetrics, } from './lifetimeMetrics';
+/** Fence terminal counters against the same commit sequencer used by journal writers. */
+export async function finalizePostgresLifetimeMetrics(ctx, apply) {
+    const lockName = postgresAdvisoryLockName('event-commit', ctx.config.namespace);
+    await ctx.sql.begin(async (tx) => {
+        await tx `
+      SELECT pg_advisory_xact_lock(hashtextextended(${lockName}, 0))
+    `;
+        const snapshot = await loadPostgresLifetimeMetrics(ctx, tx);
+        apply(snapshot);
+    });
+}

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

@@ -0,0 +1,6 @@
+import type { JobId } from '../../../domain/types/job';
+import type { JobLogEntry } from '../../../domain/types/worker';
+import { type PostgresContext } from './context';
+export declare function addPostgresJobLog(ctx: PostgresContext, id: JobId, message: string, level: JobLogEntry['level'], maxLogs?: number): Promise<boolean>;
+export declare function getPostgresJobLogs(ctx: PostgresContext, id: JobId): Promise<JobLogEntry[]>;
+export declare function clearPostgresJobLogs(ctx: PostgresContext, id: JobId, keepLogs?: number): Promise<void>;

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

@@ -0,0 +1,70 @@
+import { databaseNow } from './context';
+export async function addPostgresJobLog(ctx, id, message, level, maxLogs = 100) {
+    return await ctx.sql.begin(async (tx) => {
+        const jobs = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+      FOR UPDATE
+    `;
+        if (!jobs[0])
+            return false;
+        const now = await databaseNow(tx);
+        const rows = await tx `
+      INSERT INTO bunqueue_job_logs (namespace, job_id, timestamp, level, message)
+      VALUES (${ctx.config.namespace}, ${String(id)}, ${now}, ${level}, ${message})
+      RETURNING id
+    `;
+        if (!rows[0])
+            return false;
+        await tx `
+      DELETE FROM bunqueue_job_logs
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+        AND id NOT IN (
+          SELECT id FROM bunqueue_job_logs
+          WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+          ORDER BY id DESC
+          LIMIT ${Math.max(1, maxLogs)}
+        )
+    `;
+        return true;
+    });
+}
+export async function getPostgresJobLogs(ctx, id) {
+    const rows = await ctx.sql `
+    SELECT timestamp, level, message
+    FROM bunqueue_job_logs
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+    ORDER BY id
+  `;
+    return rows.map((row) => ({
+        timestamp: Number(row.timestamp),
+        level: row.level,
+        message: row.message,
+    }));
+}
+export async function clearPostgresJobLogs(ctx, id, keepLogs) {
+    await ctx.sql.begin(async (tx) => {
+        await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+      FOR UPDATE
+    `;
+        if (keepLogs === undefined || keepLogs <= 0) {
+            await tx `
+        DELETE FROM bunqueue_job_logs
+        WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+      `;
+            return;
+        }
+        await tx `
+      DELETE FROM bunqueue_job_logs
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+        AND id NOT IN (
+          SELECT id FROM bunqueue_job_logs
+          WHERE namespace = ${ctx.config.namespace} AND job_id = ${String(id)}
+          ORDER BY id DESC
+          LIMIT ${Math.floor(keepLogs)}
+        )
+    `;
+    });
+}

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

@@ -0,0 +1,6 @@
+import { type JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+/** Remove old jobs with the same state grouping used by Queue.clean(). */
+export declare function cleanPostgresQueue(ctx: PostgresContext, queue: string, graceMs: number, state?: string, limit?: number): Promise<JobId[]>;
+/** Permanently remove every failed job currently visible in one queue. */
+export declare function purgePostgresDlq(ctx: PostgresContext, queue: string): Promise<JobId[]>;

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

@@ -0,0 +1,138 @@
+import { jobId } from '../../../domain/types/job';
+import { decodePostgresJob } from './codec';
+import { databaseNow, recordPostgresEvent } from './context';
+import { lockPostgresDestructionCandidates, partitionPostgresDestructionCandidates, } from './dependencyDestruction';
+async function prepareDeletableRows(tx, ctx, candidateIds, load) {
+    if (candidateIds.length === 0)
+        return [];
+    await lockPostgresDestructionCandidates(tx, ctx, candidateIds);
+    const rows = await load(candidateIds);
+    const plannedIds = rows.map((row) => jobId(row.id));
+    const { deletableIds } = await partitionPostgresDestructionCandidates(tx, ctx, plannedIds, plannedIds);
+    const deletable = new Set(deletableIds.map(String));
+    return rows.filter((row) => deletable.has(row.id));
+}
+async function deleteRows(tx, ctx, rows) {
+    if (rows.length === 0)
+        return [];
+    const ids = rows.map((row) => row.id);
+    await tx `
+    DELETE FROM bunqueue_job_logs
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${tx.array(ids, 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_flow_failures
+    WHERE namespace = ${ctx.config.namespace}
+      AND parent_id = ANY(${tx.array(ids, 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_dependencies
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${tx.array(ids, 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_completions
+    WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${tx.array(ids, 'TEXT')})
+  `;
+    await tx `
+    DELETE FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ANY(${tx.array(ids, 'TEXT')})
+  `;
+    const now = await databaseNow(tx);
+    for (const row of rows) {
+        const job = decodePostgresJob(row).job;
+        await recordPostgresEvent(tx, ctx, {
+            queue: job.queue,
+            type: 'removed',
+            jobId: job.id,
+            occurredAt: now,
+            job,
+            state: row.state,
+            removed: true,
+        });
+    }
+    return ids.map(jobId);
+}
+/** Remove old jobs with the same state grouping used by Queue.clean(). */
+export async function cleanPostgresQueue(ctx, queue, graceMs, state, limit = 1000) {
+    const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 0;
+    if (cap === 0 || state === 'active')
+        return [];
+    return await ctx.sql.begin(async (tx) => {
+        const threshold = (await databaseNow(tx)) - graceMs;
+        let rows;
+        if (state === 'completed') {
+            const candidates = await tx `
+        SELECT id FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+          AND state = 'completed' AND COALESCE(completed_at, created_at) <= ${threshold}
+        ORDER BY COALESCE(completed_at, created_at), id
+        LIMIT ${cap}
+      `;
+            rows = await prepareDeletableRows(tx, ctx, candidates.map((row) => jobId(row.id)), (ids) => tx `
+            SELECT * FROM bunqueue_jobs
+            WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+              AND state = 'completed' AND COALESCE(completed_at, created_at) <= ${threshold}
+              AND id = ANY(${tx.array(ids.map(String), 'TEXT')})
+            ORDER BY COALESCE(completed_at, created_at), id
+          `);
+        }
+        else if (state === 'failed') {
+            const candidates = await tx `
+        SELECT id FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+          AND state = 'failed' AND COALESCE(completed_at, created_at) <= ${threshold}
+        ORDER BY COALESCE(completed_at, created_at), id
+        LIMIT ${cap}
+      `;
+            rows = await prepareDeletableRows(tx, ctx, candidates.map((row) => jobId(row.id)), (ids) => tx `
+            SELECT * FROM bunqueue_jobs
+            WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+              AND state = 'failed' AND COALESCE(completed_at, created_at) <= ${threshold}
+              AND id = ANY(${tx.array(ids.map(String), 'TEXT')})
+            ORDER BY COALESCE(completed_at, created_at), id
+          `);
+        }
+        else if (state === undefined ||
+            state === 'wait' ||
+            state === 'waiting' ||
+            state === 'delayed' ||
+            state === 'prioritized' ||
+            state === 'paused') {
+            const candidates = await tx `
+        SELECT id FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+          AND state IN ('waiting', 'prioritized', 'delayed') AND created_at <= ${threshold}
+        ORDER BY created_at, id
+        LIMIT ${cap}
+      `;
+            rows = await prepareDeletableRows(tx, ctx, candidates.map((row) => jobId(row.id)), (ids) => tx `
+            SELECT * FROM bunqueue_jobs
+            WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+              AND state IN ('waiting', 'prioritized', 'delayed') AND created_at <= ${threshold}
+              AND id = ANY(${tx.array(ids.map(String), 'TEXT')})
+            ORDER BY created_at, id
+          `);
+        }
+        else {
+            return [];
+        }
+        return await deleteRows(tx, ctx, rows);
+    });
+}
+/** Permanently remove every failed job currently visible in one queue. */
+export async function purgePostgresDlq(ctx, queue) {
+    return await ctx.sql.begin(async (tx) => {
+        const candidates = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND state = 'failed'
+      ORDER BY completed_at, id
+    `;
+        const rows = await prepareDeletableRows(tx, ctx, candidates.map((row) => jobId(row.id)), (ids) => tx `
+          SELECT * FROM bunqueue_jobs
+          WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND state = 'failed'
+            AND id = ANY(${tx.array(ids.map(String), 'TEXT')})
+          ORDER BY completed_at, id
+        `);
+        return await deleteRows(tx, ctx, rows);
+    });
+}

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

@@ -0,0 +1,14 @@
+type MaintenanceReporter = (subsystem: string, error: unknown) => void;
+/** Serialize maintenance per subsystem and drain every admitted execution on close. */
+export declare class PostgresMaintenanceFlights {
+    private readonly report;
+    private readonly flights;
+    private accepting;
+    constructor(report: MaintenanceReporter);
+    run(subsystem: string, operation: () => Promise<unknown>): Promise<void>;
+    close(): void;
+    drain(): Promise<void>;
+    private replacePending;
+    private runLoop;
+}
+export {};

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

@@ -0,0 +1,66 @@
+/** Serialize maintenance per subsystem and drain every admitted execution on close. */
+export class PostgresMaintenanceFlights {
+    report;
+    flights = new Map();
+    accepting = true;
+    constructor(report) {
+        this.report = report;
+    }
+    run(subsystem, operation) {
+        if (!this.accepting)
+            return Promise.resolve();
+        const existing = this.flights.get(subsystem);
+        if (existing)
+            return this.replacePending(existing, operation);
+        let resolve;
+        const result = new Promise((accept) => {
+            resolve = accept;
+        });
+        const first = { operation, waiters: [resolve] };
+        const flight = {};
+        flight.pending = first;
+        flight.loop = this.runLoop(subsystem, flight);
+        this.flights.set(subsystem, flight);
+        return result;
+    }
+    close() {
+        this.accepting = false;
+    }
+    async drain() {
+        await Promise.all([...this.flights.values()].map(({ loop }) => loop));
+    }
+    replacePending(flight, operation) {
+        let resolve;
+        const result = new Promise((accept) => {
+            resolve = accept;
+        });
+        if (flight.pending) {
+            flight.pending.operation = operation;
+            flight.pending.waiters.push(resolve);
+        }
+        else {
+            flight.pending = { operation, waiters: [resolve] };
+        }
+        return result;
+    }
+    async runLoop(subsystem, flight) {
+        while (flight.pending) {
+            const current = flight.pending;
+            flight.pending = null;
+            try {
+                await current.operation();
+                this.report(subsystem, null);
+            }
+            catch (error) {
+                this.report(subsystem, error);
+            }
+            finally {
+                for (const resolve of current.waiters)
+                    resolve();
+            }
+            await Promise.resolve();
+        }
+        if (this.flights.get(subsystem) === flight)
+            this.flights.delete(subsystem);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { TransactionSQL } from 'bun';
+import type { QueueMetricType } from '../../../domain/types/metrics';
+import type { PostgresContext } from './context';
+export interface PostgresMetricAddition {
+    readonly queue: string;
+    readonly count: number;
+}
+/** Update exact durable metrics while minimizing time spent holding shared hot rows. */
+export declare function recordPostgresMetricAdditions(tx: TransactionSQL, ctx: PostgresContext, type: QueueMetricType, inputs: readonly PostgresMetricAddition[], now: number): Promise<void>;

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

@@ -0,0 +1,94 @@
+function normalizeAdditions(inputs) {
+    const counts = new Map();
+    for (const input of inputs) {
+        if (input.count <= 0)
+            continue;
+        counts.set(input.queue, (counts.get(input.queue) ?? 0) + input.count);
+    }
+    return [...counts]
+        .map(([queue, count]) => ({ queue, count }))
+        .sort((left, right) => left.queue.localeCompare(right.queue));
+}
+async function pruneMetricBuckets(tx, ctx, queues, type, minute) {
+    const metricLimit = ctx.config.maxMetricDataPoints;
+    await tx `
+    DELETE FROM bunqueue_metric_buckets
+    WHERE namespace = ${ctx.config.namespace}
+      AND queue = ANY(${tx.array([...queues], 'TEXT')})
+      AND metric_type = ${type}
+      ${metricLimit === 0 ? tx `` : tx `AND minute < ${minute - metricLimit + 1}`}
+  `;
+}
+async function updateTotalsWithoutBuckets(tx, ctx, type, additions, now) {
+    await tx `
+    INSERT INTO bunqueue_metric_totals
+      (namespace, queue, metric_type, total_count, prev_ts, prev_count)
+    SELECT ${ctx.config.namespace}, batch.queue, ${type}, batch.addition, ${now},
+           batch.addition
+    FROM unnest(
+      ${tx.array(additions.map(({ queue }) => queue), 'TEXT')},
+      ${tx.array(additions.map(({ count }) => count), 'INTEGER')}
+    ) AS batch(queue, addition)
+    ORDER BY batch.queue
+    ON CONFLICT (namespace, queue, metric_type) DO UPDATE SET
+      total_count = bunqueue_metric_totals.total_count + excluded.total_count,
+      prev_ts = GREATEST(bunqueue_metric_totals.prev_ts, excluded.prev_ts),
+      prev_count = CASE
+        WHEN excluded.prev_ts / 60000 > bunqueue_metric_totals.prev_ts / 60000
+          THEN excluded.prev_count
+        WHEN excluded.prev_ts / 60000 = bunqueue_metric_totals.prev_ts / 60000
+          THEN bunqueue_metric_totals.prev_count + excluded.prev_count
+        ELSE bunqueue_metric_totals.prev_count
+      END
+  `;
+}
+async function updateBucketsAndTotals(tx, ctx, type, additions, now) {
+    const minute = Math.floor(now / 60_000);
+    await tx `
+    WITH incoming AS MATERIALIZED (
+      SELECT batch.queue, batch.addition
+      FROM unnest(
+        ${tx.array(additions.map(({ queue }) => queue), 'TEXT')},
+        ${tx.array(additions.map(({ count }) => count), 'INTEGER')}
+      ) AS batch(queue, addition)
+      ORDER BY batch.queue
+    ), buckets AS (
+      INSERT INTO bunqueue_metric_buckets
+        (namespace, queue, metric_type, minute, count)
+      SELECT ${ctx.config.namespace}, incoming.queue, ${type}, ${minute}, incoming.addition
+      FROM incoming
+      ORDER BY incoming.queue
+      ON CONFLICT (namespace, queue, metric_type, minute)
+      DO UPDATE SET count = bunqueue_metric_buckets.count + excluded.count
+      RETURNING queue, count
+    )
+    INSERT INTO bunqueue_metric_totals
+      (namespace, queue, metric_type, total_count, prev_ts, prev_count)
+    SELECT ${ctx.config.namespace}, incoming.queue, ${type}, incoming.addition, ${now},
+           buckets.count
+    FROM incoming
+    JOIN buckets USING (queue)
+    ORDER BY incoming.queue
+    ON CONFLICT (namespace, queue, metric_type) DO UPDATE SET
+      total_count = bunqueue_metric_totals.total_count + excluded.total_count,
+      prev_ts = GREATEST(bunqueue_metric_totals.prev_ts, excluded.prev_ts),
+      prev_count = CASE
+        WHEN excluded.prev_ts / 60000 >= bunqueue_metric_totals.prev_ts / 60000
+          THEN excluded.prev_count
+        ELSE bunqueue_metric_totals.prev_count
+      END
+  `;
+}
+/** Update exact durable metrics while minimizing time spent holding shared hot rows. */
+export async function recordPostgresMetricAdditions(tx, ctx, type, inputs, now) {
+    const additions = normalizeAdditions(inputs);
+    if (additions.length === 0)
+        return;
+    const minute = Math.floor(now / 60_000);
+    await pruneMetricBuckets(tx, ctx, additions.map(({ queue }) => queue), type, minute);
+    if (ctx.config.maxMetricDataPoints === 0) {
+        await updateTotalsWithoutBuckets(tx, ctx, type, additions, now);
+        return;
+    }
+    await updateBucketsAndTotals(tx, ctx, type, additions, now);
+}

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

@@ -0,0 +1,9 @@
+import { type JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+export declare function updatePostgresJobData(ctx: PostgresContext, id: JobId, data: unknown): Promise<boolean>;
+export declare function updatePostgresProgress(ctx: PostgresContext, id: JobId, progress: number, message?: string): Promise<boolean>;
+export declare function changePostgresPriority(ctx: PostgresContext, id: JobId, priority: number, lifo?: boolean): Promise<boolean>;
+export declare function changePostgresDelay(ctx: PostgresContext, id: JobId, runAt: number, token?: string): Promise<boolean>;
+export declare function promotePostgresJob(ctx: PostgresContext, id: JobId): Promise<boolean>;
+export declare function movePostgresJobToWaitingChildren(ctx: PostgresContext, id: JobId, token?: string): Promise<boolean>;
+export declare function clearPostgresJobUniqueKey(ctx: PostgresContext, id: JobId): Promise<boolean>;