@op-engineering/op-sqlite 15.0.7 → 15.1.1

package/cpp/bridge.cpp

@@ -7,7 +7,7 @@
 #include "DumbHostObject.h"
 #include "SmartHostObject.h"
 #include "logs.h"
-#include "utils.h"
+#include "utils.hpp"
 #include <filesystem>
 #include <iostream>
 #include <sstream>
@@ -25,42 +25,38 @@ namespace opsqlite {
 
 inline void opsqlite_bind_statement(sqlite3_stmt *statement,
                                     const std::vector<JSVariant> *values) {
-    sqlite3_clear_bindings(statement);
-
-    size_t size = values->size();
-
-    for (int ii = 0; ii < size; ii++) {
-        int stmt_index = ii + 1;
-        JSVariant value = values->at(ii);
-
-        std::visit(
-            [&](auto &&v) {
-                using T = std::decay_t<decltype(v)>;
-
-                if constexpr (std::is_same_v<T, bool>) {
-                    sqlite3_bind_int(statement, stmt_index,
-                                     static_cast<int>(v));
-                } else if constexpr (std::is_same_v<T, int>) {
-                    sqlite3_bind_int(statement, stmt_index, v);
-                } else if constexpr (std::is_same_v<T, long long>) {
-                    sqlite3_bind_double(statement, stmt_index,
-                                        static_cast<double>(v));
-                } else if constexpr (std::is_same_v<T, double>) {
-                    sqlite3_bind_double(statement, stmt_index, v);
-                } else if constexpr (std::is_same_v<T, std::string>) {
-                    sqlite3_bind_text(statement, stmt_index, v.c_str(),
-                                      static_cast<int>(v.length()),
-                                      SQLITE_TRANSIENT);
-                } else if constexpr (std::is_same_v<T, ArrayBuffer>) {
-                    sqlite3_bind_blob(statement, stmt_index, v.data.get(),
-                                      static_cast<int>(v.size),
-                                      SQLITE_TRANSIENT);
-                } else {
-                    sqlite3_bind_null(statement, stmt_index);
-                }
-            },
-            value);
-    }
+  sqlite3_clear_bindings(statement);
+
+  size_t size = values->size();
+
+  for (int ii = 0; ii < size; ii++) {
+    int stmt_index = ii + 1;
+    JSVariant value = values->at(ii);
+
+    std::visit(
+        [&](auto &&v) {
+          using T = std::decay_t<decltype(v)>;
+
+          if constexpr (std::is_same_v<T, bool>) {
+            sqlite3_bind_int(statement, stmt_index, static_cast<int>(v));
+          } else if constexpr (std::is_same_v<T, int>) {
+            sqlite3_bind_int(statement, stmt_index, v);
+          } else if constexpr (std::is_same_v<T, long long>) {
+            sqlite3_bind_double(statement, stmt_index, static_cast<double>(v));
+          } else if constexpr (std::is_same_v<T, double>) {
+            sqlite3_bind_double(statement, stmt_index, v);
+          } else if constexpr (std::is_same_v<T, std::string>) {
+            sqlite3_bind_text(statement, stmt_index, v.c_str(),
+                              static_cast<int>(v.length()), SQLITE_TRANSIENT);
+          } else if constexpr (std::is_same_v<T, ArrayBuffer>) {
+            sqlite3_bind_blob(statement, stmt_index, v.data.get(),
+                              static_cast<int>(v.size), SQLITE_TRANSIENT);
+          } else {
+            sqlite3_bind_null(statement, stmt_index);
+          }
+        },
+        value);
+  }
 }
 
 /// Returns the completely formed db path, but it also creates any sub-folders
@@ -68,18 +64,18 @@ inline void opsqlite_bind_statement(sqlite3_stmt *statement,
 std::string opsqlite_get_db_path(std::string const &db_name,
                                  std::string const &location) {
 
-    if (location == ":memory:") {
-        return location;
-    }
+  if (location == ":memory:") {
+    return location;
+  }
 
-    // Will return false if the directory already exists, no need to check
-    std::filesystem::create_directories(location);
+  // Will return false if the directory already exists, no need to check
+  std::filesystem::create_directories(location);
 
-    if (!location.empty() && location.back() != '/') {
-        return location + "/" + db_name;
-    }
+  if (!location.empty() && location.back() != '/') {
+    return location + "/" + db_name;
+  }
 
-    return location + db_name;
+  return location + db_name;
 }
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
@@ -92,369 +88,386 @@ sqlite3 *opsqlite_open(std::string const &name, std::string const &path,
                        [[maybe_unused]] std::string const &crsqlite_path,
                        [[maybe_unused]] std::string const &sqlite_vec_path) {
 #endif
-    std::string final_path = opsqlite_get_db_path(name, path);
-    char *errMsg;
-    sqlite3 *db;
+  std::string final_path = opsqlite_get_db_path(name, path);
+  char *errMsg;
+  sqlite3 *db;
 
-    int flags =
-        SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
+  int flags =
+      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
 
-    int status = sqlite3_open_v2(final_path.c_str(), &db, flags, nullptr);
+  int status = sqlite3_open_v2(final_path.c_str(), &db, flags, nullptr);
 
-    if (status != SQLITE_OK) {
-        throw std::runtime_error(sqlite3_errmsg(db));
-    }
+  if (status != SQLITE_OK) {
+    throw std::runtime_error(sqlite3_errmsg(db));
+  }
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-    if (!encryption_key.empty()) {
-        opsqlite_execute(db, "PRAGMA key = '" + encryption_key + "'", nullptr);
-    }
+  if (!encryption_key.empty()) {
+    opsqlite_execute(db, "PRAGMA key = '" + encryption_key + "'", nullptr);
+  }
 #endif
 
 #ifndef OP_SQLITE_USE_PHONE_VERSION
-    sqlite3_enable_load_extension(db, 1);
+  sqlite3_enable_load_extension(db, 1);
 #endif
 
 #ifdef OP_SQLITE_USE_CRSQLITE
-    const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
+  const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
 
-    sqlite3_load_extension(db, crsqlite_path.c_str(), crsqliteEntryPoint,
-                           &errMsg);
+  sqlite3_load_extension(db, crsqlite_path.c_str(), crsqliteEntryPoint,
+                         &errMsg);
 
-    if (errMsg != nullptr) {
-        throw std::runtime_error(errMsg);
-    }
+  if (errMsg != nullptr) {
+    throw std::runtime_error(errMsg);
+  }
 #endif
 
 #ifdef OP_SQLITE_USE_SQLITE_VEC
-    const char *vec_entry_point = "sqlite3_vec_init";
+  const char *vec_entry_point = "sqlite3_vec_init";
 
-    sqlite3_load_extension(db, sqlite_vec_path.c_str(), vec_entry_point,
-                           &errMsg);
+  sqlite3_load_extension(db, sqlite_vec_path.c_str(), vec_entry_point, &errMsg);
 
-    if (errMsg != nullptr) {
-        throw std::runtime_error(errMsg);
-    }
+  if (errMsg != nullptr) {
+    throw std::runtime_error(errMsg);
+  }
 #endif
 
-    TOKENIZER_LIST
+  TOKENIZER_LIST
 
-    return db;
+  return db;
+}
+
+void create_dirs_if_needed(const std::string &path) {
+  if (path == ":memory:") {
+    return;
+  }
+
+  // Extract directory part from path (exclude filename)
+  std::filesystem::path fs_path(path);
+  auto dir = fs_path.parent_path();
+  if (!dir.empty()) {
+    std::filesystem::create_directories(dir);
+  }
 }
 
 void opsqlite_close(sqlite3 *db) {
 #ifdef OP_SQLITE_USE_CRSQLITE
-    opsqlite_execute(db, "select crsql_finalize();", nullptr);
+  opsqlite_execute(db, "select crsql_finalize();", nullptr);
 #endif
 
-    sqlite3_close_v2(db);
+  sqlite3_close_v2(db);
 }
 
 void opsqlite_attach(sqlite3 *db, std::string const &doc_path,
                      std::string const &secondary_db_name,
                      std::string const &alias) {
-    auto secondary_db_path = opsqlite_get_db_path(secondary_db_name, doc_path);
-    auto statement = "ATTACH DATABASE '" + secondary_db_path + "' AS " + alias;
+  auto secondary_db_path = opsqlite_get_db_path(secondary_db_name, doc_path);
+  auto statement = "ATTACH DATABASE '" + secondary_db_path + "' AS " + alias;
 
-    opsqlite_execute(db, statement, nullptr);
+  opsqlite_execute(db, statement, nullptr);
 }
 
 void opsqlite_detach(sqlite3 *db, std::string const &alias) {
-    std::string statement = "DETACH DATABASE " + alias;
-    opsqlite_execute(db, statement, nullptr);
+  std::string statement = "DETACH DATABASE " + alias;
+  opsqlite_execute(db, statement, nullptr);
 }
 
 void opsqlite_remove(sqlite3 *db, std::string const &name,
                      std::string const &doc_path) {
-    opsqlite_close(db);
+  opsqlite_close(db);
 
-    std::string db_path = opsqlite_get_db_path(name, doc_path);
+  std::string db_path = opsqlite_get_db_path(name, doc_path);
 
-    if (!file_exists(db_path)) {
-        throw std::runtime_error("op-sqlite: db file not found:" + db_path);
-    }
+  if (!file_exists(db_path)) {
+    throw std::runtime_error("op-sqlite: db file not found:" + db_path);
+  }
+
+  remove(db_path.c_str());
+}
+
+void opsqlite_remove_v2(sqlite3 *db, std::string const &path) {
+  opsqlite_close(db);
 
-    remove(db_path.c_str());
+  if (!file_exists(path)) {
+    throw std::runtime_error("[op-sqlite] db file not found: " + path);
+  }
+
+  remove(path.c_str());
 }
 
 BridgeResult opsqlite_execute_prepared_statement(
     sqlite3 *db, sqlite3_stmt *statement, std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> &metadatas) {
 
-    const char *errorMessage;
+  const char *errorMessage;
 
-    bool isConsuming = true;
-    bool isFailed = false;
+  bool isConsuming = true;
+  bool isFailed = false;
 
-    int result = SQLITE_OK;
+  int result = SQLITE_OK;
 
-    int i, count, column_type;
-    std::string column_name, column_declared_type;
+  int i, count, column_type;
+  std::string column_name, column_declared_type;
 
-    while (isConsuming) {
-        result = sqlite3_step(statement);
-
-        switch (result) {
-        case SQLITE_ROW: {
-            i = 0;
-            DumbHostObject row = DumbHostObject(metadatas);
-
-            count = sqlite3_column_count(statement);
-
-            while (i < count) {
-                column_type = sqlite3_column_type(statement, i);
-
-                switch (column_type) {
-                case SQLITE_INTEGER: {
-                    /**
-                     * Warning this will loose precision because JS can
-                     * only represent Integers up to 53 bits
-                     */
-                    double column_value = sqlite3_column_double(statement, i);
-                    row.values.emplace_back(column_value);
-                    break;
-                }
-
-                case SQLITE_FLOAT: {
-                    double column_value = sqlite3_column_double(statement, i);
-                    row.values.emplace_back(column_value);
-                    break;
-                }
-
-                case SQLITE_TEXT: {
-                    const char *column_value = reinterpret_cast<const char *>(
-                        sqlite3_column_text(statement, i));
-                    int byteLen = sqlite3_column_bytes(statement, i);
-                    // Specify length too; in case string contains NULL in the
-                    // middle
-                    row.values.emplace_back(std::string(column_value, byteLen));
-                    break;
-                }
-
-                case SQLITE_BLOB: {
-                    int blob_size = sqlite3_column_bytes(statement, i);
-                    const void *blob = sqlite3_column_blob(statement, i);
-                    auto *data = new uint8_t[blob_size];
-                    // You cannot share raw memory between native and JS
-                    // always copy the data
-                    memcpy(data, blob, blob_size);
-                    row.values.emplace_back(
-                        ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                                    .size = static_cast<size_t>(blob_size)});
-                    break;
-                }
-
-                case SQLITE_NULL:
-                    // Intentionally left blank
-
-                default:
-                    row.values.emplace_back(nullptr);
-                    break;
-                }
-                i++;
-            }
-
-            results->emplace_back(row);
+  while (isConsuming) {
+    result = sqlite3_step(statement);
 
-            break;
+    switch (result) {
+    case SQLITE_ROW: {
+      i = 0;
+      DumbHostObject row = DumbHostObject(metadatas);
+
+      count = sqlite3_column_count(statement);
+
+      while (i < count) {
+        column_type = sqlite3_column_type(statement, i);
+
+        switch (column_type) {
+        case SQLITE_INTEGER: {
+          /**
+           * Warning this will loose precision because JS can
+           * only represent Integers up to 53 bits
+           */
+          double column_value = sqlite3_column_double(statement, i);
+          row.values.emplace_back(column_value);
+          break;
         }
 
-        case SQLITE_DONE:
-            if (metadatas != nullptr) {
-                i = 0;
-                count = sqlite3_column_count(statement);
-
-                while (i < count) {
-                    column_name = sqlite3_column_name(statement, i);
-                    const char *type = sqlite3_column_decltype(statement, i);
-                    auto metadata = SmartHostObject();
-                    metadata.fields.emplace_back("name", column_name);
-                    metadata.fields.emplace_back("index", i);
-                    metadata.fields.emplace_back(
-                        "type", type == nullptr ? "UNKNOWN" : type);
-
-                    metadatas->emplace_back(metadata);
-                    i++;
-                }
-            }
-            isConsuming = false;
-            break;
+        case SQLITE_FLOAT: {
+          double column_value = sqlite3_column_double(statement, i);
+          row.values.emplace_back(column_value);
+          break;
+        }
+
+        case SQLITE_TEXT: {
+          const char *column_value =
+              reinterpret_cast<const char *>(sqlite3_column_text(statement, i));
+          int byteLen = sqlite3_column_bytes(statement, i);
+          // Specify length too; in case string contains NULL in the
+          // middle
+          row.values.emplace_back(std::string(column_value, byteLen));
+          break;
+        }
+
+        case SQLITE_BLOB: {
+          int blob_size = sqlite3_column_bytes(statement, i);
+          const void *blob = sqlite3_column_blob(statement, i);
+          auto *data = new uint8_t[blob_size];
+          // You cannot share raw memory between native and JS
+          // always copy the data
+          memcpy(data, blob, blob_size);
+          row.values.emplace_back(
+              ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                          .size = static_cast<size_t>(blob_size)});
+          break;
+        }
+
+        case SQLITE_NULL:
+          // Intentionally left blank
 
         default:
-            errorMessage = sqlite3_errmsg(db);
-            isFailed = true;
-            isConsuming = false;
+          row.values.emplace_back(nullptr);
+          break;
         }
+        i++;
+      }
+
+      results->emplace_back(row);
+
+      break;
     }
 
-    sqlite3_reset(statement);
+    case SQLITE_DONE:
+      if (metadatas != nullptr) {
+        i = 0;
+        count = sqlite3_column_count(statement);
+
+        while (i < count) {
+          column_name = sqlite3_column_name(statement, i);
+          const char *type = sqlite3_column_decltype(statement, i);
+          auto metadata = SmartHostObject();
+          metadata.fields.emplace_back("name", column_name);
+          metadata.fields.emplace_back("index", i);
+          metadata.fields.emplace_back("type",
+                                       type == nullptr ? "UNKNOWN" : type);
+
+          metadatas->emplace_back(metadata);
+          i++;
+        }
+      }
+      isConsuming = false;
+      break;
 
-    if (isFailed) {
-        throw std::runtime_error(
-            "[op-sqlite] SQLite code: " + std::to_string(result) +
-            " execution error: " + std::string(errorMessage));
+    default:
+      errorMessage = sqlite3_errmsg(db);
+      isFailed = true;
+      isConsuming = false;
     }
+  }
+
+  sqlite3_reset(statement);
+
+  if (isFailed) {
+    throw std::runtime_error(
+        "[op-sqlite] SQLite code: " + std::to_string(result) +
+        " execution error: " + std::string(errorMessage));
+  }
 
-    int changedRowCount = sqlite3_changes(db);
-    long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+  int changedRowCount = sqlite3_changes(db);
+  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
 
-    return {.affectedRows = changedRowCount,
-            .insertId = static_cast<double>(latestInsertRowId)};
+  return {.affectedRows = changedRowCount,
+          .insertId = static_cast<double>(latestInsertRowId)};
 }
 
 sqlite3_stmt *opsqlite_prepare_statement(sqlite3 *db,
                                          std::string const &query) {
-    sqlite3_stmt *statement;
+  sqlite3_stmt *statement;
 
-    const char *queryStr = query.c_str();
+  const char *queryStr = query.c_str();
 
-    int statementStatus =
-        sqlite3_prepare_v2(db, queryStr, -1, &statement, nullptr);
+  int statementStatus =
+      sqlite3_prepare_v2(db, queryStr, -1, &statement, nullptr);
 
-    if (statementStatus == SQLITE_ERROR) {
-        const char *message = sqlite3_errmsg(db);
-        throw std::runtime_error("[op-sqlite] SQL prepare statement error: " +
-                                 std::string(message));
-    }
+  if (statementStatus == SQLITE_ERROR) {
+    const char *message = sqlite3_errmsg(db);
+    throw std::runtime_error("[op-sqlite] SQL prepare statement error: " +
+                             std::string(message));
+  }
 
-    return statement;
+  return statement;
 }
 
 BridgeResult opsqlite_execute(sqlite3 *db, std::string const &query,
                               const std::vector<JSVariant> *params) {
-    sqlite3_stmt *statement;
-    const char *errorMessage = nullptr;
-    const char *remainingStatement = nullptr;
-    bool has_failed = false;
-    int status, current_column, column_count, column_type;
-    std::string column_name, column_declared_type;
-    std::vector<std::string> column_names;
-    std::vector<std::vector<JSVariant>> rows;
-    rows.reserve(20);
-    std::vector<JSVariant> row;
-
-    do {
-        const char *query_str =
-            remainingStatement == nullptr ? query.c_str() : remainingStatement;
-
-        status = sqlite3_prepare_v2(db, query_str, -1, &statement,
-                                    &remainingStatement);
-
-        if (status != SQLITE_OK) {
-            errorMessage = sqlite3_errmsg(db);
-            throw std::runtime_error("[op-sqlite] sqlite query error: " +
-                                     std::string(errorMessage));
-        }
+  sqlite3_stmt *statement;
+  const char *errorMessage = nullptr;
+  const char *remainingStatement = nullptr;
+  bool has_failed = false;
+  int status, current_column, column_count, column_type;
+  std::string column_name, column_declared_type;
+  std::vector<std::string> column_names;
+  std::vector<std::vector<JSVariant>> rows;
+  rows.reserve(20);
+  std::vector<JSVariant> row;
+
+  do {
+    const char *query_str =
+        remainingStatement == nullptr ? query.c_str() : remainingStatement;
+
+    status =
+        sqlite3_prepare_v2(db, query_str, -1, &statement, &remainingStatement);
 
-        // The statement did not fail to parse but there is nothing to do, just
-        // skip to the end
-        if (statement == nullptr) {
-            continue;
-        }
+    if (status != SQLITE_OK) {
+      errorMessage = sqlite3_errmsg(db);
+      throw std::runtime_error("[op-sqlite] sqlite query error: " +
+                               std::string(errorMessage));
+    }
 
-        if (params != nullptr && !params->empty()) {
-            opsqlite_bind_statement(statement, params);
-        }
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
+    if (statement == nullptr) {
+      continue;
+    }
 
-        column_count = sqlite3_column_count(statement);
-        column_names.reserve(column_count);
-        bool is_consuming_rows = true;
-        double double_value;
-        const char *string_value;
+    if (params != nullptr && !params->empty()) {
+      opsqlite_bind_statement(statement, params);
+    }
 
-        // Do a first pass to get the column names
-        for (int i = 0; i < column_count; i++) {
-            column_name = sqlite3_column_name(statement, i);
-            column_names.emplace_back(column_name);
-        }
+    column_count = sqlite3_column_count(statement);
+    column_names.reserve(column_count);
+    bool is_consuming_rows = true;
+    double double_value;
+    const char *string_value;
+
+    // Do a first pass to get the column names
+    for (int i = 0; i < column_count; i++) {
+      column_name = sqlite3_column_name(statement, i);
+      column_names.emplace_back(column_name);
+    }
+
+    while (is_consuming_rows) {
+      status = sqlite3_step(statement);
 
-        while (is_consuming_rows) {
-            status = sqlite3_step(statement);
-
-            switch (status) {
-            case SQLITE_ROW:
-                current_column = 0;
-                row = std::vector<JSVariant>();
-                row.reserve(column_count);
-
-                while (current_column < column_count) {
-                    column_type =
-                        sqlite3_column_type(statement, current_column);
-
-                    switch (column_type) {
-
-                    case SQLITE_INTEGER:
-                        // intentional fallthrough
-                    case SQLITE_FLOAT: {
-                        double_value =
-                            sqlite3_column_double(statement, current_column);
-                        row.emplace_back(double_value);
-                        break;
-                    }
-
-                    case SQLITE_TEXT: {
-                        string_value = reinterpret_cast<const char *>(
-                            sqlite3_column_text(statement, current_column));
-                        int len =
-                            sqlite3_column_bytes(statement, current_column);
-                        // Specify length too; in case string contains NULL in
-                        // the middle
-                        row.emplace_back(std::string(string_value, len));
-                        break;
-                    }
-
-                    case SQLITE_BLOB: {
-                        int blob_size =
-                            sqlite3_column_bytes(statement, current_column);
-                        const void *blob =
-                            sqlite3_column_blob(statement, current_column);
-                        auto *data = new uint8_t[blob_size];
-                        memcpy(data, blob, blob_size);
-                        row.emplace_back(ArrayBuffer{
-                            .data = std::shared_ptr<uint8_t>{data},
+      switch (status) {
+      case SQLITE_ROW:
+        current_column = 0;
+        row = std::vector<JSVariant>();
+        row.reserve(column_count);
+
+        while (current_column < column_count) {
+          column_type = sqlite3_column_type(statement, current_column);
+
+          switch (column_type) {
+
+          case SQLITE_INTEGER:
+            // intentional fallthrough
+          case SQLITE_FLOAT: {
+            double_value = sqlite3_column_double(statement, current_column);
+            row.emplace_back(double_value);
+            break;
+          }
+
+          case SQLITE_TEXT: {
+            string_value = reinterpret_cast<const char *>(
+                sqlite3_column_text(statement, current_column));
+            int len = sqlite3_column_bytes(statement, current_column);
+            // Specify length too; in case string contains NULL in
+            // the middle
+            row.emplace_back(std::string(string_value, len));
+            break;
+          }
+
+          case SQLITE_BLOB: {
+            int blob_size = sqlite3_column_bytes(statement, current_column);
+            const void *blob = sqlite3_column_blob(statement, current_column);
+            auto *data = new uint8_t[blob_size];
+            memcpy(data, blob, blob_size);
+            row.emplace_back(
+                ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
                             .size = static_cast<size_t>(blob_size)});
-                        break;
-                    }
-
-                    case SQLITE_NULL:
-                        // Intentionally left blank to switch to default case
-                    default:
-                        row.emplace_back(nullptr);
-                        break;
-                    }
-
-                    current_column++;
-                }
-
-                rows.emplace_back(std::move(row));
-                break;
-
-            case SQLITE_DONE:
-                is_consuming_rows = false;
-                break;
-
-            default:
-                has_failed = true;
-                is_consuming_rows = false;
-            }
+            break;
+          }
+
+          case SQLITE_NULL:
+            // Intentionally left blank to switch to default case
+          default:
+            row.emplace_back(nullptr);
+            break;
+          }
+
+          current_column++;
         }
 
-        sqlite3_finalize(statement);
-    } while (remainingStatement != nullptr &&
-             strcmp(remainingStatement, "") != 0 && !has_failed);
+        rows.emplace_back(std::move(row));
+        break;
+
+      case SQLITE_DONE:
+        is_consuming_rows = false;
+        break;
 
-    if (has_failed) {
-        const char *message = sqlite3_errmsg(db);
-        throw std::runtime_error("[op-sqlite] statement execution error: " +
-                                 std::string(message));
+      default:
+        has_failed = true;
+        is_consuming_rows = false;
+      }
     }
 
-    int changedRowCount = sqlite3_changes(db);
-    long long latestInsertRowId = sqlite3_last_insert_rowid(db);
-    return {.affectedRows = changedRowCount,
-            .insertId = static_cast<double>(latestInsertRowId),
-            .rows = std::move(rows),
-            .column_names = std::move(column_names)};
+    sqlite3_finalize(statement);
+  } while (remainingStatement != nullptr &&
+           strcmp(remainingStatement, "") != 0 && !has_failed);
+
+  if (has_failed) {
+    const char *message = sqlite3_errmsg(db);
+    throw std::runtime_error("[op-sqlite] statement execution error: " +
+                             std::string(message));
+  }
+
+  int changedRowCount = sqlite3_changes(db);
+  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+  return {.affectedRows = changedRowCount,
+          .insertId = static_cast<double>(latestInsertRowId),
+          .rows = std::move(rows),
+          .column_names = std::move(column_names)};
 }
 
 BridgeResult opsqlite_execute_host_objects(
@@ -462,162 +475,157 @@ BridgeResult opsqlite_execute_host_objects(
     std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> &metadatas) {
 
-    sqlite3_stmt *statement;
-    const char *errorMessage;
-    const char *remainingStatement = nullptr;
+  sqlite3_stmt *statement;
+  const char *errorMessage;
+  const char *remainingStatement = nullptr;
+
+  bool isConsuming = true;
+  bool isFailed = false;
 
-    bool isConsuming = true;
-    bool isFailed = false;
+  int result = SQLITE_OK;
 
-    int result = SQLITE_OK;
+  do {
+    const char *queryStr =
+        remainingStatement == nullptr ? query.c_str() : remainingStatement;
 
-    do {
-        const char *queryStr =
-            remainingStatement == nullptr ? query.c_str() : remainingStatement;
+    int statementStatus =
+        sqlite3_prepare_v2(db, queryStr, -1, &statement, &remainingStatement);
+
+    if (statementStatus != SQLITE_OK) {
+      const char *message = sqlite3_errmsg(db);
+      throw std::runtime_error(
+          "[op-sqlite] SQL statement error on opsqlite_execute:\n" +
+          std::to_string(statementStatus) + " description:\n" +
+          std::string(message));
+    }
 
-        int statementStatus = sqlite3_prepare_v2(db, queryStr, -1, &statement,
-                                                 &remainingStatement);
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
+    if (statement == nullptr) {
+      continue;
+    }
 
-        if (statementStatus != SQLITE_OK) {
-            const char *message = sqlite3_errmsg(db);
-            throw std::runtime_error(
-                "[op-sqlite] SQL statement error on opsqlite_execute:\n" +
-                std::to_string(statementStatus) + " description:\n" +
-                std::string(message));
-        }
+    if (params != nullptr && !params->empty()) {
+      opsqlite_bind_statement(statement, params);
+    }
 
-        // The statement did not fail to parse but there is nothing to do, just
-        // skip to the end
-        if (statement == nullptr) {
-            continue;
-        }
+    int i, count, column_type;
+    std::string column_name, column_declared_type;
 
-        if (params != nullptr && !params->empty()) {
-            opsqlite_bind_statement(statement, params);
+    while (isConsuming) {
+      result = sqlite3_step(statement);
+
+      switch (result) {
+      case SQLITE_ROW: {
+        if (results == nullptr) {
+          break;
         }
 
-        int i, count, column_type;
-        std::string column_name, column_declared_type;
-
-        while (isConsuming) {
-            result = sqlite3_step(statement);
-
-            switch (result) {
-            case SQLITE_ROW: {
-                if (results == nullptr) {
-                    break;
-                }
-
-                i = 0;
-                DumbHostObject row = DumbHostObject(metadatas);
-
-                count = sqlite3_column_count(statement);
-
-                while (i < count) {
-                    column_type = sqlite3_column_type(statement, i);
-
-                    switch (column_type) {
-                    case SQLITE_INTEGER: {
-                        /**
-                         * Warning this will loose precision because JS can
-                         * only represent Integers up to 53 bits
-                         */
-                        double column_value =
-                            sqlite3_column_double(statement, i);
-                        row.values.emplace_back(column_value);
-                        break;
-                    }
-
-                    case SQLITE_FLOAT: {
-                        double column_value =
-                            sqlite3_column_double(statement, i);
-                        row.values.emplace_back(column_value);
-                        break;
-                    }
-
-                    case SQLITE_TEXT: {
-                        const char *column_value =
-                            reinterpret_cast<const char *>(
-                                sqlite3_column_text(statement, i));
-                        int byteLen = sqlite3_column_bytes(statement, i);
-                        // Specify length too; in case string contains NULL in
-                        // the middle
-                        row.values.emplace_back(
-                            std::string(column_value, byteLen));
-                        break;
-                    }
-
-                    case SQLITE_BLOB: {
-                        int blob_size = sqlite3_column_bytes(statement, i);
-                        const void *blob = sqlite3_column_blob(statement, i);
-                        auto *data = new uint8_t[blob_size];
-                        // You cannot share raw memory between native and JS
-                        // always copy the data
-                        memcpy(data, blob, blob_size);
-                        row.values.emplace_back(ArrayBuffer{
-                            .data = std::shared_ptr<uint8_t>{data},
+        i = 0;
+        DumbHostObject row = DumbHostObject(metadatas);
+
+        count = sqlite3_column_count(statement);
+
+        while (i < count) {
+          column_type = sqlite3_column_type(statement, i);
+
+          switch (column_type) {
+          case SQLITE_INTEGER: {
+            /**
+             * Warning this will loose precision because JS can
+             * only represent Integers up to 53 bits
+             */
+            double column_value = sqlite3_column_double(statement, i);
+            row.values.emplace_back(column_value);
+            break;
+          }
+
+          case SQLITE_FLOAT: {
+            double column_value = sqlite3_column_double(statement, i);
+            row.values.emplace_back(column_value);
+            break;
+          }
+
+          case SQLITE_TEXT: {
+            const char *column_value = reinterpret_cast<const char *>(
+                sqlite3_column_text(statement, i));
+            int byteLen = sqlite3_column_bytes(statement, i);
+            // Specify length too; in case string contains NULL in
+            // the middle
+            row.values.emplace_back(std::string(column_value, byteLen));
+            break;
+          }
+
+          case SQLITE_BLOB: {
+            int blob_size = sqlite3_column_bytes(statement, i);
+            const void *blob = sqlite3_column_blob(statement, i);
+            auto *data = new uint8_t[blob_size];
+            // You cannot share raw memory between native and JS
+            // always copy the data
+            memcpy(data, blob, blob_size);
+            row.values.emplace_back(
+                ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
                             .size = static_cast<size_t>(blob_size)});
-                        break;
-                    }
-
-                    case SQLITE_NULL:
-                        // Intentionally left blank
-
-                    default:
-                        row.values.emplace_back(nullptr);
-                        break;
-                    }
-                    i++;
-                }
-
-                results->emplace_back(row);
-                break;
-            }
-
-            case SQLITE_DONE:
-                if (metadatas != nullptr) {
-                    i = 0;
-                    count = sqlite3_column_count(statement);
-
-                    while (i < count) {
-                        column_name = sqlite3_column_name(statement, i);
-                        const char *type =
-                            sqlite3_column_decltype(statement, i);
-                        auto metadata = SmartHostObject();
-                        metadata.fields.emplace_back("name", column_name);
-                        metadata.fields.emplace_back("index", i);
-                        metadata.fields.emplace_back(
-                            "type", type == nullptr ? "UNKNOWN" : type);
-
-                        metadatas->push_back(metadata);
-                        i++;
-                    }
-                }
-                isConsuming = false;
-                break;
-
-            default:
-                errorMessage = sqlite3_errmsg(db);
-                isFailed = true;
-                isConsuming = false;
-            }
+            break;
+          }
+
+          case SQLITE_NULL:
+            // Intentionally left blank
+
+          default:
+            row.values.emplace_back(nullptr);
+            break;
+          }
+          i++;
         }
 
-        sqlite3_finalize(statement);
-    } while (remainingStatement != nullptr &&
-             strcmp(remainingStatement, "") != 0 && !isFailed);
+        results->emplace_back(row);
+        break;
+      }
+
+      case SQLITE_DONE:
+        if (metadatas != nullptr) {
+          i = 0;
+          count = sqlite3_column_count(statement);
 
-    if (isFailed) {
-        throw std::runtime_error(
-            "[op-sqlite] SQLite error code: " + std::to_string(result) +
-            ", description: " + std::string(errorMessage));
+          while (i < count) {
+            column_name = sqlite3_column_name(statement, i);
+            const char *type = sqlite3_column_decltype(statement, i);
+            auto metadata = SmartHostObject();
+            metadata.fields.emplace_back("name", column_name);
+            metadata.fields.emplace_back("index", i);
+            metadata.fields.emplace_back("type",
+                                         type == nullptr ? "UNKNOWN" : type);
+
+            metadatas->push_back(metadata);
+            i++;
+          }
+        }
+        isConsuming = false;
+        break;
+
+      default:
+        errorMessage = sqlite3_errmsg(db);
+        isFailed = true;
+        isConsuming = false;
+      }
     }
 
-    int changedRowCount = sqlite3_changes(db);
-    long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+    sqlite3_finalize(statement);
+  } while (remainingStatement != nullptr &&
+           strcmp(remainingStatement, "") != 0 && !isFailed);
 
-    return {.affectedRows = changedRowCount,
-            .insertId = static_cast<double>(latestInsertRowId)};
+  if (isFailed) {
+    throw std::runtime_error(
+        "[op-sqlite] SQLite error code: " + std::to_string(result) +
+        ", description: " + std::string(errorMessage));
+  }
+
+  int changedRowCount = sqlite3_changes(db);
+  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+
+  return {.affectedRows = changedRowCount,
+          .insertId = static_cast<double>(latestInsertRowId)};
 }
 
 /// Executes returning data in raw arrays, a small performance optimization
@@ -626,245 +634,243 @@ BridgeResult
 opsqlite_execute_raw(sqlite3 *db, std::string const &query,
                      const std::vector<JSVariant> *params,
                      std::vector<std::vector<JSVariant>> *results) {
-    sqlite3_stmt *statement;
-    const char *errorMessage;
-    const char *remainingStatement = nullptr;
+  sqlite3_stmt *statement;
+  const char *errorMessage;
+  const char *remainingStatement = nullptr;
 
-    bool isConsuming = true;
-    bool isFailed = false;
+  bool isConsuming = true;
+  bool isFailed = false;
 
-    int step = SQLITE_OK;
+  int step = SQLITE_OK;
 
-    do {
-        const char *queryStr =
-            remainingStatement == nullptr ? query.c_str() : remainingStatement;
+  do {
+    const char *queryStr =
+        remainingStatement == nullptr ? query.c_str() : remainingStatement;
 
-        int statementStatus = sqlite3_prepare_v2(db, queryStr, -1, &statement,
-                                                 &remainingStatement);
+    int statementStatus =
+        sqlite3_prepare_v2(db, queryStr, -1, &statement, &remainingStatement);
 
-        if (statementStatus != SQLITE_OK) {
-            const char *message = sqlite3_errmsg(db);
-            throw std::runtime_error("[op-sqlite] SQL statement error:" +
-                                     std::to_string(statementStatus) +
-                                     " description:" + std::string(message));
-        }
+    if (statementStatus != SQLITE_OK) {
+      const char *message = sqlite3_errmsg(db);
+      throw std::runtime_error(
+          "[op-sqlite] SQL statement error:" + std::to_string(statementStatus) +
+          " description:" + std::string(message));
+    }
 
-        // The statement did not fail to parse but there is nothing to do, just
-        // skip to the end
-        if (statement == nullptr) {
-            continue;
-        }
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
+    if (statement == nullptr) {
+      continue;
+    }
 
-        if (params != nullptr && !params->empty()) {
-            opsqlite_bind_statement(statement, params);
+    if (params != nullptr && !params->empty()) {
+      opsqlite_bind_statement(statement, params);
+    }
+
+    int i, column_type;
+    std::string column_name, column_declared_type;
+
+    int column_count = sqlite3_column_count(statement);
+
+    while (isConsuming) {
+      step = sqlite3_step(statement);
+
+      switch (step) {
+      case SQLITE_ROW: {
+        if (results == nullptr) {
+          break;
         }
 
-        int i, column_type;
-        std::string column_name, column_declared_type;
-
-        int column_count = sqlite3_column_count(statement);
-
-        while (isConsuming) {
-            step = sqlite3_step(statement);
-
-            switch (step) {
-            case SQLITE_ROW: {
-                if (results == nullptr) {
-                    break;
-                }
-
-                std::vector<JSVariant> row;
-                row.reserve(column_count);
-
-                i = 0;
-
-                while (i < column_count) {
-                    column_type = sqlite3_column_type(statement, i);
-
-                    switch (column_type) {
-                    case SQLITE_INTEGER:
-                    case SQLITE_FLOAT: {
-                        double column_value =
-                            sqlite3_column_double(statement, i);
-                        row.emplace_back(column_value);
-                        break;
-                    }
-
-                    case SQLITE_TEXT: {
-                        const char *column_value =
-                            reinterpret_cast<const char *>(
-                                sqlite3_column_text(statement, i));
-                        int byteLen = sqlite3_column_bytes(statement, i);
-                        // Specify length too; in case string contains NULL in
-                        // the middle
-                        row.emplace_back(std::string(column_value, byteLen));
-                        break;
-                    }
-
-                    case SQLITE_BLOB: {
-                        int blob_size = sqlite3_column_bytes(statement, i);
-                        const void *blob = sqlite3_column_blob(statement, i);
-                        auto *data = new uint8_t[blob_size];
-                        memcpy(data, blob, blob_size);
-                        row.emplace_back(ArrayBuffer{
-                            .data = std::shared_ptr<uint8_t>{data},
+        std::vector<JSVariant> row;
+        row.reserve(column_count);
+
+        i = 0;
+
+        while (i < column_count) {
+          column_type = sqlite3_column_type(statement, i);
+
+          switch (column_type) {
+          case SQLITE_INTEGER:
+          case SQLITE_FLOAT: {
+            double column_value = sqlite3_column_double(statement, i);
+            row.emplace_back(column_value);
+            break;
+          }
+
+          case SQLITE_TEXT: {
+            const char *column_value = reinterpret_cast<const char *>(
+                sqlite3_column_text(statement, i));
+            int byteLen = sqlite3_column_bytes(statement, i);
+            // Specify length too; in case string contains NULL in
+            // the middle
+            row.emplace_back(std::string(column_value, byteLen));
+            break;
+          }
+
+          case SQLITE_BLOB: {
+            int blob_size = sqlite3_column_bytes(statement, i);
+            const void *blob = sqlite3_column_blob(statement, i);
+            auto *data = new uint8_t[blob_size];
+            memcpy(data, blob, blob_size);
+            row.emplace_back(
+                ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
                             .size = static_cast<size_t>(blob_size)});
-                        break;
-                    }
-
-                    case SQLITE_NULL:
-                        // intentional fallthrough
-                    default:
-                        row.emplace_back(nullptr);
-                        break;
-                    }
-                    i++;
-                }
-
-                results->emplace_back(row);
-
-                break;
-            }
-
-            case SQLITE_DONE:
-                isConsuming = false;
-                break;
-
-            default:
-                errorMessage = sqlite3_errmsg(db);
-                isFailed = true;
-                isConsuming = false;
-            }
+            break;
+          }
+
+          case SQLITE_NULL:
+            // intentional fallthrough
+          default:
+            row.emplace_back(nullptr);
+            break;
+          }
+          i++;
         }
 
-        sqlite3_finalize(statement);
-    } while (remainingStatement != nullptr &&
-             strcmp(remainingStatement, "") != 0 && !isFailed);
+        results->emplace_back(row);
 
-    if (isFailed) {
-        throw std::runtime_error(
-            "[op-sqlite] SQLite error code: " + std::to_string(step) +
-            ", description: " + std::string(errorMessage));
+        break;
+      }
+
+      case SQLITE_DONE:
+        isConsuming = false;
+        break;
+
+      default:
+        errorMessage = sqlite3_errmsg(db);
+        isFailed = true;
+        isConsuming = false;
+      }
     }
 
-    int changedRowCount = sqlite3_changes(db);
-    long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+    sqlite3_finalize(statement);
+  } while (remainingStatement != nullptr &&
+           strcmp(remainingStatement, "") != 0 && !isFailed);
+
+  if (isFailed) {
+    throw std::runtime_error(
+        "[op-sqlite] SQLite error code: " + std::to_string(step) +
+        ", description: " + std::string(errorMessage));
+  }
+
+  int changedRowCount = sqlite3_changes(db);
+  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
 
-    return {.affectedRows = changedRowCount,
-            .insertId = static_cast<double>(latestInsertRowId)};
+  return {.affectedRows = changedRowCount,
+          .insertId = static_cast<double>(latestInsertRowId)};
 }
 
 std::string operation_to_string(int operation_type) {
-    switch (operation_type) {
-    case SQLITE_INSERT:
-        return "INSERT";
+  switch (operation_type) {
+  case SQLITE_INSERT:
+    return "INSERT";
 
-    case SQLITE_DELETE:
-        return "DELETE";
+  case SQLITE_DELETE:
+    return "DELETE";
 
-    case SQLITE_UPDATE:
-        return "UPDATE";
+  case SQLITE_UPDATE:
+    return "UPDATE";
 
-    default:
-        throw std::runtime_error("Unknown SQLite operation on hook");
-    }
+  default:
+    throw std::runtime_error("Unknown SQLite operation on hook");
+  }
 }
 
 void update_callback(void *db_host_object_ptr, int operation_type,
                      [[maybe_unused]] char const *database, char const *table,
                      sqlite3_int64 row_id) {
-    auto db_host_object = reinterpret_cast<DBHostObject *>(db_host_object_ptr);
-    db_host_object->on_update(std::string(table),
-                              operation_to_string(operation_type), row_id);
+  auto db_host_object = reinterpret_cast<DBHostObject *>(db_host_object_ptr);
+  db_host_object->on_update(std::string(table),
+                            operation_to_string(operation_type), row_id);
 }
 
 void opsqlite_register_update_hook(sqlite3 *db, void *db_host_object) {
-    sqlite3_update_hook(db, &update_callback, (void *)db_host_object);
+  sqlite3_update_hook(db, &update_callback, (void *)db_host_object);
 }
 
 void opsqlite_deregister_update_hook(sqlite3 *db) {
-    sqlite3_update_hook(db, nullptr, nullptr);
+  sqlite3_update_hook(db, nullptr, nullptr);
 }
 
 int commit_callback(void *db_host_object_ptr) {
-    auto db_host_object = reinterpret_cast<DBHostObject *>(db_host_object_ptr);
-    db_host_object->on_commit();
-    return 0;
+  auto db_host_object = reinterpret_cast<DBHostObject *>(db_host_object_ptr);
+  db_host_object->on_commit();
+  return 0;
 }
 
 void opsqlite_register_commit_hook(sqlite3 *db, void *db_host_object_ptr) {
-    sqlite3_commit_hook(db, &commit_callback, db_host_object_ptr);
+  sqlite3_commit_hook(db, &commit_callback, db_host_object_ptr);
 }
 
 void opsqlite_deregister_commit_hook(sqlite3 *db) {
-    sqlite3_commit_hook(db, nullptr, nullptr);
+  sqlite3_commit_hook(db, nullptr, nullptr);
 }
 
 void rollback_callback(void *db_host_object_ptr) {
-    auto db_host_object = reinterpret_cast<DBHostObject *>(db_host_object_ptr);
-    db_host_object->on_rollback();
+  auto db_host_object = reinterpret_cast<DBHostObject *>(db_host_object_ptr);
+  db_host_object->on_rollback();
 }
 
 void opsqlite_register_rollback_hook(sqlite3 *db, void *db_host_object_ptr) {
-    sqlite3_rollback_hook(db, &rollback_callback, db_host_object_ptr);
+  sqlite3_rollback_hook(db, &rollback_callback, db_host_object_ptr);
 }
 
 void opsqlite_deregister_rollback_hook(sqlite3 *db) {
-    sqlite3_rollback_hook(db, nullptr, nullptr);
+  sqlite3_rollback_hook(db, nullptr, nullptr);
 }
 
 void opsqlite_load_extension(sqlite3 *db, std::string &path,
                              std::string &entry_point) {
 #ifdef OP_SQLITE_USE_PHONE_VERSION
-    throw std::runtime_error("[op-sqlite] Embedded version of SQLite does not "
-                             "support loading extensions");
+  throw std::runtime_error("[op-sqlite] Embedded version of SQLite does not "
+                           "support loading extensions");
 #else
-    int status = 0;
-    status = sqlite3_enable_load_extension(db, 1);
+  int status = 0;
+  status = sqlite3_enable_load_extension(db, 1);
 
-    if (status != SQLITE_OK) {
-        throw std::runtime_error("Could not enable extension loading");
-    }
+  if (status != SQLITE_OK) {
+    throw std::runtime_error("Could not enable extension loading");
+  }
 
-    const char *entry_point_cstr = nullptr;
-    if (!entry_point.empty()) {
-        entry_point_cstr = entry_point.c_str();
-    }
+  const char *entry_point_cstr = nullptr;
+  if (!entry_point.empty()) {
+    entry_point_cstr = entry_point.c_str();
+  }
 
-    char *error_message;
+  char *error_message;
 
-    status = sqlite3_load_extension(db, path.c_str(), entry_point_cstr,
-                                    &error_message);
-    if (status != SQLITE_OK) {
-        throw std::runtime_error(error_message);
-    }
+  status = sqlite3_load_extension(db, path.c_str(), entry_point_cstr,
+                                  &error_message);
+  if (status != SQLITE_OK) {
+    throw std::runtime_error(error_message);
+  }
 #endif
 }
 
 BatchResult
 opsqlite_execute_batch(sqlite3 *db,
                        const std::vector<BatchArguments> *commands) {
-    size_t commandCount = commands->size();
-    if (commandCount <= 0) {
-        throw std::runtime_error("No SQL commands provided");
-    }
-
-    int affectedRows = 0;
-    // opsqlite_execute(db, "BEGIN EXCLUSIVE TRANSACTION", nullptr);
-    for (int i = 0; i < commandCount; i++) {
-        const auto &command = commands->at(i);
-        // We do not provide a datastructure to receive query data because we
-        // don't need/want to handle this results in a batch execution
-        // There is also no need to commit/catch this transaction, this is done
-        // in the JS code
-        auto result = opsqlite_execute(db, command.sql, &command.params);
-        affectedRows += result.affectedRows;
-    }
-
-    return BatchResult{
-        .affectedRows = affectedRows,
-        .commands = static_cast<int>(commandCount),
-    };
+  size_t commandCount = commands->size();
+  if (commandCount <= 0) {
+    throw std::runtime_error("No SQL commands provided");
+  }
+
+  int affectedRows = 0;
+  // opsqlite_execute(db, "BEGIN EXCLUSIVE TRANSACTION", nullptr);
+  for (int i = 0; i < commandCount; i++) {
+    const auto &command = commands->at(i);
+    // We do not provide a datastructure to receive query data because we
+    // don't need/want to handle this results in a batch execution
+    // There is also no need to commit/catch this transaction, this is done
+    // in the JS code
+    auto result = opsqlite_execute(db, command.sql, &command.params);
+    affectedRows += result.affectedRows;
+  }
+
+  return BatchResult{
+      .affectedRows = affectedRows,
+      .commands = static_cast<int>(commandCount),
+  };
 }
 
 } // namespace opsqlite