bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/persistence/sqlite/queries.js

@@ -0,0 +1,89 @@
+import { rowToJob } from '../sqliteSerializer';
+import { SqliteRecords } from './records';
+/** Persisted and logical-state job queries used by recovery and public pagination. */
+export class SqliteQueries extends SqliteRecords {
+    queryJobs(queue, options) {
+        const order = options.asc ? 'ASC' : 'DESC';
+        let rows;
+        if (options.states && options.states.length > 0) {
+            const placeholders = options.states.map(() => '?').join(',');
+            rows = this.db
+                .query(`SELECT * FROM jobs WHERE queue = ? AND state IN (${placeholders}) ORDER BY created_at ${order}, id ${order} LIMIT ? OFFSET ?`)
+                .all(queue, ...options.states, options.limit, options.offset);
+        }
+        else if (options.state) {
+            rows = this.db
+                .query(`SELECT * FROM jobs WHERE queue = ? AND state = ? ORDER BY created_at ${order}, id ${order} LIMIT ? OFFSET ?`)
+                .all(queue, options.state, options.limit, options.offset);
+        }
+        else {
+            rows = this.db
+                .query(`SELECT * FROM jobs WHERE queue = ? ORDER BY created_at ${order}, id ${order} LIMIT ? OFFSET ?`)
+                .all(queue, options.limit, options.offset);
+        }
+        return rows.map((row) => rowToJob(row));
+    }
+    queryJobsByLogicalStates(queue, states, options) {
+        const uniqueStates = Array.from(new Set(states));
+        if (uniqueStates.length === 0)
+            return [];
+        const predicates = [];
+        const predicateParams = [];
+        const requested = new Set(uniqueStates);
+        if (requested.has('waiting')) {
+            predicates.push("(state IN ('waiting', 'prioritized', 'delayed') AND run_at <= ? AND priority <= 0)");
+            predicateParams.push(options.now);
+        }
+        if (requested.has('prioritized')) {
+            predicates.push("(state IN ('waiting', 'prioritized', 'delayed') AND run_at <= ? AND priority > 0)");
+            predicateParams.push(options.now);
+        }
+        if (requested.has('delayed')) {
+            predicates.push("(state IN ('waiting', 'prioritized', 'delayed') AND run_at > ?)");
+            predicateParams.push(options.now);
+        }
+        const persistedStates = uniqueStates.filter((state) => state !== 'waiting' && state !== 'prioritized' && state !== 'delayed');
+        if (persistedStates.length > 0) {
+            predicates.push(`state IN (${persistedStates.map(() => '?').join(',')})`);
+            predicateParams.push(...persistedStates);
+        }
+        const order = options.asc ? 'ASC' : 'DESC';
+        const rows = this.db
+            .query(`SELECT * FROM jobs INDEXED BY idx_jobs_queue_created
+         WHERE queue = ? AND (${predicates.join(' OR ')})
+         ORDER BY created_at ${order}, id ${order}
+         LIMIT ? OFFSET ?`)
+            .all(queue, ...predicateParams, options.limit, options.offset);
+        return rows.map((row) => rowToJob(row));
+    }
+    loadPendingJobs(limit = 10000, offset = 0) {
+        const rows = this.db
+            .query("SELECT * FROM jobs WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed') ORDER BY priority DESC, run_at ASC, id ASC LIMIT ? OFFSET ?")
+            .all(limit, offset);
+        return rows.map((row) => rowToJob(row));
+    }
+    loadActiveJobs(limit = 10000, offset = 0) {
+        const rows = this.db
+            .query("SELECT * FROM jobs WHERE state = 'active' ORDER BY started_at ASC LIMIT ? OFFSET ?")
+            .all(limit, offset);
+        return rows.map((row) => rowToJob(row));
+    }
+    loadCompletedJobs(limit = 10000, offset = 0) {
+        const rows = this.db
+            .query("SELECT * FROM jobs WHERE state = 'completed' ORDER BY completed_at DESC LIMIT ? OFFSET ?")
+            .all(limit, offset);
+        return rows.map((row) => rowToJob(row));
+    }
+    countPendingJobs() {
+        const result = this.db
+            .query("SELECT COUNT(*) as count FROM jobs WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed')")
+            .get();
+        return result?.count ?? 0;
+    }
+    countActiveJobs() {
+        const result = this.db
+            .query("SELECT COUNT(*) as count FROM jobs WHERE state = 'active'")
+            .get();
+        return result?.count ?? 0;
+    }
+}

