Add support for connection "timeout" option (#170)

Fixes #160

Author: penberg

Cargo.lock

@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-libsql = { git = "https://github.com/tursodatabase/libsql/", rev = "9aa89fee3a096538336d30f3d9e9f2df8ba6677d", features = ["encryption"] }
+libsql = { git = "https://github.com/tursodatabase/libsql/", rev = "e40c4319829e0805313fadcaa19034b89b7708ad", features = ["encryption"] }
 tracing = "0.1"
 once_cell = "1.18.0"
 tokio = { version = "1.29.1", features = [ "rt-multi-thread" ] }

Cargo.toml

@@ -21,6 +21,7 @@ You can use the `options` parameter to specify various options. Options supporte
 - `syncUrl`: open the database as embedded replica synchronizing from the provided URL.
 - `syncPeriod`: synchronize the database periodically every `syncPeriod` seconds.
 - `authToken`: authentication token for the provider URL (optional).
+- `timeout`: number of milliseconds to wait on locked database before returning `SQLITE_BUSY` error
 
 The function returns a `Database` object.
 

docs/api.md

@@ -83,7 +83,8 @@ class Database {
     } else {
       const authToken = opts?.authToken ?? "";
       const encryptionKey = opts?.encryptionKey ?? "";
-      this.db = databaseOpen(path, authToken, encryptionCipher, encryptionKey);
+      const timeout = opts?.timeout ?? 0.0;
+      this.db = databaseOpen(path, authToken, encryptionCipher, encryptionKey, timeout);
     }
     // TODO: Use a libSQL API for this?
     this.memory = path === ":memory:";

index.js

@@ -1,4 +1,7 @@
 import test from "ava";
+import crypto from 'crypto';
+import fs from 'fs';
+
 
 test.beforeEach(async (t) => {
   const [db, errorType] = await connect();
@@ -343,6 +346,28 @@ test.serial("Statement.interrupt()", async (t) => {
   });
 });
 
+test.serial("Timeout option", async (t) => {
+  const timeout = 1000;
+  const path = genDatabaseFilename();
+  const [conn1] = await connect(path);
+  await conn1.exec("CREATE TABLE t(x)");
+  await conn1.exec("BEGIN IMMEDIATE");
+  await conn1.exec("INSERT INTO t VALUES (1)")
+  const options = { timeout };
+  const [conn2] = await connect(path, options);
+  const start = Date.now();
+  try {
+    await conn2.exec("INSERT INTO t VALUES (1)")
+  } catch (e) {
+    t.is(e.code, "SQLITE_BUSY");
+    const end = Date.now();
+    const elapsed = end - start;
+    // Allow some tolerance for the timeout.
+    t.is(elapsed > timeout/2, true);
+  }
+  fs.unlinkSync(path);
+});
+
 test.serial("Concurrent writes over same connection", async (t) => {
   const db = t.context.db;
   await db.exec(`
@@ -360,12 +385,16 @@ test.serial("Concurrent writes over same connection", async (t) => {
   t.is(rows.length, 1000);
 });
 
-const connect = async (path_opt) => {
+const connect = async (path_opt, options = {}) => {
   const path = path_opt ?? "hello.db";
   const provider = process.env.PROVIDER;
   const database = process.env.LIBSQL_DATABASE ?? path;
   const x = await import("libsql/promise");
-  const options = {};
   const db = new x.default(database, options);
   return [db, x.SqliteError];
 };
+
+/// Generate a unique database filename
+const genDatabaseFilename = () => {
+  return `test-${crypto.randomBytes(8).toString('hex')}.db`;
+};

integration-tests/package-lock.json

@@ -1,4 +1,6 @@
 import test from "ava";
+import crypto from 'crypto';
+import fs from 'fs';
 
 test.beforeEach(async (t) => {
   const [db, errorType, provider] = await connect();
@@ -408,21 +410,46 @@ test.serial("Database.exec() after close()", async (t) => {
   });
 });
 
-const connect = async (path_opt) => {
+test.serial("Timeout option", async (t) => {
+  const timeout = 1000;
+  const path = genDatabaseFilename();
+  const [conn1] = await connect(path);
+  conn1.exec("CREATE TABLE t(x)");
+  conn1.exec("BEGIN IMMEDIATE");
+  conn1.exec("INSERT INTO t VALUES (1)")
+  const options = { timeout };
+  const [conn2] = await connect(path, options);
+  const start = Date.now();
+  try {
+    conn2.exec("INSERT INTO t VALUES (1)")
+  } catch (e) {
+    t.is(e.code, "SQLITE_BUSY");
+    const end = Date.now();
+    const elapsed = end - start;
+    // Allow some tolerance for the timeout.
+    t.is(elapsed > timeout/2, true);
+  }
+  fs.unlinkSync(path);
+});
+
+const connect = async (path_opt, options = {}) => {
   const path = path_opt ?? "hello.db";
   const provider = process.env.PROVIDER;
   if (provider === "libsql") {
     const database = process.env.LIBSQL_DATABASE ?? path;
     const x = await import("libsql");
-    const options = {};
     const db = new x.default(database, options);
     return [db, x.SqliteError, provider];
   }
   if (provider == "sqlite") {
     const x = await import("better-sqlite3");
-    const options = {};
     const db = x.default(path, options);
     return [db, x.SqliteError, provider];
   }
   throw new Error("Unknown provider: " + provider);
 };
+
+/// Generate a unique database filename
+const genDatabaseFilename = () => {
+  return `test-${crypto.randomBytes(8).toString('hex')}.db`;
+};

integration-tests/tests/async.test.js

@@ -86,7 +86,8 @@ class Database {
     } else {
       const authToken = opts?.authToken ?? "";
       const encryptionKey = opts?.encryptionKey ?? "";
-      this.db = databaseOpen(path, authToken, encryptionCipher, encryptionKey);
+      const timeout = opts?.timeout ?? 0.0;
+      this.db = databaseOpen(path, authToken, encryptionCipher, encryptionKey, timeout);
     }
     // TODO: Use a libSQL API for this?
     this.memory = path === ":memory:";

integration-tests/tests/sync.test.js

@@ -34,6 +34,7 @@ impl Database {
         let auth_token = cx.argument::<JsString>(1)?.value(&mut cx);
         let encryption_cipher = cx.argument::<JsString>(2)?.value(&mut cx);
         let encryption_key = cx.argument::<JsString>(3)?.value(&mut cx);
+        let busy_timeout = cx.argument::<JsNumber>(4)?.value(&mut cx);
         let db = if is_remote_path(&db_path) {
             let version = version("remote");
             trace!("Opening remote database: {}", db_path);
@@ -57,6 +58,10 @@ impl Database {
         let conn = db
             .connect()
             .or_else(|err| throw_libsql_error(&mut cx, err))?;
+        if busy_timeout > 0.0 {
+            conn.busy_timeout(Duration::from_millis(busy_timeout as u64))
+                .or_else(|err| throw_libsql_error(&mut cx, err))?;
+        }
         let db = Database::new(db, conn);
         Ok(cx.boxed(db))
     }