sqlite: add timeout options to DatabaseSync

PR-URL: #57752
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

Author: geeksilva97

doc/api/sqlite.md

@@ -78,6 +78,9 @@ console.log(query.all());
 <!-- YAML
 added: v22.5.0
 changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/57752
+ description: Add `timeout` option.
  - version: v22.15.0
  pr-url: https://github.com/nodejs/node/pull/56991
  description: The `path` argument now supports Buffer and URL objects.
@@ -116,6 +119,9 @@ added: v22.5.0
  and the `loadExtension()` method are enabled.
  You can call `enableLoadExtension(false)` later to disable this feature.
 **Default:**`false`.
+*`timeout` {number} The [busy timeout][] in milliseconds. This is the maximum amount of
+ time that SQLite will wait for a database lock to be released before
+ returning an error. **Default:**`0`.
 
 Constructs a new `DatabaseSync` instance.
 
@@ -821,6 +827,7 @@ resolution handler passed to [`database.applyChangeset()`][]. See also
 [`sqlite3session_create()`]: https://www.sqlite.org/session/sqlite3session_create.html
 [`sqlite3session_delete()`]: https://www.sqlite.org/session/sqlite3session_delete.html
 [`sqlite3session_patchset()`]: https://www.sqlite.org/session/sqlite3session_patchset.html
+[busy timeout]: https://sqlite.org/c3ref/busy_timeout.html
 [connection]: https://www.sqlite.org/c3ref/sqlite3.html
 [data types]: https://www.sqlite.org/datatype3.html
 [double-quoted string literals]: https://www.sqlite.org/quirks.html#dblquote

src/node_sqlite.cc

@@ -731,6 +731,8 @@ bool DatabaseSync::Open() {
 CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);
 CHECK_EQ(foreign_keys_enabled, open_config_.get_enable_foreign_keys());
 
+sqlite3_busy_timeout(connection_, open_config_.get_timeout());
+
 if (allow_load_extension_) {
 if (env()->permission()->enabled()) [[unlikely]] {
 THROW_ERR_LOAD_SQLITE_EXTENSION(env(),
@@ -940,6 +942,23 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
  }
  allow_load_extension = allow_extension_v.As<Boolean>()->Value();
  }
+
+ Local<Value> timeout_v;
+if (!options->Get(env->context(), env->timeout_string())
+ .ToLocal(&timeout_v)) {
+return;
+ }
+
+if (!timeout_v->IsUndefined()) {
+if (!timeout_v->IsInt32()) {
+THROW_ERR_INVALID_ARG_TYPE(
+ env->isolate(),
+"The \"options.timeout\" argument must be an integer.");
+return;
+ }
+
+ open_config.set_timeout(timeout_v.As<Int32>()->Value());
+ }
  }
 
 newDatabaseSync(

src/node_sqlite.h

@@ -35,11 +35,16 @@ class DatabaseOpenConfiguration {
 
 inlinevoidset_enable_dqs(bool flag) { enable_dqs_ = flag; }
 
+inlinevoidset_timeout(int timeout) { timeout_ = timeout; }
+
+inlineintget_timeout() { return timeout_; }
+
 private:
  std::string location_;
 bool read_only_ = false;
 bool enable_foreign_keys_ = true;
 bool enable_dqs_ = false;
+int timeout_ = 0;
 };
 
 classStatementSync;

test/parallel/test-sqlite-database-sync.js

@@ -77,6 +77,15 @@ suite('DatabaseSync() constructor', () => {
 });
 });
 
+test('throws if options.timeout is provided but is not an integer',(t)=>{
+t.assert.throws(()=>{
+newDatabaseSync('foo',{timeout: .99});
+},{
+code: 'ERR_INVALID_ARG_TYPE',
+message: /The"options\.timeout"argumentmustbeaninteger/,
+});
+});
+
 test('is not read-only by default',(t)=>{
 constdbPath=nextDb();
 constdb=newDatabaseSync(dbPath);

test/parallel/test-sqlite-timeout.js

@@ -0,0 +1,72 @@
+'use strict';
+require('../common');
+consttmpdir=require('../common/tmpdir');
+const{ join }=require('node:path');
+const{ DatabaseSync }=require('node:sqlite');
+const{ test }=require('node:test');
+const{ once }=require('node:events');
+const{ Worker }=require('node:worker_threads');
+letcnt=0;
+
+tmpdir.refresh();
+
+functionnextDb(){
+returnjoin(tmpdir.path,`database-${cnt++}.db`);
+}
+
+test('waits to acquire lock',async(t)=>{
+constDB_PATH=nextDb();
+constconn=newDatabaseSync(DB_PATH);
+t.after(()=>{
+try{
+conn.close();
+}catch{
+// Ignore.
+}
+});
+
+conn.exec('CREATE TABLE IF NOT EXISTS data (value TEXT)');
+conn.exec('BEGIN EXCLUSIVE;');
+constworker=newWorker(`
+ 'use strict';
+ const { DatabaseSync } = require('node:sqlite');
+ const { workerData } = require('node:worker_threads');
+ const conn = new DatabaseSync(workerData.database, { timeout: 30000 });
+ conn.exec('SELECT * FROM data');
+ conn.close();
+ `,{
+eval: true,
+workerData: {
+database: DB_PATH,
+}
+});
+awaitonce(worker,'online');
+conn.exec('COMMIT;');
+awaitonce(worker,'exit');
+});
+
+test('throws if the lock cannot be acquired before timeout',(t)=>{
+constDB_PATH=nextDb();
+constconn1=newDatabaseSync(DB_PATH);
+t.after(()=>{
+try{
+conn1.close();
+}catch{
+// Ignore.
+}
+});
+constconn2=newDatabaseSync(DB_PATH,{timeout: 1});
+t.after(()=>{
+try{
+conn2.close();
+}catch{
+// Ignore.
+}
+});
+
+conn1.exec('CREATE TABLE IF NOT EXISTS data (value TEXT)');
+conn1.exec('PRAGMA locking_mode = EXCLUSIVE; BEGIN EXCLUSIVE;');
+t.assert.throws(()=>{
+conn2.exec('SELECT * FROM data');
+},/databaseislocked/);
+});