package/dist/infrastructure/persistence/sqlite/records.d.ts

@@ -0,0 +1,24 @@
+import type { DlqEntry } from '../../../domain/types/dlq';
+import type { Job, JobId } from '../../../domain/types/job';
+import type { DependencyCompletionRecord } from '../dependencyCompletionStore';
+import { SqliteFlows } from './flows';
+/** Direct job/result lookup and payload-free dependency completion records. */
+export declare abstract class SqliteRecords extends SqliteFlows {
+    getJob(id: JobId): Job | null;
+    storeResult(jobId: JobId, result: unknown): void;
+    getResult(jobId: JobId): unknown;
+    hasResult(jobId: JobId): boolean;
+    hasDlqEntry(jobId: JobId): boolean;
+    getDlqEntry(jobId: JobId): DlqEntry | null;
+    loadDlqJobIds(): Set<JobId>;
+    getJobStateRaw(jobId: JobId): string | null;
+    loadCompletedJobIds(): Set<JobId>;
+    commitRemovedCompletion(job: Pick<Job, 'id' | 'queue'>, retentionLimit: number, pinned: boolean, completedAt?: number): void;
+    loadDependencyCompletions(): DependencyCompletionRecord[];
+    pinDependencyCompletions(jobIds: Iterable<JobId>): void;
+    unpinDependencyCompletions(jobIds: Iterable<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    reconcileDependencyCompletionPins(referenced: ReadonlySet<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    deleteDependencyCompletion(jobId: JobId): boolean;
+    deleteDependencyCompletionsForQueue(queue: string): JobId[];
+    insertJobsBatch(jobs: Job[], durable?: boolean): void;
+}

package/dist/infrastructure/persistence/sqlite/records.js

@@ -0,0 +1,115 @@
+import { pack, reconstructDlqEntry, rowToJob, unpack } from '../sqliteSerializer';
+import { SqliteFlows } from './flows';
+/** Direct job/result lookup and payload-free dependency completion records. */
+export class SqliteRecords extends SqliteFlows {
+    getJob(id) {
+        const row = this.statements.get('getJob').get(id);
+        return row ? rowToJob(row) : null;
+    }
+    storeResult(jobId, result) {
+        this.safeWrite(() => {
+            this.statements.get('insertResult').run(jobId, pack(result), Date.now());
+        });
+    }
+    getResult(jobId) {
+        const row = this.statements.get('getResult').get(jobId);
+        return row ? unpack(row.result, null, `getResult:${jobId}`) : null;
+    }
+    hasResult(jobId) {
+        const row = this.db
+            .query('SELECT job_id FROM job_results WHERE job_id = ?')
+            .get(String(jobId));
+        return row !== null;
+    }
+    hasDlqEntry(jobId) {
+        const row = this.db
+            .query('SELECT job_id FROM dlq WHERE job_id = ? LIMIT 1')
+            .get(String(jobId));
+        return row !== null;
+    }
+    getDlqEntry(jobId) {
+        const row = this.db
+            .query('SELECT entry FROM dlq WHERE job_id = ? ORDER BY entered_at DESC LIMIT 1')
+            .get(String(jobId));
+        if (!row)
+            return null;
+        const entry = unpack(row.entry, null, `getDlqEntry:${String(jobId)}`);
+        return entry?.job ? reconstructDlqEntry(entry) : null;
+    }
+    loadDlqJobIds() {
+        const rows = this.db.query('SELECT job_id FROM dlq').all();
+        return new Set(rows.map((row) => row.job_id));
+    }
+    getJobStateRaw(jobId) {
+        const row = this.db
+            .query('SELECT state FROM jobs WHERE id = ?')
+            .get(String(jobId));
+        return row?.state ?? null;
+    }
+    loadCompletedJobIds() {
+        const ids = new Set();
+        const stateRows = this.db
+            .query("SELECT id FROM jobs WHERE state = 'completed'")
+            .all();
+        for (const row of stateRows)
+            ids.add(row.id);
+        for (const record of this.dependencyCompletionStore.load())
+            ids.add(record.jobId);
+        return ids;
+    }
+    commitRemovedCompletion(job, retentionLimit, pinned, completedAt = Date.now()) {
+        this.writeBuffer.removePending(job.id);
+        this.safeWrite(() => {
+            this.dependencyCompletionStore.commit({ jobId: job.id, queue: job.queue, completedAt, pinned }, retentionLimit);
+        });
+    }
+    loadDependencyCompletions() {
+        return this.dependencyCompletionStore.load();
+    }
+    pinDependencyCompletions(jobIds) {
+        this.safeWrite(() => {
+            this.dependencyCompletionStore.pin(jobIds);
+        });
+    }
+    unpinDependencyCompletions(jobIds, retentionLimit) {
+        let records = [];
+        this.safeWrite(() => {
+            records = this.dependencyCompletionStore.unpin(jobIds, retentionLimit);
+        });
+        return records;
+    }
+    reconcileDependencyCompletionPins(referenced, retentionLimit) {
+        let records = [];
+        this.safeWrite(() => {
+            records = this.dependencyCompletionStore.reconcilePins(referenced, retentionLimit);
+        });
+        return records;
+    }
+    deleteDependencyCompletion(jobId) {
+        let deleted = false;
+        this.safeWrite(() => {
+            deleted = this.dependencyCompletionStore.delete(jobId);
+        });
+        return deleted;
+    }
+    deleteDependencyCompletionsForQueue(queue) {
+        let deleted = [];
+        this.safeWrite(() => {
+            deleted = this.dependencyCompletionStore.deleteForQueue(queue);
+        });
+        return deleted;
+    }
+    insertJobsBatch(jobs, durable) {
+        if (durable) {
+            this.safeWrite(() => {
+                const transaction = this.db.transaction((batch) => {
+                    for (const job of batch)
+                        this.runInsertJobStmt(job);
+                });
+                transaction(jobs);
+            });
+            return;
+        }
+        this.writeBuffer.addBatch(jobs);
+    }
+}

package/dist/infrastructure/persistence/sqlite/state.d.ts

@@ -0,0 +1,36 @@
+import { Database } from 'bun:sqlite';
+import { type DlqEntry } from '../../../domain/types/dlq';
+import { BatchInsertManager, WriteBuffer } from '../sqliteBatch';
+import { DependencyCompletionStore } from '../dependencyCompletionStore';
+import { type StatementName } from '../statements';
+import type { SqliteConfig, SqliteCriticalLoss, SqliteCriticalLossCallback } from '../types/sqlite';
+/** Owns the database, prepared statements, buffering, and storage health state. */
+export declare abstract class SqliteState {
+    protected readonly db: Database;
+    protected readonly statements: Map<StatementName, ReturnType<Database['prepare']>>;
+    protected readonly batchManager: BatchInsertManager;
+    protected readonly writeBuffer: WriteBuffer;
+    protected readonly dependencyCompletionStore: DependencyCompletionStore;
+    protected _diskFull: boolean;
+    protected _lastDiskFullError: string | null;
+    protected _lastDiskFullAt: number | null;
+    protected readonly _criticalLosses: SqliteCriticalLoss[];
+    protected readonly _onCriticalLoss?: SqliteCriticalLossCallback;
+    private static readonly MAX_RETAINED_LOSSES;
+    protected abstract saveDlqEntry(entry: DlqEntry): void;
+    constructor(config: SqliteConfig);
+    private handleCriticalLoss;
+    private previewJobData;
+    getCriticalLosses(): readonly SqliteCriticalLoss[];
+    clearCriticalLosses(): void;
+    private setDiskFull;
+    protected safeWrite(operation: () => void): void;
+    get diskFull(): boolean;
+    getDiskFullStatus(): {
+        diskFull: boolean;
+        error: string | null;
+        since: number | null;
+    };
+    flushWriteBuffer(): number;
+    private migrate;
+}

package/dist/infrastructure/persistence/sqlite/state.js

@@ -0,0 +1,207 @@
+import { Database } from 'bun:sqlite';
+import { createDlqEntry } from '../../../domain/types/dlq';
+import { storageLog } from '../../../shared/logger';
+import { BatchInsertManager, WriteBuffer } from '../sqliteBatch';
+import { DependencyCompletionStore } from '../dependencyCompletionStore';
+import { migrateLegacyCronJobNames, migrateLegacyJobNames } from '../legacyNameMigration';
+import { MIGRATIONS } from '../migrations';
+import { MIGRATION_TABLE, PRAGMA_SETTINGS, SCHEMA, SCHEMA_VERSION } from '../schema';
+import { prepareStatements } from '../statements';
+function isSqliteFullError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return (error.message.includes('SQLITE_FULL') || error.message.includes('database or disk is full'));
+}
+function isIdempotentMigrationError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return (/^duplicate column name: [A-Za-z_][A-Za-z0-9_]*$/i.test(error.message) ||
+        /^(?:index|table) [A-Za-z_][A-Za-z0-9_]* already exists$/i.test(error.message));
+}
+/** Owns the database, prepared statements, buffering, and storage health state. */
+export class SqliteState {
+    db;
+    statements;
+    batchManager;
+    writeBuffer;
+    dependencyCompletionStore;
+    _diskFull = false;
+    _lastDiskFullError = null;
+    _lastDiskFullAt = null;
+    _criticalLosses = [];
+    _onCriticalLoss;
+    static MAX_RETAINED_LOSSES = 100;
+    constructor(config) {
+        this.db = new Database(config.path, { create: true });
+        try {
+            this.db.run(PRAGMA_SETTINGS);
+        }
+        catch (error) {
+            storageLog.error('Failed to apply PRAGMA settings', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        this.migrate();
+        this.dependencyCompletionStore = new DependencyCompletionStore(this.db);
+        this.statements = prepareStatements(this.db);
+        this._onCriticalLoss = config.onCriticalLoss;
+        this.batchManager = new BatchInsertManager(this.db);
+        this.writeBuffer = new WriteBuffer(this.batchManager, config.writeBufferSize ?? 100, config.writeBufferFlushMs ?? 10, (error, jobCount) => {
+            if (isSqliteFullError(error))
+                this.setDiskFull(error.message);
+            if (/constraint failed/i.test(error.message)) {
+                storageLog.error('Write buffer rejected jobs (constraint violation, dropped)', {
+                    rejectedJobCount: jobCount,
+                    error: error.message,
+                });
+            }
+            else {
+                storageLog.error('Write buffer flush failed', {
+                    jobCount,
+                    error: error.message,
+                    diskFull: this._diskFull,
+                });
+            }
+        }, (jobs, lastError, attempts) => {
+            this.handleCriticalLoss(jobs, lastError, attempts);
+        });
+    }
+    handleCriticalLoss(jobs, lastError, attempts) {
+        storageLog.error('CRITICAL: WriteBuffer dropped jobs after exhausting retries', {
+            lostJobCount: jobs.length,
+            attempts,
+            error: lastError.message,
+            diskFull: this._diskFull,
+        });
+        for (const job of jobs) {
+            storageLog.error('Lost job (recover from this log if needed)', {
+                id: String(job.id),
+                queue: job.queue,
+                customId: job.customId,
+                priority: job.priority,
+                createdAt: job.createdAt,
+                attempts: job.attempts,
+                dataPreview: this.previewJobData(job.data),
+            });
+        }
+        this._criticalLosses.push({
+            jobs,
+            error: lastError.message,
+            attempts,
+            at: Date.now(),
+        });
+        while (this._criticalLosses.length > SqliteState.MAX_RETAINED_LOSSES) {
+            this._criticalLosses.shift();
+        }
+        for (const job of jobs) {
+            try {
+                this.saveDlqEntry(createDlqEntry(job, "unknown" /* FailureReason.Unknown */, lastError.message));
+            }
+            catch (error) {
+                storageLog.error('Failed to persist lost job to DLQ', {
+                    id: String(job.id),
+                    queue: job.queue,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        if (this._onCriticalLoss) {
+            try {
+                this._onCriticalLoss(jobs, lastError, attempts);
+            }
+            catch (error) {
+                storageLog.error('onCriticalLoss callback threw', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    previewJobData(data) {
+        try {
+            const serialized = JSON.stringify(data);
+            return serialized.length > 500 ? serialized.slice(0, 500) + '...[truncated]' : serialized;
+        }
+        catch {
+            return '[unserializable]';
+        }
+    }
+    getCriticalLosses() {
+        return this._criticalLosses;
+    }
+    clearCriticalLosses() {
+        this._criticalLosses.length = 0;
+    }
+    setDiskFull(message) {
+        if (!this._diskFull) {
+            storageLog.error('DISK FULL: SQLite cannot write, persistence degraded', { error: message });
+        }
+        this._diskFull = true;
+        this._lastDiskFullError = message;
+        this._lastDiskFullAt = Date.now();
+    }
+    safeWrite(operation) {
+        try {
+            operation();
+            if (this._diskFull) {
+                this._diskFull = false;
+                this._lastDiskFullError = null;
+                storageLog.info('Disk full condition cleared - writes succeeding again');
+            }
+        }
+        catch (error) {
+            if (isSqliteFullError(error)) {
+                this.setDiskFull(error instanceof Error ? error.message : String(error));
+            }
+            throw error;
+        }
+    }
+    get diskFull() {
+        return this._diskFull;
+    }
+    getDiskFullStatus() {
+        return {
+            diskFull: this._diskFull,
+            error: this._lastDiskFullError,
+            since: this._lastDiskFullAt,
+        };
+    }
+    flushWriteBuffer() {
+        const flushed = this.writeBuffer.flush();
+        const pending = this.writeBuffer.pendingCount;
+        if (pending > 0) {
+            throw new Error(`Cannot create a consistent backup while ${pending} write${pending === 1 ? '' : 's'} remains buffered`);
+        }
+        return flushed;
+    }
+    migrate() {
+        this.db.run(MIGRATION_TABLE);
+        const currentVersion = this.db.query('SELECT MAX(version) as version FROM migrations').get()
+            ?.version ?? 0;
+        if (currentVersion < SCHEMA_VERSION) {
+            const applyMigrations = this.db.transaction(() => {
+                this.db.run(SCHEMA);
+                for (const [version, sql] of Object.entries(MIGRATIONS)) {
+                    const numericVersion = Number(version);
+                    if (numericVersion > currentVersion && numericVersion > 1) {
+                        const statements = typeof sql === 'string' ? [sql] : sql;
+                        for (const statement of statements) {
+                            try {
+                                this.db.run(statement);
+                            }
+                            catch (error) {
+                                if (!isIdempotentMigrationError(error))
+                                    throw error;
+                            }
+                        }
+                    }
+                }
+                migrateLegacyJobNames(this.db);
+                migrateLegacyCronJobNames(this.db);
+                this.db
+                    .prepare('INSERT INTO migrations (version, applied_at) VALUES (?, ?)')
+                    .run(SCHEMA_VERSION, Date.now());
+            });
+            applyMigrations();
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { QueueMetricsMeta, QueueMetricType } from '../../../domain/types/metrics';
+import { type JobEvent } from '../../../domain/types/queue';
+import { SqliteControl } from './control';
+export interface PersistedQueueMetrics {
+    meta: QueueMetricsMeta;
+    data: number[];
+}
+/** Durable lifecycle journal and minute-bucket metrics. */
+export declare abstract class SqliteTelemetry extends SqliteControl {
+    recordQueueEvent(event: JobEvent, maxEvents: number, maxMetricDataPoints: number): void;
+    getQueueMetrics(queue: string, type: QueueMetricType, maxMetricDataPoints: number): PersistedQueueMetrics;
+    trimQueueEvents(queue: string, maxLength: number): number;
+    countQueueEvents(queue: string): number;
+    clearQueueTelemetry(queue: string): void;
+    private expandMetricBuckets;
+}

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

@@ -0,0 +1,126 @@
+import { pack } from '../sqliteSerializer';
+import { SqliteControl } from './control';
+function terminalMetricType(event) {
+    if (event.eventType === "completed" /* EventType.Completed */)
+        return 'completed';
+    if (event.eventType === "failed" /* EventType.Failed */ && event.terminal !== false)
+        return 'failed';
+    return null;
+}
+function eventPayload(event) {
+    return pack({
+        data: event.data,
+        error: event.error,
+        progress: event.progress,
+        prev: event.prev,
+        delay: event.delay,
+        terminal: event.terminal,
+    });
+}
+/** Durable lifecycle journal and minute-bucket metrics. */
+export class SqliteTelemetry extends SqliteControl {
+    recordQueueEvent(event, maxEvents, maxMetricDataPoints) {
+        const eventLimit = Math.max(0, Math.floor(maxEvents));
+        const metricLimit = Math.max(0, Math.floor(maxMetricDataPoints));
+        const metricType = terminalMetricType(event);
+        const minute = Math.floor(event.timestamp / 60_000);
+        const payload = eventPayload(event);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.db
+                    .prepare('INSERT INTO queue_events (queue, event_type, job_id, occurred_at, payload) VALUES (?, ?, ?, ?, ?)')
+                    .run(event.queue, event.eventType, String(event.jobId), event.timestamp, payload);
+                this.db
+                    .prepare('DELETE FROM queue_events WHERE queue = ? AND id IN (SELECT id FROM queue_events WHERE queue = ? ORDER BY id DESC LIMIT -1 OFFSET ?)')
+                    .run(event.queue, event.queue, eventLimit);
+                if (!metricType)
+                    return;
+                this.db
+                    .prepare(`INSERT INTO queue_metric_buckets (queue, type, minute, count)
+             VALUES (?, ?, ?, 1)
+             ON CONFLICT(queue, type, minute) DO UPDATE SET count = count + 1`)
+                    .run(event.queue, metricType, minute);
+                const bucketCount = this.db
+                    .query('SELECT count FROM queue_metric_buckets WHERE queue = ? AND type = ? AND minute = ?')
+                    .get(event.queue, metricType, minute)?.count ?? 1;
+                this.db
+                    .prepare(`INSERT INTO queue_metrics_meta (queue, type, total_count, prev_ts, prev_count)
+             VALUES (?, ?, 1, ?, ?)
+             ON CONFLICT(queue, type) DO UPDATE SET
+               total_count = total_count + 1,
+               prev_ts = excluded.prev_ts,
+               prev_count = excluded.prev_count`)
+                    .run(event.queue, metricType, event.timestamp, bucketCount);
+                if (metricLimit === 0) {
+                    this.db
+                        .prepare('DELETE FROM queue_metric_buckets WHERE queue = ? AND type = ?')
+                        .run(event.queue, metricType);
+                    return;
+                }
+                const newest = this.db
+                    .query('SELECT MAX(minute) AS minute FROM queue_metric_buckets WHERE queue = ? AND type = ?')
+                    .get(event.queue, metricType)?.minute ?? minute;
+                this.db
+                    .prepare('DELETE FROM queue_metric_buckets WHERE queue = ? AND type = ? AND minute < ?')
+                    .run(event.queue, metricType, newest - metricLimit + 1);
+            });
+            transaction();
+        });
+    }
+    getQueueMetrics(queue, type, maxMetricDataPoints) {
+        const metaRow = this.db
+            .query('SELECT total_count, prev_ts, prev_count FROM queue_metrics_meta WHERE queue = ? AND type = ?')
+            .get(queue, type);
+        const limit = Math.max(0, Math.floor(maxMetricDataPoints));
+        const rows = limit === 0
+            ? []
+            : this.db
+                .query('SELECT minute, count FROM queue_metric_buckets WHERE queue = ? AND type = ? ORDER BY minute DESC LIMIT ?')
+                .all(queue, type, limit);
+        return {
+            meta: {
+                count: metaRow?.total_count ?? 0,
+                prevTS: metaRow?.prev_ts ?? 0,
+                prevCount: metaRow?.prev_count ?? 0,
+            },
+            data: this.expandMetricBuckets(rows, limit),
+        };
+    }
+    trimQueueEvents(queue, maxLength) {
+        let removed = 0;
+        this.safeWrite(() => {
+            removed = this.db
+                .prepare('DELETE FROM queue_events WHERE queue = ? AND id IN (SELECT id FROM queue_events WHERE queue = ? ORDER BY id DESC LIMIT -1 OFFSET ?)')
+                .run(queue, queue, maxLength).changes;
+        });
+        return removed;
+    }
+    countQueueEvents(queue) {
+        return (this.db
+            .query('SELECT COUNT(*) AS count FROM queue_events WHERE queue = ?')
+            .get(queue)?.count ?? 0);
+    }
+    clearQueueTelemetry(queue) {
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.db.prepare('DELETE FROM queue_events WHERE queue = ?').run(queue);
+                this.db.prepare('DELETE FROM queue_metrics_meta WHERE queue = ?').run(queue);
+                this.db.prepare('DELETE FROM queue_metric_buckets WHERE queue = ?').run(queue);
+            });
+            transaction();
+        });
+    }
+    expandMetricBuckets(rows, limit) {
+        if (rows.length === 0 || limit === 0)
+            return [];
+        const newest = rows[0].minute;
+        const oldest = Math.max(rows[rows.length - 1].minute, newest - limit + 1);
+        const data = new Array(newest - oldest + 1).fill(0);
+        for (const row of rows) {
+            const index = newest - row.minute;
+            if (index >= 0 && index < data.length)
+                data[index] = row.count;
+        }
+        return data;
+    }
+}