@absurd-sqlite/bun-worker 0.2.0 → 0.2.2-alpha.0

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { Absurd } from "absurd-sdk";
+import type { AbsurdClient } from "@absurd-sqlite/sdk";
+export type { AbsurdClient } from "@absurd-sqlite/sdk";
 /**
  * Register tasks and perform any one-time setup before the worker starts.
  */
-export type SetupFunction = (absurd: Absurd) => void | Promise<void>;
+export type SetupFunction = (absurd: AbsurdClient) => void | Promise<void>;
 /**
  * Boots a worker using Bun's SQLite driver and Absurd's task engine.
  *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAKpC;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErE;;;;;;GAMG;AACH,wBAA8B,GAAG,CAC/B,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,IAAI,CAAC,CA2Cf"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE3E;;;;;;GAMG;AACH,wBAA8B,GAAG,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C7E"}

package/dist/index.js

@@ -5308,6 +5308,8 @@ import { Database } from "bun:sqlite";
 // src/sqlite.ts
 class BunSqliteConnection {
   db;
+  maxRetries = 5;
+  baseRetryDelayMs = 50;
   constructor(db) {
     this.db = db;
   }
@@ -5315,13 +5317,28 @@ class BunSqliteConnection {
     const { sql: sqliteQuery, paramOrder } = rewritePostgresQuery(sql);
     const sqliteParams = rewritePostgresParams(normalizeParams(params), paramOrder);
     const statement = this.db.query(sqliteQuery);
-    const rows = statement.all(...sqliteParams).map((row) => decodeRowValues(row));
+    const rows = await this.runWithRetry(() => statement.all(...sqliteParams).map((row) => decodeRowValues(row)));
     return { rows };
   }
   async exec(sql, params) {
     const { sql: sqliteQuery, paramOrder } = rewritePostgresQuery(sql);
     const sqliteParams = rewritePostgresParams(normalizeParams(params), paramOrder);
-    this.db.query(sqliteQuery).run(...sqliteParams);
+    const statement = this.db.query(sqliteQuery);
+    await this.runWithRetry(() => statement.run(...sqliteParams));
+  }
+  async runWithRetry(operation) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return operation();
+      } catch (err) {
+        if (!isRetryableSQLiteError(err) || attempt >= this.maxRetries) {
+          throw err;
+        }
+        attempt++;
+        await delay(this.baseRetryDelayMs * attempt);
+      }
+    }
   }
 }
 function rewritePostgresQuery(text) {
@@ -5415,6 +5432,29 @@ function isBindParams(value) {
   const tag = Object.prototype.toString.call(value);
   return tag === "[object Object]";
 }
+var sqliteRetryableErrorCodes = new Set(["SQLITE_BUSY", "SQLITE_LOCKED"]);
+var sqliteRetryableErrnos = new Set([5, 6]);
+function isRetryableSQLiteError(err) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const code = err.code;
+  if (typeof code === "string") {
+    for (const retryableCode of sqliteRetryableErrorCodes) {
+      if (code.startsWith(retryableCode)) {
+        return true;
+      }
+    }
+  }
+  const errno = err.errno;
+  if (typeof errno === "number" && sqliteRetryableErrnos.has(errno)) {
+    return true;
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/index.ts
 async function run(setupFunction) {

package/dist/sqlite.d.ts

@@ -3,10 +3,13 @@ import type { Queryable } from "@absurd-sqlite/sdk";
 import type { SQLiteRestBindParams } from "@absurd-sqlite/sdk";
 export declare class BunSqliteConnection implements Queryable {
     private readonly db;
+    private readonly maxRetries;
+    private readonly baseRetryDelayMs;
     constructor(db: Database);
     query<R extends object = Record<string, any>>(sql: string, params?: SQLiteRestBindParams): Promise<{
         rows: R[];
     }>;
     exec(sql: string, params?: SQLiteRestBindParams): Promise<void>;
+    private runWithRetry;
 }
 //# sourceMappingURL=sqlite.d.ts.map

package/dist/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,qBAAa,mBAAoB,YAAW,SAAS;IACnD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;gBAElB,EAAE,EAAE,QAAQ;IAIlB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChD,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC;QAAE,IAAI,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC;IAenB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;CAStE"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,qBAAa,mBAAoB,YAAW,SAAS;IACnD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAM;gBAE3B,EAAE,EAAE,QAAQ;IAIlB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChD,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC;QAAE,IAAI,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC;IAiBnB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;YAWvD,YAAY;CAc3B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absurd-sqlite/bun-worker",
-  "version": "0.2.0",
+  "version": "0.2.2-alpha.0",
   "description": "Bun worker utilities for Absurd-SQLite",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -1,12 +1,15 @@
 import { Absurd } from "absurd-sdk";
 import { Database } from "bun:sqlite";
+import type { AbsurdClient } from "@absurd-sqlite/sdk";
 
 import { BunSqliteConnection } from "./sqlite";
 
+export type { AbsurdClient } from "@absurd-sqlite/sdk";
+
 /**
  * Register tasks and perform any one-time setup before the worker starts.
  */
