bunqueue 2.8.54 → 2.8.57

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

@@ -0,0 +1,167 @@
+import { pack, unpack } from '../sqliteSerializer';
+import { SqliteMutations } from './mutations';
+/** Atomic persistence for parent/child relationships and failure outbox rows. */
+export class SqliteFlows extends SqliteMutations {
+    updateFlowLink(child, parent, parentState) {
+        this.commitFlowLink(child, parent, parentState, { type: 'update' });
+    }
+    commitFlowLink(child, parent, parentState, mode, admission) {
+        if (mode.type === 'update' && admission !== undefined) {
+            throw new Error('Durable admission metadata requires an inserting flow-link mode');
+        }
+        if (mode.type === 'update')
+            this.flushIfBuffered(child.id);
+        if (mode.type === 'replace')
+            this.flushIfBuffered(mode.previousJobId);
+        this.flushIfBuffered(parent.id);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.runAdmissionMetadata(admission);
+                if (mode.type === 'update') {
+                    this.db
+                        .prepare('UPDATE jobs SET parent_id = ?, data = ? WHERE id = ?')
+                        .run(child.parentId, pack(child.data), child.id);
+                }
+                else {
+                    if (mode.type === 'replace')
+                        this.runDeleteJobRows(mode.previousJobId);
+                    if (mode.type === 'transfer-active') {
+                        this.runClearActiveDedupKey(mode.previousJobId);
+                    }
+                    this.runInsertJobStmt(child);
+                }
+                const parentUpdate = this.db
+                    .prepare(`UPDATE jobs
+             SET children_ids = ?, depends_on = ?, data = ?, state = ?, timeline = ?
+             WHERE id = ?`)
+                    .run(parent.childrenIds.length > 0 ? pack(parent.childrenIds) : null, parent.dependsOn.length > 0 ? pack(parent.dependsOn) : null, pack(parent.data), parentState, parent.timeline.length > 0 ? pack(parent.timeline) : null, parent.id);
+                if (parentUpdate.changes !== 1) {
+                    throw new Error(`Flow parent is no longer persisted: ${String(parent.id)}`);
+                }
+            });
+            transaction();
+        });
+        this.finalizeAdmissionMetadata(admission);
+    }
+    backpatchFlowChild(child, previousParentId) {
+        this.flushIfBuffered(child.id);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                let persisted = this.db
+                    .prepare('UPDATE jobs SET parent_id = ?, data = ? WHERE id = ?')
+                    .run(child.parentId, pack(child.data), child.id).changes > 0;
+                const dlqRows = this.db
+                    .query('SELECT id, entry FROM dlq WHERE job_id = ?')
+                    .all(String(child.id));
+                for (const row of dlqRows) {
+                    const entry = unpack(row.entry, null, `backpatchFlowChild:${String(child.id)}`);
+                    if (!entry?.job)
+                        continue;
+                    const updated = {
+                        ...entry,
+                        job: { ...entry.job, parentId: child.parentId, data: child.data },
+                    };
+                    this.db.prepare('UPDATE dlq SET entry = ? WHERE id = ?').run(pack(updated), row.id);
+                    persisted = true;
+                }
+                if (!persisted) {
+                    throw new Error(`Flow child is no longer persisted: ${String(child.id)}`);
+                }
+                if (previousParentId && child.parentId && previousParentId !== child.parentId) {
+                    const failure = this.db
+                        .query(`SELECT child_queue, mode, error, created_at
+               FROM flow_failures
+               WHERE parent_id = ? AND child_id = ?`)
+                        .get(String(previousParentId), String(child.id));
+                    if (failure) {
+                        this.db
+                            .prepare(`INSERT INTO flow_failures
+                 (parent_id, child_id, child_queue, mode, error, created_at)
+                 VALUES (?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(parent_id, child_id) DO UPDATE SET
+                   child_queue=excluded.child_queue, mode=excluded.mode,
+                   error=excluded.error, created_at=excluded.created_at`)
+                            .run(child.parentId, child.id, failure.child_queue, failure.mode, failure.error, failure.created_at);
+                        this.db
+                            .prepare('DELETE FROM flow_failures WHERE parent_id = ? AND child_id = ?')
+                            .run(previousParentId, child.id);
+                    }
+                }
+            });
+            transaction();
+        });
+    }
+    removeFlowLink(child, parent, parentState) {
+        this.flushIfBuffered(child.id);
+        this.flushIfBuffered(parent.id);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.db
+                    .prepare('UPDATE jobs SET parent_id = ?, data = ? WHERE id = ?')
+                    .run(child.parentId, pack(child.data), child.id);
+                this.db
+                    .prepare(`UPDATE jobs
+             SET children_ids = ?, depends_on = ?, data = ?, run_at = ?, state = ?
+             WHERE id = ?`)
+                    .run(parent.childrenIds.length > 0 ? pack(parent.childrenIds) : null, parent.dependsOn.length > 0 ? pack(parent.dependsOn) : null, pack(parent.data), parent.runAt, parentState, parent.id);
+                this.db
+                    .prepare('DELETE FROM flow_failures WHERE parent_id = ? AND child_id = ?')
+                    .run(parent.id, child.id);
+            });
+            transaction();
+        });
+    }
+    saveFlowFailure(record) {
+        this.safeWrite(() => {
+            this.db
+                .prepare(`INSERT INTO flow_failures
+           (parent_id, child_id, child_queue, mode, error, created_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(parent_id, child_id) DO UPDATE SET
+             child_queue=excluded.child_queue, mode=excluded.mode,
+             error=excluded.error, created_at=excluded.created_at`)
+                .run(record.parentId, record.childId, record.childQueue, record.mode, record.error, record.createdAt);
+        });
+    }
+    loadFlowFailures() {
+        const rows = this.db
+            .query('SELECT * FROM flow_failures ORDER BY created_at, parent_id, child_id')
+            .all();
+        return rows.map((row) => ({
+            parentId: row.parent_id,
+            childId: row.child_id,
+            childQueue: row.child_queue,
+            mode: row.mode,
+            error: row.error,
+            createdAt: row.created_at,
+        }));
+    }
+    deleteFlowFailure(parentId, childId) {
+        this.safeWrite(() => {
+            if (childId) {
+                this.db
+                    .prepare('DELETE FROM flow_failures WHERE parent_id = ? AND child_id = ?')
+                    .run(parentId, childId);
+            }
+            else {
+                this.db.prepare('DELETE FROM flow_failures WHERE parent_id = ?').run(parentId);
+            }
+        });
+    }
+    updateFlowParentResolution(job, stateOverride) {
+        this.flushIfBuffered(job.id);
+        const state = stateOverride ??
+            (job.dependsOn.length > 0
+                ? 'waiting-children'
+                : job.runAt > Date.now()
+                    ? 'delayed'
+                    : job.priority > 0
+                        ? 'prioritized'
+                        : 'waiting');
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET depends_on = ?, run_at = ?, state = ?, timeline = ? WHERE id = ?')
+                .run(job.dependsOn.length > 0 ? pack(job.dependsOn) : null, job.runAt, state, job.timeline.length > 0 ? pack(job.timeline) : null, job.id);
+        });
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { DlqEntry } from '../../../domain/types/dlq';
+import type { FlowFailureRecord } from '../../../domain/types/flow';
+import type { Job, JobId, JobTimelineEntry } from '../../../domain/types/job';
+import type { DurableAdmissionMetadata } from '../types/admission';
+import { SqliteAdmission } from './admission';
+/** Job insertion, state transitions, and DLQ persistence. */
+export declare abstract class SqliteJobs extends SqliteAdmission {
+    insertJob(job: Job, durable?: boolean, admission?: DurableAdmissionMetadata): void;
+    insertJobImmediate(job: Job, admission?: DurableAdmissionMetadata): void;
+    protected runInsertJobStmt(job: Job): void;
+    protected flushIfBuffered(jobId: JobId): void;
+    markActive(jobId: JobId, startedAt: number, timeline?: JobTimelineEntry[]): void;
+    markWaitingChildren(jobId: JobId, timeline?: JobTimelineEntry[]): void;
+    markCompleted(jobId: JobId, completedAt: number, timeline?: JobTimelineEntry[]): void;
+    markFailed(job: Job, error: string | null): void;
+    saveDlqEntry(entry: DlqEntry): void;
+    commitFailedJob(jobId: JobId, entry: DlqEntry | null, flowFailure: FlowFailureRecord | null): void;
+    deleteDlqEntry(jobId: JobId): void;
+    requeueDlqJob(job: Job): void;
+    clearDlqQueue(queue: string): void;
+    purgeDlqEntries(queue: string, dlqJobIds: readonly JobId[], terminalJobIds: readonly JobId[], clearQueue: boolean): void;
+    loadDlq(): Map<string, DlqEntry[]>;
+}

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

