@ventually/sqlite 0.0.1

package/dist/cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { type SQLiteAdapterOptions } from "./index.js";
+declare function main(argv?: string[]): Promise<void>;
+declare function readAdapterOptions(args: string[]): SQLiteAdapterOptions;
+declare function readFlagValue(args: string[], flag: string): string | null;
+export { main, readAdapterOptions, readFlagValue };
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAIA,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA4CtE,iBAAe,IAAI,CAAC,IAAI,WAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAU/D;AAED,iBAAS,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAwBhE;AAED,iBAAS,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0BlE;AA2CD,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC"}

package/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { SQLiteAdapter } from "./index.js";
+const migrateDescription = "Create the adapter tables and indexes if they do not exist.";
+const helpDescription = "Show available commands.";
+const versionDescription = "Print the installed package version.";
+const commands = {
+    help: {
+        description: helpDescription,
+        run: async () => {
+            printHelp();
+        },
+    },
+    migrate: {
+        description: migrateDescription,
+        run: async (args) => {
+            const options = readAdapterOptions(args);
+            const adapter = new SQLiteAdapter(options);
+            try {
+                await adapter.migrate();
+            }
+            finally {
+                await adapter.close();
+            }
+            console.log(`Migrated @ventually/sqlite schema for ${describeConnection(options.connection)}${options.namespace ? ` (namespace: ${options.namespace})` : ""}.`);
+        },
+    },
+    version: {
+        description: versionDescription,
+        run: async () => {
+            console.log(process.env.npm_package_version ?? "0.0.0");
+        },
+    },
+};
+async function main(argv = process.argv.slice(2)) {
+    const [rawCommand, ...rest] = argv;
+    const commandName = rawCommand ?? "help";
+    if (!Object.hasOwn(commands, commandName)) {
+        throw new Error(`Unsupported command: ${commandName}`);
+    }
+    const command = commands[commandName];
+    await command.run(rest);
+}
+function readAdapterOptions(args) {
+    const url = readFlagValue(args, "--connection") ??
+        readFlagValue(args, "--url") ??
+        process.env.EVENTUALLY_SQLITE_URL ??
+        process.env.DATABASE_URL ??
+        process.env.TURSO_DATABASE_URL;
+    if (!url) {
+        throw new Error("Missing SQLite connection. Pass --connection <url> or set EVENTUALLY_SQLITE_URL/DATABASE_URL.");
+    }
+    const authToken = readFlagValue(args, "--auth-token") ??
+        process.env.EVENTUALLY_SQLITE_AUTH_TOKEN ??
+        process.env.TURSO_AUTH_TOKEN;
+    const namespace = readFlagValue(args, "--namespace") ?? process.env.EVENTUALLY_SQLITE_NAMESPACE;
+    return {
+        connection: authToken ? { url, authToken } : url,
+        namespace: namespace || undefined,
+    };
+}
+function readFlagValue(args, flag) {
+    const equalsPrefix = `${flag}=`;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg) {
+            continue;
+        }
+        if (arg === flag) {
+            const value = args[index + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error(`Missing value for ${flag}.`);
+            }
+            return value;
+        }
+        if (arg.startsWith(equalsPrefix)) {
+            const value = arg.slice(equalsPrefix.length);
+            if (!value) {
+                throw new Error(`Missing value for ${flag}.`);
+            }
+            return value;
+        }
+    }
+    return null;
+}
+function describeConnection(connection) {
+    if (typeof connection === "string") {
+        return connection;
+    }
+    return connection?.url ?? ":memory:";
+}
+function printHelp() {
+    console.log(`Usage: bunx @ventually/sqlite <command> [options]
+
+Commands:
+  migrate   ${migrateDescription}
+  help      ${helpDescription}
+  version   ${versionDescription}
+
+Options for migrate:
+  --connection, --url <url>   SQLite/libSQL connection string
+  --auth-token <token>        Optional auth token for remote libSQL
+  --namespace <name>          Optional adapter namespace
+
+Env fallbacks:
+  EVENTUALLY_SQLITE_URL
+  EVENTUALLY_SQLITE_AUTH_TOKEN
+  EVENTUALLY_SQLITE_NAMESPACE
+  DATABASE_URL
+  TURSO_DATABASE_URL
+  TURSO_AUTH_TOKEN`);
+}
+const isDirectExecution = process.argv[1] !== undefined && import.meta.url === new URL(`file://${process.argv[1]}`).href;
+if (isDirectExecution) {
+    void main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    });
+}
+export { main, readAdapterOptions, readFlagValue };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SQLiteAdapter } from "./sqlite-adapter.js";
+export type { SQLiteAdapterOptions } from "./sqlite-adapter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { SQLiteAdapter } from "./sqlite-adapter.js";

