@photostructure/sqlite 0.0.1 → 0.2.0

package/src/sqlite_impl.cpp

@@ -4,13 +4,57 @@
 #include <cctype>
 #include <climits>
 #include <cmath>
-#include <iostream>
+#include <limits>
 
 #include "aggregate_function.h"
+#include "shims/sqlite_errors.h"
+
+// Database-aware error handling functions to avoid forward declaration issues
+namespace {
+inline void ThrowErrSqliteErrorWithDb(Napi::Env env,
+                                      photostructure::sqlite::DatabaseSync *db,
+                                      const char *message = nullptr) {
+  // Check if we should ignore this SQLite error due to pending JavaScript
+  // exception (e.g., from authorizer callback)
+  if (db != nullptr && db->ShouldIgnoreSQLiteError()) {
+    db->SetIgnoreNextSQLiteError(false);
+    // Check for deferred authorizer exception and throw it instead
+    if (db->HasDeferredAuthorizerException()) {
+      std::string deferred_msg = db->GetDeferredAuthorizerException();
+      db->ClearDeferredAuthorizerException();
+      Napi::Error::New(env, deferred_msg).ThrowAsJavaScriptException();
+    }
+    return; // Don't throw SQLite error, JavaScript exception takes precedence
+  }
+
+  const char *msg = (message != nullptr) ? message : "SQLite error";
+  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void ThrowEnhancedSqliteErrorWithDB(
+    Napi::Env env, photostructure::sqlite::DatabaseSync *db_sync, sqlite3 *db,
+    int sqlite_code, const std::string &message) {
+  // Check if we should ignore this SQLite error due to pending JavaScript
+  // exception (e.g., from authorizer callback)
+  if (db_sync != nullptr && db_sync->ShouldIgnoreSQLiteError()) {
+    db_sync->SetIgnoreNextSQLiteError(false);
+    // Check for deferred authorizer exception and throw it instead
+    if (db_sync->HasDeferredAuthorizerException()) {
+      std::string deferred_msg = db_sync->GetDeferredAuthorizerException();
+      db_sync->ClearDeferredAuthorizerException();
+      Napi::Error::New(env, deferred_msg).ThrowAsJavaScriptException();
+    }
+    return; // Don't throw SQLite error, JavaScript exception takes precedence
+  }
+
+  // Call the original function
+  node::ThrowEnhancedSqliteError(env, db, sqlite_code, message);
+}
+} // namespace
+#include "sqlite_exception.h"
 #include "user_function.h"
 
-namespace photostructure {
-namespace sqlite {
+namespace photostructure::sqlite {
 
 // JavaScript safe integer limits (2^53 - 1)
 constexpr int64_t JS_MAX_SAFE_INTEGER = 9007199254740991LL;
@@ -29,8 +73,8 @@ std::optional<std::string> ValidateDatabasePath(Napi::Env env, Napi::Value path,
       return location;
     }
   } else if (path.IsBuffer()) {
-    Napi::Buffer<uint8_t> buffer = path.As<Napi::Buffer<uint8_t>>();
-    size_t length = buffer.Length();
+    const auto buffer = path.As<Napi::Buffer<uint8_t>>();
+    const size_t length = buffer.Length();
     const uint8_t *data = buffer.Data();
 
     // Check for null bytes in buffer
@@ -238,6 +282,7 @@ Napi::Object DatabaseSync::Init(Napi::Env env, Napi::Object exports) {
       env, "DatabaseSync",
       {InstanceMethod("open", &DatabaseSync::Open),
        InstanceMethod("close", &DatabaseSync::Close),
+       InstanceMethod("dispose", &DatabaseSync::Dispose),
        InstanceMethod("prepare", &DatabaseSync::Prepare),
        InstanceMethod("exec", &DatabaseSync::Exec),
        InstanceMethod("function", &DatabaseSync::CustomFunction),
@@ -245,9 +290,11 @@ Napi::Object DatabaseSync::Init(Napi::Env env, Napi::Object exports) {
        InstanceMethod("enableLoadExtension",
                       &DatabaseSync::EnableLoadExtension),
        InstanceMethod("loadExtension", &DatabaseSync::LoadExtension),
+       InstanceMethod("enableDefensive", &DatabaseSync::EnableDefensive),
        InstanceMethod("createSession", &DatabaseSync::CreateSession),
        InstanceMethod("applyChangeset", &DatabaseSync::ApplyChangeset),
        InstanceMethod("backup", &DatabaseSync::Backup),
+       InstanceMethod("setAuthorizer", &DatabaseSync::SetAuthorizer),
        InstanceMethod("location", &DatabaseSync::LocationMethod),
        InstanceAccessor("isOpen", &DatabaseSync::IsOpenGetter, nullptr),
        InstanceAccessor("isTransaction", &DatabaseSync::IsTransactionGetter,
@@ -260,13 +307,40 @@ Napi::Object DatabaseSync::Init(Napi::Env env, Napi::Object exports) {
         Napi::Reference<Napi::Function>::New(func);
   }
 
+  // Add Symbol.dispose to the prototype (Node.js v25+ compatibility)
+  Napi::Value symbolDispose =
+      env.Global().Get("Symbol").As<Napi::Object>().Get("dispose");
+  if (!symbolDispose.IsUndefined()) {
+    func.Get("prototype")
+        .As<Napi::Object>()
+        .Set(symbolDispose,
+             Napi::Function::New(
+                 env, [](const Napi::CallbackInfo &info) -> Napi::Value {
+                   DatabaseSync *db =
+                       DatabaseSync::Unwrap(info.This().As<Napi::Object>());
+                   return db->Dispose(info);
+                 }));
+  }
+
+  // Add Symbol.for('sqlite-type') property for type identification
+  // See: https://github.com/nodejs/node/pull/59405
+  Napi::Object symbolConstructor =
+      env.Global().Get("Symbol").As<Napi::Object>();
+  Napi::Function symbolFor = symbolConstructor.Get("for").As<Napi::Function>();
+  Napi::Value sqliteTypeSymbol = symbolFor.Call(
+      symbolConstructor, {Napi::String::New(env, "sqlite-type")});
+  func.Get("prototype")
+      .As<Napi::Object>()
+      .Set(sqliteTypeSymbol, Napi::String::New(env, "node:sqlite"));
+
   exports.Set("DatabaseSync", func);
   return exports;
 }
 
 DatabaseSync::DatabaseSync(const Napi::CallbackInfo &info)
     : Napi::ObjectWrap<DatabaseSync>(info),
-      creation_thread_(std::this_thread::get_id()), env_(info.Env()) {
+      creation_thread_(std::this_thread::get_id()), env_(info.Env()),
+      config_("") {
   // Register this instance for cleanup tracking
   RegisterDatabaseInstance(info.Env(), this);
 
@@ -285,6 +359,9 @@ DatabaseSync::DatabaseSync(const Napi::CallbackInfo &info)
   try {
     DatabaseOpenConfiguration config(std::move(location.value()));
 
+    // Track whether to open immediately (default: true)
+    bool should_open = true;
+
     // Handle options object if provided as second argument
     if (info.Length() > 1 && info[1].IsObject()) {
       Napi::Object options = info[1].As<Napi::Object>();
@@ -324,9 +401,68 @@ DatabaseSync::DatabaseSync(const Napi::CallbackInfo &info)
         allow_load_extension_ =
             options.Get("allowExtension").As<Napi::Boolean>().Value();
       }
+
+      if (options.Has("readBigInts") &&
+          options.Get("readBigInts").IsBoolean()) {
+        config.set_read_big_ints(
+            options.Get("readBigInts").As<Napi::Boolean>().Value());
+      }
+
+      if (options.Has("returnArrays") &&
+          options.Get("returnArrays").IsBoolean()) {
+        config.set_return_arrays(
+            options.Get("returnArrays").As<Napi::Boolean>().Value());
+      }
+
+      if (options.Has("allowBareNamedParameters") &&
+          options.Get("allowBareNamedParameters").IsBoolean()) {
+        config.set_allow_bare_named_params(
+            options.Get("allowBareNamedParameters")
+                .As<Napi::Boolean>()
+                .Value());
+      }
+
+      if (options.Has("allowUnknownNamedParameters") &&
+          options.Get("allowUnknownNamedParameters").IsBoolean()) {
+        config.set_allow_unknown_named_params(
+            options.Get("allowUnknownNamedParameters")
+                .As<Napi::Boolean>()
+                .Value());
+      }
+
+      if (options.Has("defensive")) {
+        Napi::Value defensive_val = options.Get("defensive");
+        if (!defensive_val.IsUndefined()) {
+          if (!defensive_val.IsBoolean()) {
+            node::THROW_ERR_INVALID_ARG_TYPE(
+                info.Env(),
+                "The \"options.defensive\" argument must be a boolean.");
+            return;
+          }
+          config.set_enable_defensive(
+              defensive_val.As<Napi::Boolean>().Value());
+        }
+      }
+
+      // Handle the open option
+      if (options.Has("open")) {
+        Napi::Value open_val = options.Get("open");
+        if (open_val.IsBoolean()) {
+          should_open = open_val.As<Napi::Boolean>().Value();
+        }
+        // For non-boolean values, default to true (existing behavior)
+      }
     }
 
-    InternalOpen(config);
+    // Store configuration for later use
+    config_ = std::move(config);
+
+    // Only open if should_open is true
+    if (should_open) {
+      InternalOpen(config_);
+    }
+  } catch (const SqliteException &e) {
+    node::ThrowFromSqliteException(info.Env(), e);
   } catch (const std::exception &e) {
     node::THROW_ERR_SQLITE_ERROR(info.Env(), e.what());
   }
@@ -345,65 +481,14 @@ Napi::Value DatabaseSync::Open(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
   if (IsOpen()) {
-    node::THROW_ERR_INVALID_STATE(env, "Database is already open");
-    return env.Undefined();
-  }
-
-  if (info.Length() < 1 || !info[0].IsObject()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(env, "Expected configuration object");
-    return env.Undefined();
-  }
-
-  Napi::Object config_obj = info[0].As<Napi::Object>();
-
-  if (!config_obj.Has("location") || !config_obj.Get("location").IsString()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(env,
-                                     "Configuration must have location string");
+    node::THROW_ERR_INVALID_STATE(env, "database is already open");
     return env.Undefined();
   }
 
-  std::string location =
-      config_obj.Get("location").As<Napi::String>().Utf8Value();
-  DatabaseOpenConfiguration config(std::move(location));
-
-  // Parse other options
-  if (config_obj.Has("readOnly") && config_obj.Get("readOnly").IsBoolean()) {
-    config.set_read_only(
-        config_obj.Get("readOnly").As<Napi::Boolean>().Value());
-  }
-
-  // Support both old and new naming for backwards compatibility
-  if (config_obj.Has("enableForeignKeyConstraints") &&
-      config_obj.Get("enableForeignKeyConstraints").IsBoolean()) {
-    config.set_enable_foreign_keys(config_obj.Get("enableForeignKeyConstraints")
-                                       .As<Napi::Boolean>()
-                                       .Value());
-  } else if (config_obj.Has("enableForeignKeys") &&
-             config_obj.Get("enableForeignKeys").IsBoolean()) {
-    config.set_enable_foreign_keys(
-        config_obj.Get("enableForeignKeys").As<Napi::Boolean>().Value());
-  }
-
-  if (config_obj.Has("timeout") && config_obj.Get("timeout").IsNumber()) {
-    config.set_timeout(
-        config_obj.Get("timeout").As<Napi::Number>().Int32Value());
-  }
-
-  if (config_obj.Has("enableDoubleQuotedStringLiterals") &&
-      config_obj.Get("enableDoubleQuotedStringLiterals").IsBoolean()) {
-    config.set_enable_dqs(config_obj.Get("enableDoubleQuotedStringLiterals")
-                              .As<Napi::Boolean>()
-                              .Value());
-  }
-
-  if (config_obj.Has("allowExtension") &&
-      config_obj.Get("allowExtension").IsBoolean()) {
-    allow_load_extension_ =
-        config_obj.Get("allowExtension").As<Napi::Boolean>().Value();
-  }
-
   try {
-    InternalOpen(config);
+    InternalOpen(config_);
+  } catch (const SqliteException &e) {
+    node::ThrowFromSqliteException(env, e);
   } catch (const std::exception &e) {
     node::THROW_ERR_SQLITE_ERROR(env, e.what());
   }
@@ -432,6 +517,26 @@ Napi::Value DatabaseSync::Close(const Napi::CallbackInfo &info) {
   return env.Undefined();
 }
 
+Napi::Value DatabaseSync::Dispose(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (!ValidateThread(env)) {
+    return env.Undefined();
+  }
+
+  // Try to close, but ignore errors during disposal (matches Node.js v25
+  // behavior)
+  try {
+    if (IsOpen()) {
+      InternalClose();
+    }
+  } catch (...) {
+    // Ignore errors during disposal
+  }
+
+  return env.Undefined();
+}
+
 Napi::Value DatabaseSync::Prepare(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
@@ -451,6 +556,10 @@ Napi::Value DatabaseSync::Prepare(const Napi::CallbackInfo &info) {
 
   std::string sql = info[0].As<Napi::String>().Utf8Value();
 
+  // Clear any stale deferred exception from a previous operation
+  ClearDeferredAuthorizerException();
+  SetIgnoreNextSQLiteError(false);
+
   try {
     // Create new StatementSync instance using addon data constructor
     AddonData *addon_data = GetAddonData(env);
@@ -468,6 +577,25 @@ Napi::Value DatabaseSync::Prepare(const Napi::CallbackInfo &info) {
 
     return stmt_obj;
   } catch (const std::exception &e) {
+    // Handle deferred authorizer exceptions:
+    //
+    // When an authorizer callback throws a JavaScript exception, we use a
+    // "marker" exception pattern to safely propagate the error:
+    //
+    // 1. On Windows (MSVC), std::exception::what() can sometimes return an
+    //    empty string, causing message loss.
+    //
+    // 2. By storing the message in the DatabaseSync instance, we can retrieve
+    //    it here and throw a proper JavaScript exception with the original text.
+    //
+    // See also: StatementSync::InitStatement for the other half of this pattern.
+    if (HasDeferredAuthorizerException()) {
+      std::string deferred_msg = GetDeferredAuthorizerException();
+      ClearDeferredAuthorizerException();
+      SetIgnoreNextSQLiteError(false);
+      Napi::Error::New(env, deferred_msg).ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
     node::THROW_ERR_SQLITE_ERROR(env, e.what());
     return env.Undefined();
   }
@@ -492,15 +620,30 @@ Napi::Value DatabaseSync::Exec(const Napi::CallbackInfo &info) {
 
   std::string sql = info[0].As<Napi::String>().Utf8Value();
 
+  // Clear any stale deferred exception from a previous operation
+  ClearDeferredAuthorizerException();
+  SetIgnoreNextSQLiteError(false);
+
   char *error_msg = nullptr;
   int result =
       sqlite3_exec(connection(), sql.c_str(), nullptr, nullptr, &error_msg);
 
   if (result != SQLITE_OK) {
+    // Check for deferred authorizer exception first
+    if (HasDeferredAuthorizerException()) {
+      if (error_msg)
+        sqlite3_free(error_msg);
+      std::string deferred_msg = GetDeferredAuthorizerException();
+      ClearDeferredAuthorizerException();
+      SetIgnoreNextSQLiteError(false);
+      Napi::Error::New(env, deferred_msg).ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
     std::string error = error_msg ? error_msg : "Unknown SQLite error";
     if (error_msg)
       sqlite3_free(error_msg);
-    node::THROW_ERR_SQLITE_ERROR(env, error.c_str());
+    // Use enhanced error throwing with database handle
+    node::ThrowSqliteError(env, connection(), error);
   }
 
   return env.Undefined();
@@ -543,8 +686,10 @@ Napi::Value DatabaseSync::IsTransactionGetter(const Napi::CallbackInfo &info) {
 }
 
 void DatabaseSync::InternalOpen(DatabaseOpenConfiguration config) {
-  location_ = config.location();
-  read_only_ = config.get_read_only();
+  // Store configuration for later use by statements
+  config_ = std::move(config);
+  location_ = config_.location();
+  read_only_ = config_.get_read_only();
 
   int flags = SQLITE_OPEN_CREATE;
   if (read_only_) {
@@ -557,42 +702,64 @@ void DatabaseSync::InternalOpen(DatabaseOpenConfiguration config) {
 
   if (result != SQLITE_OK) {
     std::string error = sqlite3_errmsg(connection_);
+    // Capture error info before closing
+    SqliteException ex(connection_, result,
+                       "Failed to open database: " + error);
     if (connection_) {
       sqlite3_close(connection_);
       connection_ = nullptr;
     }
-    throw std::runtime_error("Failed to open database: " + error);
+    throw ex;
   }
 
   // Configure database
-  if (config.get_enable_foreign_keys()) {
+  if (config_.get_enable_foreign_keys()) {
     sqlite3_exec(connection(), "PRAGMA foreign_keys = ON", nullptr, nullptr,
                  nullptr);
   }
 
-  if (config.get_timeout() > 0) {
-    sqlite3_busy_timeout(connection(), config.get_timeout());
+  if (config_.get_timeout() > 0) {
+    sqlite3_busy_timeout(connection(), config_.get_timeout());
   }
 
   // Configure double-quoted string literals
-  if (config.get_enable_dqs()) {
+  if (config_.get_enable_dqs()) {
     int dqs_enable = 1;
     result = sqlite3_db_config(connection(), SQLITE_DBCONFIG_DQS_DML,
                                dqs_enable, nullptr);
     if (result != SQLITE_OK) {
       std::string error = sqlite3_errmsg(connection());
+      SqliteException ex(connection_, result,
+                         "Failed to configure DQS_DML: " + error);
       sqlite3_close(connection_);
       connection_ = nullptr;
-      throw std::runtime_error("Failed to configure DQS_DML: " + error);
+      throw ex;
     }
 
     result = sqlite3_db_config(connection(), SQLITE_DBCONFIG_DQS_DDL,
                                dqs_enable, nullptr);
     if (result != SQLITE_OK) {
       std::string error = sqlite3_errmsg(connection());
+      SqliteException ex(connection_, result,
+                         "Failed to configure DQS_DDL: " + error);
+      sqlite3_close(connection_);
+      connection_ = nullptr;
+      throw ex;
+    }
+  }
+
+  // Configure defensive mode
+  if (config_.get_enable_defensive()) {
+    int defensive_enabled;
+    result = sqlite3_db_config(connection(), SQLITE_DBCONFIG_DEFENSIVE, 1,
+                               &defensive_enabled);
+    if (result != SQLITE_OK) {
+      std::string error = sqlite3_errmsg(connection());
+      SqliteException ex(connection_, result,
+                         "Failed to configure DEFENSIVE: " + error);
       sqlite3_close(connection_);
       connection_ = nullptr;
-      throw std::runtime_error("Failed to configure DQS_DDL: " + error);
+      throw ex;
     }
   }
 }
@@ -711,7 +878,7 @@ Napi::Value DatabaseSync::CustomFunction(const Napi::CallbackInfo &info) {
     delete user_data; // Clean up on failure
     std::string error = "Failed to create function: ";
     error += sqlite3_errmsg(connection());
-    node::THROW_ERR_SQLITE_ERROR(env, error.c_str());
+    ThrowErrSqliteErrorWithDb(env, this, error.c_str());
   }
 
   return env.Undefined();
@@ -954,6 +1121,36 @@ Napi::Value DatabaseSync::LoadExtension(const Napi::CallbackInfo &info) {
   return env.Undefined();
 }
 
+Napi::Value DatabaseSync::EnableDefensive(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (!ValidateThread(env)) {
+    return env.Undefined();
+  }
+
+  if (!IsOpen()) {
+    node::THROW_ERR_INVALID_STATE(env, "database is not open");
+    return env.Undefined();
+  }
+
+  if (info.Length() < 1 || !info[0].IsBoolean()) {
+    node::THROW_ERR_INVALID_ARG_TYPE(
+        env, "The \"active\" argument must be a boolean.");
+    return env.Undefined();
+  }
+
+  int enable = info[0].As<Napi::Boolean>().Value() ? 1 : 0;
+  int defensive_enabled;
+  int result = sqlite3_db_config(connection(), SQLITE_DBCONFIG_DEFENSIVE,
+                                 enable, &defensive_enabled);
+  if (result != SQLITE_OK) {
+    node::ThrowEnhancedSqliteError(env, connection(), result,
+                                   "Failed to set defensive mode");
+  }
+
+  return env.Undefined();
+}
+
 Napi::Value DatabaseSync::CreateSession(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
@@ -1120,19 +1317,30 @@ Napi::Value DatabaseSync::ApplyChangeset(const Napi::CallbackInfo &info) {
         callbacks.conflictCallback = [env,
                                       conflictFunc](int conflictType) -> int {
           Napi::HandleScope scope(env);
-          Napi::Value result =
-              conflictFunc.Call({Napi::Number::New(env, conflictType)});
+          try {
+            Napi::Value result =
+                conflictFunc.Call({Napi::Number::New(env, conflictType)});
+
+            if (env.IsExceptionPending()) {
+              // Clear the exception to prevent propagation
+              env.GetAndClearPendingException();
+              // If callback threw, abort the changeset apply
+              return SQLITE_CHANGESET_ABORT;
+            }
 
-          if (env.IsExceptionPending()) {
-            // If callback threw, abort the changeset apply
-            return SQLITE_CHANGESET_ABORT;
-          }
+            if (!result.IsNumber()) {
+              // If the callback returns a non-numeric value, treat it as ABORT
+              return SQLITE_CHANGESET_ABORT;
+            }
 
-          if (!result.IsNumber()) {
-            return -1; // Invalid value
+            return result.As<Napi::Number>().Int32Value();
+          } catch (...) {
+            // Catch any C++ exceptions
+            if (env.IsExceptionPending()) {
+              env.GetAndClearPendingException();
+            }
+            return SQLITE_CHANGESET_ABORT;
           }
-
-          return result.As<Napi::Number>().Int32Value();
         };
       }
     }
@@ -1150,15 +1358,25 @@ Napi::Value DatabaseSync::ApplyChangeset(const Napi::CallbackInfo &info) {
       callbacks.filterCallback = [env,
                                   filterFunc](std::string tableName) -> bool {
         Napi::HandleScope scope(env);
-        Napi::Value result =
-            filterFunc.Call({Napi::String::New(env, tableName)});
+        try {
+          Napi::Value result =
+              filterFunc.Call({Napi::String::New(env, tableName)});
+
+          if (env.IsExceptionPending()) {
+            // Clear the exception to prevent propagation
+            env.GetAndClearPendingException();
+            // If callback threw, exclude the table
+            return false;
+          }
 
-        if (env.IsExceptionPending()) {
-          // If callback threw, exclude the table
+          return result.ToBoolean().Value();
+        } catch (...) {
+          // Catch any C++ exceptions
+          if (env.IsExceptionPending()) {
+            env.GetAndClearPendingException();
+          }
           return false;
         }
-
-        return result.ToBoolean().Value();
       };
     }
   }
@@ -1195,13 +1413,18 @@ Napi::Object StatementSync::Init(Napi::Env env, Napi::Object exports) {
        InstanceMethod("all", &StatementSync::All),
        InstanceMethod("iterate", &StatementSync::Iterate),
        InstanceMethod("finalize", &StatementSync::FinalizeStatement),
+       InstanceMethod("dispose", &StatementSync::Dispose),
        InstanceMethod("setReadBigInts", &StatementSync::SetReadBigInts),
        InstanceMethod("setReturnArrays", &StatementSync::SetReturnArrays),
        InstanceMethod("setAllowBareNamedParameters",
                       &StatementSync::SetAllowBareNamedParameters),
+       InstanceMethod("setAllowUnknownNamedParameters",
+                      &StatementSync::SetAllowUnknownNamedParameters),
        InstanceMethod("columns", &StatementSync::Columns),
        InstanceAccessor("sourceSQL", &StatementSync::SourceSQLGetter, nullptr),
        InstanceAccessor("expandedSQL", &StatementSync::ExpandedSQLGetter,
+                        nullptr),
+       InstanceAccessor("finalized", &StatementSync::FinalizedGetter,
                         nullptr)});
 
   // Store constructor in per-instance addon data instead of static variable
@@ -1211,6 +1434,21 @@ Napi::Object StatementSync::Init(Napi::Env env, Napi::Object exports) {
         Napi::Reference<Napi::Function>::New(func);
   }
 
+  // Add Symbol.dispose to the prototype (Node.js v25+ compatibility)
+  Napi::Value symbolDispose =
+      env.Global().Get("Symbol").As<Napi::Object>().Get("dispose");
+  if (!symbolDispose.IsUndefined()) {
+    func.Get("prototype")
+        .As<Napi::Object>()
+        .Set(symbolDispose,
+             Napi::Function::New(
+                 env, [](const Napi::CallbackInfo &info) -> Napi::Value {
+                   StatementSync *stmt =
+                       StatementSync::Unwrap(info.This().As<Napi::Object>());
+                   return stmt->Dispose(info);
+                 }));
+  }
+
   exports.Set("StatementSync", func);
   return exports;
 }
@@ -1228,14 +1466,44 @@ void StatementSync::InitStatement(DatabaseSync *database,
   }
 
   database_ = database;
+  // Create a strong reference to the database object to prevent it from being
+  // garbage collected while this statement exists. This fixes use-after-free
+  // when the database is GC'd before its statements.
+  // See: https://github.com/nodejs/node/pull/56840
+  database_ref_ = Napi::Persistent(database->Value());
   source_sql_ = sql;
 
+  // Apply database-level defaults
+  use_big_ints_ = database->config_.get_read_big_ints();
+  return_arrays_ = database->config_.get_return_arrays();
+  allow_bare_named_params_ = database->config_.get_allow_bare_named_params();
+  allow_unknown_named_params_ =
+      database->config_.get_allow_unknown_named_params();
+
   // Prepare the statement
   const char *tail = nullptr;
   int result = sqlite3_prepare_v2(database->connection(), sql.c_str(), -1,
                                   &statement_, &tail);
 
   if (result != SQLITE_OK) {
+    // Handle deferred authorizer exceptions:
+    //
+    // When an authorizer callback throws a JavaScript exception, we use a
+    // "marker" exception pattern to safely propagate the error:
+    //
+    // 1. On Windows (MSVC), std::exception::what() can sometimes return an
+    //    empty string, causing message loss.
+    //
+    // 2. By storing the message in the DatabaseSync instance, the caller can
+    //    retrieve it and throw a proper JavaScript exception with the original text.
+    //
+    // 3. This matches Node.js's behavior where JavaScript exceptions from
+    //    authorizer callbacks propagate correctly to the caller.
+    if (database->HasDeferredAuthorizerException()) {
+      // Throw a marker exception - the actual message is stored in the database
+      // object and will be retrieved by the caller.
+      throw std::runtime_error("");
+    }
     std::string error = sqlite3_errmsg(database->connection());
     throw std::runtime_error("Failed to prepare statement: " + error);
   }
@@ -1245,6 +1513,10 @@ StatementSync::~StatementSync() {
   if (statement_ && !finalized_) {
     sqlite3_finalize(statement_);
   }
+  // Release the strong reference to the database object
+  if (!database_ref_.IsEmpty()) {
+    database_ref_.Reset();
+  }
 }
 
 Napi::Value StatementSync::Run(const Napi::CallbackInfo &info) {
@@ -1273,11 +1545,23 @@ Napi::Value StatementSync::Run(const Napi::CallbackInfo &info) {
     Reset();
     BindParameters(info);
 
-    int result = sqlite3_step(statement_);
+    // Check if BindParameters set a pending exception
+    if (env.IsExceptionPending()) {
+      return env.Undefined();
+    }
+
+    // Execute the statement
+    sqlite3_step(statement_);
+    // Reset immediately after step to ensure sqlite3_changes() returns
+    // correct value. This fixes an issue where RETURNING queries would
+    // report changes: 0 on the first call.
+    // See: https://github.com/nodejs/node/issues/57344
+    int result = sqlite3_reset(statement_);
 
-    if (result != SQLITE_DONE && result != SQLITE_ROW) {
+    if (result != SQLITE_OK) {
       std::string error = sqlite3_errmsg(database_->connection());
-      node::THROW_ERR_SQLITE_ERROR(env, error.c_str());
+      ThrowEnhancedSqliteErrorWithDB(env, database_, database_->connection(),
+                                     result, error);
       return env.Undefined();
     }
 
@@ -1300,7 +1584,7 @@ Napi::Value StatementSync::Run(const Napi::CallbackInfo &info) {
 
     return result_obj;
   } catch (const std::exception &e) {
-    node::THROW_ERR_SQLITE_ERROR(env, e.what());
+    ThrowErrSqliteErrorWithDb(env, database_, e.what());
     return env.Undefined();
   }
 }
@@ -1331,6 +1615,11 @@ Napi::Value StatementSync::Get(const Napi::CallbackInfo &info) {
     Reset();
     BindParameters(info);
 
+    // Check if BindParameters set a pending exception
+    if (env.IsExceptionPending()) {
+      return env.Undefined();
+    }
+
     int result = sqlite3_step(statement_);
 
     if (result == SQLITE_ROW) {
@@ -1339,11 +1628,12 @@ Napi::Value StatementSync::Get(const Napi::CallbackInfo &info) {
       return env.Undefined();
     } else {
       std::string error = sqlite3_errmsg(database_->connection());
-      node::THROW_ERR_SQLITE_ERROR(env, error.c_str());
+      ThrowEnhancedSqliteErrorWithDB(env, database_, database_->connection(),
+                                     result, error);
       return env.Undefined();
     }
   } catch (const std::exception &e) {
-    node::THROW_ERR_SQLITE_ERROR(env, e.what());
+    ThrowErrSqliteErrorWithDb(env, database_, e.what());
     return env.Undefined();
   }
 }
@@ -1370,6 +1660,11 @@ Napi::Value StatementSync::All(const Napi::CallbackInfo &info) {
     Reset();
     BindParameters(info);
 
+    // Check if BindParameters set a pending exception
+    if (env.IsExceptionPending()) {
+      return env.Undefined();
+    }
+
     Napi::Array results = Napi::Array::New(env);
     uint32_t index = 0;
 
@@ -1422,6 +1717,11 @@ Napi::Value StatementSync::Iterate(const Napi::CallbackInfo &info) {
   // Bind parameters if provided
   BindParameters(info, 0);
 
+  // Check if BindParameters set a pending exception
+  if (info.Env().IsExceptionPending()) {
+    return info.Env().Undefined();
+  }
+
   // Create and return iterator
   return StatementSyncIterator::Create(info.Env(), this);
 }
@@ -1437,6 +1737,21 @@ Napi::Value StatementSync::FinalizeStatement(const Napi::CallbackInfo &info) {
   return info.Env().Undefined();
 }
 
+Napi::Value StatementSync::Dispose(const Napi::CallbackInfo &info) {
+  // Try to finalize, but ignore errors during disposal (matches Node.js v25
+  // behavior)
+  try {
+    if (statement_ && !finalized_) {
+      sqlite3_finalize(statement_);
+      statement_ = nullptr;
+      finalized_ = true;
+    }
+  } catch (...) {
+    // Ignore errors during disposal
+  }
+  return info.Env().Undefined();
+}
+
 Napi::Value StatementSync::SourceSQLGetter(const Napi::CallbackInfo &info) {
   return Napi::String::New(info.Env(), source_sql_);
 }
@@ -1463,6 +1778,10 @@ Napi::Value StatementSync::ExpandedSQLGetter(const Napi::CallbackInfo &info) {
   return info.Env().Undefined();
 }
 
+Napi::Value StatementSync::FinalizedGetter(const Napi::CallbackInfo &info) {
+  return Napi::Boolean::New(info.Env(), finalized_);
+}
+
 Napi::Value StatementSync::SetReadBigInts(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
@@ -1533,6 +1852,30 @@ StatementSync::SetAllowBareNamedParameters(const Napi::CallbackInfo &info) {
   return env.Undefined();
 }
 
+Napi::Value
+StatementSync::SetAllowUnknownNamedParameters(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (finalized_) {
+    node::THROW_ERR_INVALID_STATE(env, "The statement has been finalized");
+    return env.Undefined();
+  }
+
+  if (!database_ || !database_->IsOpen()) {
+    node::THROW_ERR_INVALID_STATE(env, "Database connection is closed");
+    return env.Undefined();
+  }
+
+  if (info.Length() < 1 || !info[0].IsBoolean()) {
+    node::THROW_ERR_INVALID_ARG_TYPE(
+        env, "The \"enabled\" argument must be a boolean.");
+    return env.Undefined();
+  }
+
+  allow_unknown_named_params_ = info[0].As<Napi::Boolean>().Value();
+  return env.Undefined();
+}
+
 Napi::Value StatementSync::Columns(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
@@ -1689,6 +2032,17 @@ void StatementSync::BindParameters(const Napi::CallbackInfo &info,
           node::THROW_ERR_INVALID_ARG_VALUE(env, msg.c_str());
           return;
         }
+      } else {
+        // Unknown named parameter
+        if (allow_unknown_named_params_) {
+          // Skip unknown parameters when allowed (matches Node.js v25 behavior)
+          continue;
+        } else {
+          // Throw error when not allowed (default behavior)
+          std::string msg = "Unknown named parameter '" + key_str + "'";
+          node::THROW_ERR_INVALID_ARG_VALUE(env, msg.c_str());
+          return;
+        }
       }
     }
   } else {
@@ -1733,7 +2087,9 @@ void StatementSync::BindSingleParameter(int param_index, Napi::Value param) {
       }
     } else if (param.IsNumber()) {
       double val = param.As<Napi::Number>().DoubleValue();
-      if (val == std::floor(val) && val >= INT32_MIN && val <= INT32_MAX) {
+      if (std::abs(val - std::floor(val)) <
+              std::numeric_limits<double>::epsilon() &&
+          val >= INT32_MIN && val <= INT32_MAX) {
         sqlite3_bind_int(statement_, param_index,
                          param.As<Napi::Number>().Int32Value());
       } else {
@@ -1747,22 +2103,55 @@ void StatementSync::BindSingleParameter(int param_index, Napi::Value param) {
     } else if (param.IsBoolean()) {
       sqlite3_bind_int(statement_, param_index,
                        param.As<Napi::Boolean>().Value() ? 1 : 0);
+    } else if (param.IsDataView()) {
+      // IMPORTANT: Check DataView BEFORE IsBuffer() because N-API's IsBuffer()
+      // returns true for ALL ArrayBufferViews (including DataView), but
+      // Buffer::As() doesn't work correctly for DataView (returns length=0).
+      Napi::DataView dataView = param.As<Napi::DataView>();
+      Napi::ArrayBuffer arrayBuffer = dataView.ArrayBuffer();
+      size_t byteOffset = dataView.ByteOffset();
+      size_t byteLength = dataView.ByteLength();
+
+      if (arrayBuffer.Data() != nullptr && byteLength > 0) {
+        const uint8_t *data =
+            static_cast<const uint8_t *>(arrayBuffer.Data()) + byteOffset;
+        sqlite3_bind_blob(statement_, param_index, data,
+                          SafeCastToInt(byteLength), SQLITE_TRANSIENT);
+      } else {
+        sqlite3_bind_null(statement_, param_index);
+      }
     } else if (param.IsBuffer()) {
+      // Handles Buffer and TypedArray (both are ArrayBufferViews that work
+      // correctly with Buffer cast - Buffer::Data() handles byte offsets
+      // internally)
       Napi::Buffer<uint8_t> buffer = param.As<Napi::Buffer<uint8_t>>();
       sqlite3_bind_blob(statement_, param_index, buffer.Data(),
-                        static_cast<int>(buffer.Length()), SQLITE_TRANSIENT);
+                        SafeCastToInt(buffer.Length()), SQLITE_TRANSIENT);
     } else if (param.IsFunction()) {
       // Functions cannot be stored in SQLite - bind as NULL
       sqlite3_bind_null(statement_, param_index);
+    } else if (param.IsArrayBuffer()) {
+      // Handle ArrayBuffer as binary data
+      Napi::ArrayBuffer arrayBuffer = param.As<Napi::ArrayBuffer>();
+      if (!arrayBuffer.IsEmpty() && arrayBuffer.Data() != nullptr) {
+        sqlite3_bind_blob(statement_, param_index, arrayBuffer.Data(),
+                          SafeCastToInt(arrayBuffer.ByteLength()),
+                          SQLITE_TRANSIENT);
+      } else {
+        sqlite3_bind_null(statement_, param_index);
+      }
     } else if (param.IsObject()) {
-      // Try to convert object to string
-      Napi::String str_value = param.ToString();
-      std::string str = str_value.Utf8Value();
-      sqlite3_bind_text(statement_, param_index, str.c_str(), -1,
-                        SQLITE_TRANSIENT);
+      // Objects and arrays cannot be bound to SQLite parameters (same as
+      // Node.js behavior). Note: DataView, Buffer, TypedArray, and ArrayBuffer
+      // are handled above and don't reach this branch.
+      throw Napi::Error::New(
+          Env(), "Provided value cannot be bound to SQLite parameter " +
+                     std::to_string(param_index) + ".");
     } else {
-      // For any other type, bind as NULL
-      sqlite3_bind_null(statement_, param_index);
+      // For any other type, throw error like Node.js does
+      throw Napi::Error::New(
+          Env(), "Provided value cannot be bound to SQLite parameter " +
+                     std::to_string(param_index) + ".");
     }
   } catch (const Napi::Error &e) {
     // Re-throw Napi errors
@@ -1820,14 +2209,25 @@ Napi::Value StatementSync::CreateResult() {
         break;
       case SQLITE_TEXT: {
         const unsigned char *text = sqlite3_column_text(statement_, i);
-        value = Napi::String::New(env, reinterpret_cast<const char *>(text));
+        // sqlite3_column_text() can return NULL on OOM or encoding errors
+        if (!text) {
+          value = Napi::String::New(env, "");
+        } else {
+          value = Napi::String::New(env, reinterpret_cast<const char *>(text));
+        }
         break;
       }
       case SQLITE_BLOB: {
         const void *blob_data = sqlite3_column_blob(statement_, i);
         int blob_size = sqlite3_column_bytes(statement_, i);
-        value = Napi::Buffer<uint8_t>::Copy(
-            env, static_cast<const uint8_t *>(blob_data), blob_size);
+        // sqlite3_column_blob() can return NULL for zero-length BLOBs or on OOM
+        if (!blob_data || blob_size == 0) {
+          // Handle empty/NULL blob - create empty buffer
+          value = Napi::Buffer<uint8_t>::New(env, 0);
+        } else {
+          value = Napi::Buffer<uint8_t>::Copy(
+              env, static_cast<const uint8_t *>(blob_data), blob_size);
+        }
         break;
       }
       default:
@@ -1872,14 +2272,25 @@ Napi::Value StatementSync::CreateResult() {
         break;
       case SQLITE_TEXT: {
         const unsigned char *text = sqlite3_column_text(statement_, i);
-        value = Napi::String::New(env, reinterpret_cast<const char *>(text));
+        // sqlite3_column_text() can return NULL on OOM or encoding errors
+        if (!text) {
+          value = Napi::String::New(env, "");
+        } else {
+          value = Napi::String::New(env, reinterpret_cast<const char *>(text));
+        }
         break;
       }
       case SQLITE_BLOB: {
         const void *blob_data = sqlite3_column_blob(statement_, i);
         int blob_size = sqlite3_column_bytes(statement_, i);
-        value = Napi::Buffer<uint8_t>::Copy(
-            env, static_cast<const uint8_t *>(blob_data), blob_size);
+        // sqlite3_column_blob() can return NULL for zero-length BLOBs or on OOM
+        if (!blob_data || blob_size == 0) {
+          // Handle empty/NULL blob - create empty buffer
+          value = Napi::Buffer<uint8_t>::New(env, 0);
+        } else {
+          value = Napi::Buffer<uint8_t>::Copy(
+              env, static_cast<const uint8_t *>(blob_data), blob_size);
+        }
         break;
       }
       default:
@@ -2037,7 +2448,8 @@ Napi::Object Session::Init(Napi::Env env, Napi::Object exports) {
       DefineClass(env, "Session",
                   {InstanceMethod("changeset", &Session::Changeset),
                    InstanceMethod("patchset", &Session::Patchset),
-                   InstanceMethod("close", &Session::Close)});
+                   InstanceMethod("close", &Session::Close),
+                   InstanceMethod("dispose", &Session::Dispose)});
 
   // Store constructor in per-instance addon data instead of static variable
   AddonData *addon_data = GetAddonData(env);
@@ -2045,6 +2457,21 @@ Napi::Object Session::Init(Napi::Env env, Napi::Object exports) {
     addon_data->sessionConstructor = Napi::Reference<Napi::Function>::New(func);
   }
 
+  // Add Symbol.dispose to the prototype (Node.js v25+ compatibility)
+  Napi::Value symbolDispose =
+      env.Global().Get("Symbol").As<Napi::Object>().Get("dispose");
+  if (!symbolDispose.IsUndefined()) {
+    func.Get("prototype")
+        .As<Napi::Object>()
+        .Set(symbolDispose,
+             Napi::Function::New(
+                 env, [](const Napi::CallbackInfo &info) -> Napi::Value {
+                   Session *session =
+                       Session::Unwrap(info.This().As<Napi::Object>());
+                   return session->Dispose(info);
+                 }));
+  }
+
   exports.Set("Session", func);
   return exports;
 }
@@ -2154,6 +2581,19 @@ Napi::Value Session::Close(const Napi::CallbackInfo &info) {
   return env.Undefined();
 }
 
+Napi::Value Session::Dispose(const Napi::CallbackInfo &info) {
+  // Try to close, but ignore errors during disposal (matches Node.js v25
+  // behavior)
+  try {
+    if (session_ != nullptr) {
+      Delete();
+    }
+  } catch (...) {
+    // Ignore errors during disposal
+  }
+  return info.Env().Undefined();
+}
+
 // Static members for tracking active jobs
 std::atomic<int> BackupJob::active_jobs_(0);
 std::mutex BackupJob::active_jobs_mutex_;
@@ -2161,17 +2601,17 @@ std::set<BackupJob *> BackupJob::active_job_instances_;
 
 // BackupJob Implementation
 BackupJob::BackupJob(Napi::Env env, DatabaseSync *source,
-                     const std::string &destination_path,
-                     const std::string &source_db, const std::string &dest_db,
-                     int pages, Napi::Function progress_func,
+                     std::string destination_path, std::string source_db,
+                     std::string dest_db, int pages,
+                     Napi::Function progress_func,
                      Napi::Promise::Deferred deferred)
     : Napi::AsyncProgressWorker<BackupProgress>(
           !progress_func.IsEmpty() && !progress_func.IsUndefined()
               ? progress_func
               : Napi::Function::New(env, [](const Napi::CallbackInfo &) {})),
-      source_(source), destination_path_(destination_path),
-      source_db_(source_db), dest_db_(dest_db), pages_(pages),
-      deferred_(deferred) {
+      source_(source), destination_path_(std::move(destination_path)),
+      source_db_(std::move(source_db)), dest_db_(std::move(dest_db)),
+      pages_(pages), deferred_(deferred) {
   if (!progress_func.IsEmpty() && !progress_func.IsUndefined()) {
     progress_func_ = Napi::Reference<Napi::Function>::New(progress_func);
   }
@@ -2284,15 +2724,27 @@ void BackupJob::OnError(const Napi::Error &error) {
   // This runs on the main thread if Execute encounters an error
   Napi::HandleScope scope(Env());
 
-  // Cleanup SQLite resources
+  // Save error info BEFORE cleanup nulls the pointers
+  int saved_status = backup_status_;
+  std::string saved_errmsg;
+  if (dest_) {
+    saved_errmsg = sqlite3_errmsg(dest_);
+    // Capture any final error code from dest
+    int dest_err = sqlite3_errcode(dest_);
+    if (dest_err != SQLITE_OK && saved_status == SQLITE_OK) {
+      saved_status = dest_err;
+    }
+  }
+
+  // Now safe to cleanup
   Cleanup();
 
-  // Create a more detailed error if we have SQLite error info
-  if (dest_ && backup_status_ != SQLITE_OK) {
+  // Use saved values for error details (matching node:sqlite property names)
+  if (saved_status != SQLITE_OK && saved_status != SQLITE_DONE) {
     Napi::Error detailed_error = Napi::Error::New(Env(), error.Message());
-    detailed_error.Set(
-        "code", Napi::String::New(Env(), sqlite3_errstr(backup_status_)));
-    detailed_error.Set("errno", Napi::Number::New(Env(), backup_status_));
+    detailed_error.Set("errcode", Napi::Number::New(Env(), saved_status));
+    detailed_error.Set("errstr",
+                       Napi::String::New(Env(), sqlite3_errstr(saved_status)));
     deferred_.Reject(detailed_error.Value());
   } else {
     deferred_.Reject(error.Value());
@@ -2408,8 +2860,9 @@ Napi::Value DatabaseSync::Backup(const Napi::CallbackInfo &info) {
   }
 
   // Create and schedule backup job
-  BackupJob *job = new BackupJob(env, this, destination_path.value(), source_db,
-                                 target_db, rate, progress_func, deferred);
+  BackupJob *job = new BackupJob(env, this, std::move(destination_path).value(),
+                                 std::move(source_db), std::move(target_db),
+                                 rate, progress_func, deferred);
 
   // Queue the async work - AsyncWorker will delete itself when complete
   job->Queue();
@@ -2417,6 +2870,138 @@ Napi::Value DatabaseSync::Backup(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
+// Helper function to convert nullable C string to JavaScript value
+static Napi::Value NullableSQLiteStringToValue(Napi::Env env, const char *str) {
+  if (str == nullptr) {
+    return env.Null();
+  }
+  return Napi::String::New(env, str);
+}
+
+// DatabaseSync::SetAuthorizer implementation
+Napi::Value DatabaseSync::SetAuthorizer(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (!IsOpen()) {
+    node::THROW_ERR_INVALID_STATE(env, "database is not open");
+    return env.Undefined();
+  }
+
+  // Handle null to clear the authorizer
+  if (info.Length() > 0 && info[0].IsNull()) {
+    sqlite3_set_authorizer(connection_, nullptr, nullptr);
+    authorizer_callback_.reset();
+    return env.Undefined();
+  }
+
+  // Validate callback argument
+  if (info.Length() < 1 || !info[0].IsFunction()) {
+    node::THROW_ERR_INVALID_ARG_TYPE(
+        env, "The \"callback\" argument must be a function or null.");
+    return env.Undefined();
+  }
+
+  // Store the JavaScript callback
+  Napi::Function fn = info[0].As<Napi::Function>();
+  authorizer_callback_ =
+      std::make_unique<Napi::FunctionReference>(Napi::Persistent(fn));
+
+  // Set the SQLite authorizer with our static callback
+  int r = sqlite3_set_authorizer(connection_, AuthorizerCallback, this);
+
+  if (r != SQLITE_OK) {
+    authorizer_callback_.reset();
+    ThrowEnhancedSqliteErrorWithDB(env, this, connection_, r,
+                                   "Failed to set authorizer");
+    return env.Undefined();
+  }
+
+  return env.Undefined();
+}
+
+// Static callback for SQLite authorization
+int DatabaseSync::AuthorizerCallback(void *user_data, int action_code,
+                                     const char *param1, const char *param2,
+                                     const char *param3, const char *param4) {
+  DatabaseSync *db = static_cast<DatabaseSync *>(user_data);
+
+  // If no callback is set, allow everything
+  if (!db->authorizer_callback_ || db->authorizer_callback_->IsEmpty()) {
+    return SQLITE_OK;
+  }
+
+  Napi::Env env(db->env_);
+  Napi::HandleScope scope(env);
+
+  try {
+    // Convert SQLite authorizer parameters to JavaScript values
+    std::vector<napi_value> args;
+    args.push_back(Napi::Number::New(env, action_code));
+    args.push_back(NullableSQLiteStringToValue(env, param1));
+    args.push_back(NullableSQLiteStringToValue(env, param2));
+    args.push_back(NullableSQLiteStringToValue(env, param3));
+    args.push_back(NullableSQLiteStringToValue(env, param4));
+
+    // Call the JavaScript callback
+    Napi::Value result = db->authorizer_callback_->Call(env.Undefined(), args);
+
+    // Handle JavaScript exceptions - must clear before returning to SQLite
+    if (env.IsExceptionPending()) {
+      Napi::Error error = env.GetAndClearPendingException();
+      db->SetDeferredAuthorizerException(error.Message());
+      db->SetIgnoreNextSQLiteError(true);
+      return SQLITE_DENY;
+    }
+
+    // Check if result is an integer - don't throw in callback context
+    if (!result.IsNumber()) {
+      db->SetDeferredAuthorizerException(
+          "Authorizer callback must return an integer authorization code");
+      db->SetIgnoreNextSQLiteError(true);
+      return SQLITE_DENY;
+    }
+
+    int32_t int_result = result.As<Napi::Number>().Int32Value();
+
+    // Validate the return code - don't throw in callback context
+    if (int_result != SQLITE_OK && int_result != SQLITE_DENY &&
+        int_result != SQLITE_IGNORE) {
+      db->SetDeferredAuthorizerException(
+          "Authorizer callback returned an invalid authorization code");
+      db->SetIgnoreNextSQLiteError(true);
+      return SQLITE_DENY;
+    }
+
+    return int_result;
+  } catch (const Napi::Error &e) {
+    // JavaScript exception occurred - clear any pending exception and store
+    if (env.IsExceptionPending()) {
+      Napi::Error error = env.GetAndClearPendingException();
+      db->SetDeferredAuthorizerException(error.Message());
+    } else {
+      db->SetDeferredAuthorizerException(e.Message());
+    }
+    db->SetIgnoreNextSQLiteError(true);
+    return SQLITE_DENY;
+  } catch (const std::exception &e) {
+    // C++ exception - clear any pending JS exception and store message
+    if (env.IsExceptionPending()) {
+      env.GetAndClearPendingException();
+    }
+    db->SetDeferredAuthorizerException(e.what());
+    db->SetIgnoreNextSQLiteError(true);
+    return SQLITE_DENY;
+  } catch (...) {
+    // Unknown error - clear any pending JS exception and deny
+    if (env.IsExceptionPending()) {
+      env.GetAndClearPendingException();
+    }
+    db->SetDeferredAuthorizerException("Unknown error in authorizer callback");
+    db->SetIgnoreNextSQLiteError(true);
+    return SQLITE_DENY;
+  }
+}
+
 // Thread validation implementations
 bool DatabaseSync::ValidateThread(Napi::Env env) const {
   if (std::this_thread::get_id() != creation_thread_) {
@@ -2436,5 +3021,4 @@ bool StatementSync::ValidateThread(Napi::Env env) const {
   return true;
 }
 
-} // namespace sqlite
-} // namespace photostructure
+} // namespace photostructure::sqlite