@@ -0,0 +1,166 @@
+import { getDlqRetryState } from '../../../domain/types/dlq';
+import { pack, persistedInitialState, persistedStallCount, reconstructDlqEntry, unpack, } from '../sqliteSerializer';
+import { encodeJobOptions } from '../jobOptionsBlob';
+import { SqliteAdmission } from './admission';
+/** Job insertion, state transitions, and DLQ persistence. */
+export class SqliteJobs extends SqliteAdmission {
+    insertJob(job, durable, admission) {
+        if (durable) {
+            this.insertJobImmediate(job, admission);
+            return;
+        }
+        this.commitBufferedAdmissionMetadata(admission);
+        this.writeBuffer.add(job);
+    }
+    insertJobImmediate(job, admission) {
+        if (!this.hasAdmissionMetadata(admission)) {
+            this.safeWrite(() => this.runInsertJobStmt(job));
+            return;
+        }
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.runAdmissionMetadata(admission);
+                this.runInsertJobStmt(job);
+            });
+            transaction();
+        });
+        this.finalizeAdmissionMetadata(admission);
+    }
+    runInsertJobStmt(job) {
+        const dlqRetryState = getDlqRetryState(job);
+        this.statements
+            .get('insertJob')
+            .run(job.id, job.queue, job.name, pack(job.data), job.priority, job.createdAt, job.runAt, job.attempts, job.maxAttempts, job.backoff, job.ttl, job.timeout, job.uniqueKey, job.customId, job.dependsOn.length > 0 ? pack(job.dependsOn) : null, job.parentId, job.childrenIds.length > 0 ? pack(job.childrenIds) : null, job.tags.length > 0 ? pack(job.tags) : null, persistedInitialState(job), job.lifo ? 1 : 0, job.groupId, job.removeOnComplete ? 1 : 0, job.removeOnFail ? 1 : 0, job.failParentOnFailure ? 1 : 0, job.removeDependencyOnFailure ? 1 : 0, job.continueParentOnFailure ? 1 : 0, job.ignoreDependencyOnFailure ? 1 : 0, job.stallTimeout, persistedStallCount(job), job.timeline.length > 0 ? pack(job.timeline) : null, dlqRetryState ? pack(dlqRetryState) : null, encodeJobOptions(job));
+    }
+    flushIfBuffered(jobId) {
+        if (this.writeBuffer.hasPending(String(jobId))) {
+            try {
+                this.writeBuffer.flush();
+            }
+            catch {
+                // Flush errors are already reported by the buffer callbacks.
+            }
+        }
+    }
+    markActive(jobId, startedAt, timeline) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.statements
+                .get('updateJobState')
+                .run('active', startedAt, timeline && timeline.length > 0 ? pack(timeline) : null, jobId);
+        });
+    }
+    markWaitingChildren(jobId, timeline) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET state = ?, started_at = NULL, timeline = ? WHERE id = ?')
+                .run('waiting-children', timeline && timeline.length > 0 ? pack(timeline) : null, jobId);
+        });
+    }
+    markCompleted(jobId, completedAt, timeline) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.statements
+                .get('completeJob')
+                .run('completed', completedAt, timeline && timeline.length > 0 ? pack(timeline) : null, jobId);
+        });
+    }
+    markFailed(job, error) {
+        this.flushIfBuffered(job.id);
+        this.safeWrite(() => {
+            this.statements.get('insertDlq').run(job.id, job.queue, pack({ job, error }), Date.now());
+        });
+    }
+    saveDlqEntry(entry) {
+        this.safeWrite(() => {
+            this.statements
+                .get('insertDlq')
+                .run(entry.job.id, entry.job.queue, pack(entry), entry.enteredAt);
+        });
+    }
+    commitFailedJob(jobId, entry, flowFailure) {
+        this.writeBuffer.removePending(jobId);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                if (entry) {
+                    this.statements
+                        .get('insertDlq')
+                        .run(entry.job.id, entry.job.queue, pack(entry), entry.enteredAt);
+                }
+                if (flowFailure) {
+                    this.db
+                        .prepare(`INSERT INTO flow_failures
+               (parent_id, child_id, child_queue, mode, error, created_at)
+               VALUES (?, ?, ?, ?, ?, ?)
+               ON CONFLICT(parent_id, child_id) DO UPDATE SET
+                 child_queue=excluded.child_queue, mode=excluded.mode,
+                 error=excluded.error, created_at=excluded.created_at`)
+                        .run(flowFailure.parentId, flowFailure.childId, flowFailure.childQueue, flowFailure.mode, flowFailure.error, flowFailure.createdAt);
+                }
+                this.statements.get('deleteJob').run(jobId);
+                this.statements.get('deleteJobResult').run(jobId);
+            });
+            transaction();
+        });
+    }
+    deleteDlqEntry(jobId) {
+        this.safeWrite(() => {
+            this.statements.get('deleteDlqEntry').run(jobId);
+        });
+    }
+    requeueDlqJob(job) {
+        this.writeBuffer.removePending(job.id);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.statements.get('deleteDlqEntry').run(job.id);
+                this.runInsertJobStmt(job);
+            });
+            transaction();
+        });
+    }
+    clearDlqQueue(queue) {
+        this.safeWrite(() => {
+            this.statements.get('clearDlqQueue').run(queue);
+        });
+    }
+    purgeDlqEntries(queue, dlqJobIds, terminalJobIds, clearQueue) {
+        for (const jobId of terminalJobIds)
+            this.writeBuffer.removePending(jobId);
+        this.safeWrite(() => {
+            const deleteDlq = this.statements.get('deleteDlqEntryForQueue');
+            const clearDlq = this.statements.get('clearDlqQueue');
+            const deleteJob = this.statements.get('deleteJob');
+            const deleteResult = this.statements.get('deleteJobResult');
+            const transaction = this.db.transaction(() => {
+                if (clearQueue)
+                    clearDlq.run(queue);
+                else
+                    for (const jobId of dlqJobIds)
+                        deleteDlq.run(jobId, queue);
+                for (const jobId of terminalJobIds) {
+                    deleteJob.run(jobId);
+                    deleteResult.run(jobId);
+                }
+            });
+            transaction();
+        });
+    }
+    loadDlq() {
+        const rows = this.statements.get('loadDlq').all();
+        const result = new Map();
+        for (const row of rows) {
+            const entry = unpack(row.entry, null, `loadDlq:${row.job_id}`);
+            if (!entry?.job)
+                continue;
+            const reconstructedEntry = reconstructDlqEntry(entry);
+            let queueEntries = result.get(row.queue);
+            if (!queueEntries) {
+                queueEntries = [];
+                result.set(row.queue, queueEntries);
+            }
+            queueEntries.push(reconstructedEntry);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,6 @@
+import { SqliteTelemetry } from './telemetry';
+/** Storage shutdown and file-size inspection. */
+export declare class SqliteLifecycle extends SqliteTelemetry {
+    close(): void;
+    getSize(): number;
+}

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

@@ -0,0 +1,30 @@
+import { storageLog } from '../../../shared/logger';
+import { SqliteTelemetry } from './telemetry';
+/** Storage shutdown and file-size inspection. */
+export class SqliteLifecycle extends SqliteTelemetry {
+    close() {
+        this.writeBuffer.stop();
+        try {
+            this.writeBuffer.flush();
+        }
+        catch (error) {
+            storageLog.error('Failed to flush write buffer on close', {
+                bufferedJobs: this.writeBuffer.pendingCount,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        try {
+            this.db.run('PRAGMA wal_checkpoint(TRUNCATE)');
+        }
+        catch (error) {
+            storageLog.error('WAL checkpoint failed on close', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        this.db.close();
+    }
+    getSize() {
+        const file = Bun.file(this.db.filename);
+        return file.size;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { Job, JobId } from '../../../domain/types/job';
+import type { DurableAdmissionMetadata } from '../types/admission';
+import { SqliteJobs } from './jobs';
+/** Non-terminal job field and scheduling mutations. */
+export declare abstract class SqliteMutations extends SqliteJobs {
+    updateForRetry(job: Job): void;
+    /** Atomically move a completed job back to waiting and retire its old result. */
+    requeueCompletedJob(job: Job): void;
+    deleteJob(jobId: JobId): void;
+    replaceJob(oldJobId: JobId, newJob: Job, durable?: boolean, admission?: DurableAdmissionMetadata): void;
+    transferActiveDedupJob(oldJobId: JobId, newJob: Job, durable?: boolean, admission?: DurableAdmissionMetadata): void;
+    protected runDeleteJobRows(jobId: JobId): void;
+    protected runClearActiveDedupKey(jobId: JobId): void;
+    updateJobData(jobId: JobId, data: unknown): void;
+    clearJobUniqueKey(jobId: JobId): void;
+    updateJobPriority(jobId: JobId, priority: number, lifo: boolean): void;
+    updateJobProgress(jobId: JobId, progress: number, message: string | null, lastHeartbeat: number): void;
+    updateRunAt(jobId: JobId, runAt: number): void;
+    updateJobChildrenIds(jobId: JobId, childrenIds: JobId[]): void;
+}

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

@@ -0,0 +1,149 @@
+import { getDlqRetryState } from '../../../domain/types/dlq';
+import { pack, persistedStallCount } from '../sqliteSerializer';
+import { SqliteJobs } from './jobs';
+/** Non-terminal job field and scheduling mutations. */
+export class SqliteMutations extends SqliteJobs {
+    updateForRetry(job) {
+        const dlqRetryState = getDlqRetryState(job);
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET attempts = ?, stall_count = ?, run_at = ?, state = ?, timeline = ?, stacktrace = ?, dlq_retry_state = ? WHERE id = ?')
+                .run(job.attempts, persistedStallCount(job), job.runAt, 'waiting', job.timeline.length > 0 ? pack(job.timeline) : null, job.stacktrace && job.stacktrace.length > 0 ? pack(job.stacktrace) : null, dlqRetryState ? pack(dlqRetryState) : null, job.id);
+        });
+    }
+    /** Atomically move a completed job back to waiting and retire its old result. */
+    requeueCompletedJob(job) {
+        this.flushIfBuffered(job.id);
+        const dlqRetryState = getDlqRetryState(job);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                const result = this.db
+                    .prepare(`UPDATE jobs SET
+               attempts = ?, stall_count = ?, run_at = ?, state = 'waiting',
+               started_at = NULL, completed_at = NULL, progress = ?,
+               progress_msg = ?, last_heartbeat = ?, timeline = ?,
+               dlq_retry_state = ?
+             WHERE id = ? AND state = 'completed'`)
+                    .run(job.attempts, persistedStallCount(job), job.runAt, job.progress, job.progressMessage, job.lastHeartbeat, job.timeline.length > 0 ? pack(job.timeline) : null, dlqRetryState ? pack(dlqRetryState) : null, job.id);
+                if (result.changes !== 1) {
+                    throw new Error(`Completed job is not persisted: ${String(job.id)}`);
+                }
+                this.statements.get('deleteJobResult').run(job.id);
+            });
+            transaction();
+        });
+    }
+    deleteJob(jobId) {
+        this.writeBuffer.removePending(jobId);
+        this.safeWrite(() => {
+            const transaction = this.db.transaction((id) => {
+                this.runDeleteJobRows(id);
+            });
+            transaction(jobId);
+        });
+    }
+    replaceJob(oldJobId, newJob, durable, admission) {
+        if (!durable) {
+            this.safeWrite(() => {
+                const transaction = this.db.transaction((id) => {
+                    this.runDeleteJobRows(id);
+                    this.runAdmissionMetadata(admission);
+                });
+                transaction(oldJobId);
+            });
+            this.writeBuffer.removePending(oldJobId);
+            this.finalizeAdmissionMetadata(admission);
+            this.writeBuffer.add(newJob);
+            return;
+        }
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.runDeleteJobRows(oldJobId);
+                this.runAdmissionMetadata(admission);
+                this.runInsertJobStmt(newJob);
+            });
+            transaction();
+        });
+        this.writeBuffer.removePending(oldJobId);
+        this.finalizeAdmissionMetadata(admission);
+    }
+    transferActiveDedupJob(oldJobId, newJob, durable, admission) {
+        if (!durable) {
+            this.safeWrite(() => {
+                const transaction = this.db.transaction(() => {
+                    this.runClearActiveDedupKey(oldJobId);
+                    this.runAdmissionMetadata(admission);
+                });
+                transaction();
+            });
+            this.finalizeAdmissionMetadata(admission);
+            this.writeBuffer.add(newJob);
+            return;
+        }
+        this.safeWrite(() => {
+            const transaction = this.db.transaction(() => {
+                this.runClearActiveDedupKey(oldJobId);
+                this.runAdmissionMetadata(admission);
+                this.runInsertJobStmt(newJob);
+            });
+            transaction();
+        });
+        this.finalizeAdmissionMetadata(admission);
+    }
+    runDeleteJobRows(jobId) {
+        this.statements.get('deleteJob').run(jobId);
+        this.statements.get('deleteJobResult').run(jobId);
+        this.db.prepare('DELETE FROM flow_failures WHERE parent_id = ?').run(jobId);
+    }
+    runClearActiveDedupKey(jobId) {
+        const result = this.db
+            .prepare("UPDATE jobs SET unique_key = NULL WHERE id = ? AND state = 'active'")
+            .run(jobId);
+        if (result.changes === 0) {
+            throw new Error(`Active deduplication owner is not persisted: ${String(jobId)}`);
+        }
+    }
+    updateJobData(jobId, data) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db.prepare('UPDATE jobs SET data = ? WHERE id = ?').run(pack(data), jobId);
+        });
+    }
+    clearJobUniqueKey(jobId) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db.prepare('UPDATE jobs SET unique_key = NULL WHERE id = ?').run(jobId);
+        });
+    }
+    updateJobPriority(jobId, priority, lifo) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET priority = ?, lifo = ? WHERE id = ?')
+                .run(priority, lifo ? 1 : 0, jobId);
+        });
+    }
+    updateJobProgress(jobId, progress, message, lastHeartbeat) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.statements.get('updateJobProgress').run(progress, message, lastHeartbeat, jobId);
+        });
+    }
+    updateRunAt(jobId, runAt) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            const state = runAt > Date.now() ? 'delayed' : 'waiting';
+            this.db
+                .prepare('UPDATE jobs SET run_at = ?, state = ?, started_at = NULL WHERE id = ?')
+                .run(runAt, state, jobId);
+        });
+    }
+    updateJobChildrenIds(jobId, childrenIds) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET children_ids = ? WHERE id = ?')
+                .run(childrenIds.length > 0 ? pack(childrenIds) : null, jobId);
+        });
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { Job } from '../../../domain/types/job';
+import { SqliteRecords } from './records';
+/** Persisted and logical-state job queries used by recovery and public pagination. */
+export declare abstract class SqliteQueries extends SqliteRecords {
+    queryJobs(queue: string, options: {
+        state?: string;
+        states?: string[];
+        limit: number;
+        offset: number;
+        asc: boolean;
+    }): Job[];
+    queryJobsByLogicalStates(queue: string, states: string[], options: {
+        limit: number;
+        offset: number;
+        asc: boolean;
+        now: number;
+    }): Job[];
+    loadPendingJobs(limit?: number, offset?: number): Job[];
+    loadActiveJobs(limit?: number, offset?: number): Job[];
+    loadCompletedJobs(limit?: number, offset?: number): Job[];
+    countPendingJobs(): number;
+    countActiveJobs(): number;
+}