package/dist/sqlite-adapter.d.ts

@@ -0,0 +1,56 @@
+import { type Config } from "@libsql/client";
+import type { AdapterClaimOptions, AdapterEnqueueRequest, AdapterFailureRecord, AdapterJobRecord, IQueueAdapter } from "@ventually/core";
+type KeepMode = {
+    mode: "all" | "none" | "count";
+    count?: number;
+};
+export interface SQLiteAdapterOptions {
+    connection?: string | Config;
+    namespace?: string;
+}
+export declare class SQLiteAdapter implements IQueueAdapter {
+    private readonly client;
+    private readonly db;
+    private readonly namespace;
+    private schemaPromise;
+    private closed;
+    constructor(options?: SQLiteAdapterOptions);
+    enqueue(request: AdapterEnqueueRequest): Promise<AdapterJobRecord>;
+    enqueueMany(requests: AdapterEnqueueRequest[]): Promise<AdapterJobRecord[]>;
+    getJob(queueName: string, jobId: string): Promise<AdapterJobRecord | null>;
+    claimNext(queueName: string, options: AdapterClaimOptions): Promise<AdapterJobRecord[]>;
+    complete(queueName: string, jobId: string, lockToken: string, result: unknown, finishedAt: number, keep: KeepMode): Promise<void>;
+    fail(queueName: string, jobId: string, lockToken: string, failure: AdapterFailureRecord, finishedAt: number, retryAt: number | null, keep: KeepMode): Promise<void>;
+    updateProgress(queueName: string, jobId: string, lockToken: string, progress: unknown, updatedAt: number): Promise<void>;
+    recoverStalled(queueName: string, now: number, lockTtlMs: number, limit: number): Promise<AdapterJobRecord[]>;
+    migrate(): Promise<void>;
+    close(): Promise<void>;
+    private ensureReady;
+    private createSchema;
+    private allocateSequences;
+    private createJobRow;
+    private toRecord;
+    private findJob;
+    private requireJob;
+    private assertLock;
+    private createLockToken;
+    private writeJob;
+    private trimTerminal;
+    private resolveParent;
+    private computeRetryAt;
+    private parseParentKey;
+    private matchJob;
+    private jobKey;
+    private encode;
+    private decode;
+    private decodeBackoff;
+    private decodeKeep;
+    private withTransaction;
+    private normalizeConnection;
+    private normalizeUrl;
+    private createInMemoryUrl;
+    private isRetryableSqliteError;
+    private sleep;
+}
+export {};
+//# sourceMappingURL=sqlite-adapter.d.ts.map

package/dist/sqlite-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-adapter.d.ts","sourceRoot":"","sources":["../src/sqlite-adapter.ts"],"names":[],"mappings":"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"}

package/dist/sqlite-adapter.js

