sqlite: restore connection state on reopen

close() destroys the connection but keeps the DatabaseSync object, and
open() did not replay the state held on it.

An authorizer set with setAuthorizer() was not reinstalled, silently
dropping a deny-all policy. Limits written through db.limits.* reverted
to the constructor values. Extension loading was re-enabled from the
constructor ceiling rather than the current setting, leaving the SQL
load_extension() function reachable after enableLoadExtension(false).

Signed-off-by: Guilherme Araújo <arauujogui@gmail.com>
Assisted-by: Claude Code

Author: araujogui

src/node_sqlite.cc

@@ -968,8 +968,7 @@ Intercepted DatabaseSyncLimits::LimitsSetter(
     }
   }
 
-  sqlite3_limit(
-      limits->database_->Connection(), limit_info->sqlite_limit_id, new_value);
+  limits->database_->SetLimit(limit_info->sqlite_limit_id, new_value);
   return Intercepted::kYes;
 }
 
@@ -1149,15 +1148,14 @@ bool DatabaseSync::Open() {
 
   sqlite3_busy_timeout(connection_.get(), open_config_.get_timeout());
 
-  // Apply initial limits
   for (const auto& [js_name, sqlite_limit_id] : kLimitMapping) {
-    const auto& limit_value = open_config_.initial_limits()[sqlite_limit_id];
+    const auto& limit_value = open_config_.limits()[sqlite_limit_id];
     if (limit_value.has_value()) {
       sqlite3_limit(connection_.get(), sqlite_limit_id, *limit_value);
     }
   }
 
-  if (allow_load_extension_) {
+  if (enable_load_extension_) {
     if (env()->permission()->enabled()) [[unlikely]] {
       THROW_ERR_LOAD_SQLITE_EXTENSION(env(),
                                       "Cannot load SQLite extensions when the "
@@ -1176,6 +1174,15 @@ bool DatabaseSync::Open() {
         connection_.get(), SQLITE_TRACE_PROFILE, TraceCallback, this);
   }
 
+  // The authorizer outlives the connection, so reopening must reinstall it.
+  Local<Value> authorizer =
+      object()->GetInternalField(kAuthorizerCallback).template As<Value>();
+  if (authorizer->IsFunction()) {
+    r = sqlite3_set_authorizer(
+        connection_.get(), DatabaseSync::AuthorizerCallback, this);
+    CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);
+  }
+
   opened = true;
   return true;
 }
@@ -1223,6 +1230,11 @@ inline sqlite3* DatabaseSync::Connection() {
   return connection_.get();
 }
 
+void DatabaseSync::SetLimit(int sqlite_limit_id, int value) {
+  sqlite3_limit(connection_.get(), sqlite_limit_id, value);
+  open_config_.set_limit(sqlite_limit_id, value);
+}
+
 void DatabaseSync::SetIgnoreNextSQLiteError(bool ignore) {
   ignore_next_sqlite_error_ = ignore;
 }
@@ -1564,7 +1576,7 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
             return;
           }
 
-          open_config.set_initial_limit(sqlite_limit_id, limit_val);
+          open_config.set_limit(sqlite_limit_id, limit_val);
         }
       }
     }

src/node_sqlite.h

@@ -139,13 +139,13 @@ class DatabaseOpenConfiguration {
 
   inline bool get_enable_defensive() const { return defensive_; }
 
-  inline void set_initial_limit(int sqlite_limit_id, int value) {
-    initial_limits_.at(sqlite_limit_id) = value;
+  inline void set_limit(int sqlite_limit_id, int value) {
+    limits_.at(sqlite_limit_id) = value;
   }
 
-  inline const std::array<std::optional<int>, kLimitMapping.size()>&
-  initial_limits() const {
-    return initial_limits_;
+  inline const std::array<std::optional<int>, kLimitMapping.size()>& limits()
+      const {
+    return limits_;
   }
 
  private:
@@ -159,7 +159,7 @@ class DatabaseOpenConfiguration {
   bool allow_bare_named_params_ = true;
   bool allow_unknown_named_params_ = false;
   bool defensive_ = true;
-  std::array<std::optional<int>, kLimitMapping.size()> initial_limits_{};
+  std::array<std::optional<int>, kLimitMapping.size()> limits_{};
 };
 
 class DatabaseSync;
@@ -279,6 +279,7 @@ class DatabaseSync : public BaseObject {
     return open_config_.get_allow_unknown_named_params();
   }
   sqlite3* Connection();
+  void SetLimit(int sqlite_limit_id, int value);
 
   // In some situations, such as when using custom functions, it is possible
   // that SQLite reports an error while JavaScript already has a pending

test/parallel/test-sqlite-authz.js

@@ -287,6 +287,37 @@ suite('DatabaseSync.prototype.setAuthorizer()', () => {
       message: 'database is not open',
     });
   });
+
+  it('remains installed after close() and open()', (t) => {
+    const db = new DatabaseSync(':memory:');
+    const authorizer = t.mock.fn(() => constants.SQLITE_DENY);
+    db.setAuthorizer(authorizer);
+
+    assert.throws(() => {
+      db.exec('CREATE TABLE x (a)');
+    }, { code: 'ERR_SQLITE_ERROR' });
+    const callsBefore = authorizer.mock.callCount();
+    assert.ok(callsBefore > 0);
+
+    db.close();
+    db.open();
+
+    assert.throws(() => {
+      db.exec('CREATE TABLE x (a)');
+    }, { code: 'ERR_SQLITE_ERROR' });
+    assert.ok(authorizer.mock.callCount() > callsBefore);
+  });
+
+  it('stays cleared after close() and open()', () => {
+    const db = new DatabaseSync(':memory:');
+    db.setAuthorizer(() => constants.SQLITE_DENY);
+    db.setAuthorizer(null);
+
+    db.close();
+    db.open();
+
+    db.exec('CREATE TABLE x (a)');
+  });
 });
 
 // SQLite forbids an authorizer callback from modifying the connection that

test/parallel/test-sqlite-limits.js

@@ -301,4 +301,19 @@ suite('DatabaseSync limits', () => {
       message: /too many attached databases/,
     });
   });
+
+  test('limits set at runtime survive close() and open()', (t) => {
+    const db = new DatabaseSync(':memory:');
+
+    db.limits.attach = 0;
+    db.close();
+    db.open();
+
+    t.assert.strictEqual(db.limits.attach, 0);
+    t.assert.throws(() => {
+      db.exec("ATTACH DATABASE ':memory:' AS db1");
+    }, {
+      message: /too many attached databases/,
+    });
+  });
 });