From d3c9c6ed3f50fcd81faac886bf05a7237e904d13 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:17:33 +0100
Subject: [PATCH 01/31] sqlite: add support for SQLite Session Extension

---
 deps/sqlite/sqlite.gyp       |   4 +
 doc/api/sqlite.md            |  75 ++++++++
 src/env_properties.h         |   1 +
 src/node_sqlite.cc           | 309 ++++++++++++++++++++++++++++--
 src/node_sqlite.h            |  37 ++++
 test/parallel/test-sqlite.js | 357 ++++++++++++++++++++++++++++++++++-
 tools/doc/type-parser.mjs    |   1 +
 7 files changed, 766 insertions(+), 18 deletions(-)

diff --git a/deps/sqlite/sqlite.gyp b/deps/sqlite/sqlite.gyp
index c37ae18d78bc37..c3ecef214ad004 100644
--- a/deps/sqlite/sqlite.gyp
+++ b/deps/sqlite/sqlite.gyp
@@ -12,6 +12,10 @@
       'xcode_settings': {
         'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES',  # -fvisibility=hidden
       },
+      'defines': [
+        'SQLITE_ENABLE_SESSION',
+        'SQLITE_ENABLE_PREUPDATE_HOOK'
+      ],
       'include_dirs': ['.'],
       'sources': [
         '<@(sqlite_sources)',
diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 34dfdaf1b11365..5d1235927d110a 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -164,6 +164,74 @@ added: v22.5.0
 Compiles a SQL statement into a [prepared statement][]. This method is a wrapper
 around [`sqlite3_prepare_v2()`][].
 
+### `database.createSession([options])`
+
+* `options` {Object} An optional object used to configure the session.
+  * `table` {string} When provided, only changes to this table are tracked by the created session.
+    By default, changes to all tables are tracked.
+  * `db` {string} Name of the database to track. Default: `'main'`.
+* Returns: {Session} A session handle.
+
+Creates and attaches a session to the database. This method is a wrapper around [`sqlite3session_create()`][] and [`sqlite3session_attach()`][].
+
+### `database.applyChangeset(changeset[, options])`
+
+* `changeset` {Uint8Array} A binary changeset or patchset.
+* `options` {Object} An optional object to configure how changes are applied.
+  * `filter` {Function} Optional function. Skips changes when a truthy value is returned from it.
+    Takes the name of the table that a change targets as first argument. When this option is not
+    provided all changes are attempted.
+  * `onConflict` {number} Determines how conflicts are handled. When provided, must be one of the values below:
+    * `SQLITE_CHANGESET_OMIT`: conflicting changes are omitted.
+    * `SQLITE_CHANGESET_REPLACE`: conflicting changes replace existing values.
+    * `SQLITE_CHANGESET_ABORT`: abort on conflict and roll back databsase (default).
+* Returns: {boolean} Whether the changeset was applied succesfully without being aborted.
+
+An exception is thrown if the database is not
+open. This method is a wrapper around [`sqlite3changeset_apply()`][].
+
+Example usage is demonstrated below.
+
+```js
+const database1 = new DatabaseSync(':memory:');
+const database2 = new DatabaseSync(':memory:');
+
+database1.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+database2.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+const session = database1.createSession();
+
+const insert = database1.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
+insert.run(1, 'hello');
+insert.run(2, 'world');
+
+const changeset = session.changeset();
+database2.applyChangeset(changeset);
+// Now database2 contains the same data as database1
+```
+
+## Class: `Session`
+
+### `session.changeset()`
+
+* Returns: {Uint8Array} Binary changeset that can be applied to other databases.
+
+Retrieves a changeset containing all changes since the changeset was created. Can be called multiple times.
+An exception is thrown if the database or the session is not open. This method is a wrapper around [`sqlite3session_changeset()`][].
+
+### `session.patchset()`
+
+* Returns: {Uint8Array} Binary patchset that can be applied to other databases.
+
+Similar to the method above, but generates a more compact patchset. See [Changesets and Patchsets][]
+in the documentation of SQLite. An exception is thrown if the database or the session is not open. This method is a
+wrapper around [`sqlite3session_patchset()`][].
+
+### `session.close()`.
+
+Closes the session. An exception is thrown if the database or the session is not open. This method is a
+wrapper around [`sqlite3session_delete()`][].
+
 ## Class: `StatementSync`
 
 <!-- YAML
@@ -326,6 +394,7 @@ exception.
 | `TEXT`    | {string}             |
 | `BLOB`    | {Uint8Array}         |
 
+[Changesets and Patchsets]: https://www.sqlite.org/sessionintro.html#changesets_and_patchsets
 [SQL injection]: https://en.wikipedia.org/wiki/SQL_injection
 [`--experimental-sqlite`]: cli.md#--experimental-sqlite
 [`PRAGMA foreign_keys`]: https://www.sqlite.org/pragma.html#pragma_foreign_keys
@@ -336,6 +405,12 @@ exception.
 [`sqlite3_last_insert_rowid()`]: https://www.sqlite.org/c3ref/last_insert_rowid.html
 [`sqlite3_prepare_v2()`]: https://www.sqlite.org/c3ref/prepare.html
 [`sqlite3_sql()`]: https://www.sqlite.org/c3ref/expanded_sql.html
+[`sqlite3changeset_apply()`]: https://www.sqlite.org/session/sqlite3changeset_apply.html
+[`sqlite3session_attach()`]: https://www.sqlite.org/session/sqlite3session_attach.html
+[`sqlite3session_changeset()`]: https://www.sqlite.org/session/sqlite3session_changeset.html
+[`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
 [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
diff --git a/src/env_properties.h b/src/env_properties.h
index 4265b87c516375..508986ad5ad947 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -411,6 +411,7 @@
   V(shutdown_wrap_template, v8::ObjectTemplate)                                \
   V(socketaddress_constructor_template, v8::FunctionTemplate)                  \
   V(sqlite_statement_sync_constructor_template, v8::FunctionTemplate)          \
+  V(sqlite_session_constructor_template, v8::FunctionTemplate)                 \
   V(streambaseentry_ctor_template, v8::FunctionTemplate)                       \
   V(streambaseoutputstream_constructor_template, v8::ObjectTemplate)           \
   V(streamentry_ctor_template, v8::FunctionTemplate)                           \
diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 742c15233ccd13..a7745dd8d3a928 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -22,6 +22,7 @@ using v8::ConstructorBehavior;
 using v8::Context;
 using v8::DontDelete;
 using v8::Exception;
+using v8::Function;
 using v8::FunctionCallback;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -31,6 +32,7 @@ using v8::Local;
 using v8::LocalVector;
 using v8::MaybeLocal;
 using v8::Name;
+using v8::NewStringType;
 using v8::Null;
 using v8::Number;
 using v8::Object;
@@ -105,9 +107,19 @@ DatabaseSync::DatabaseSync(Environment* env,
   }
 }
 
+void DatabaseSync::DeleteSessions() {
+  // all attached sessions need to be deleted before the database is closed
+  // https://www.sqlite.org/session/sqlite3session_create.html
+  for (auto* session : sessions_) {
+    sqlite3session_delete(session);
+  }
+  sessions_.clear();
+}
+
 DatabaseSync::~DatabaseSync() {
   if (IsOpen()) {
     FinalizeStatements();
+    DeleteSessions();
     sqlite3_close_v2(connection_);
     connection_ = nullptr;
   }
@@ -290,6 +302,7 @@ void DatabaseSync::Close(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
   db->FinalizeStatements();
+  db->DeleteSessions();
   int r = sqlite3_close_v2(db->connection_);
   CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
   db->connection_ = nullptr;
@@ -333,6 +346,175 @@ void DatabaseSync::Exec(const FunctionCallbackInfo<Value>& args) {
   CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
 }
 
+void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
+  std::string table;
+  std::string dbName = "main";
+
+  Environment* env = Environment::GetCurrent(args);
+  if (args.Length() > 0) {
+    if (!args[0]->IsObject()) {
+      node::THROW_ERR_INVALID_ARG_TYPE(
+          env->isolate(), "The \"options\" argument must be an object.");
+      return;
+    }
+
+    Local<Object> options = args[0].As<Object>();
+
+    Local<String> table_key =
+        String::NewFromUtf8(env->isolate(), "table", NewStringType::kNormal)
+            .ToLocalChecked();
+    if (options->HasOwnProperty(env->context(), table_key).FromJust()) {
+      Local<Value> table_value =
+          options->Get(env->context(), table_key).ToLocalChecked();
+
+      if (table_value->IsString()) {
+        String::Utf8Value str(env->isolate(), table_value);
+        table = std::string(*str);
+      } else {
+        node::THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(), "The \"options.table\" argument must be a string.");
+        return;
+      }
+    }
+
+    Local<String> db_key =
+        String::NewFromUtf8(env->isolate(), "db", NewStringType::kNormal)
+            .ToLocalChecked();
+    if (options->HasOwnProperty(env->context(), db_key).FromJust()) {
+      Local<Value> db_value =
+          options->Get(env->context(), db_key).ToLocalChecked();
+      if (db_value->IsString()) {
+        String::Utf8Value str(env->isolate(), db_value);
+        dbName = std::string(*str);
+      } else {
+        node::THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(), "The \"options.db\" argument must be a string.");
+        return;
+      }
+    }
+  }
+
+  DatabaseSync* db;
+  ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
+  THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
+
+  sqlite3_session* pSession;
+  int r = sqlite3session_create(db->connection_, dbName.c_str(), &pSession);
+  CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
+  db->sessions_.insert(pSession);
+
+  r = sqlite3session_attach(pSession, table == "" ? nullptr : table.c_str());
+  CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
+
+  BaseObjectPtr<Session> session =
+      Session::Create(env, BaseObjectWeakPtr<DatabaseSync>(db), pSession);
+  args.GetReturnValue().Set(session->object());
+}
+
+static std::function<int()> conflictCallback;
+
+static int xConflict(void* pCtx, int eConflict, sqlite3_changeset_iter* pIter) {
+  if (!conflictCallback) return SQLITE_CHANGESET_ABORT;
+  return conflictCallback();
+}
+
+static std::function<bool(std::string)> filterCallback;
+
+static int xFilter(void* pCtx, const char* zTab) {
+  if (!filterCallback) return 1;
+
+  return filterCallback(zTab) ? 1 : 0;
+}
+
+void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
+  conflictCallback = nullptr;
+  filterCallback = nullptr;
+
+  DatabaseSync* db;
+  ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
+
+  if (!args[0]->IsUint8Array()) {
+    node::THROW_ERR_INVALID_ARG_TYPE(
+        env->isolate(), "The \"changeset\" argument must be a Uint8Array.");
+    return;
+  }
+
+  if (args.Length() > 1 && !args[1]->IsUndefined()) {
+    if (!args[1]->IsObject()) {
+      node::THROW_ERR_INVALID_ARG_TYPE(
+          env->isolate(), "The \"options\" argument must be an object.");
+      return;
+    }
+
+    Local<Object> options = args[1].As<Object>();
+
+    Local<String> conflictKey =
+        String::NewFromUtf8(
+            env->isolate(), "onConflict", NewStringType::kNormal)
+            .ToLocalChecked();
+    if (options->HasOwnProperty(env->context(), conflictKey).FromJust()) {
+      Local<Value> conflictValue =
+          options->Get(env->context(), conflictKey).ToLocalChecked();
+
+      if (!conflictValue->IsNumber()) {
+        node::THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(),
+            "The \"options.onConflict\" argument must be a number.");
+        return;
+      }
+
+      int conflictInt = conflictValue->Int32Value(env->context()).FromJust();
+      conflictCallback = [conflictInt]() -> int { return conflictInt; };
+    }
+
+    Local<String> filterKey =
+        String::NewFromUtf8(env->isolate(), "filter", NewStringType::kNormal)
+            .ToLocalChecked();
+
+    if (options->HasOwnProperty(env->context(), filterKey).FromJust()) {
+      Local<Value> filterValue =
+          options->Get(env->context(), filterKey).ToLocalChecked();
+
+      if (!filterValue->IsFunction()) {
+        node::THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(),
+            "The \"options.filter\" argument must be a function.");
+        return;
+      }
+
+      Local<Function> filterFunc = filterValue.As<Function>();
+
+      filterCallback = [env, filterFunc](std::string item) -> bool {
+        Local<Value> argv[] = {String::NewFromUtf8(env->isolate(),
+                                                   item.c_str(),
+                                                   NewStringType::kNormal)
+                                   .ToLocalChecked()};
+        Local<Value> result =
+            filterFunc->Call(env->context(), Null(env->isolate()), 1, argv)
+                .ToLocalChecked();
+        return result->BooleanValue(env->isolate());
+      };
+    }
+  }
+
+  ArrayBufferViewContents<uint8_t> buf(args[0]);
+  int r = sqlite3changeset_apply(
+      db->connection_,
+      buf.length(),
+      const_cast<void*>(static_cast<const void*>(buf.data())),
+      xFilter,
+      xConflict,
+      nullptr);
+  if (r == SQLITE_ABORT) {
+    args.GetReturnValue().Set(false);
+    return;
+  }
+  CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
+  args.GetReturnValue().Set(true);
+}
+
 StatementSync::StatementSync(Environment* env,
                              Local<Object> object,
                              DatabaseSync* db,
@@ -575,32 +757,23 @@ void StatementSync::All(const FunctionCallbackInfo<Value>& args) {
   auto reset = OnScopeLeave([&]() { sqlite3_reset(stmt->statement_); });
   int num_cols = sqlite3_column_count(stmt->statement_);
   LocalVector<Value> rows(isolate);
-  LocalVector<Name> row_keys(isolate);
   while ((r = sqlite3_step(stmt->statement_)) == SQLITE_ROW) {
-    if (row_keys.size() == 0) {
-      row_keys.reserve(num_cols);
-
-      for (int i = 0; i < num_cols; ++i) {
-        Local<Name> key;
-        if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
-        row_keys.emplace_back(key);
-      }
-    }
-
+    LocalVector<Name> row_keys(isolate);
+    row_keys.reserve(num_cols);
     LocalVector<Value> row_values(isolate);
     row_values.reserve(num_cols);
 
-    for (size_t i = 0; i < row_keys.size(); ++i) {
+    for (int i = 0; i < num_cols; ++i) {
+      Local<Name> key;
+      if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
       Local<Value> val;
       if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+      row_keys.emplace_back(key);
       row_values.emplace_back(val);
     }
 
-    Local<Object> row = Object::New(isolate,
-                                    Null(isolate),
-                                    row_keys.data(),
-                                    row_values.data(),
-                                    row_keys.size());
+    Local<Object> row = Object::New(
+        isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols);
     rows.emplace_back(row);
   }
 
@@ -843,6 +1016,100 @@ BaseObjectPtr<StatementSync> StatementSync::Create(Environment* env,
   return MakeBaseObject<StatementSync>(env, obj, db, stmt);
 }
 
+Session::Session(Environment* env,
+                 Local<Object> object,
+                 BaseObjectWeakPtr<DatabaseSync> database,
+                 sqlite3_session* session)
+    : BaseObject(env, object),
+      session_(session),
+      database_(std::move(database)) {
+  MakeWeak();
+}
+
+Session::~Session() {
+  Delete();
+}
+
+BaseObjectPtr<Session> Session::Create(Environment* env,
+                                       BaseObjectWeakPtr<DatabaseSync> database,
+                                       sqlite3_session* session) {
+  Local<Object> obj;
+  if (!GetConstructorTemplate(env)
+           ->InstanceTemplate()
+           ->NewInstance(env->context())
+           .ToLocal(&obj)) {
+    return BaseObjectPtr<Session>();
+  }
+
+  return MakeBaseObject<Session>(env, obj, std::move(database), session);
+}
+
+Local<FunctionTemplate> Session::GetConstructorTemplate(Environment* env) {
+  Local<FunctionTemplate> tmpl = env->sqlite_session_constructor_template();
+  if (tmpl.IsEmpty()) {
+    Isolate* isolate = env->isolate();
+    tmpl = NewFunctionTemplate(isolate, IllegalConstructor);
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Session"));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        Session::kInternalFieldCount);
+    SetProtoMethod(isolate,
+                   tmpl,
+                   "changeset",
+                   Session::Changeset<sqlite3session_changeset>);
+    SetProtoMethod(
+        isolate, tmpl, "patchset", Session::Changeset<sqlite3session_patchset>);
+    SetProtoMethod(isolate, tmpl, "close", Session::Close);
+    env->set_sqlite_session_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void Session::MemoryInfo(MemoryTracker* tracker) const {}
+
+template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>
+void Session::Changeset(const FunctionCallbackInfo<Value>& args) {
+  Session* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  sqlite3* db = session->database_ ? session->database_->connection_ : nullptr;
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, !session->database_->IsOpen(), "database is not open");
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, session->session_ == nullptr, "session is not open");
+
+  int nChangeset;
+  void* pChangeset;
+  int r = sqliteChangesetFunc(session->session_, &nChangeset, &pChangeset);
+  CHECK_ERROR_OR_THROW(env->isolate(), db, r, SQLITE_OK, void());
+
+  auto freeChangeset = OnScopeLeave([&] { sqlite3_free(pChangeset); });
+
+  Local<ArrayBuffer> buffer = ArrayBuffer::New(env->isolate(), nChangeset);
+  std::memcpy(buffer->GetBackingStore()->Data(), pChangeset, nChangeset);
+  Local<Uint8Array> uint8Array = Uint8Array::New(buffer, 0, nChangeset);
+
+  args.GetReturnValue().Set(uint8Array);
+}
+
+void Session::Close(const FunctionCallbackInfo<Value>& args) {
+  Session* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, !session->database_->IsOpen(), "database is not open");
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, session->session_ == nullptr, "session is not open");
+
+  session->Delete();
+}
+
+void Session::Delete() {
+  if (!database_ || !database_->connection_ || session_ == nullptr) return;
+  sqlite3session_delete(session_);
+  database_->sessions_.erase(session_);
+  session_ = nullptr;
+}
+
 static void Initialize(Local<Object> target,
                        Local<Value> unused,
                        Local<Context> context,
@@ -858,11 +1125,19 @@ static void Initialize(Local<Object> target,
   SetProtoMethod(isolate, db_tmpl, "close", DatabaseSync::Close);
   SetProtoMethod(isolate, db_tmpl, "prepare", DatabaseSync::Prepare);
   SetProtoMethod(isolate, db_tmpl, "exec", DatabaseSync::Exec);
+  SetProtoMethod(
+      isolate, db_tmpl, "createSession", DatabaseSync::CreateSession);
+  SetProtoMethod(
+      isolate, db_tmpl, "applyChangeset", DatabaseSync::ApplyChangeset);
   SetConstructorFunction(context, target, "DatabaseSync", db_tmpl);
   SetConstructorFunction(context,
                          target,
                          "StatementSync",
                          StatementSync::GetConstructorTemplate(env));
+
+  NODE_DEFINE_CONSTANT(target, SQLITE_CHANGESET_OMIT);
+  NODE_DEFINE_CONSTANT(target, SQLITE_CHANGESET_REPLACE);
+  NODE_DEFINE_CONSTANT(target, SQLITE_CHANGESET_ABORT);
 }
 
 }  // namespace sqlite
diff --git a/src/node_sqlite.h b/src/node_sqlite.h
index 6d06eb551a469e..831d4d1786b34e 100644
--- a/src/node_sqlite.h
+++ b/src/node_sqlite.h
@@ -3,6 +3,8 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#define SQLITE_ENABLE_SESSION
+
 #include "base_object.h"
 #include "node_mem.h"
 #include "sqlite3.h"
@@ -56,6 +58,8 @@ class DatabaseSync : public BaseObject {
   static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Prepare(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Exec(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CreateSession(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ApplyChangeset(const v8::FunctionCallbackInfo<v8::Value>& args);
   void FinalizeStatements();
   void UntrackStatement(StatementSync* statement);
   bool IsOpen();
@@ -66,11 +70,16 @@ class DatabaseSync : public BaseObject {
 
  private:
   bool Open();
+  void DeleteSessions();
 
   ~DatabaseSync() override;
   DatabaseOpenConfiguration open_config_;
   sqlite3* connection_;
+
+  std::set<sqlite3_session*> sessions_;
   std::unordered_set<StatementSync*> statements_;
+
+  friend class Session;
 };
 
 class StatementSync : public BaseObject {
@@ -113,6 +122,34 @@ class StatementSync : public BaseObject {
   v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
 };
 
+using Sqlite3ChangesetGenFunc = int (*)(sqlite3_session*, int*, void**);
+
+class Session : public BaseObject {
+ public:
+  Session(Environment* env,
+          v8::Local<v8::Object> object,
+          BaseObjectWeakPtr<DatabaseSync> database,
+          sqlite3_session* session);
+  ~Session() override;
+  template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>
+  static void Changeset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static BaseObjectPtr<Session> Create(Environment* env,
+                                       BaseObjectWeakPtr<DatabaseSync> database,
+                                       sqlite3_session* session);
+
+  SET_MEMORY_INFO_NAME(Session)
+  SET_SELF_SIZE(Session)
+
+ private:
+  void Delete();
+  sqlite3_session* session_;
+  BaseObjectWeakPtr<DatabaseSync> database_;  // The Parent Database
+};
+
 }  // namespace sqlite
 }  // namespace node
 
diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js
index f8b122131fe7a2..27dc666066ef7b 100644
--- a/test/parallel/test-sqlite.js
+++ b/test/parallel/test-sqlite.js
@@ -3,7 +3,12 @@
 const { spawnPromisified } = require('../common');
 const tmpdir = require('../common/tmpdir');
 const { join } = require('node:path');
-const { DatabaseSync } = require('node:sqlite');
+const {
+  DatabaseSync,
+  SQLITE_CHANGESET_OMIT,
+  SQLITE_CHANGESET_REPLACE,
+  SQLITE_CHANGESET_ABORT
+} = require('node:sqlite');
 const { suite, test } = require('node:test');
 let cnt = 0;
 
@@ -97,3 +102,353 @@ test('PRAGMAs are supported', (t) => {
     { __proto__: null, journal_mode: 'wal' },
   );
 });
+
+suite('session extension', () => {
+  test('creating and applying a changeset', (t) => {
+    const createDataTableSql = `
+      CREATE TABLE data(
+        key INTEGER PRIMARY KEY,
+        value TEXT
+      ) STRICT`;
+
+    const createDatabase = () => {
+      const database = new DatabaseSync(':memory:');
+      database.exec(createDataTableSql);
+      return database;
+    };
+
+    const databaseFrom = createDatabase();
+    const session = databaseFrom.createSession();
+
+    const select = 'SELECT * FROM data ORDER BY key';
+
+    const insert = databaseFrom.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
+    insert.run(1, 'hello');
+    insert.run(2, 'world');
+
+    const databaseTo = createDatabase();
+
+    t.assert.strictEqual(databaseTo.applyChangeset(session.changeset()), true);
+    t.assert.deepStrictEqual(
+      databaseFrom.prepare(select).all(),
+      databaseTo.prepare(select).all()
+    );
+  });
+
+  test('database.createSession() - closed database results in exception', (t) => {
+    const database = new DatabaseSync(':memory:');
+    database.close();
+    t.assert.throws(() => {
+      database.createSession();
+    }, {
+      name: 'Error',
+      message: 'database is not open',
+    });
+  });
+
+  test('session.changeset() - closed database results in exception', (t) => {
+    const database = new DatabaseSync(':memory:');
+    const session = database.createSession();
+    database.close();
+    t.assert.throws(() => {
+      session.changeset();
+    }, {
+      name: 'Error',
+      message: 'database is not open',
+    });
+  });
+
+  test('database.applyChangeset() - closed database results in exception', (t) => {
+    const database = new DatabaseSync(':memory:');
+    const session = database.createSession();
+    const changeset = session.changeset();
+    database.close();
+    t.assert.throws(() => {
+      database.applyChangeset(changeset);
+    }, {
+      name: 'Error',
+      message: 'database is not open',
+    });
+  });
+
+  test('database1.createSession() - use table option to track specific table', (t) => {
+    const database1 = new DatabaseSync(':memory:');
+    const database2 = new DatabaseSync(':memory:');
+
+    const createData1TableSql = `CREATE TABLE data1 (
+      key INTEGER PRIMARY KEY,
+      value TEXT
+    ) STRICT
+    `;
+    const createData2TableSql = `CREATE TABLE data2 (
+      key INTEGER PRIMARY KEY,
+      value TEXT
+    ) STRICT
+    `;
+    database1.exec(createData1TableSql);
+    database1.exec(createData2TableSql);
+    database2.exec(createData1TableSql);
+    database2.exec(createData2TableSql);
+
+    const session = database1.createSession({
+      table: 'data1'
+    });
+    const insert1 = database1.prepare('INSERT INTO data1 (key, value) VALUES (?, ?)');
+    insert1.run(1, 'hello');
+    insert1.run(2, 'world');
+    const insert2 = database1.prepare('INSERT INTO data2 (key, value) VALUES (?, ?)');
+    insert2.run(1, 'hello');
+    insert2.run(2, 'world');
+    const select1 = 'SELECT * FROM data1 ORDER BY key';
+    const select2 = 'SELECT * FROM data2 ORDER BY key';
+    t.assert.strictEqual(database2.applyChangeset(session.changeset()), true);
+    t.assert.deepStrictEqual(
+      database1.prepare(select1).all(),
+      database2.prepare(select1).all());  // data1 table should be equal
+    t.assert.deepStrictEqual(database2.prepare(select2).all(), []);  // data2 should be empty in database2
+    t.assert.strictEqual(database1.prepare(select2).all().length, 2);  // data1 should have values in database1
+  });
+
+  const prepareConflict = () => {
+    const database1 = new DatabaseSync(':memory:');
+    const database2 = new DatabaseSync(':memory:');
+
+    const createDataTableSql = `CREATE TABLE data (
+      key INTEGER PRIMARY KEY,
+      value TEXT
+    ) STRICT
+    `;
+    database1.exec(createDataTableSql);
+    database2.exec(createDataTableSql);
+
+    const insertSql = 'INSERT INTO data (key, value) VALUES (?, ?)';
+    const session = database1.createSession();
+    database1.prepare(insertSql).run(1, 'hello');
+    database1.prepare(insertSql).run(2, 'foo');
+    database2.prepare(insertSql).run(1, 'world');
+    return {
+      database2,
+      changeset: session.changeset()
+    };
+  };
+
+  test('database.applyChangeset() - conflict with default behavior (abort)', (t) => {
+    const { database2, changeset } = prepareConflict();
+    // When changeset is aborted due to a conflict, applyChangeset should return false
+    t.assert.strictEqual(database2.applyChangeset(changeset), false);
+    t.assert.deepStrictEqual(
+      database2.prepare('SELECT value from data').all(),
+      [{ value: 'world' }]);  // unchanged
+  });
+
+  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_ABORT', (t) => {
+    const { database2, changeset } = prepareConflict();
+    const result = database2.applyChangeset(changeset, {
+      onConflict: SQLITE_CHANGESET_ABORT
+    });
+    // When changeset is aborted due to a conflict, applyChangeset should return false
+    t.assert.strictEqual(result, false);
+    t.assert.deepStrictEqual(
+      database2.prepare('SELECT value from data').all(),
+      [{ value: 'world' }]);  // unchanged
+  });
+
+  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_REPLACE', (t) => {
+    const { database2, changeset } = prepareConflict();
+    const result = database2.applyChangeset(changeset, {
+      onConflict: SQLITE_CHANGESET_REPLACE
+    });
+    // Not aborted due to conflict, so should return true
+    t.assert.strictEqual(result, true);
+    t.assert.deepStrictEqual(
+      database2.prepare('SELECT value from data ORDER BY key').all(),
+      [{ value: 'hello' }, { value: 'foo' }]);  // replaced
+  });
+
+  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_OMIT', (t) => {
+    const { database2, changeset } = prepareConflict();
+    const result = database2.applyChangeset(changeset, {
+      onConflict: SQLITE_CHANGESET_OMIT
+    });
+    // Not aborted due to conflict, so should return true
+    t.assert.strictEqual(result, true);
+    t.assert.deepStrictEqual(
+      database2.prepare('SELECT value from data ORDER BY key ASC').all(),
+      [{ value: 'world' }, { value: 'foo' }]);  // Conflicting change omitted
+  });
+
+  test('session related constants are defined', (t) => {
+    t.assert.strictEqual(SQLITE_CHANGESET_OMIT, 0);
+    t.assert.strictEqual(SQLITE_CHANGESET_REPLACE, 1);
+    t.assert.strictEqual(SQLITE_CHANGESET_ABORT, 2);
+  });
+
+  test('database.createSession() - filter changes', (t) => {
+    const database1 = new DatabaseSync(':memory:');
+    const database2 = new DatabaseSync(':memory:');
+    const createTableSql = 'CREATE TABLE data1(key INTEGER PRIMARY KEY); CREATE TABLE data2(key INTEGER PRIMARY KEY);';
+    database1.exec(createTableSql);
+    database2.exec(createTableSql);
+
+    const session = database1.createSession();
+
+    database1.exec('INSERT INTO data1 (key) VALUES (1), (2), (3)');
+    database1.exec('INSERT INTO data2 (key) VALUES (1), (2), (3), (4), (5)');
+
+    database2.applyChangeset(session.changeset(), {
+      filter: (tableName) => tableName === 'data2'
+    });
+
+    const data1Rows = database2.prepare('SELECT * FROM data1').all();
+    const data2Rows = database2.prepare('SELECT * FROM data2').all();
+
+    // Expect no rows since all changes were filtered out
+    t.assert.strictEqual(data1Rows.length, 0);
+    // Expect 5 rows since these changes were not filtered out
+    t.assert.strictEqual(data2Rows.length, 5);
+  });
+
+  test('database.createSession() - specify other database', (t) => {
+    const database = new DatabaseSync(':memory:');
+    const session = database.createSession();
+    const sessionMain = database.createSession({
+      db: 'main'
+    });
+    const sessionTest = database.createSession({
+      db: 'test'
+    });
+    database.exec('CREATE TABLE data (key INTEGER PRIMARY KEY)');
+    database.exec('INSERT INTO data (key) VALUES (1)');
+    t.assert.notStrictEqual(session.changeset().length, 0);
+    t.assert.notStrictEqual(sessionMain.changeset().length, 0);
+    // Since this session is attached to a different database, its changeset should be empty
+    t.assert.strictEqual(sessionTest.changeset().length, 0);
+  });
+
+  test('database.createSession() - wrong arguments', (t) => {
+    const database = new DatabaseSync(':memory:');
+    t.assert.throws(() => {
+      database.createSession(null);
+    }, {
+      name: 'TypeError',
+      message: 'The "options" argument must be an object.'
+    });
+
+    t.assert.throws(() => {
+      database.createSession({
+        table: 123
+      });
+    }, {
+      name: 'TypeError',
+      message: 'The "options.table" argument must be a string.'
+    });
+
+    t.assert.throws(() => {
+      database.createSession({
+        db: 123
+      });
+    }, {
+      name: 'TypeError',
+      message: 'The "options.db" argument must be a string.'
+    });
+  });
+
+  test('database.applyChangeset() - wrong arguments', (t) => {
+    const database = new DatabaseSync(':memory:');
+    const session = database.createSession();
+    t.assert.throws(() => {
+      database.applyChangeset(null);
+    }, {
+      name: 'TypeError',
+      message: 'The "changeset" argument must be a Uint8Array.'
+    });
+
+    t.assert.throws(() => {
+      database.applyChangeset(session.changeset(), null);
+    }, {
+      name: 'TypeError',
+      message: 'The "options" argument must be an object.'
+    });
+
+    t.assert.throws(() => {
+      database.applyChangeset(session.changeset(), {
+        filter: null
+      }, null);
+    }, {
+      name: 'TypeError',
+      message: 'The "options.filter" argument must be a function.'
+    });
+
+    t.assert.throws(() => {
+      database.applyChangeset(session.changeset(), {
+        onConflict: null
+      }, null);
+    }, {
+      name: 'TypeError',
+      message: 'The "options.onConflict" argument must be a number.'
+    });
+  });
+
+  test('session.patchset()', (t) => {
+    const database = new DatabaseSync(':memory:');
+    database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+    database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
+
+    const session = database.createSession();
+    database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
+
+    t.assert.ok(
+      session.patchset().length < session.changeset().length,
+      'expected patchset to be smaller than changeset');
+  });
+
+  test('session.close() - using session after close throws exception', (t) => {
+    const database = new DatabaseSync(':memory:');
+    database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+    database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
+
+    const session = database.createSession();
+    database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
+    session.close();
+
+    database.exec("UPDATE data SET value = 'world' WHERE key = 1");
+    t.assert.throws(() => {
+      session.changeset();
+    }, {
+      name: 'Error',
+      message: 'session is not open'
+    });
+  });
+
+  test('session.close() - after closing database throws exception', (t) => {
+    const database = new DatabaseSync(':memory:');
+    database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+    database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
+
+    const session = database.createSession();
+    database.close();
+
+    t.assert.throws(() => {
+      session.close();
+    }, {
+      name: 'Error',
+      message: 'database is not open'
+    });
+  });
+
+  test('session.close() - closing twice', (t) => {
+    const database = new DatabaseSync(':memory:');
+    const session = database.createSession();
+    session.close();
+
+    t.assert.throws(() => {
+      session.close();
+    }, {
+      name: 'Error',
+      message: 'session is not open'
+    });
+  });
+});
diff --git a/tools/doc/type-parser.mjs b/tools/doc/type-parser.mjs
index 6b94a94283ccb2..06fc72dab73cdb 100644
--- a/tools/doc/type-parser.mjs
+++ b/tools/doc/type-parser.mjs
@@ -199,6 +199,7 @@ const customTypesMap = {
 
   'repl.REPLServer': 'repl.html#class-replserver',
 
+  'Session': 'sqlite.html#class-session',
   'StatementSync': 'sqlite.html#class-statementsync',
 
   'Stream': 'stream.html#stream',

From 210f947cfcee7a376f39c549bb2b62636470f5b3 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:21:26 +0100
Subject: [PATCH 02/31] doc: address PR comment @RedYetiDev

---
 doc/api/sqlite.md | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 5d1235927d110a..dc91ec92c29f20 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -190,24 +190,22 @@ Creates and attaches a session to the database. This method is a wrapper around
 An exception is thrown if the database is not
 open. This method is a wrapper around [`sqlite3changeset_apply()`][].
 
-Example usage is demonstrated below.
-
 ```js
-const database1 = new DatabaseSync(':memory:');
-const database2 = new DatabaseSync(':memory:');
+const sourceDb = new DatabaseSync(':memory:');
+const targetDb = new DatabaseSync(':memory:');
 
-database1.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
-database2.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+sourceDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+targetDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
 
-const session = database1.createSession();
+const session = sourceDb.createSession();
 
-const insert = database1.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
+const insert = sourceDb.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
 insert.run(1, 'hello');
 insert.run(2, 'world');
 
 const changeset = session.changeset();
-database2.applyChangeset(changeset);
-// Now database2 contains the same data as database1
+targetDb.applyChangeset(changeset);
+// Now that the changeset has been applied, targetDb contains the same data as sourceDb.
 ```
 
 ## Class: `Session`

From bae7f678ab7620141ef8abb4351d007515db9141 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart.louwers@gmail.com>
Date: Sat, 2 Nov 2024 19:24:26 +0100
Subject: [PATCH 03/31] sqlite: keep MemoryInfo related stuff together

Co-authored-by: James M Snell <jasnell@gmail.com>
---
 src/node_sqlite.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node_sqlite.h b/src/node_sqlite.h
index 831d4d1786b34e..40caa62ca7fe83 100644
--- a/src/node_sqlite.h
+++ b/src/node_sqlite.h
@@ -134,13 +134,13 @@ class Session : public BaseObject {
   template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>
   static void Changeset(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
-  void MemoryInfo(MemoryTracker* tracker) const override;
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
   static BaseObjectPtr<Session> Create(Environment* env,
                                        BaseObjectWeakPtr<DatabaseSync> database,
                                        sqlite3_session* session);
 
+  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Session)
   SET_SELF_SIZE(Session)
 

From fd645753b8336865be1611b7557340932f353356 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:27:58 +0100
Subject: [PATCH 04/31] sqlite: use snake_case for local variables

---
 src/node_sqlite.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index a7745dd8d3a928..fb3e171861a5c5 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -348,7 +348,7 @@ void DatabaseSync::Exec(const FunctionCallbackInfo<Value>& args) {
 
 void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
   std::string table;
-  std::string dbName = "main";
+  std::string db_name = "main";
 
   Environment* env = Environment::GetCurrent(args);
   if (args.Length() > 0) {
@@ -385,7 +385,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
           options->Get(env->context(), db_key).ToLocalChecked();
       if (db_value->IsString()) {
         String::Utf8Value str(env->isolate(), db_value);
-        dbName = std::string(*str);
+        db_name = std::string(*str);
       } else {
         node::THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(), "The \"options.db\" argument must be a string.");
@@ -399,7 +399,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
   THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
 
   sqlite3_session* pSession;
-  int r = sqlite3session_create(db->connection_, dbName.c_str(), &pSession);
+  int r = sqlite3session_create(db->connection_, db_name.c_str(), &pSession);
   CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
   db->sessions_.insert(pSession);
 

From ed2851f2d45407cd501365503e22346bbb42cee8 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:38:17 +0100
Subject: [PATCH 05/31] sqlite: remove unneccesary use of node namespace

---
 src/node_sqlite.cc | 74 ++++++++++++++++++++++------------------------
 1 file changed, 36 insertions(+), 38 deletions(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index fb3e171861a5c5..7ae09c4698ff6a 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -53,7 +53,7 @@ using v8::Value;
 #define THROW_AND_RETURN_ON_BAD_STATE(env, condition, msg)                     \
   do {                                                                         \
     if ((condition)) {                                                         \
-      node::THROW_ERR_INVALID_STATE((env), (msg));                             \
+      THROW_ERR_INVALID_STATE((env), (msg));                                   \
       return;                                                                  \
     }                                                                          \
   } while (0)
@@ -133,7 +133,7 @@ void DatabaseSync::MemoryInfo(MemoryTracker* tracker) const {
 
 bool DatabaseSync::Open() {
   if (IsOpen()) {
-    node::THROW_ERR_INVALID_STATE(env(), "database is already open");
+    THROW_ERR_INVALID_STATE(env(), "database is already open");
     return false;
   }
 
@@ -200,21 +200,21 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
   }
 
   if (!args[0]->IsString()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
-                                     "The \"path\" argument must be a string.");
+    THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                               "The \"path\" argument must be a string.");
     return;
   }
 
   std::string location =
-      node::Utf8Value(env->isolate(), args[0].As<String>()).ToString();
+      Utf8Value(env->isolate(), args[0].As<String>()).ToString();
   DatabaseOpenConfiguration open_config(std::move(location));
 
   bool open = true;
 
   if (args.Length() > 1) {
     if (!args[1]->IsObject()) {
-      node::THROW_ERR_INVALID_ARG_TYPE(
-          env->isolate(), "The \"options\" argument must be an object.");
+      THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                                 "The \"options\" argument must be an object.");
       return;
     }
 
@@ -226,7 +226,7 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
     }
     if (!open_v->IsUndefined()) {
       if (!open_v->IsBoolean()) {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(), "The \"options.open\" argument must be a boolean.");
         return;
       }
@@ -241,7 +241,7 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
     }
     if (!read_only_v->IsUndefined()) {
       if (!read_only_v->IsBoolean()) {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(),
             "The \"options.readOnly\" argument must be a boolean.");
         return;
@@ -258,7 +258,7 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
     }
     if (!enable_foreign_keys_v->IsUndefined()) {
       if (!enable_foreign_keys_v->IsBoolean()) {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(),
             "The \"options.enableForeignKeyConstraints\" argument must be a "
             "boolean.");
@@ -277,7 +277,7 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
     }
     if (!enable_dqs_v->IsUndefined()) {
       if (!enable_dqs_v->IsBoolean()) {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(),
             "The \"options.enableDoubleQuotedStringLiterals\" argument must be "
             "a boolean.");
@@ -315,12 +315,12 @@ void DatabaseSync::Prepare(const FunctionCallbackInfo<Value>& args) {
   THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
 
   if (!args[0]->IsString()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
-                                     "The \"sql\" argument must be a string.");
+    THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                               "The \"sql\" argument must be a string.");
     return;
   }
 
-  node::Utf8Value sql(env->isolate(), args[0].As<String>());
+  Utf8Value sql(env->isolate(), args[0].As<String>());
   sqlite3_stmt* s = nullptr;
   int r = sqlite3_prepare_v2(db->connection_, *sql, -1, &s, 0);
   CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
@@ -336,12 +336,12 @@ void DatabaseSync::Exec(const FunctionCallbackInfo<Value>& args) {
   THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
 
   if (!args[0]->IsString()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
-                                     "The \"sql\" argument must be a string.");
+    THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                               "The \"sql\" argument must be a string.");
     return;
   }
 
-  node::Utf8Value sql(env->isolate(), args[0].As<String>());
+  Utf8Value sql(env->isolate(), args[0].As<String>());
   int r = sqlite3_exec(db->connection_, *sql, nullptr, nullptr, nullptr);
   CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
 }
@@ -353,8 +353,8 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   if (args.Length() > 0) {
     if (!args[0]->IsObject()) {
-      node::THROW_ERR_INVALID_ARG_TYPE(
-          env->isolate(), "The \"options\" argument must be an object.");
+      THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                                 "The \"options\" argument must be an object.");
       return;
     }
 
@@ -371,7 +371,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
         String::Utf8Value str(env->isolate(), table_value);
         table = std::string(*str);
       } else {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(), "The \"options.table\" argument must be a string.");
         return;
       }
@@ -387,7 +387,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
         String::Utf8Value str(env->isolate(), db_value);
         db_name = std::string(*str);
       } else {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(), "The \"options.db\" argument must be a string.");
         return;
       }
@@ -436,15 +436,15 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
   THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
 
   if (!args[0]->IsUint8Array()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(
+    THROW_ERR_INVALID_ARG_TYPE(
         env->isolate(), "The \"changeset\" argument must be a Uint8Array.");
     return;
   }
 
   if (args.Length() > 1 && !args[1]->IsUndefined()) {
     if (!args[1]->IsObject()) {
-      node::THROW_ERR_INVALID_ARG_TYPE(
-          env->isolate(), "The \"options\" argument must be an object.");
+      THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                                 "The \"options\" argument must be an object.");
       return;
     }
 
@@ -459,7 +459,7 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
           options->Get(env->context(), conflictKey).ToLocalChecked();
 
       if (!conflictValue->IsNumber()) {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(),
             "The \"options.onConflict\" argument must be a number.");
         return;
@@ -478,7 +478,7 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
           options->Get(env->context(), filterKey).ToLocalChecked();
 
       if (!filterValue->IsFunction()) {
-        node::THROW_ERR_INVALID_ARG_TYPE(
+        THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(),
             "The \"options.filter\" argument must be a function.");
         return;
@@ -578,7 +578,7 @@ bool StatementSync::BindParams(const FunctionCallbackInfo<Value>& args) {
         if (insertion.second == false) {
           auto existing_full_name = (*insertion.first).second;
           if (full_name != existing_full_name) {
-            node::THROW_ERR_INVALID_STATE(
+            THROW_ERR_INVALID_STATE(
                 env(),
                 "Cannot create bare named parameter '%s' because of "
                 "conflicting names '%s' and '%s'.",
@@ -598,7 +598,7 @@ bool StatementSync::BindParams(const FunctionCallbackInfo<Value>& args) {
         return false;
       }
 
-      node::Utf8Value utf8_key(env()->isolate(), key);
+      Utf8Value utf8_key(env()->isolate(), key);
       int r = sqlite3_bind_parameter_index(statement_, *utf8_key);
       if (r == 0) {
         if (allow_bare_named_params_) {
@@ -610,7 +610,7 @@ bool StatementSync::BindParams(const FunctionCallbackInfo<Value>& args) {
         }
 
         if (r == 0) {
-          node::THROW_ERR_INVALID_STATE(
+          THROW_ERR_INVALID_STATE(
               env(), "Unknown named parameter '%s'", *utf8_key);
           return false;
         }
@@ -654,7 +654,7 @@ bool StatementSync::BindValue(const Local<Value>& value, const int index) {
     double val = value.As<Number>()->Value();
     r = sqlite3_bind_double(statement_, index, val);
   } else if (value->IsString()) {
-    node::Utf8Value val(env()->isolate(), value.As<String>());
+    Utf8Value val(env()->isolate(), value.As<String>());
     r = sqlite3_bind_text(
         statement_, index, *val, val.length(), SQLITE_TRANSIENT);
   } else if (value->IsNull()) {
@@ -667,13 +667,12 @@ bool StatementSync::BindValue(const Local<Value>& value, const int index) {
     bool lossless;
     int64_t as_int = value.As<BigInt>()->Int64Value(&lossless);
     if (!lossless) {
-      node::THROW_ERR_INVALID_ARG_VALUE(env(),
-                                        "BigInt value is too large to bind.");
+      THROW_ERR_INVALID_ARG_VALUE(env(), "BigInt value is too large to bind.");
       return false;
     }
     r = sqlite3_bind_int64(statement_, index, as_int);
   } else {
-    node::THROW_ERR_INVALID_ARG_TYPE(
+    THROW_ERR_INVALID_ARG_TYPE(
         env()->isolate(),
         "Provided value cannot be bound to SQLite parameter %d.",
         index);
@@ -730,8 +729,7 @@ MaybeLocal<Value> StatementSync::ColumnToValue(const int column) {
 MaybeLocal<Name> StatementSync::ColumnNameToName(const int column) {
   const char* col_name = sqlite3_column_name(statement_, column);
   if (col_name == nullptr) {
-    node::THROW_ERR_INVALID_STATE(
-        env(), "Cannot get name of column %d", column);
+    THROW_ERR_INVALID_STATE(env(), "Cannot get name of column %d", column);
     return MaybeLocal<Name>();
   }
 
@@ -924,7 +922,7 @@ void StatementSync::SetAllowBareNamedParameters(
       env, stmt->IsFinalized(), "statement has been finalized");
 
   if (!args[0]->IsBoolean()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(
+    THROW_ERR_INVALID_ARG_TYPE(
         env->isolate(),
         "The \"allowBareNamedParameters\" argument must be a boolean.");
     return;
@@ -941,7 +939,7 @@ void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
       env, stmt->IsFinalized(), "statement has been finalized");
 
   if (!args[0]->IsBoolean()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(
+    THROW_ERR_INVALID_ARG_TYPE(
         env->isolate(), "The \"readBigInts\" argument must be a boolean.");
     return;
   }
@@ -950,7 +948,7 @@ void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
 }
 
 void IllegalConstructor(const FunctionCallbackInfo<Value>& args) {
-  node::THROW_ERR_ILLEGAL_CONSTRUCTOR(Environment::GetCurrent(args));
+  THROW_ERR_ILLEGAL_CONSTRUCTOR(Environment::GetCurrent(args));
 }
 
 static inline void SetSideEffectFreeGetter(

From bf9db72e6ee55ea159cc516d116c509b026ece67 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart.louwers@gmail.com>
Date: Sat, 2 Nov 2024 19:53:16 +0100
Subject: [PATCH 06/31] sqlite: improve working filter parameter

Co-authored-by: Aviv Keller <redyetidev@gmail.com>
---
 doc/api/sqlite.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index dc91ec92c29f20..4373b91a7c32c3 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -178,9 +178,7 @@ Creates and attaches a session to the database. This method is a wrapper around
 
 * `changeset` {Uint8Array} A binary changeset or patchset.
 * `options` {Object} An optional object to configure how changes are applied.
-  * `filter` {Function} Optional function. Skips changes when a truthy value is returned from it.
-    Takes the name of the table that a change targets as first argument. When this option is not
-    provided all changes are attempted.
+  * `filter` {Function} Skip changes that, when targeted table name is supplied to this function, return a truthy value. By default, all changes are attempted.
   * `onConflict` {number} Determines how conflicts are handled. When provided, must be one of the values below:
     * `SQLITE_CHANGESET_OMIT`: conflicting changes are omitted.
     * `SQLITE_CHANGESET_REPLACE`: conflicting changes replace existing values.

From c4c81472f64a5afeb1220ffec2016fe8cf7579c2 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:41:34 +0100
Subject: [PATCH 07/31] sqlite: add comment about using static functions

---
 src/node_sqlite.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 7ae09c4698ff6a..f9d069aba720f4 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -411,6 +411,8 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(session->object());
 }
 
+// the reason for using static functions here is that SQLite needs a
+// function pointer
 static std::function<int()> conflictCallback;
 
 static int xConflict(void* pCtx, int eConflict, sqlite3_changeset_iter* pIter) {

From 351c34eceaff49890216fed667f9f0a8b4782e04 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:56:08 +0100
Subject: [PATCH 08/31] doc: improve wording default value onConflict

---
 doc/api/sqlite.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 4373b91a7c32c3..05d408c51b90ff 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -179,10 +179,10 @@ Creates and attaches a session to the database. This method is a wrapper around
 * `changeset` {Uint8Array} A binary changeset or patchset.
 * `options` {Object} An optional object to configure how changes are applied.
   * `filter` {Function} Skip changes that, when targeted table name is supplied to this function, return a truthy value. By default, all changes are attempted.
-  * `onConflict` {number} Determines how conflicts are handled. When provided, must be one of the values below:
+  * `onConflict` {number} Determines how conflicts are handled. Default: `SQLITE_CHANGESET_ABORT`.
     * `SQLITE_CHANGESET_OMIT`: conflicting changes are omitted.
     * `SQLITE_CHANGESET_REPLACE`: conflicting changes replace existing values.
-    * `SQLITE_CHANGESET_ABORT`: abort on conflict and roll back databsase (default).
+    * `SQLITE_CHANGESET_ABORT`: abort on conflict and roll back databsase.
 * Returns: {boolean} Whether the changeset was applied succesfully without being aborted.
 
 An exception is thrown if the database is not

From a98e5b0a5eb8a2d840626e739e98ac38ffc65caa Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 19:57:27 +0100
Subject: [PATCH 09/31] doc: capitalize Default

---
 doc/api/sqlite.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 05d408c51b90ff..966e5d9857cf02 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -169,7 +169,7 @@ around [`sqlite3_prepare_v2()`][].
 * `options` {Object} An optional object used to configure the session.
   * `table` {string} When provided, only changes to this table are tracked by the created session.
     By default, changes to all tables are tracked.
-  * `db` {string} Name of the database to track. Default: `'main'`.
+  * `db` {string} Name of the database to track. **Default**: `'main'`.
 * Returns: {Session} A session handle.
 
 Creates and attaches a session to the database. This method is a wrapper around [`sqlite3session_create()`][] and [`sqlite3session_attach()`][].
@@ -179,7 +179,7 @@ Creates and attaches a session to the database. This method is a wrapper around
 * `changeset` {Uint8Array} A binary changeset or patchset.
 * `options` {Object} An optional object to configure how changes are applied.
   * `filter` {Function} Skip changes that, when targeted table name is supplied to this function, return a truthy value. By default, all changes are attempted.
-  * `onConflict` {number} Determines how conflicts are handled. Default: `SQLITE_CHANGESET_ABORT`.
+  * `onConflict` {number} Determines how conflicts are handled. **Default**: `SQLITE_CHANGESET_ABORT`.
     * `SQLITE_CHANGESET_OMIT`: conflicting changes are omitted.
     * `SQLITE_CHANGESET_REPLACE`: conflicting changes replace existing values.
     * `SQLITE_CHANGESET_ABORT`: abort on conflict and roll back databsase.

From 6876522109ef2d529ac924d51d323c3c2e405d80 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart.louwers@gmail.com>
Date: Sat, 2 Nov 2024 19:57:53 +0100
Subject: [PATCH 10/31] doc: improve wording options documentation

Co-authored-by: Aviv Keller <redyetidev@gmail.com>
---
 doc/api/sqlite.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 966e5d9857cf02..ac30a12106fbc4 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -177,7 +177,7 @@ Creates and attaches a session to the database. This method is a wrapper around
 ### `database.applyChangeset(changeset[, options])`
 
 * `changeset` {Uint8Array} A binary changeset or patchset.
-* `options` {Object} An optional object to configure how changes are applied.
+* `options` {Object} The configuration options for how the changes will be applied.
   * `filter` {Function} Skip changes that, when targeted table name is supplied to this function, return a truthy value. By default, all changes are attempted.
   * `onConflict` {number} Determines how conflicts are handled. **Default**: `SQLITE_CHANGESET_ABORT`.
     * `SQLITE_CHANGESET_OMIT`: conflicting changes are omitted.

From 7362f4e047bac4bc1e7b2a7a51d7c581a7996046 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart.louwers@gmail.com>
Date: Sat, 2 Nov 2024 19:58:48 +0100
Subject: [PATCH 11/31] doc: improve options documentation

Co-authored-by: Aviv Keller <redyetidev@gmail.com>
---
 doc/api/sqlite.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index ac30a12106fbc4..24b8aa4a5d0673 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -166,7 +166,7 @@ around [`sqlite3_prepare_v2()`][].
 
 ### `database.createSession([options])`
 
-* `options` {Object} An optional object used to configure the session.
+* `options` {Object} The configuration options for the session.
   * `table` {string} When provided, only changes to this table are tracked by the created session.
     By default, changes to all tables are tracked.
   * `db` {string} Name of the database to track. **Default**: `'main'`.

From fb9162839f2df45cff7c7fa436b6707b9661de22 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart.louwers@gmail.com>
Date: Sat, 2 Nov 2024 19:59:45 +0100
Subject: [PATCH 12/31] doc: improve wording table parameter

Co-authored-by: Aviv Keller <redyetidev@gmail.com>
---
 doc/api/sqlite.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 24b8aa4a5d0673..d7192feb1167d4 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -167,8 +167,7 @@ around [`sqlite3_prepare_v2()`][].
 ### `database.createSession([options])`
 
 * `options` {Object} The configuration options for the session.
-  * `table` {string} When provided, only changes to this table are tracked by the created session.
-    By default, changes to all tables are tracked.
+  * `table` {string} A specific table to track changes for. By default, changes to all tables are tracked.
   * `db` {string} Name of the database to track. **Default**: `'main'`.
 * Returns: {Session} A session handle.
 

From f15f1b05190596bcb393a3dddd6acf56b72c2a74 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart.louwers@gmail.com>
Date: Sat, 2 Nov 2024 20:00:12 +0100
Subject: [PATCH 13/31] test: improve test name

Co-authored-by: Colin Ihrig <cjihrig@gmail.com>
---
 test/parallel/test-sqlite.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js
index 27dc666066ef7b..f3f94cf50ca444 100644
--- a/test/parallel/test-sqlite.js
+++ b/test/parallel/test-sqlite.js
@@ -171,7 +171,7 @@ suite('session extension', () => {
     });
   });
 
-  test('database1.createSession() - use table option to track specific table', (t) => {
+  test('database.createSession() - use table option to track specific table', (t) => {
     const database1 = new DatabaseSync(':memory:');
     const database2 = new DatabaseSync(':memory:');
 

From 763da58a5e09740a77e7a6dd7b33dd254885338e Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 22:01:38 +0100
Subject: [PATCH 14/31] sqlite: move SQLITE_ENABLE_SESSION to node.gyp

---
 node.gyp          | 1 +
 src/node_sqlite.h | 2 --
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/node.gyp b/node.gyp
index 5b5b2b7c1c9627..f018e0a34d5782 100644
--- a/node.gyp
+++ b/node.gyp
@@ -882,6 +882,7 @@
         # Warn when using deprecated V8 APIs.
         'V8_DEPRECATION_WARNINGS=1',
         'NODE_OPENSSL_SYSTEM_CERT_PATH="<(openssl_system_ca_path)"',
+        "SQLITE_ENABLE_SESSION"
       ],
 
       # - "C4244: conversion from 'type1' to 'type2', possible loss of data"
diff --git a/src/node_sqlite.h b/src/node_sqlite.h
index 40caa62ca7fe83..d778d28e9ac289 100644
--- a/src/node_sqlite.h
+++ b/src/node_sqlite.h
@@ -3,8 +3,6 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#define SQLITE_ENABLE_SESSION
-
 #include "base_object.h"
 #include "node_mem.h"
 #include "sqlite3.h"

From 40837f2453a83da3738426c24e2af66764bb23ab Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 22:28:23 +0100
Subject: [PATCH 15/31] test: split out sqlite session test and fix null
 __proto__

---
 test/parallel/test-sqlite-session.js | 368 +++++++++++++++++++++++++++
 test/parallel/test-sqlite.js         | 350 -------------------------
 2 files changed, 368 insertions(+), 350 deletions(-)
 create mode 100644 test/parallel/test-sqlite-session.js

diff --git a/test/parallel/test-sqlite-session.js b/test/parallel/test-sqlite-session.js
new file mode 100644
index 00000000000000..8a24277ec4b128
--- /dev/null
+++ b/test/parallel/test-sqlite-session.js
@@ -0,0 +1,368 @@
+// Flags: --experimental-sqlite
+'use strict';
+const {
+  DatabaseSync,
+  SQLITE_CHANGESET_OMIT,
+  SQLITE_CHANGESET_REPLACE,
+  SQLITE_CHANGESET_ABORT
+} = require('node:sqlite');
+const { test } = require('node:test');
+
+/**
+ * Convenience wrapper around assert.deepStrictEqual that sets a null
+ * prototype to the expected object.
+ */
+function deepStrictEqual(t) {
+  return (actual, expected, message) => {
+    expected.__proto__ = null;
+  }
+}
+
+test('creating and applying a changeset', (t) => {
+  const createDataTableSql = `
+      CREATE TABLE data(
+        key INTEGER PRIMARY KEY,
+        value TEXT
+      ) STRICT`;
+
+  const createDatabase = () => {
+    const database = new DatabaseSync(':memory:');
+    database.exec(createDataTableSql);
+    return database;
+  };
+
+  const databaseFrom = createDatabase();
+  const session = databaseFrom.createSession();
+
+  const select = 'SELECT * FROM data ORDER BY key';
+
+  const insert = databaseFrom.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
+  insert.run(1, 'hello');
+  insert.run(2, 'world');
+
+  const databaseTo = createDatabase();
+
+  t.assert.strictEqual(databaseTo.applyChangeset(session.changeset()), true);
+  deepStrictEqual(t)(
+    databaseFrom.prepare(select).all(),
+    databaseTo.prepare(select).all()
+  );
+});
+
+test('database.createSession() - closed database results in exception', (t) => {
+  const database = new DatabaseSync(':memory:');
+  database.close();
+  t.assert.throws(() => {
+    database.createSession();
+  }, {
+    name: 'Error',
+    message: 'database is not open',
+  });
+});
+
+test('session.changeset() - closed database results in exception', (t) => {
+  const database = new DatabaseSync(':memory:');
+  const session = database.createSession();
+  database.close();
+  t.assert.throws(() => {
+    session.changeset();
+  }, {
+    name: 'Error',
+    message: 'database is not open',
+  });
+});
+
+test('database.applyChangeset() - closed database results in exception', (t) => {
+  const database = new DatabaseSync(':memory:');
+  const session = database.createSession();
+  const changeset = session.changeset();
+  database.close();
+  t.assert.throws(() => {
+    database.applyChangeset(changeset);
+  }, {
+    name: 'Error',
+    message: 'database is not open',
+  });
+});
+
+test('database.createSession() - use table option to track specific table', (t) => {
+  const database1 = new DatabaseSync(':memory:');
+  const database2 = new DatabaseSync(':memory:');
+
+  const createData1TableSql = `CREATE TABLE data1 (
+      key INTEGER PRIMARY KEY,
+      value TEXT
+    ) STRICT
+    `;
+  const createData2TableSql = `CREATE TABLE data2 (
+      key INTEGER PRIMARY KEY,
+      value TEXT
+    ) STRICT
+    `;
+  database1.exec(createData1TableSql);
+  database1.exec(createData2TableSql);
+  database2.exec(createData1TableSql);
+  database2.exec(createData2TableSql);
+
+  const session = database1.createSession({
+    table: 'data1'
+  });
+  const insert1 = database1.prepare('INSERT INTO data1 (key, value) VALUES (?, ?)');
+  insert1.run(1, 'hello');
+  insert1.run(2, 'world');
+  const insert2 = database1.prepare('INSERT INTO data2 (key, value) VALUES (?, ?)');
+  insert2.run(1, 'hello');
+  insert2.run(2, 'world');
+  const select1 = 'SELECT * FROM data1 ORDER BY key';
+  const select2 = 'SELECT * FROM data2 ORDER BY key';
+  t.assert.strictEqual(database2.applyChangeset(session.changeset()), true);
+  deepStrictEqual(t)(
+    database1.prepare(select1).all(),
+    database2.prepare(select1).all());  // data1 table should be equal
+  deepStrictEqual(t)(database2.prepare(select2).all(), []);  // data2 should be empty in database2
+  t.assert.strictEqual(database1.prepare(select2).all().length, 2);  // data1 should have values in database1
+});
+
+const prepareConflict = () => {
+  const database1 = new DatabaseSync(':memory:');
+  const database2 = new DatabaseSync(':memory:');
+
+  const createDataTableSql = `CREATE TABLE data (
+      key INTEGER PRIMARY KEY,
+      value TEXT
+    ) STRICT
+    `;
+  database1.exec(createDataTableSql);
+  database2.exec(createDataTableSql);
+
+  const insertSql = 'INSERT INTO data (key, value) VALUES (?, ?)';
+  const session = database1.createSession();
+  database1.prepare(insertSql).run(1, 'hello');
+  database1.prepare(insertSql).run(2, 'foo');
+  database2.prepare(insertSql).run(1, 'world');
+  return {
+    database2,
+    changeset: session.changeset()
+  };
+};
+
+test('database.applyChangeset() - conflict with default behavior (abort)', (t) => {
+  const { database2, changeset } = prepareConflict();
+  // When changeset is aborted due to a conflict, applyChangeset should return false
+  t.assert.strictEqual(database2.applyChangeset(changeset), false);
+  console.log("----------------", database2.prepare('SELECT value from data').all());
+  deepStrictEqual(t)(
+    database2.prepare('SELECT value from data').all(),
+    [{ value: 'world' }]);  // unchanged
+});
+
+test('database.applyChangeset() - conflict with SQLITE_CHANGESET_ABORT', (t) => {
+  const { database2, changeset } = prepareConflict();
+  const result = database2.applyChangeset(changeset, {
+    onConflict: SQLITE_CHANGESET_ABORT
+  });
+  // When changeset is aborted due to a conflict, applyChangeset should return false
+  t.assert.strictEqual(result, false);
+  deepStrictEqual(t)(
+    database2.prepare('SELECT value from data').all(),
+    [{ value: 'world' }]);  // unchanged
+});
+
+test('database.applyChangeset() - conflict with SQLITE_CHANGESET_REPLACE', (t) => {
+  const { database2, changeset } = prepareConflict();
+  const result = database2.applyChangeset(changeset, {
+    onConflict: SQLITE_CHANGESET_REPLACE
+  });
+  // Not aborted due to conflict, so should return true
+  t.assert.strictEqual(result, true);
+  deepStrictEqual(t)(
+    database2.prepare('SELECT value from data ORDER BY key').all(),
+    [{ value: 'hello' }, { value: 'foo' }]);  // replaced
+});
+
+test('database.applyChangeset() - conflict with SQLITE_CHANGESET_OMIT', (t) => {
+  const { database2, changeset } = prepareConflict();
+  const result = database2.applyChangeset(changeset, {
+    onConflict: SQLITE_CHANGESET_OMIT
+  });
+  // Not aborted due to conflict, so should return true
+  t.assert.strictEqual(result, true);
+  deepStrictEqual(t)(
+    database2.prepare('SELECT value from data ORDER BY key ASC').all(),
+    [{ value: 'world' }, { value: 'foo' }]);  // Conflicting change omitted
+});
+
+test('session related constants are defined', (t) => {
+  t.assert.strictEqual(SQLITE_CHANGESET_OMIT, 0);
+  t.assert.strictEqual(SQLITE_CHANGESET_REPLACE, 1);
+  t.assert.strictEqual(SQLITE_CHANGESET_ABORT, 2);
+});
+
+test('database.createSession() - filter changes', (t) => {
+  const database1 = new DatabaseSync(':memory:');
+  const database2 = new DatabaseSync(':memory:');
+  const createTableSql = 'CREATE TABLE data1(key INTEGER PRIMARY KEY); CREATE TABLE data2(key INTEGER PRIMARY KEY);';
+  database1.exec(createTableSql);
+  database2.exec(createTableSql);
+
+  const session = database1.createSession();
+
+  database1.exec('INSERT INTO data1 (key) VALUES (1), (2), (3)');
+  database1.exec('INSERT INTO data2 (key) VALUES (1), (2), (3), (4), (5)');
+
+  database2.applyChangeset(session.changeset(), {
+    filter: (tableName) => tableName === 'data2'
+  });
+
+  const data1Rows = database2.prepare('SELECT * FROM data1').all();
+  const data2Rows = database2.prepare('SELECT * FROM data2').all();
+
+  // Expect no rows since all changes were filtered out
+  t.assert.strictEqual(data1Rows.length, 0);
+  // Expect 5 rows since these changes were not filtered out
+  t.assert.strictEqual(data2Rows.length, 5);
+});
+
+test('database.createSession() - specify other database', (t) => {
+  const database = new DatabaseSync(':memory:');
+  const session = database.createSession();
+  const sessionMain = database.createSession({
+    db: 'main'
+  });
+  const sessionTest = database.createSession({
+    db: 'test'
+  });
+  database.exec('CREATE TABLE data (key INTEGER PRIMARY KEY)');
+  database.exec('INSERT INTO data (key) VALUES (1)');
+  t.assert.notStrictEqual(session.changeset().length, 0);
+  t.assert.notStrictEqual(sessionMain.changeset().length, 0);
+  // Since this session is attached to a different database, its changeset should be empty
+  t.assert.strictEqual(sessionTest.changeset().length, 0);
+});
+
+test('database.createSession() - wrong arguments', (t) => {
+  const database = new DatabaseSync(':memory:');
+  t.assert.throws(() => {
+    database.createSession(null);
+  }, {
+    name: 'TypeError',
+    message: 'The "options" argument must be an object.'
+  });
+
+  t.assert.throws(() => {
+    database.createSession({
+      table: 123
+    });
+  }, {
+    name: 'TypeError',
+    message: 'The "options.table" argument must be a string.'
+  });
+
+  t.assert.throws(() => {
+    database.createSession({
+      db: 123
+    });
+  }, {
+    name: 'TypeError',
+    message: 'The "options.db" argument must be a string.'
+  });
+});
+
+test('database.applyChangeset() - wrong arguments', (t) => {
+  const database = new DatabaseSync(':memory:');
+  const session = database.createSession();
+  t.assert.throws(() => {
+    database.applyChangeset(null);
+  }, {
+    name: 'TypeError',
+    message: 'The "changeset" argument must be a Uint8Array.'
+  });
+
+  t.assert.throws(() => {
+    database.applyChangeset(session.changeset(), null);
+  }, {
+    name: 'TypeError',
+    message: 'The "options" argument must be an object.'
+  });
+
+  t.assert.throws(() => {
+    database.applyChangeset(session.changeset(), {
+      filter: null
+    }, null);
+  }, {
+    name: 'TypeError',
+    message: 'The "options.filter" argument must be a function.'
+  });
+
+  t.assert.throws(() => {
+    database.applyChangeset(session.changeset(), {
+      onConflict: null
+    }, null);
+  }, {
+    name: 'TypeError',
+    message: 'The "options.onConflict" argument must be a number.'
+  });
+});
+
+test('session.patchset()', (t) => {
+  const database = new DatabaseSync(':memory:');
+  database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+  database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
+
+  const session = database.createSession();
+  database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
+
+  t.assert.ok(
+    session.patchset().length < session.changeset().length,
+    'expected patchset to be smaller than changeset');
+});
+
+test('session.close() - using session after close throws exception', (t) => {
+  const database = new DatabaseSync(':memory:');
+  database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+  database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
+
+  const session = database.createSession();
+  database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
+  session.close();
+
+  database.exec("UPDATE data SET value = 'world' WHERE key = 1");
+  t.assert.throws(() => {
+    session.changeset();
+  }, {
+    name: 'Error',
+    message: 'session is not open'
+  });
+});
+
+test('session.close() - after closing database throws exception', (t) => {
+  const database = new DatabaseSync(':memory:');
+  database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+
+  database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
+
+  const session = database.createSession();
+  database.close();
+
+  t.assert.throws(() => {
+    session.close();
+  }, {
+    name: 'Error',
+    message: 'database is not open'
+  });
+});
+
+test('session.close() - closing twice', (t) => {
+  const database = new DatabaseSync(':memory:');
+  const session = database.createSession();
+  session.close();
+
+  t.assert.throws(() => {
+    session.close();
+  }, {
+    name: 'Error',
+    message: 'session is not open'
+  });
+});
diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js
index f3f94cf50ca444..0216a9bbc58508 100644
--- a/test/parallel/test-sqlite.js
+++ b/test/parallel/test-sqlite.js
@@ -102,353 +102,3 @@ test('PRAGMAs are supported', (t) => {
     { __proto__: null, journal_mode: 'wal' },
   );
 });
-
-suite('session extension', () => {
-  test('creating and applying a changeset', (t) => {
-    const createDataTableSql = `
-      CREATE TABLE data(
-        key INTEGER PRIMARY KEY,
-        value TEXT
-      ) STRICT`;
-
-    const createDatabase = () => {
-      const database = new DatabaseSync(':memory:');
-      database.exec(createDataTableSql);
-      return database;
-    };
-
-    const databaseFrom = createDatabase();
-    const session = databaseFrom.createSession();
-
-    const select = 'SELECT * FROM data ORDER BY key';
-
-    const insert = databaseFrom.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
-    insert.run(1, 'hello');
-    insert.run(2, 'world');
-
-    const databaseTo = createDatabase();
-
-    t.assert.strictEqual(databaseTo.applyChangeset(session.changeset()), true);
-    t.assert.deepStrictEqual(
-      databaseFrom.prepare(select).all(),
-      databaseTo.prepare(select).all()
-    );
-  });
-
-  test('database.createSession() - closed database results in exception', (t) => {
-    const database = new DatabaseSync(':memory:');
-    database.close();
-    t.assert.throws(() => {
-      database.createSession();
-    }, {
-      name: 'Error',
-      message: 'database is not open',
-    });
-  });
-
-  test('session.changeset() - closed database results in exception', (t) => {
-    const database = new DatabaseSync(':memory:');
-    const session = database.createSession();
-    database.close();
-    t.assert.throws(() => {
-      session.changeset();
-    }, {
-      name: 'Error',
-      message: 'database is not open',
-    });
-  });
-
-  test('database.applyChangeset() - closed database results in exception', (t) => {
-    const database = new DatabaseSync(':memory:');
-    const session = database.createSession();
-    const changeset = session.changeset();
-    database.close();
-    t.assert.throws(() => {
-      database.applyChangeset(changeset);
-    }, {
-      name: 'Error',
-      message: 'database is not open',
-    });
-  });
-
-  test('database.createSession() - use table option to track specific table', (t) => {
-    const database1 = new DatabaseSync(':memory:');
-    const database2 = new DatabaseSync(':memory:');
-
-    const createData1TableSql = `CREATE TABLE data1 (
-      key INTEGER PRIMARY KEY,
-      value TEXT
-    ) STRICT
-    `;
-    const createData2TableSql = `CREATE TABLE data2 (
-      key INTEGER PRIMARY KEY,
-      value TEXT
-    ) STRICT
-    `;
-    database1.exec(createData1TableSql);
-    database1.exec(createData2TableSql);
-    database2.exec(createData1TableSql);
-    database2.exec(createData2TableSql);
-
-    const session = database1.createSession({
-      table: 'data1'
-    });
-    const insert1 = database1.prepare('INSERT INTO data1 (key, value) VALUES (?, ?)');
-    insert1.run(1, 'hello');
-    insert1.run(2, 'world');
-    const insert2 = database1.prepare('INSERT INTO data2 (key, value) VALUES (?, ?)');
-    insert2.run(1, 'hello');
-    insert2.run(2, 'world');
-    const select1 = 'SELECT * FROM data1 ORDER BY key';
-    const select2 = 'SELECT * FROM data2 ORDER BY key';
-    t.assert.strictEqual(database2.applyChangeset(session.changeset()), true);
-    t.assert.deepStrictEqual(
-      database1.prepare(select1).all(),
-      database2.prepare(select1).all());  // data1 table should be equal
-    t.assert.deepStrictEqual(database2.prepare(select2).all(), []);  // data2 should be empty in database2
-    t.assert.strictEqual(database1.prepare(select2).all().length, 2);  // data1 should have values in database1
-  });
-
-  const prepareConflict = () => {
-    const database1 = new DatabaseSync(':memory:');
-    const database2 = new DatabaseSync(':memory:');
-
-    const createDataTableSql = `CREATE TABLE data (
-      key INTEGER PRIMARY KEY,
-      value TEXT
-    ) STRICT
-    `;
-    database1.exec(createDataTableSql);
-    database2.exec(createDataTableSql);
-
-    const insertSql = 'INSERT INTO data (key, value) VALUES (?, ?)';
-    const session = database1.createSession();
-    database1.prepare(insertSql).run(1, 'hello');
-    database1.prepare(insertSql).run(2, 'foo');
-    database2.prepare(insertSql).run(1, 'world');
-    return {
-      database2,
-      changeset: session.changeset()
-    };
-  };
-
-  test('database.applyChangeset() - conflict with default behavior (abort)', (t) => {
-    const { database2, changeset } = prepareConflict();
-    // When changeset is aborted due to a conflict, applyChangeset should return false
-    t.assert.strictEqual(database2.applyChangeset(changeset), false);
-    t.assert.deepStrictEqual(
-      database2.prepare('SELECT value from data').all(),
-      [{ value: 'world' }]);  // unchanged
-  });
-
-  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_ABORT', (t) => {
-    const { database2, changeset } = prepareConflict();
-    const result = database2.applyChangeset(changeset, {
-      onConflict: SQLITE_CHANGESET_ABORT
-    });
-    // When changeset is aborted due to a conflict, applyChangeset should return false
-    t.assert.strictEqual(result, false);
-    t.assert.deepStrictEqual(
-      database2.prepare('SELECT value from data').all(),
-      [{ value: 'world' }]);  // unchanged
-  });
-
-  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_REPLACE', (t) => {
-    const { database2, changeset } = prepareConflict();
-    const result = database2.applyChangeset(changeset, {
-      onConflict: SQLITE_CHANGESET_REPLACE
-    });
-    // Not aborted due to conflict, so should return true
-    t.assert.strictEqual(result, true);
-    t.assert.deepStrictEqual(
-      database2.prepare('SELECT value from data ORDER BY key').all(),
-      [{ value: 'hello' }, { value: 'foo' }]);  // replaced
-  });
-
-  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_OMIT', (t) => {
-    const { database2, changeset } = prepareConflict();
-    const result = database2.applyChangeset(changeset, {
-      onConflict: SQLITE_CHANGESET_OMIT
-    });
-    // Not aborted due to conflict, so should return true
-    t.assert.strictEqual(result, true);
-    t.assert.deepStrictEqual(
-      database2.prepare('SELECT value from data ORDER BY key ASC').all(),
-      [{ value: 'world' }, { value: 'foo' }]);  // Conflicting change omitted
-  });
-
-  test('session related constants are defined', (t) => {
-    t.assert.strictEqual(SQLITE_CHANGESET_OMIT, 0);
-    t.assert.strictEqual(SQLITE_CHANGESET_REPLACE, 1);
-    t.assert.strictEqual(SQLITE_CHANGESET_ABORT, 2);
-  });
-
-  test('database.createSession() - filter changes', (t) => {
-    const database1 = new DatabaseSync(':memory:');
-    const database2 = new DatabaseSync(':memory:');
-    const createTableSql = 'CREATE TABLE data1(key INTEGER PRIMARY KEY); CREATE TABLE data2(key INTEGER PRIMARY KEY);';
-    database1.exec(createTableSql);
-    database2.exec(createTableSql);
-
-    const session = database1.createSession();
-
-    database1.exec('INSERT INTO data1 (key) VALUES (1), (2), (3)');
-    database1.exec('INSERT INTO data2 (key) VALUES (1), (2), (3), (4), (5)');
-
-    database2.applyChangeset(session.changeset(), {
-      filter: (tableName) => tableName === 'data2'
-    });
-
-    const data1Rows = database2.prepare('SELECT * FROM data1').all();
-    const data2Rows = database2.prepare('SELECT * FROM data2').all();
-
-    // Expect no rows since all changes were filtered out
-    t.assert.strictEqual(data1Rows.length, 0);
-    // Expect 5 rows since these changes were not filtered out
-    t.assert.strictEqual(data2Rows.length, 5);
-  });
-
-  test('database.createSession() - specify other database', (t) => {
-    const database = new DatabaseSync(':memory:');
-    const session = database.createSession();
-    const sessionMain = database.createSession({
-      db: 'main'
-    });
-    const sessionTest = database.createSession({
-      db: 'test'
-    });
-    database.exec('CREATE TABLE data (key INTEGER PRIMARY KEY)');
-    database.exec('INSERT INTO data (key) VALUES (1)');
-    t.assert.notStrictEqual(session.changeset().length, 0);
-    t.assert.notStrictEqual(sessionMain.changeset().length, 0);
-    // Since this session is attached to a different database, its changeset should be empty
-    t.assert.strictEqual(sessionTest.changeset().length, 0);
-  });
-
-  test('database.createSession() - wrong arguments', (t) => {
-    const database = new DatabaseSync(':memory:');
-    t.assert.throws(() => {
-      database.createSession(null);
-    }, {
-      name: 'TypeError',
-      message: 'The "options" argument must be an object.'
-    });
-
-    t.assert.throws(() => {
-      database.createSession({
-        table: 123
-      });
-    }, {
-      name: 'TypeError',
-      message: 'The "options.table" argument must be a string.'
-    });
-
-    t.assert.throws(() => {
-      database.createSession({
-        db: 123
-      });
-    }, {
-      name: 'TypeError',
-      message: 'The "options.db" argument must be a string.'
-    });
-  });
-
-  test('database.applyChangeset() - wrong arguments', (t) => {
-    const database = new DatabaseSync(':memory:');
-    const session = database.createSession();
-    t.assert.throws(() => {
-      database.applyChangeset(null);
-    }, {
-      name: 'TypeError',
-      message: 'The "changeset" argument must be a Uint8Array.'
-    });
-
-    t.assert.throws(() => {
-      database.applyChangeset(session.changeset(), null);
-    }, {
-      name: 'TypeError',
-      message: 'The "options" argument must be an object.'
-    });
-
-    t.assert.throws(() => {
-      database.applyChangeset(session.changeset(), {
-        filter: null
-      }, null);
-    }, {
-      name: 'TypeError',
-      message: 'The "options.filter" argument must be a function.'
-    });
-
-    t.assert.throws(() => {
-      database.applyChangeset(session.changeset(), {
-        onConflict: null
-      }, null);
-    }, {
-      name: 'TypeError',
-      message: 'The "options.onConflict" argument must be a number.'
-    });
-  });
-
-  test('session.patchset()', (t) => {
-    const database = new DatabaseSync(':memory:');
-    database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
-
-    database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
-
-    const session = database.createSession();
-    database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
-
-    t.assert.ok(
-      session.patchset().length < session.changeset().length,
-      'expected patchset to be smaller than changeset');
-  });
-
-  test('session.close() - using session after close throws exception', (t) => {
-    const database = new DatabaseSync(':memory:');
-    database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
-
-    database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
-
-    const session = database.createSession();
-    database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
-    session.close();
-
-    database.exec("UPDATE data SET value = 'world' WHERE key = 1");
-    t.assert.throws(() => {
-      session.changeset();
-    }, {
-      name: 'Error',
-      message: 'session is not open'
-    });
-  });
-
-  test('session.close() - after closing database throws exception', (t) => {
-    const database = new DatabaseSync(':memory:');
-    database.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
-
-    database.exec("INSERT INTO data VALUES ('1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')");
-
-    const session = database.createSession();
-    database.close();
-
-    t.assert.throws(() => {
-      session.close();
-    }, {
-      name: 'Error',
-      message: 'database is not open'
-    });
-  });
-
-  test('session.close() - closing twice', (t) => {
-    const database = new DatabaseSync(':memory:');
-    const session = database.createSession();
-    session.close();
-
-    t.assert.throws(() => {
-      session.close();
-    }, {
-      name: 'Error',
-      message: 'session is not open'
-    });
-  });
-});

From b70d41c52564fc9d66695c80bf10d8712904a763 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 22:50:35 +0100
Subject: [PATCH 16/31] sqlite:  use FIXED_ONE_BYTE_STRING instead of
 NewFromUtf8

---
 src/node_sqlite.cc | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index f9d069aba720f4..622ee9a5402128 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -360,9 +360,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
 
     Local<Object> options = args[0].As<Object>();
 
-    Local<String> table_key =
-        String::NewFromUtf8(env->isolate(), "table", NewStringType::kNormal)
-            .ToLocalChecked();
+    Local<String> table_key = FIXED_ONE_BYTE_STRING(env->isolate(), "table");
     if (options->HasOwnProperty(env->context(), table_key).FromJust()) {
       Local<Value> table_value =
           options->Get(env->context(), table_key).ToLocalChecked();

From 56131e869521502f643c50b67448c8689dcc1ab5 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 22:52:16 +0100
Subject: [PATCH 17/31] sqlite: don't use ToLocalChecked

---
 src/node_sqlite.cc | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 622ee9a5402128..4f1ed7f0c02813 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -362,8 +362,10 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
 
     Local<String> table_key = FIXED_ONE_BYTE_STRING(env->isolate(), "table");
     if (options->HasOwnProperty(env->context(), table_key).FromJust()) {
-      Local<Value> table_value =
-          options->Get(env->context(), table_key).ToLocalChecked();
+      Local<Value> table_value;
+      if (!options->Get(env->context(), table_key).ToLocal(&table_value)) {
+	       return;
+      }
 
       if (table_value->IsString()) {
         String::Utf8Value str(env->isolate(), table_value);

From 3202fbbdd7b81b829e2dadeeace9e7c6299b1f31 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 23:18:02 +0100
Subject: [PATCH 18/31] sqlite: avoid double check

---
 src/node_sqlite.cc | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 4f1ed7f0c02813..31cf6d0800bfb5 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -456,10 +456,9 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
         String::NewFromUtf8(
             env->isolate(), "onConflict", NewStringType::kNormal)
             .ToLocalChecked();
-    if (options->HasOwnProperty(env->context(), conflictKey).FromJust()) {
-      Local<Value> conflictValue =
-          options->Get(env->context(), conflictKey).ToLocalChecked();
+    Local<Value> conflictValue = options->Get(env->context(), conflictKey).ToLocalChecked();
 
+    if (!conflictValue->IsUndefined()) {
       if (!conflictValue->IsNumber()) {
         THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(),

From df83e4b39586cd9c459186dede6014cdceaafd1d Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 23:43:50 +0100
Subject: [PATCH 19/31] doc: add documentation for constants

---
 doc/api/sqlite.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index d7192feb1167d4..3ceb307bed1c3e 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -389,6 +389,35 @@ exception.
 | `TEXT`    | {string}             |
 | `BLOB`    | {Uint8Array}         |
 
+## SQLite constants
+
+The following constants are exported by the `node:sqlite` module.
+
+### SQLite Session constants
+
+#### Conflict-resolution constants
+
+The following constants are meant for use with [`database.applyChangeset()`](#databaseapplychangesetchangeset-options).
+
+<table>
+  <tr>
+    <th>Constant</th>
+    <th>Description</th>
+  </tr>
+  <tr>
+    <td><code>SQLITE_CHANGESET_OMIT</code></td>
+    <td>Conflicting changes are omitted.</td>
+  </tr>
+  <tr>
+    <td><code>SQLITE_CHANGESET_REPLACE</code></td>
+    <td>Conflicting changes replace existing values.</td>
+  </tr>
+  <tr>
+    <td><code>SQLITE_CHANGESET_ABORT</code></td>
+    <td>Abort when a change encounters a conflict and roll back databsase.</td>
+  </tr>
+</table>
+
 [Changesets and Patchsets]: https://www.sqlite.org/sessionintro.html#changesets_and_patchsets
 [SQL injection]: https://en.wikipedia.org/wiki/SQL_injection
 [`--experimental-sqlite`]: cli.md#--experimental-sqlite

From 8addc586a478a274c4cfd1bd7774f03c8d60dc37 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 23:49:52 +0100
Subject: [PATCH 20/31] doc: add explanation database name

---
 doc/api/sqlite.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 3ceb307bed1c3e..93b214b79468c0 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -168,7 +168,7 @@ around [`sqlite3_prepare_v2()`][].
 
 * `options` {Object} The configuration options for the session.
   * `table` {string} A specific table to track changes for. By default, changes to all tables are tracked.
-  * `db` {string} Name of the database to track. **Default**: `'main'`.
+  * `db` {string} Name of the database to track. This is useful when multiple databases have been added using [`ATTACH DATABASE`][]. **Default**: `'main'`.
 * Returns: {Session} A session handle.
 
 Creates and attaches a session to the database. This method is a wrapper around [`sqlite3session_create()`][] and [`sqlite3session_attach()`][].
@@ -418,9 +418,11 @@ The following constants are meant for use with [`database.applyChangeset()`](#da
   </tr>
 </table>
 
+
 [Changesets and Patchsets]: https://www.sqlite.org/sessionintro.html#changesets_and_patchsets
 [SQL injection]: https://en.wikipedia.org/wiki/SQL_injection
 [`--experimental-sqlite`]: cli.md#--experimental-sqlite
+[`ATTACH DATABASE`]: https://www.sqlite.org/lang_attach.html
 [`PRAGMA foreign_keys`]: https://www.sqlite.org/pragma.html#pragma_foreign_keys
 [`sqlite3_changes64()`]: https://www.sqlite.org/c3ref/changes.html
 [`sqlite3_close_v2()`]: https://www.sqlite.org/c3ref/close.html

From d31b038fc0858b67097f9ee893dd1820742ef0b4 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 23:50:14 +0100
Subject: [PATCH 21/31] test: remove unused imports test-sqlite.js

---
 test/parallel/test-sqlite.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js
index 0216a9bbc58508..0e79481dc36dd4 100644
--- a/test/parallel/test-sqlite.js
+++ b/test/parallel/test-sqlite.js
@@ -5,9 +5,6 @@ const tmpdir = require('../common/tmpdir');
 const { join } = require('node:path');
 const {
   DatabaseSync,
-  SQLITE_CHANGESET_OMIT,
-  SQLITE_CHANGESET_REPLACE,
-  SQLITE_CHANGESET_ABORT
 } = require('node:sqlite');
 const { suite, test } = require('node:test');
 let cnt = 0;

From 4e62d6a045c6eec553dd21ef41a3eb1ba6bd2421 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 23:53:47 +0100
Subject: [PATCH 22/31] test: add some extra asserts for changeset and patchset

---
 test/parallel/test-sqlite-session.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-sqlite-session.js b/test/parallel/test-sqlite-session.js
index 8a24277ec4b128..72979cf86437e9 100644
--- a/test/parallel/test-sqlite-session.js
+++ b/test/parallel/test-sqlite-session.js
@@ -313,8 +313,17 @@ test('session.patchset()', (t) => {
   const session = database.createSession();
   database.exec("UPDATE data SET value = 'hi' WHERE key = 1");
 
+  const patchset = session.patchset();
+  const changeset = session.changeset();
+
+  t.assert.ok(patchset instanceof Uint8Array);
+  t.assert.ok(changeset instanceof Uint8Array);
+
+  t.assert.deepStrictEqual(patchset, session.patchset());
+  t.assert.deepStrictEqual(changeset, session.changeset());
+
   t.assert.ok(
-    session.patchset().length < session.changeset().length,
+    patchset.length < changeset.length,
     'expected patchset to be smaller than changeset');
 });
 

From 7918a6cf82e57eb6e69210569063bba76368c1fb Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 2 Nov 2024 23:58:35 +0100
Subject: [PATCH 23/31] test: create suite for conflict resolution

---
 test/parallel/test-sqlite-session.js | 130 ++++++++++++++-------------
 1 file changed, 66 insertions(+), 64 deletions(-)

diff --git a/test/parallel/test-sqlite-session.js b/test/parallel/test-sqlite-session.js
index 72979cf86437e9..aa259a298ca4be 100644
--- a/test/parallel/test-sqlite-session.js
+++ b/test/parallel/test-sqlite-session.js
@@ -6,7 +6,7 @@ const {
   SQLITE_CHANGESET_REPLACE,
   SQLITE_CHANGESET_ABORT
 } = require('node:sqlite');
-const { test } = require('node:test');
+const { test, suite } = require('node:test');
 
 /**
  * Convenience wrapper around assert.deepStrictEqual that sets a null
@@ -123,73 +123,75 @@ test('database.createSession() - use table option to track specific table', (t)
   t.assert.strictEqual(database1.prepare(select2).all().length, 2);  // data1 should have values in database1
 });
 
-const prepareConflict = () => {
-  const database1 = new DatabaseSync(':memory:');
-  const database2 = new DatabaseSync(':memory:');
-
-  const createDataTableSql = `CREATE TABLE data (
-      key INTEGER PRIMARY KEY,
-      value TEXT
-    ) STRICT
-    `;
-  database1.exec(createDataTableSql);
-  database2.exec(createDataTableSql);
-
-  const insertSql = 'INSERT INTO data (key, value) VALUES (?, ?)';
-  const session = database1.createSession();
-  database1.prepare(insertSql).run(1, 'hello');
-  database1.prepare(insertSql).run(2, 'foo');
-  database2.prepare(insertSql).run(1, 'world');
-  return {
-    database2,
-    changeset: session.changeset()
+suite('conflict resolution', () => {
+  const prepareConflict = () => {
+    const database1 = new DatabaseSync(':memory:');
+    const database2 = new DatabaseSync(':memory:');
+  
+    const createDataTableSql = `CREATE TABLE data (
+        key INTEGER PRIMARY KEY,
+        value TEXT
+      ) STRICT
+      `;
+    database1.exec(createDataTableSql);
+    database2.exec(createDataTableSql);
+  
+    const insertSql = 'INSERT INTO data (key, value) VALUES (?, ?)';
+    const session = database1.createSession();
+    database1.prepare(insertSql).run(1, 'hello');
+    database1.prepare(insertSql).run(2, 'foo');
+    database2.prepare(insertSql).run(1, 'world');
+    return {
+      database2,
+      changeset: session.changeset()
+    };
   };
-};
-
-test('database.applyChangeset() - conflict with default behavior (abort)', (t) => {
-  const { database2, changeset } = prepareConflict();
-  // When changeset is aborted due to a conflict, applyChangeset should return false
-  t.assert.strictEqual(database2.applyChangeset(changeset), false);
-  console.log("----------------", database2.prepare('SELECT value from data').all());
-  deepStrictEqual(t)(
-    database2.prepare('SELECT value from data').all(),
-    [{ value: 'world' }]);  // unchanged
-});
-
-test('database.applyChangeset() - conflict with SQLITE_CHANGESET_ABORT', (t) => {
-  const { database2, changeset } = prepareConflict();
-  const result = database2.applyChangeset(changeset, {
-    onConflict: SQLITE_CHANGESET_ABORT
+  
+  test('database.applyChangeset() - conflict with default behavior (abort)', (t) => {
+    const { database2, changeset } = prepareConflict();
+    // When changeset is aborted due to a conflict, applyChangeset should return false
+    t.assert.strictEqual(database2.applyChangeset(changeset), false);
+    console.log("----------------", database2.prepare('SELECT value from data').all());
+    deepStrictEqual(t)(
+      database2.prepare('SELECT value from data').all(),
+      [{ value: 'world' }]);  // unchanged
   });
-  // When changeset is aborted due to a conflict, applyChangeset should return false
-  t.assert.strictEqual(result, false);
-  deepStrictEqual(t)(
-    database2.prepare('SELECT value from data').all(),
-    [{ value: 'world' }]);  // unchanged
-});
-
-test('database.applyChangeset() - conflict with SQLITE_CHANGESET_REPLACE', (t) => {
-  const { database2, changeset } = prepareConflict();
-  const result = database2.applyChangeset(changeset, {
-    onConflict: SQLITE_CHANGESET_REPLACE
+  
+  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_ABORT', (t) => {
+    const { database2, changeset } = prepareConflict();
+    const result = database2.applyChangeset(changeset, {
+      onConflict: SQLITE_CHANGESET_ABORT
+    });
+    // When changeset is aborted due to a conflict, applyChangeset should return false
+    t.assert.strictEqual(result, false);
+    deepStrictEqual(t)(
+      database2.prepare('SELECT value from data').all(),
+      [{ value: 'world' }]);  // unchanged
   });
-  // Not aborted due to conflict, so should return true
-  t.assert.strictEqual(result, true);
-  deepStrictEqual(t)(
-    database2.prepare('SELECT value from data ORDER BY key').all(),
-    [{ value: 'hello' }, { value: 'foo' }]);  // replaced
-});
-
-test('database.applyChangeset() - conflict with SQLITE_CHANGESET_OMIT', (t) => {
-  const { database2, changeset } = prepareConflict();
-  const result = database2.applyChangeset(changeset, {
-    onConflict: SQLITE_CHANGESET_OMIT
+  
+  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_REPLACE', (t) => {
+    const { database2, changeset } = prepareConflict();
+    const result = database2.applyChangeset(changeset, {
+      onConflict: SQLITE_CHANGESET_REPLACE
+    });
+    // Not aborted due to conflict, so should return true
+    t.assert.strictEqual(result, true);
+    deepStrictEqual(t)(
+      database2.prepare('SELECT value from data ORDER BY key').all(),
+      [{ value: 'hello' }, { value: 'foo' }]);  // replaced
+  });
+  
+  test('database.applyChangeset() - conflict with SQLITE_CHANGESET_OMIT', (t) => {
+    const { database2, changeset } = prepareConflict();
+    const result = database2.applyChangeset(changeset, {
+      onConflict: SQLITE_CHANGESET_OMIT
+    });
+    // Not aborted due to conflict, so should return true
+    t.assert.strictEqual(result, true);
+    deepStrictEqual(t)(
+      database2.prepare('SELECT value from data ORDER BY key ASC').all(),
+      [{ value: 'world' }, { value: 'foo' }]);  // Conflicting change omitted
   });
-  // Not aborted due to conflict, so should return true
-  t.assert.strictEqual(result, true);
-  deepStrictEqual(t)(
-    database2.prepare('SELECT value from data ORDER BY key ASC').all(),
-    [{ value: 'world' }, { value: 'foo' }]);  // Conflicting change omitted
 });
 
 test('session related constants are defined', (t) => {

From f4b814ddf07b5e34a3cd94b04a86d3f2f9fcc63a Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 3 Nov 2024 00:08:41 +0100
Subject: [PATCH 24/31] test: fix deepStrictEqual helper

---
 test/parallel/test-sqlite-session.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-sqlite-session.js b/test/parallel/test-sqlite-session.js
index aa259a298ca4be..9e15d21e8ddf4e 100644
--- a/test/parallel/test-sqlite-session.js
+++ b/test/parallel/test-sqlite-session.js
@@ -1,5 +1,6 @@
 // Flags: --experimental-sqlite
 'use strict';
+require('../common');
 const {
   DatabaseSync,
   SQLITE_CHANGESET_OMIT,
@@ -14,7 +15,12 @@ const { test, suite } = require('node:test');
  */
 function deepStrictEqual(t) {
   return (actual, expected, message) => {
-    expected.__proto__ = null;
+    if (Array.isArray(expected)) {
+      expected = expected.map(obj => ({...obj, __proto__: null }));
+    } else if (typeof expected === 'object') {
+      expected = {...expected, __proto__: null};
+    }
+    t.assert.deepStrictEqual(actual, expected, message);
   }
 }
 

From 14ba0024d5411a6b1c0f00de1a330578c077fcea Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 3 Nov 2024 00:10:41 +0100
Subject: [PATCH 25/31] test: fix lint issues

---
 test/parallel/test-sqlite-session.js | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/test/parallel/test-sqlite-session.js b/test/parallel/test-sqlite-session.js
index 9e15d21e8ddf4e..306f439939e2e0 100644
--- a/test/parallel/test-sqlite-session.js
+++ b/test/parallel/test-sqlite-session.js
@@ -16,12 +16,12 @@ const { test, suite } = require('node:test');
 function deepStrictEqual(t) {
   return (actual, expected, message) => {
     if (Array.isArray(expected)) {
-      expected = expected.map(obj => ({...obj, __proto__: null }));
+      expected = expected.map((obj) => ({ ...obj, __proto__: null }));
     } else if (typeof expected === 'object') {
-      expected = {...expected, __proto__: null};
+      expected = { ...expected, __proto__: null };
     }
     t.assert.deepStrictEqual(actual, expected, message);
-  }
+  };
 }
 
 test('creating and applying a changeset', (t) => {
@@ -133,7 +133,7 @@ suite('conflict resolution', () => {
   const prepareConflict = () => {
     const database1 = new DatabaseSync(':memory:');
     const database2 = new DatabaseSync(':memory:');
-  
+
     const createDataTableSql = `CREATE TABLE data (
         key INTEGER PRIMARY KEY,
         value TEXT
@@ -141,7 +141,7 @@ suite('conflict resolution', () => {
       `;
     database1.exec(createDataTableSql);
     database2.exec(createDataTableSql);
-  
+
     const insertSql = 'INSERT INTO data (key, value) VALUES (?, ?)';
     const session = database1.createSession();
     database1.prepare(insertSql).run(1, 'hello');
@@ -152,17 +152,16 @@ suite('conflict resolution', () => {
       changeset: session.changeset()
     };
   };
-  
+
   test('database.applyChangeset() - conflict with default behavior (abort)', (t) => {
     const { database2, changeset } = prepareConflict();
     // When changeset is aborted due to a conflict, applyChangeset should return false
     t.assert.strictEqual(database2.applyChangeset(changeset), false);
-    console.log("----------------", database2.prepare('SELECT value from data').all());
     deepStrictEqual(t)(
       database2.prepare('SELECT value from data').all(),
       [{ value: 'world' }]);  // unchanged
   });
-  
+
   test('database.applyChangeset() - conflict with SQLITE_CHANGESET_ABORT', (t) => {
     const { database2, changeset } = prepareConflict();
     const result = database2.applyChangeset(changeset, {
@@ -174,7 +173,7 @@ suite('conflict resolution', () => {
       database2.prepare('SELECT value from data').all(),
       [{ value: 'world' }]);  // unchanged
   });
-  
+
   test('database.applyChangeset() - conflict with SQLITE_CHANGESET_REPLACE', (t) => {
     const { database2, changeset } = prepareConflict();
     const result = database2.applyChangeset(changeset, {
@@ -186,7 +185,7 @@ suite('conflict resolution', () => {
       database2.prepare('SELECT value from data ORDER BY key').all(),
       [{ value: 'hello' }, { value: 'foo' }]);  // replaced
   });
-  
+
   test('database.applyChangeset() - conflict with SQLITE_CHANGESET_OMIT', (t) => {
     const { database2, changeset } = prepareConflict();
     const result = database2.applyChangeset(changeset, {

From 1d8da20a6618bfc3b70bfa8c52fc41e241b8b0db Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 3 Nov 2024 00:11:11 +0100
Subject: [PATCH 26/31] doc: fix lint issue

---
 doc/api/sqlite.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 93b214b79468c0..9f11cb0e2832a8 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -177,7 +177,8 @@ Creates and attaches a session to the database. This method is a wrapper around
 
 * `changeset` {Uint8Array} A binary changeset or patchset.
 * `options` {Object} The configuration options for how the changes will be applied.
-  * `filter` {Function} Skip changes that, when targeted table name is supplied to this function, return a truthy value. By default, all changes are attempted.
+  * `filter` {Function} Skip changes that, when targeted table name is supplied to this function, return a truthy value.
+    By default, all changes are attempted.
   * `onConflict` {number} Determines how conflicts are handled. **Default**: `SQLITE_CHANGESET_ABORT`.
     * `SQLITE_CHANGESET_OMIT`: conflicting changes are omitted.
     * `SQLITE_CHANGESET_REPLACE`: conflicting changes replace existing values.
@@ -418,7 +419,6 @@ The following constants are meant for use with [`database.applyChangeset()`](#da
   </tr>
 </table>
 
-
 [Changesets and Patchsets]: https://www.sqlite.org/sessionintro.html#changesets_and_patchsets
 [SQL injection]: https://en.wikipedia.org/wiki/SQL_injection
 [`--experimental-sqlite`]: cli.md#--experimental-sqlite

From 80725c5e089aa640f20c9cd740c04dd59e1bc6ea Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 3 Nov 2024 00:13:37 +0100
Subject: [PATCH 27/31] test: format import

---
 test/parallel/test-sqlite.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js
index 0e79481dc36dd4..f8b122131fe7a2 100644
--- a/test/parallel/test-sqlite.js
+++ b/test/parallel/test-sqlite.js
@@ -3,9 +3,7 @@
 const { spawnPromisified } = require('../common');
 const tmpdir = require('../common/tmpdir');
 const { join } = require('node:path');
-const {
-  DatabaseSync,
-} = require('node:sqlite');
+const { DatabaseSync } = require('node:sqlite');
 const { suite, test } = require('node:test');
 let cnt = 0;
 

From c3cf3f39cb3832b925b0957e28e1b867fae9d5b6 Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sat, 16 Nov 2024 18:31:57 +0100
Subject: [PATCH 28/31] sqlite: run format

---
 src/node_sqlite.cc | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 31cf6d0800bfb5..a6fbc0021c09e8 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -364,7 +364,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
     if (options->HasOwnProperty(env->context(), table_key).FromJust()) {
       Local<Value> table_value;
       if (!options->Get(env->context(), table_key).ToLocal(&table_value)) {
-	       return;
+        return;
       }
 
       if (table_value->IsString()) {
@@ -456,7 +456,8 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
         String::NewFromUtf8(
             env->isolate(), "onConflict", NewStringType::kNormal)
             .ToLocalChecked();
-    Local<Value> conflictValue = options->Get(env->context(), conflictKey).ToLocalChecked();
+    Local<Value> conflictValue =
+        options->Get(env->context(), conflictKey).ToLocalChecked();
 
     if (!conflictValue->IsUndefined()) {
       if (!conflictValue->IsNumber()) {

From 6f0854010654cd4ae98f9215294251279c2f250b Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 17 Nov 2024 02:58:21 +0100
Subject: [PATCH 29/31] sqlite: add filter and onConflict to env_properties.h

---
 src/env_properties.h |  2 ++
 src/node_sqlite.cc   | 15 +++------------
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/env_properties.h b/src/env_properties.h
index 508986ad5ad947..f83db2c839c342 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -159,6 +159,7 @@
   V(fields_string, "fields")                                                   \
   V(file_string, "file")                                                       \
   V(filename_string, "filename")                                               \
+  V(filter_string, "filter")                                                   \
   V(fingerprint256_string, "fingerprint256")                                   \
   V(fingerprint512_string, "fingerprint512")                                   \
   V(fingerprint_string, "fingerprint")                                         \
@@ -244,6 +245,7 @@
   V(onchange_string, "onchange")                                               \
   V(onclienthello_string, "onclienthello")                                     \
   V(oncomplete_string, "oncomplete")                                           \
+  V(onconflict_string, "onConflict")                                           \
   V(onconnection_string, "onconnection")                                       \
   V(ondone_string, "ondone")                                                   \
   V(onerror_string, "onerror")                                                 \
diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index a6fbc0021c09e8..b50d46d5090672 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -451,13 +451,8 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
     }
 
     Local<Object> options = args[1].As<Object>();
-
-    Local<String> conflictKey =
-        String::NewFromUtf8(
-            env->isolate(), "onConflict", NewStringType::kNormal)
-            .ToLocalChecked();
     Local<Value> conflictValue =
-        options->Get(env->context(), conflictKey).ToLocalChecked();
+        options->Get(env->context(), env->onconflict_string()).ToLocalChecked();
 
     if (!conflictValue->IsUndefined()) {
       if (!conflictValue->IsNumber()) {
@@ -471,13 +466,9 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
       conflictCallback = [conflictInt]() -> int { return conflictInt; };
     }
 
-    Local<String> filterKey =
-        String::NewFromUtf8(env->isolate(), "filter", NewStringType::kNormal)
-            .ToLocalChecked();
-
-    if (options->HasOwnProperty(env->context(), filterKey).FromJust()) {
+    if (options->HasOwnProperty(env->context(), env->filter_string()).FromJust()) {
       Local<Value> filterValue =
-          options->Get(env->context(), filterKey).ToLocalChecked();
+          options->Get(env->context(), env->filter_string()).ToLocalChecked();
 
       if (!filterValue->IsFunction()) {
         THROW_ERR_INVALID_ARG_TYPE(

From 8776af6053f054c3bd2ecaeae97475695cc6802b Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 17 Nov 2024 02:58:48 +0100
Subject: [PATCH 30/31] sqlite: format

---
 src/node_sqlite.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index b50d46d5090672..1b57e2a70ac4fb 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -466,7 +466,8 @@ void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {
       conflictCallback = [conflictInt]() -> int { return conflictInt; };
     }
 
-    if (options->HasOwnProperty(env->context(), env->filter_string()).FromJust()) {
+    if (options->HasOwnProperty(env->context(), env->filter_string())
+            .FromJust()) {
       Local<Value> filterValue =
           options->Get(env->context(), env->filter_string()).ToLocalChecked();
 

From 092a28c38383074589e763f7cc5df7f41e710f0f Mon Sep 17 00:00:00 2001
From: Bart Louwers <bart@emeel.net>
Date: Sun, 17 Nov 2024 03:09:00 +0100
Subject: [PATCH 31/31] sqlite: simplify string conversion

---
 src/node_sqlite.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 1b57e2a70ac4fb..f0b424df6ab23f 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -369,7 +369,7 @@ void DatabaseSync::CreateSession(const FunctionCallbackInfo<Value>& args) {
 
       if (table_value->IsString()) {
         String::Utf8Value str(env->isolate(), table_value);
-        table = std::string(*str);
+        table = *str;
       } else {
         THROW_ERR_INVALID_ARG_TYPE(
             env->isolate(), "The \"options.table\" argument must be a string.");