@@ -0,0 +1,648 @@
+import { createClient } from "@libsql/client";
+import { and, asc, count, desc, eq, inArray, lte, or, sql } from "drizzle-orm";
+import { drizzle, } from "drizzle-orm/libsql";
+import { index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+const SEQUENCE_KEY = "sequence";
+const TRANSACTION_MAX_RETRIES = 32;
+const counters = sqliteTable("eventually_counters", {
+    namespace: text("namespace").notNull(),
+    key: text("key").notNull(),
+    value: integer("value").notNull(),
+}, (table) => ({
+    pk: primaryKey({ columns: [table.namespace, table.key] }),
+}));
+const jobs = sqliteTable("eventually_jobs", {
+    namespace: text("namespace").notNull(),
+    queueName: text("queue_name").notNull(),
+    jobId: text("job_id").notNull(),
+    name: text("name").notNull(),
+    data: text("data").notNull(),
+    state: text("state").notNull().$type(),
+    attempt: integer("attempt").notNull(),
+    attempts: integer("attempts").notNull(),
+    priority: integer("priority").notNull(),
+    delay: integer("delay").notNull(),
+    createdAt: integer("created_at").notNull(),
+    processedAt: integer("processed_at"),
+    finishedAt: integer("finished_at"),
+    result: text("result"),
+    failedReason: text("failed_reason"),
+    stack: text("stack"),
+    progress: text("progress"),
+    lockToken: text("lock_token"),
+    availableAt: integer("available_at").notNull(),
+    backoff: text("backoff"),
+    removeOnComplete: text("remove_on_complete").notNull(),
+    removeOnFail: text("remove_on_fail").notNull(),
+    parentKey: text("parent_key"),
+    pendingChildren: integer("pending_children").notNull(),
+    childFailure: text("child_failure"),
+    sequence: integer("sequence").notNull(),
+}, (table) => ({
+    pk: primaryKey({ columns: [table.namespace, table.queueName, table.jobId] }),
+    waitingIdx: index("eventually_jobs_waiting_idx").on(table.namespace, table.queueName, table.state, table.priority, table.sequence),
+    availableIdx: index("eventually_jobs_available_idx").on(table.namespace, table.queueName, table.state, table.availableAt, table.sequence),
+    finishedIdx: index("eventually_jobs_finished_idx").on(table.namespace, table.queueName, table.state, table.finishedAt, table.sequence),
+}));
+export class SQLiteAdapter {
+    client;
+    db;
+    namespace;
+    schemaPromise = null;
+    closed = false;
+    constructor(options = {}) {
+        this.client = createClient(this.normalizeConnection(options.connection));
+        this.db = drizzle(this.client);
+        this.namespace = options.namespace ?? "default";
+    }
+    async enqueue(request) {
+        await this.ensureReady();
+        return this.withTransaction(async (tx) => {
+            const existing = await this.findJob(tx, request.queueName, request.id);
+            if (existing) {
+                return this.toRecord(existing);
+            }
+            const [sequence] = await this.allocateSequences(tx, 1);
+            if (sequence === undefined) {
+                throw new Error("Failed to allocate job sequence.");
+            }
+            const row = this.createJobRow(request, sequence);
+            await tx.insert(jobs).values(row);
+            return this.toRecord(row);
+        });
+    }
+    async enqueueMany(requests) {
+        await this.ensureReady();
+        if (requests.length === 0) {
+            return [];
+        }
+        return this.withTransaction(async (tx) => {
+            const existing = new Map();
+            const requestedByQueue = new Map();
+            for (const request of requests) {
+                let ids = requestedByQueue.get(request.queueName);
+                if (!ids) {
+                    ids = new Set();
+                    requestedByQueue.set(request.queueName, ids);
+                }
+                ids.add(request.id);
+            }
+            for (const [queueName, ids] of requestedByQueue) {
+                const rows = await tx
+                    .select()
+                    .from(jobs)
+                    .where(and(eq(jobs.namespace, this.namespace), eq(jobs.queueName, queueName), inArray(jobs.jobId, [...ids])));
+                for (const row of rows) {
+                    existing.set(this.jobKey(row.queueName, row.jobId), row);
+                }
+            }
+            const uniqueMissing = new Map();
+            for (const request of requests) {
+                const key = this.jobKey(request.queueName, request.id);
+                if (!existing.has(key) && !uniqueMissing.has(key)) {
+                    uniqueMissing.set(key, request);
+                }
+            }
+            const missing = [...uniqueMissing.values()];
+            const sequences = await this.allocateSequences(tx, missing.length);
+            const rowsToInsert = missing.map((request, index) => this.createJobRow(request, sequences[index]));
+            if (rowsToInsert.length > 0) {
+                await tx.insert(jobs).values(rowsToInsert);
+            }
+            const inserted = new Map(rowsToInsert.map((row) => [this.jobKey(row.queueName, row.jobId), row]));
+            return requests.map((request) => {
+                const key = this.jobKey(request.queueName, request.id);
+                const row = existing.get(key) ?? inserted.get(key);
+                if (!row) {
+                    throw new Error(`Failed to enqueue job ${key}.`);
+                }
+                return this.toRecord(row);
+            });
+        });
+    }
+    async getJob(queueName, jobId) {
+        await this.ensureReady();
+        const row = await this.findJob(this.db, queueName, jobId);
+        return row ? this.toRecord(row) : null;
+    }
+    async claimNext(queueName, options) {
+        await this.ensureReady();
+        return this.withTransaction(async (tx) => {
+            const candidates = await tx
+                .select()
+                .from(jobs)
+                .where(and(eq(jobs.namespace, this.namespace), eq(jobs.queueName, queueName), or(eq(jobs.state, "waiting"), and(eq(jobs.state, "delayed"), lte(jobs.availableAt, options.now)))))
+                .orderBy(desc(jobs.priority), asc(jobs.sequence))
+                .limit(options.limit);
+            const claimed = [];
+            for (const row of candidates) {
+                const updated = await tx
+                    .update(jobs)
+                    .set({
+                    state: "active",
+                    attempt: row.attempt + 1,
+                    processedAt: row.processedAt ?? options.now,
+                    lockToken: this.createLockToken(row, options.now),
+                    availableAt: options.now + options.lockTtlMs,
+                    finishedAt: null,
+                })
+                    .where(and(this.matchJob(row.queueName, row.jobId), eq(jobs.state, row.state), row.state === "delayed" ? lte(jobs.availableAt, options.now) : undefined))
+                    .returning();
+                const next = updated[0];
+                if (next) {
+                    claimed.push(this.toRecord(next));
+                }
+            }
+            return claimed;
+        });
+    }
+    async complete(queueName, jobId, lockToken, result, finishedAt, keep) {
+        await this.ensureReady();
+        await this.withTransaction(async (tx) => {
+            const row = await this.requireJob(tx, queueName, jobId);
+            this.assertLock(row, lockToken);
+            const updated = {
+                ...row,
+                state: "completed",
+                finishedAt,
+                result: this.encode(result),
+                lockToken: null,
+                availableAt: finishedAt,
+            };
+            if (keep.mode === "none") {
+                await tx.delete(jobs).where(this.matchJob(updated.queueName, updated.jobId));
+            }
+            else {
+                await this.writeJob(tx, updated);
+                await this.trimTerminal(tx, queueName, "completed", keep);
+            }
+            await this.resolveParent(tx, updated.parentKey, finishedAt, null);
+        });
+    }
+    async fail(queueName, jobId, lockToken, failure, finishedAt, retryAt, keep) {
+        await this.ensureReady();
+        await this.withTransaction(async (tx) => {
+            const row = await this.requireJob(tx, queueName, jobId);
+            this.assertLock(row, lockToken);
+            if (retryAt !== null) {
+                const retried = {
+                    ...row,
+                    state: retryAt <= finishedAt ? "waiting" : "delayed",
+                    finishedAt: null,
+                    failedReason: failure.message,
+                    stack: failure.stack,
+                    result: null,
+                    lockToken: null,
+                    availableAt: retryAt,
+                };
+                await this.writeJob(tx, retried);
+                return;
+            }
+            const failed = {
+                ...row,
+                state: "failed",
+                finishedAt,
+                failedReason: failure.message,
+                stack: failure.stack,
+                result: null,
+                lockToken: null,
+                availableAt: finishedAt,
+            };
+            if (keep.mode === "none") {
+                await tx.delete(jobs).where(this.matchJob(failed.queueName, failed.jobId));
+            }
+            else {
+                await this.writeJob(tx, failed);
+                await this.trimTerminal(tx, queueName, "failed", keep);
+            }
+            await this.resolveParent(tx, failed.parentKey, finishedAt, failure.message);
+        });
+    }
+    async updateProgress(queueName, jobId, lockToken, progress, updatedAt) {
+        void updatedAt;
+        await this.ensureReady();
+        await this.withTransaction(async (tx) => {
+            const row = await this.requireJob(tx, queueName, jobId);
+            this.assertLock(row, lockToken);
+            await tx
+                .update(jobs)
+                .set({
+                progress: this.encode(progress),
+            })
+                .where(this.matchJob(queueName, jobId));
+        });
+    }
+    async recoverStalled(queueName, now, lockTtlMs, limit) {
+        void lockTtlMs;
+        await this.ensureReady();
+        return this.withTransaction(async (tx) => {
+            const stalled = await tx
+                .select()
+                .from(jobs)
+                .where(and(eq(jobs.namespace, this.namespace), eq(jobs.queueName, queueName), eq(jobs.state, "active"), lte(jobs.availableAt, now)))
+                .orderBy(asc(jobs.availableAt), asc(jobs.sequence))
+                .limit(limit);
+            const recovered = [];
+            for (const row of stalled) {
+                if (row.attempt < row.attempts) {
+                    const retryAt = this.computeRetryAt(row, now);
+                    const retried = {
+                        ...row,
+                        state: retryAt <= now ? "waiting" : "delayed",
+                        lockToken: null,
+                        finishedAt: null,
+                        availableAt: retryAt,
+                    };
+                    await this.writeJob(tx, retried);
+                    recovered.push(this.toRecord(retried));
+                    continue;
+                }
+                const message = row.failedReason ?? "stalled job failed";
+                const failed = {
+                    ...row,
+                    state: "failed",
+                    finishedAt: now,
+                    failedReason: message,
+                    lockToken: null,
+                    availableAt: now,
+                };
+                const keep = this.decodeKeep(row.removeOnFail);
+                if (keep.mode === "none") {
+                    await tx.delete(jobs).where(this.matchJob(row.queueName, row.jobId));
+                }
+                else {
+                    await this.writeJob(tx, failed);
+                    await this.trimTerminal(tx, queueName, "failed", keep);
+                }
+                await this.resolveParent(tx, row.parentKey, now, message);
+                recovered.push(this.toRecord(failed));
+            }
+            return recovered;
+        });
+    }
+    async migrate() {
+        await this.ensureReady();
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        await this.client.close?.();
+    }
+    async ensureReady() {
+        if (this.closed) {
+            throw new Error("SQLiteAdapter is closed.");
+        }
+        if (!this.schemaPromise) {
+            this.schemaPromise = this.createSchema();
+        }
+        await this.schemaPromise;
+    }
+    async createSchema() {
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS eventually_counters (
+        namespace TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value INTEGER NOT NULL,
+        PRIMARY KEY (namespace, key)
+      )
+    `);
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS eventually_jobs (
+        namespace TEXT NOT NULL,
+        queue_name TEXT NOT NULL,
+        job_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        data TEXT NOT NULL,
+        state TEXT NOT NULL,
+        attempt INTEGER NOT NULL,
+        attempts INTEGER NOT NULL,
+        priority INTEGER NOT NULL,
+        delay INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        processed_at INTEGER,
+        finished_at INTEGER,
+        result TEXT,
+        failed_reason TEXT,
+        stack TEXT,
+        progress TEXT,
+        lock_token TEXT,
+        available_at INTEGER NOT NULL,
+        backoff TEXT,
+        remove_on_complete TEXT NOT NULL,
+        remove_on_fail TEXT NOT NULL,
+        parent_key TEXT,
+        pending_children INTEGER NOT NULL,
+        child_failure TEXT,
+        sequence INTEGER NOT NULL,
+        PRIMARY KEY (namespace, queue_name, job_id)
+      )
+    `);
+        await this.client.execute(`
+      CREATE INDEX IF NOT EXISTS eventually_jobs_waiting_idx
+      ON eventually_jobs (namespace, queue_name, state, priority DESC, sequence ASC)
+    `);
+        await this.client.execute(`
+      CREATE INDEX IF NOT EXISTS eventually_jobs_available_idx
+      ON eventually_jobs (namespace, queue_name, state, available_at ASC, sequence ASC)
+    `);
+        await this.client.execute(`
+      CREATE INDEX IF NOT EXISTS eventually_jobs_finished_idx
+      ON eventually_jobs (namespace, queue_name, state, finished_at ASC, sequence ASC)
+    `);
+    }
+    async allocateSequences(tx, countNeeded) {
+        if (countNeeded === 0) {
+            return [];
+        }
+        await tx
+            .insert(counters)
+            .values({
+            namespace: this.namespace,
+            key: SEQUENCE_KEY,
+            value: 0,
+        })
+            .onConflictDoNothing();
+        await tx
+            .update(counters)
+            .set({
+            value: sql `${counters.value} + ${countNeeded}`,
+        })
+            .where(and(eq(counters.namespace, this.namespace), eq(counters.key, SEQUENCE_KEY)));
+        const [row] = await tx
+            .select()
+            .from(counters)
+            .where(and(eq(counters.namespace, this.namespace), eq(counters.key, SEQUENCE_KEY)))
+            .limit(1);
+        const end = row?.value;
+        if (end === undefined) {
+            throw new Error("Failed to read allocated sequence.");
+        }
+        return Array.from({ length: countNeeded }, (_, index) => end - countNeeded + index + 1);
+    }
+    createJobRow(request, sequence) {
+        const state = (request.pendingChildren ?? 0) > 0
+            ? "blocked"
+            : request.delay > 0
+                ? "delayed"
+                : "waiting";
+        return {
+            namespace: this.namespace,
+            queueName: request.queueName,
+            jobId: request.id,
+            name: request.name,
+            data: this.encode(request.data),
+            state,
+            attempt: 0,
+            attempts: request.attempts,
+            priority: request.priority,
+            delay: request.delay,
+            createdAt: request.createdAt,
+            processedAt: null,
+            finishedAt: null,
+            result: null,
+            failedReason: null,
+            stack: null,
+            progress: null,
+            lockToken: null,
+            availableAt: request.createdAt + request.delay,
+            backoff: request.backoff ? this.encode(request.backoff) : null,
+            removeOnComplete: this.encode(request.removeOnComplete),
+            removeOnFail: this.encode(request.removeOnFail),
+            parentKey: request.parentKey ?? null,
+            pendingChildren: request.pendingChildren ?? 0,
+            childFailure: null,
+            sequence,
+        };
+    }
+    toRecord(row) {
+        return {
+            id: row.jobId,
+            queueName: row.queueName,
+            name: row.name,
+            data: this.decode(row.data),
+            state: row.state,
+            attempt: row.attempt,
+            attempts: row.attempts,
+            priority: row.priority,
+            delay: row.delay,
+            createdAt: row.createdAt,
+            processedAt: row.processedAt,
+            finishedAt: row.finishedAt,
+            result: this.decode(row.result),
+            failedReason: row.failedReason,
+            stack: row.stack,
+            progress: this.decode(row.progress),
+            lockToken: row.lockToken,
+            backoff: this.decodeBackoff(row.backoff),
+            removeOnComplete: this.decodeKeep(row.removeOnComplete),
+            removeOnFail: this.decodeKeep(row.removeOnFail),
+            parentKey: row.parentKey,
+            pendingChildren: row.pendingChildren,
+            childFailure: row.childFailure,
+        };
+    }
+    async findJob(tx, queueName, jobId) {
+        const [row] = await tx
+            .select()
+            .from(jobs)
+            .where(this.matchJob(queueName, jobId))
+            .limit(1);
+        return row ?? null;
+    }
+    async requireJob(tx, queueName, jobId) {
+        const row = await this.findJob(tx, queueName, jobId);
+        if (!row) {
+            throw new Error(`Job ${jobId} was not found in queue ${queueName}.`);
+        }
+        return row;
+    }
+    assertLock(row, lockToken) {
+        if (row.lockToken !== lockToken) {
+            throw new Error("lock-mismatch");
+        }
+    }
+    createLockToken(row, now) {
+        return `${row.queueName}:${row.jobId}:${row.attempt + 1}:${now}`;
+    }
+    async writeJob(tx, row) {
+        await tx
+            .update(jobs)
+            .set({
+            state: row.state,
+            attempt: row.attempt,
+            processedAt: row.processedAt,
+            finishedAt: row.finishedAt,
+            result: row.result,
+            failedReason: row.failedReason,
+            stack: row.stack,
+            progress: row.progress,
+            lockToken: row.lockToken,
+            availableAt: row.availableAt,
+            backoff: row.backoff,
+            removeOnComplete: row.removeOnComplete,
+            removeOnFail: row.removeOnFail,
+            parentKey: row.parentKey,
+            pendingChildren: row.pendingChildren,
+            childFailure: row.childFailure,
+        })
+            .where(this.matchJob(row.queueName, row.jobId));
+    }
+    async trimTerminal(tx, queueName, state, keep) {
+        if (keep.mode !== "count") {
+            return;
+        }
+        const [counter] = await tx
+            .select({ value: count() })
+            .from(jobs)
+            .where(and(eq(jobs.namespace, this.namespace), eq(jobs.queueName, queueName), eq(jobs.state, state)));
+        const current = Number(counter?.value ?? 0);
+        const limit = keep.count ?? 0;
+        const overflow = current - limit;
+        if (overflow <= 0) {
+            return;
+        }
+        const doomed = await tx
+            .select({ queueName: jobs.queueName, jobId: jobs.jobId })
+            .from(jobs)
+            .where(and(eq(jobs.namespace, this.namespace), eq(jobs.queueName, queueName), eq(jobs.state, state)))
+            .orderBy(asc(jobs.finishedAt), asc(jobs.sequence))
+            .limit(overflow);
+        for (const row of doomed) {
+            await tx.delete(jobs).where(this.matchJob(row.queueName, row.jobId));
+        }
+    }
+    async resolveParent(tx, parentKey, finishedAt, failureMessage) {
+        let currentParentKey = parentKey;
+        let propagatedFailure = failureMessage;
+        while (currentParentKey) {
+            const parsed = this.parseParentKey(currentParentKey);
+            if (!parsed) {
+                return;
+            }
+            const parent = await this.findJob(tx, parsed.queueName, parsed.jobId);
+            if (!parent) {
+                return;
+            }
+            parent.pendingChildren = Math.max(0, parent.pendingChildren - 1);
+            if (propagatedFailure) {
+                parent.childFailure = propagatedFailure;
+            }
+            if (parent.pendingChildren > 0) {
+                await this.writeJob(tx, parent);
+                return;
+            }
+            if (parent.childFailure) {
+                parent.state = "failed";
+                parent.finishedAt = finishedAt;
+                parent.failedReason = parent.childFailure;
+                parent.lockToken = null;
+                parent.availableAt = finishedAt;
+                const keep = this.decodeKeep(parent.removeOnFail);
+                if (keep.mode === "none") {
+                    await tx.delete(jobs).where(this.matchJob(parent.queueName, parent.jobId));
+                }
+                else {
+                    await this.writeJob(tx, parent);
+                    await this.trimTerminal(tx, parent.queueName, "failed", keep);
+                }
+                propagatedFailure = parent.childFailure;
+                currentParentKey = parent.parentKey;
+                continue;
+            }
+            if (parent.delay > 0 && parent.createdAt + parent.delay > finishedAt) {
+                parent.state = "delayed";
+                parent.availableAt = parent.createdAt + parent.delay;
+            }
+            else {
+                parent.state = "waiting";
+                parent.availableAt = finishedAt;
+            }
+            await this.writeJob(tx, parent);
+            return;
+        }
+    }
+    computeRetryAt(row, now) {
+        const backoff = this.decodeBackoff(row.backoff);
+        if (!backoff) {
+            return now;
+        }
+        if (backoff.type === "fixed") {
+            return now + backoff.delayMs;
+        }
+        const delay = backoff.delayMs * 2 ** Math.max(0, row.attempt - 1);
+        return now + Math.min(delay, backoff.maxDelayMs ?? delay);
+    }
+    parseParentKey(parentKey) {
+        const separator = parentKey.indexOf(":");
+        if (separator < 1 || separator === parentKey.length - 1) {
+            return null;
+        }
+        return {
+            queueName: parentKey.slice(0, separator),
+            jobId: parentKey.slice(separator + 1),
+        };
+    }
+    matchJob(queueName, jobId) {
+        return and(eq(jobs.namespace, this.namespace), eq(jobs.queueName, queueName), eq(jobs.jobId, jobId));
+    }
+    jobKey(queueName, jobId) {
+        return `${queueName}:${jobId}`;
+    }
+    encode(value) {
+        return JSON.stringify(value ?? null);
+    }
+    decode(value) {
+        return value === null ? null : JSON.parse(value);
+    }
+    decodeBackoff(value) {
+        return this.decode(value);
+    }
+    decodeKeep(value) {
+        return JSON.parse(value);
+    }
+    async withTransaction(callback) {
+        let attempt = 0;
+        while (true) {
+            try {
+                return await this.db.transaction((tx) => callback(tx));
+            }
+            catch (error) {
+                if (!this.isRetryableSqliteError(error) || attempt >= TRANSACTION_MAX_RETRIES) {
+                    throw error;
+                }
+                attempt += 1;
+                await this.sleep(Math.min(10, attempt));
+            }
+        }
+    }
+    normalizeConnection(connection) {
+        if (typeof connection === "string") {
+            return { url: this.normalizeUrl(connection) };
+        }
+        if (connection) {
+            return {
+                ...connection,
+                url: this.normalizeUrl(connection.url),
+            };
+        }
+        return { url: this.createInMemoryUrl() };
+    }
+    normalizeUrl(url) {
+        return url === ":memory:" ? this.createInMemoryUrl() : url;
+    }
+    createInMemoryUrl() {
+        return "file::memory:?cache=shared";
+    }
+    isRetryableSqliteError(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        const code = "code" in error ? String(error.code) : "";
+        return code.startsWith("SQLITE_BUSY") || code.startsWith("SQLITE_LOCKED");
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@ventually/sqlite",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "@ventually/sqlite": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run --project unit",
+    "test:stress": "bun run ./test/sqlite.stress.ts"
+  },
+  "dependencies": {
+    "@libsql/client": "^0.15.15",
+    "drizzle-orm": "^0.44.5",
+    "@ventually/core": "*"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "@types/node": "^25.5.2",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  }
+}