-export type SetupFunction = (absurd: Absurd) => void | Promise<void>;
+export type SetupFunction = (absurd: AbsurdClient) => void | Promise<void>;
 
 /**
  * Boots a worker using Bun's SQLite driver and Absurd's task engine.
@@ -15,9 +18,7 @@ export type SetupFunction = (absurd: Absurd) => void | Promise<void>;
  * - ABSURD_DATABASE_PATH: SQLite database file path.
  * - ABSURD_DATABASE_EXTENSION_PATH: Absurd-SQLite extension path (libabsurd.*).
  */
-export default async function run(
-  setupFunction: SetupFunction
-): Promise<void> {
+export default async function run(setupFunction: SetupFunction): Promise<void> {
   const dbPath = process.env.ABSURD_DATABASE_PATH;
   const extensionPath = process.env.ABSURD_DATABASE_EXTENSION_PATH;
 

package/src/sqlite.ts

@@ -9,6 +9,8 @@ import type {
 
 export class BunSqliteConnection implements Queryable {
   private readonly db: Database;
+  private readonly maxRetries = 5;
+  private readonly baseRetryDelayMs = 50;
 
   constructor(db: Database) {
     this.db = db;
@@ -25,8 +27,10 @@ export class BunSqliteConnection implements Queryable {
     );
 
     const statement = this.db.query(sqliteQuery);
-    const rows = statement.all(...sqliteParams).map((row) =>
-      decodeRowValues(row as Record<string, unknown>)
+    const rows = await this.runWithRetry(() =>
+      statement.all(...sqliteParams).map((row) =>
+        decodeRowValues(row as Record<string, unknown>)
+      )
     );
 
     return { rows: rows as R[] };
@@ -39,7 +43,23 @@ export class BunSqliteConnection implements Queryable {
       paramOrder
     );
 
-    this.db.query(sqliteQuery).run(...sqliteParams);
+    const statement = this.db.query(sqliteQuery);
+    await this.runWithRetry(() => statement.run(...sqliteParams));
+  }
+
+  private async runWithRetry<T>(operation: () => T): Promise<T> {
+    let attempt = 0;
+    while (true) {
+      try {
+        return operation();
+      } catch (err) {
+        if (!isRetryableSQLiteError(err) || attempt >= this.maxRetries) {
+          throw err;
+        }
+        attempt++;
+        await delay(this.baseRetryDelayMs * attempt);
+      }
+    }
   }
 }
 
@@ -167,3 +187,32 @@ function isBindParams(value: unknown): value is SQLiteBindParams {
   const tag = Object.prototype.toString.call(value);
   return tag === "[object Object]";
 }
+
+const sqliteRetryableErrorCodes = new Set(["SQLITE_BUSY", "SQLITE_LOCKED"]);
+const sqliteRetryableErrnos = new Set([5, 6]);
+
+function isRetryableSQLiteError(err: unknown): boolean {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+
+  const code = (err as any).code;
+  if (typeof code === "string") {
+    for (const retryableCode of sqliteRetryableErrorCodes) {
+      if (code.startsWith(retryableCode)) {
+        return true;
+      }
+    }
+  }
+
+  const errno = (err as any).errno;
+  if (typeof errno === "number" && sqliteRetryableErrnos.has(errno)) {
+    return true;
+  }
+
+  return false;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/test/run.test.ts

@@ -57,10 +57,13 @@ afterEach(() => {
 
 describe("run", () => {
   it("requires ABSURD_DATABASE_PATH", async () => {
+    process.env.ABSURD_DATABASE_PATH = "";
     process.env.ABSURD_DATABASE_EXTENSION_PATH = extensionPath;
     const { default: run } = await import("../src/index");
 
-    await expect(run(() => {})).rejects.toThrow("ABSURD_DATABASE_PATH is required");
+    await expect(run(() => {})).rejects.toThrow(
+      "ABSURD_DATABASE_PATH is required"
+    );
   });
 
   it("requires ABSURD_DATABASE_EXTENSION_PATH", async () => {

package/test/sqlite.test.ts

@@ -1,5 +1,8 @@
 import { Database } from "bun:sqlite";
-import { describe, expect, it } from "bun:test";
+import { describe, expect, it, jest } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { BunSqliteConnection } from "../src/sqlite";
 
@@ -86,4 +89,71 @@ describe("BunSqliteConnection", () => {
     expect(rows[0]?.created_at.getTime()).toBe(now);
     db.close();
   });
+
+  it("retries when SQLite reports the database is busy", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "absurd-sqlite-busy-"));
+    const dbPath = join(tempDir, "busy.db");
+    const primary = new Database(dbPath);
+    primary.run("PRAGMA busy_timeout = 1");
+    const conn = new BunSqliteConnection(primary);
+    await conn.exec("CREATE TABLE t_busy (id INTEGER PRIMARY KEY, value TEXT)");
+
+    const blocker = new Database(dbPath);
+    blocker.run("PRAGMA busy_timeout = 1");
+    blocker.run("BEGIN EXCLUSIVE");
+
+    let released = false;
+    const releaseLock = () => {
+      if (released) return;
+      released = true;
+      try {
+        blocker.run("COMMIT");
+      } catch {
+        // ignore if already closed
+      }
+      blocker.close();
+    };
+    const timer = setTimeout(releaseLock, 20);
+
+    try {
+      await conn.exec("INSERT INTO t_busy (value) VALUES ($1)", ["alpha"]);
+      const { rows } = await conn.query<{ value: string }>(
+        "SELECT value FROM t_busy"
+      );
+      expect(rows[0]?.value).toBe("alpha");
+    } finally {
+      clearTimeout(timer);
+      releaseLock();
+      primary.close();
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it("retries on locked error codes from SQLite", async () => {
+    const lockedError = new Error("SQLITE_LOCKED: mock lock") as any;
+    lockedError.code = "SQLITE_LOCKED_SHAREDCACHE";
+    lockedError.errno = 6;
+
+    let attempts = 0;
+    const statement = {
+      all: jest.fn(),
+      run: jest.fn(() => {
+        attempts++;
+        if (attempts === 1) {
+          throw lockedError;
+        }
+        return 1;
+      }),
+    };
+
+    const querySpy = jest.fn().mockReturnValue(statement as any);
+    const db = { query: querySpy } as unknown as Database;
+    const conn = new BunSqliteConnection(db);
+
+    await expect(
+      conn.exec("UPDATE locked_table SET value = $1 WHERE id = $2", [1, 1])
+    ).resolves.toBeUndefined();
+    expect(statement.run).toHaveBeenCalledTimes(2);
+    expect(querySpy).toHaveBeenCalledTimes(1);
+  });
 });