react-native-nitro-sqlite 9.2.2 → 9.4.0

package/android/CMakeLists.txt

@@ -24,7 +24,7 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/RNNitroSQLite+autolink
 # Specifies a path to native header files.
 include_directories(
   ../cpp
-  ../cpp/specs
+  ../cpp/hybridObjects
   ../cpp/sqlite
   src/main/cpp
 )

package/cpp/NitroSQLiteException.hpp

@@ -2,12 +2,11 @@
 
 #include <exception>
 #include <iostream>
-#include <string>
 #include <optional>
+#include <string>
 
 const std::string NITRO_SQLITE_EXCEPTION_PREFIX = "[NativeNitroSQLiteException]";
 
-
 enum NitroSQLiteExceptionType {
   UnknownError,
   DatabaseCannotBeOpened,

package/cpp/{specs → hybridObjects}/HybridNitroSQLite.cpp

@@ -1,5 +1,5 @@
 #include "HybridNitroSQLite.hpp"
-#include "HybridNativeQueryResult.hpp"
+#include "HybridNitroSQLiteQueryResult.hpp"
 #include "NitroSQLiteException.hpp"
 #include "importSqlFile.hpp"
 #include "logs.hpp"
@@ -8,11 +8,54 @@
 #include "sqliteExecuteBatch.hpp"
 #include <iostream>
 #include <map>
+#include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 namespace margelo::nitro::rnnitrosqlite {
 
+// Copy any JS-backed ArrayBuffers on the JS thread so they can be safely
+// accessed from the background thread used by Promise::async.
+static std::optional<SQLiteQueryParams> copyArrayBufferParamsForBackground(const std::optional<SQLiteQueryParams>& params) {
+  if (!params) {
+    return std::nullopt;
+  }
+
+  SQLiteQueryParams copiedParams;
+  copiedParams.reserve(params->size());
+
+  for (const auto& value : *params) {
+    if (std::holds_alternative<std::shared_ptr<ArrayBuffer>>(value)) {
+      const auto& buffer = std::get<std::shared_ptr<ArrayBuffer>>(value);
+      const auto copiedBuffer = ArrayBuffer::copy(buffer);
+      copiedParams.push_back(copiedBuffer);
+    } else {
+      copiedParams.push_back(value);
+    }
+  }
+
+  return copiedParams;
+}
+
+// Overload for batch execution: copy ArrayBuffer params inside each BatchQuery.
+static std::vector<BatchQuery> copyArrayBufferParamsForBackground(const std::vector<BatchQuery>& commands) {
+  std::vector<BatchQuery> copiedCommands;
+  copiedCommands.reserve(commands.size());
+
+  for (const auto& command : commands) {
+    BatchQuery copiedCommand = command;
+
+    if (command.params) {
+      copiedCommand.params = copyArrayBufferParamsForBackground(command.params);
+    }
+
+    copiedCommands.push_back(std::move(copiedCommand));
+  }
+
+  return copiedCommands;
+}
+
 const std::string getDocPath(const std::optional<std::string>& location) {
   std::string tempDocPath = std::string(HybridNitroSQLite::docPath);
   if (location) {
@@ -50,23 +93,23 @@ void HybridNitroSQLite::detach(const std::string& mainDbName, const std::string&
   sqliteDetachDb(mainDbName, alias);
 };
 
-using ExecuteQueryResult = std::shared_ptr<HybridNativeQueryResultSpec>;
-
-ExecuteQueryResult HybridNitroSQLite::execute(const std::string& dbName, const std::string& query,
-                                              const std::optional<SQLiteQueryParams>& params) {
-  SQLiteExecuteQueryResult result = sqliteExecute(dbName, query, params);
-  return std::make_shared<HybridNativeQueryResult>(std::move(result));
+std::shared_ptr<HybridNitroSQLiteQueryResultSpec> HybridNitroSQLite::execute(const std::string& dbName, const std::string& query,
+                                                                             const std::optional<SQLiteQueryParams>& params) {
+  return sqliteExecute(dbName, query, params);
 };
 
-std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>>
+std::shared_ptr<Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>>
 HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) {
-  return Promise<std::shared_ptr<HybridNativeQueryResultSpec>>::async([=, this]() -> std::shared_ptr<HybridNativeQueryResultSpec> {
-    auto result = execute(dbName, query, params);
-    return result;
-  });
+  const auto copiedParams = copyArrayBufferParamsForBackground(params);
+
+  return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::async(
+      [=, this]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> {
+        auto result = sqliteExecute(dbName, query, copiedParams);
+        return result;
+      });
 };
 
-BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& batchParams) {
+BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& batchParams) {
   const auto commands = batchParamsToCommands(batchParams);
 
   auto result = sqliteExecuteBatch(dbName, commands);
@@ -74,10 +117,15 @@ BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, cons
 };
 
 std::shared_ptr<Promise<BatchQueryResult>> HybridNitroSQLite::executeBatchAsync(const std::string& dbName,
-                                                                                const std::vector<NativeBatchQueryCommand>& batchParams) {
+                                                                                const std::vector<BatchQueryCommand>& batchParams) {
+  // Convert BatchQueryCommand objects on the JS thread and copy any JS-backed
+  // ArrayBuffers into native buffers before going off-thread.
+  const auto commands = batchParamsToCommands(batchParams);
+  const auto copiedCommands = copyArrayBufferParamsForBackground(commands);
+
   return Promise<BatchQueryResult>::async([=, this]() -> BatchQueryResult {
-    auto result = executeBatch(dbName, batchParams);
-    return result;
+    auto result = sqliteExecuteBatch(dbName, copiedCommands);
+    return BatchQueryResult(result.rowsAffected);
   });
 };
 

package/cpp/{specs → hybridObjects}/HybridNitroSQLite.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "HybridNativeQueryResultSpec.hpp"
+#include "HybridNitroSQLiteQueryResultSpec.hpp"
 #include "HybridNitroSQLiteSpec.hpp"
 #include "types.hpp"
 
@@ -28,15 +28,15 @@ public:
 
   void detach(const std::string& mainDbName, const std::string& alias) override;
 
-  std::shared_ptr<HybridNativeQueryResultSpec> execute(const std::string& dbName, const std::string& query,
-                                                       const std::optional<SQLiteQueryParams>& params) override;
+  std::shared_ptr<HybridNitroSQLiteQueryResultSpec> execute(const std::string& dbName, const std::string& query,
+                                                            const std::optional<SQLiteQueryParams>& params) override;
 
-  std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>>
+  std::shared_ptr<Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>>
   executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
 
-  BatchQueryResult executeBatch(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& commands) override;
+  BatchQueryResult executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
   std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName,
-                                                               const std::vector<NativeBatchQueryCommand>& commands) override;
+                                                               const std::vector<BatchQueryCommand>& commands) override;
 
   FileLoadResult loadFile(const std::string& dbName, const std::string& location) override;
   std::shared_ptr<Promise<FileLoadResult>> loadFileAsync(const std::string& dbName, const std::string& location) override;

package/cpp/hybridObjects/HybridNitroSQLiteQueryResult.cpp

@@ -0,0 +1,93 @@
+#include "HybridNitroSQLiteQueryResult.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+namespace {
+
+  /**
+   * Compute the approximate external memory size of a single result row.
+   * This includes:
+   * - Column name string capacities,
+   * - Heap usage for the actual SQLiteValue contents.
+   */
+  size_t getRowExternalMemorySize(const SQLiteQueryResultRow& row) {
+    size_t bucketMemory = row.bucket_count() * sizeof(void*);
+    constexpr size_t nodePadding = 24;
+    size_t nodesMemory = row.size() * (sizeof(std::pair<std::string, SQLiteValue>) * nodePadding);
+    return bucketMemory + nodesMemory;
+  }
+
+  /**
+   * Compute the approximate external memory size of the full result set.
+   * We add:
+   * - The vector's backing storage,
+   * - All rows (column names + values).
+   */
+  size_t getResultsExternalMemorySize(const SQLiteQueryResults& results) {
+    size_t size = sizeof(SQLiteQueryResults);
+
+    const auto resultCapacity = results.capacity();
+    size += resultCapacity * sizeof(SQLiteQueryResultRow);
+
+    for (const auto& row : results) {
+      size += getRowExternalMemorySize(row);
+    }
+
+    return size;
+  }
+
+  /**
+   * Compute the approximate external memory size of the table metadata.
+   * We include:
+   * - Column name string capacities (map keys),
+   * - Metadata contents, especially the `name` string on each metadata entry.
+   */
+  size_t getMetadataExternalMemorySize(const SQLiteQueryTableMetadata& metadata) {
+    size_t size = 0;
+
+    for (const auto& [columnName, columnMeta] : metadata) {
+
+      size += columnName.capacity();
+      size += columnMeta.name.capacity();
+    }
+
+    return size;
+  }
+
+} // namespace
+
+std::optional<double> HybridNitroSQLiteQueryResult::getInsertId() {
+  return _insertId;
+}
+
+double HybridNitroSQLiteQueryResult::getRowsAffected() {
+  return _rowsAffected;
+}
+
+SQLiteQueryResults HybridNitroSQLiteQueryResult::getResults() {
+  return _results;
+};
+
+std::optional<SQLiteQueryTableMetadata> HybridNitroSQLiteQueryResult::getMetadata() {
+  return _metadata;
+}
+
+size_t HybridNitroSQLiteQueryResult::getExternalMemorySize() noexcept {
+  size_t size = sizeof(*this);
+
+  size += getResultsExternalMemorySize(_results);
+
+  if (_metadata) {
+    size += getMetadataExternalMemorySize(*_metadata);
+  }
+
+  return size;
+}
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/hybridObjects/HybridNitroSQLiteQueryResult.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "HybridNitroSQLiteQueryResultSpec.hpp"
+#include "types.hpp"
+#include <map>
+
+using namespace margelo::rnnitrosqlite;
+
+namespace margelo::nitro::rnnitrosqlite {
+
+class HybridNitroSQLiteQueryResult : public HybridNitroSQLiteQueryResultSpec {
+public:
+  HybridNitroSQLiteQueryResult() : HybridObject(TAG) {}
+  HybridNitroSQLiteQueryResult(SQLiteQueryResults results, std::optional<double> insertId, double rowsAffected,
+                               std::optional<SQLiteQueryTableMetadata> metadata)
+      : HybridObject(TAG), _insertId(insertId), _rowsAffected(rowsAffected), _results(std::move(results)), _metadata(metadata) {}
+
+private:
+  std::optional<double> _insertId;
+  double _rowsAffected;
+  SQLiteQueryResults _results;
+  std::optional<SQLiteQueryTableMetadata> _metadata;
+
+public:
+  // Properties
+  std::optional<double> getInsertId() override;
+  double getRowsAffected() override;
+  SQLiteQueryResults getResults() override;
+  std::optional<SQLiteQueryTableMetadata> getMetadata() override;
+
+  /**
+   * Approximate the native memory used by this query result.
+   *
+   * We account for:
+   * - The size of this C++ object (`sizeof(*this)`),
+   * - All rows and columns (including column name strings),
+   * - String values stored in the result set,
+   * - ArrayBuffers used for BLOB columns (object overhead + raw byte size),
+   * - Column metadata strings.
+   *
+   * This is a best-effort estimate and intentionally focuses on external
+   * heap allocations that can put pressure on the JS GC.
+   */
+  size_t getExternalMemorySize() noexcept override;
+};
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/operations.cpp

@@ -1,5 +1,6 @@
 #include "operations.hpp"
 #include "NitroSQLiteException.hpp"
+#include "hybridObjects/HybridNitroSQLiteQueryResult.hpp"
 #include "logs.hpp"
 #include "utils.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
@@ -105,7 +106,7 @@ void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
   for (int valueIndex = 0; valueIndex < values.size(); valueIndex++) {
     int sqliteIndex = valueIndex + 1;
     SQLiteValue value = values.at(valueIndex);
-    if (std::holds_alternative<SQLiteNullValue>(value)) {
+    if (std::holds_alternative<NullType>(value)) {
       sqlite3_bind_null(statement, sqliteIndex);
     } else if (std::holds_alternative<bool>(value)) {
       sqlite3_bind_int(statement, sqliteIndex, std::get<bool>(value));
@@ -121,8 +122,8 @@ void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
   }
 }
 
-SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::string& query,
-                                       const std::optional<SQLiteQueryParams>& params) {
+std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const std::string& dbName, const std::string& query,
+                                                            const std::optional<SQLiteQueryParams>& params) {
   if (dbMap.count(dbName) == 0) {
     throw NitroSQLiteException::DatabaseNotOpen(dbName);
   }
@@ -183,15 +184,21 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
             case SQLITE_BLOB: {
               int blob_size = sqlite3_column_bytes(statement, i);
               const void* blob = sqlite3_column_blob(statement, i);
-              uint8_t* data = new uint8_t[blob_size];
-              memcpy(data, blob, blob_size);
-              row[column_name] = ArrayBuffer::wrap(data, blob_size, [&data]() -> void { delete[] data; });
+              // Copy the SQLite BLOB into a new native ArrayBuffer.
+              // This avoids manual memory management and unsafe pointer handling.
+              if (blob_size > 0) {
+                const auto* blob_data = reinterpret_cast<const uint8_t*>(blob);
+                row[column_name] = ArrayBuffer::copy(blob_data, static_cast<size_t>(blob_size));
+              } else {
+                // Represent empty BLOBs as an empty, but valid, ArrayBuffer.
+                row[column_name] = ArrayBuffer::allocate(0);
+              }
               break;
             }
             case SQLITE_NULL:
               // Intentionally left blank to switch to default case
             default:
-              row[column_name] = SQLiteNullValue(true);
+              row[column_name] = NullType::null;
               break;
           }
           i++;
@@ -205,7 +212,7 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
           column_name = sqlite3_column_name(statement, i);
           const char* tp = sqlite3_column_decltype(statement, i);
           column_declared_type = mapSQLiteTypeToColumnType(tp);
-          auto columnMeta = SQLiteQueryColumnMetadata(std::move(column_name), std::move(column_declared_type), i);
+          auto columnMeta = NitroSQLiteQueryColumnMetadata(std::move(column_name), std::move(column_declared_type), i);
 
           if (!metadata) {
             metadata = std::make_optional<SQLiteQueryTableMetadata>();
@@ -229,10 +236,7 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
 
   int rowsAffected = sqlite3_changes(db);
   long long latestInsertRowId = sqlite3_last_insert_rowid(db);
-  return {.rowsAffected = rowsAffected,
-          .insertId = static_cast<double>(latestInsertRowId),
-          .results = std::move(results),
-          .metadata = std::move(metadata)};
+  return std::make_shared<HybridNitroSQLiteQueryResult>(results, static_cast<double>(latestInsertRowId), rowsAffected, metadata);
 }
 
 SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std::string& query) {

package/cpp/operations.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "hybridObjects/HybridNitroSQLiteQueryResult.hpp"
 #include "types.hpp"
 
 namespace margelo::rnnitrosqlite {
@@ -15,7 +16,8 @@ void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, c
 
 void sqliteDetachDb(const std::string& mainDBName, const std::string& alias);
 
-SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params);
+std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const std::string& dbName, const std::string& query,
+                                                            const std::optional<SQLiteQueryParams>& params);
 
 SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std::string& query);
 

package/cpp/sqliteExecuteBatch.cpp

@@ -8,7 +8,7 @@
 
 namespace margelo::rnnitrosqlite {
 
-std::vector<BatchQuery> batchParamsToCommands(const std::vector<NativeBatchQueryCommand>& batchParams) {
+std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryCommand>& batchParams) {
   auto commands = std::vector<BatchQuery>();
 
   for (auto& command : batchParams) {
@@ -49,7 +49,7 @@ SQLiteOperationResult sqliteExecuteBatch(const std::string& dbName, const std::v
       auto metadata = std::optional<SQLiteQueryTableMetadata>(std::nullopt);
       try {
         auto result = sqliteExecute(dbName, command.sql, command.params);
-        rowsAffected += result.rowsAffected;
+        rowsAffected += result->getRowsAffected();
       } catch (NitroSQLiteException& e) {
         sqliteExecuteLiteral(dbName, "ROLLBACK");
         throw e;

package/cpp/sqliteExecuteBatch.hpp

@@ -3,7 +3,7 @@
  */
 #pragma once
 
-#include "NativeBatchQueryCommand.hpp"
+#include "BatchQueryCommand.hpp"
 #include "types.hpp"
 
 using namespace facebook;
@@ -20,7 +20,7 @@ struct BatchQuery {
  * Local Helper method to translate JSI objects BatchQuery datastructure
  * MUST be called in the JavaScript Thread
  */
-std::vector<BatchQuery> batchParamsToCommands(const std::vector<NativeBatchQueryCommand>& batchParams);
+std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryCommand>& batchParams);
 
 /**
  * Execute a batch of commands in a exclusive transaction

package/cpp/types.hpp

@@ -1,8 +1,7 @@
 #pragma once
 
 #include "ColumnType.hpp"
-#include "SQLiteNullValue.hpp"
-#include "SQLiteQueryColumnMetadata.hpp"
+#include "NitroSQLiteQueryColumnMetadata.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <string>
 
@@ -11,24 +10,15 @@ using namespace margelo::nitro::rnnitrosqlite;
 
 namespace margelo::rnnitrosqlite {
 
-using SQLiteValue = std::variant<std::string, double, bool, std::shared_ptr<ArrayBuffer>, SQLiteNullValue>;
+using SQLiteValue = std::variant<nitro::NullType, bool, std::shared_ptr<ArrayBuffer>, std::string, double>;
 using SQLiteQueryParams = std::vector<SQLiteValue>;
 using SQLiteQueryResultRow = std::unordered_map<std::string, SQLiteValue>;
 using SQLiteQueryResults = std::vector<SQLiteQueryResultRow>;
-using SQLiteQueryTableMetadata = std::unordered_map<std::string, SQLiteQueryColumnMetadata>;
+using SQLiteQueryTableMetadata = std::unordered_map<std::string, NitroSQLiteQueryColumnMetadata>;
 
 struct SQLiteOperationResult {
   int rowsAffected;
-  double insertId;
-  int commands;
-};
-
-struct SQLiteExecuteQueryResult {
-  int rowsAffected;
-  double insertId;
-
-  SQLiteQueryResults results;
-  std::optional<SQLiteQueryTableMetadata> metadata;
+  int commands = 0;
 };
 
 // constexpr function that maps SQLiteColumnType to string literals

package/ios/NitroSQLite.xcodeproj/project.pbxproj

@@ -173,7 +173,7 @@
 			path = ../nitrogen;
 			sourceTree = "<group>";
 		};
-		83BC6E5F2C8F78A200B954D2 /* specs */ = {
+		83BC6E5F2C8F78A200B954D2 /* hybridObjects */ = {
 			isa = PBXGroup;
 			children = (
 				83BC6E5A2C8F78A200B954D2 /* HybridNitroSQLite.cpp */,
@@ -188,7 +188,7 @@
 		83BC6E702C8F78A200B954D2 /* cpp */ = {
 			isa = PBXGroup;
 			children = (
-				83BC6E5F2C8F78A200B954D2 /* specs */,
+				83BC6E5F2C8F78A200B954D2 /* hybridObjects */,
 				83BC6E602C8F78A200B954D2 /* JSIHelper.cpp */,
 				83BC6E612C8F78A200B954D2 /* JSIHelper.h */,
 				83BC6E622C8F78A200B954D2 /* logs.h */,

package/lib/commonjs/index.js

@@ -3,12 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "NITRO_SQLITE_NULL", {
-  enumerable: true,
-  get: function () {
-    return _nullHandling.NITRO_SQLITE_NULL;
-  }
-});
 exports.NitroSQLite = void 0;
 Object.defineProperty(exports, "NitroSQLiteError", {
   enumerable: true,
@@ -16,24 +10,6 @@ Object.defineProperty(exports, "NitroSQLiteError", {
     return _NitroSQLiteError.default;
   }
 });
-Object.defineProperty(exports, "enableSimpleNullHandling", {
-  enumerable: true,
-  get: function () {
-    return _nullHandling.enableSimpleNullHandling;
-  }
-});
-Object.defineProperty(exports, "isNitroSQLiteNull", {
-  enumerable: true,
-  get: function () {
-    return _nullHandling.isNitroSQLiteNull;
-  }
-});
-Object.defineProperty(exports, "isSimpleNullHandlingEnabled", {
-  enumerable: true,
-  get: function () {
-    return _nullHandling.isSimpleNullHandlingEnabled;
-  }
-});
 Object.defineProperty(exports, "open", {
   enumerable: true,
   get: function () {
@@ -52,7 +28,6 @@ var _session = require("./operations/session.js");
 var _execute = require("./operations/execute.js");
 var _OnLoad = require("./OnLoad");
 var _executeBatch = require("./operations/executeBatch.js");
-var _nullHandling = require("./nullHandling.js");
 var _NitroSQLiteError = _interopRequireDefault(require("./NitroSQLiteError.js"));
 var _typeORM = require("./typeORM.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_transaction","require","_nitro","_session","_execute","_OnLoad","_executeBatch","_nullHandling","_NitroSQLiteError","_interopRequireDefault","_typeORM","e","__esModule","default","init","NitroSQLite","exports","HybridNitroSQLite","native","open","transaction","execute","executeAsync","executeBatch","executeBatchAsync"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,aAAA,GAAAL,OAAA;AAmBA,IAAAM,aAAA,GAAAN,OAAA;AAMA,IAAAO,iBAAA,GAAAC,sBAAA,CAAAR,OAAA;AAEA,IAAAS,QAAA,GAAAT,OAAA;AAAyC,SAAAQ,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAzBzC,IAAAG,YAAI,EAAC,CAAC;AAEC,MAAMC,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzB,GAAGE,wBAAiB;EACpBC,MAAM,EAAED,wBAAiB;EACzB;EACA;EACAE,IAAI,EAAJA,aAAI;EACJ;EACAC,WAAW,EAAXA,wBAAW;EACXC,OAAO,EAAPA,gBAAO;EACPC,YAAY,EAAZA,qBAAY;EACZC,YAAY,EAAZA,0BAAY;EACZC,iBAAiB,EAAjBA;AACF,CAAC","ignoreList":[]}
+{"version":3,"names":["_transaction","require","_nitro","_session","_execute","_OnLoad","_executeBatch","_NitroSQLiteError","_interopRequireDefault","_typeORM","e","__esModule","default","init","NitroSQLite","exports","HybridNitroSQLite","native","open","transaction","execute","executeAsync","executeBatch","executeBatchAsync"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,aAAA,GAAAL,OAAA;AAmBA,IAAAM,iBAAA,GAAAC,sBAAA,CAAAP,OAAA;AAEA,IAAAQ,QAAA,GAAAR,OAAA;AAAyC,SAAAO,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAnBzC,IAAAG,YAAI,EAAC,CAAC;AAEC,MAAMC,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzB,GAAGE,wBAAiB;EACpBC,MAAM,EAAED,wBAAiB;EACzB;EACA;EACAE,IAAI,EAAJA,aAAI;EACJ;EACAC,WAAW,EAAXA,wBAAW;EACXC,OAAO,EAAPA,gBAAO;EACPC,YAAY,EAAZA,qBAAY;EACZC,YAAY,EAAZA,0BAAY;EACZC,iBAAiB,EAAjBA;AACF,CAAC","ignoreList":[]}

package/lib/commonjs/operations/execute.js

@@ -5,53 +5,40 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.execute = execute;
 exports.executeAsync = executeAsync;
-var _nullHandling = require("../nullHandling.js");
 var _nitro = require("../nitro.js");
 var _NitroSQLiteError = _interopRequireDefault(require("../NitroSQLiteError.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function execute(dbName, query, params) {
-  const transformedParams = (0, _nullHandling.isSimpleNullHandlingEnabled)() ? toNativeQueryParams(params) : params;
   try {
-    const nativeResult = _nitro.HybridNitroSQLite.execute(dbName, query, transformedParams);
-    return buildJsQueryResult(nativeResult);
+    const nativeResult = _nitro.HybridNitroSQLite.execute(dbName, query, params);
+    return buildJSQueryResult(nativeResult);
   } catch (error) {
     throw _NitroSQLiteError.default.fromError(error);
   }
 }
 async function executeAsync(dbName, query, params) {
-  const transformedParams = (0, _nullHandling.isSimpleNullHandlingEnabled)() ? toNativeQueryParams(params) : params;
   try {
-    const nativeResult = await _nitro.HybridNitroSQLite.executeAsync(dbName, query, transformedParams);
-    return buildJsQueryResult(nativeResult);
+    const nativeResult = await _nitro.HybridNitroSQLite.executeAsync(dbName, query, params);
+    return buildJSQueryResult(nativeResult);
   } catch (error) {
     throw _NitroSQLiteError.default.fromError(error);
   }
 }
-function toNativeQueryParams(params) {
-  return params?.map(param => (0, _nullHandling.replaceWithNativeNullValue)(param));
-}
-function buildJsQueryResult({
-  insertId,
-  rowsAffected,
-  results
-}) {
-  let data = results;
-  if ((0, _nullHandling.isSimpleNullHandlingEnabled)()) {
-    data = results.map(row => Object.fromEntries(Object.entries(row).map(([key, value]) => {
-      if ((0, _nullHandling.isNitroSQLiteNull)(value)) {
-        return [key, null];
-      }
-      return [key, value];
-    })));
-  }
-  return {
-    insertId,
-    rowsAffected,
-    rows: {
-      _array: data,
-      length: data.length,
-      item: idx => data[idx]
-    }
+function buildJSQueryResult(result) {
+  const resultWithRows = result;
+  resultWithRows.rows = {
+    _array: result.results,
+    length: result.results.length,
+    item: idx => result.results[idx]
   };
+  return resultWithRows;
+
+  // return Object.assign(result, {
+  //   rows: {
+  //     _array: result.results,
+  //     length: result.results.length,
+  //     item: (idx: number) => result.results[idx],
+  //   },
+  // })
 }
 //# sourceMappingURL=execute.js.map

package/lib/commonjs/operations/execute.js.map

@@ -1 +1 @@
-{"version":3,"names":["_nullHandling","require","_nitro","_NitroSQLiteError","_interopRequireDefault","e","__esModule","default","execute","dbName","query","params","transformedParams","isSimpleNullHandlingEnabled","toNativeQueryParams","nativeResult","HybridNitroSQLite","buildJsQueryResult","error","NitroSQLiteError","fromError","executeAsync","map","param","replaceWithNativeNullValue","insertId","rowsAffected","results","data","row","Object","fromEntries","entries","key","value","isNitroSQLiteNull","rows","_array","length","item","idx"],"sourceRoot":"../../../src","sources":["operations/execute.ts"],"mappings":";;;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AASA,IAAAE,iBAAA,GAAAC,sBAAA,CAAAH,OAAA;AAAkD,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE3C,SAASG,OAAOA,CACrBC,MAAc,EACdC,KAAa,EACbC,MAA0B,EACR;EAClB,MAAMC,iBAAiB,GAAG,IAAAC,yCAA2B,EAAC,CAAC,GACnDC,mBAAmB,CAACH,MAAM,CAAC,GAC1BA,MAAkC;EAEvC,IAAI;IACF,MAAMI,YAAY,GAAGC,wBAAiB,CAACR,OAAO,CAC5CC,MAAM,EACNC,KAAK,EACLE,iBACF,CAAC;IAED,OAAOK,kBAAkB,CAAMF,YAAY,CAAC;EAC9C,CAAC,CAAC,OAAOG,KAAK,EAAE;IACd,MAAMC,yBAAgB,CAACC,SAAS,CAACF,KAAK,CAAC;EACzC;AACF;AAEO,eAAeG,YAAYA,CAChCZ,MAAc,EACdC,KAAa,EACbC,MAA0B,EACC;EAC3B,MAAMC,iBAAiB,GAAG,IAAAC,yCAA2B,EAAC,CAAC,GACnDC,mBAAmB,CAACH,MAAM,CAAC,GAC1BA,MAAkC;EAEvC,IAAI;IACF,MAAMI,YAAY,GAAG,MAAMC,wBAAiB,CAACK,YAAY,CACvDZ,MAAM,EACNC,KAAK,EACLE,iBACF,CAAC;IACD,OAAOK,kBAAkB,CAAMF,YAAY,CAAC;EAC9C,CAAC,CAAC,OAAOG,KAAK,EAAE;IACd,MAAMC,yBAAgB,CAACC,SAAS,CAACF,KAAK,CAAC;EACzC;AACF;AAEA,SAASJ,mBAAmBA,CAC1BH,MAAqC,EACA;EACrC,OAAOA,MAAM,EAAEW,GAAG,CAAEC,KAAK,IAAK,IAAAC,wCAA0B,EAACD,KAAK,CAAC,CAAC;AAClE;AAEA,SAASN,kBAAkBA,CAAqC;EAC9DQ,QAAQ;EACRC,YAAY;EACZC;AACiB,CAAC,EAAoB;EACtC,IAAIC,IAAW,GAAGD,OAAgB;EAElC,IAAI,IAAAd,yCAA2B,EAAC,CAAC,EAAE;IACjCe,IAAI,GAAGD,OAAO,CAACL,GAAG,CAAEO,GAAG,IACrBC,MAAM,CAACC,WAAW,CAChBD,MAAM,CAACE,OAAO,CAACH,GAAG,CAAC,CAACP,GAAG,CAAC,CAAC,CAACW,GAAG,EAAEC,KAAK,CAAC,KAAK;MACxC,IAAI,IAAAC,+BAAiB,EAACD,KAAK,CAAC,EAAE;QAC5B,OAAO,CAACD,GAAG,EAAE,IAAI,CAAC;MACpB;MACA,OAAO,CAACA,GAAG,EAAEC,KAAK,CAAC;IACrB,CAAC,CACH,CACF,CAAU;EACZ;EAEA,OAAO;IACLT,QAAQ;IACRC,YAAY;IACZU,IAAI,EAAE;MACJC,MAAM,EAAET,IAAI;MACZU,MAAM,EAAEV,IAAI,CAACU,MAAM;MACnBC,IAAI,EAAGC,GAAW,IAAKZ,IAAI,CAACY,GAAG;IACjC;EACF,CAAC;AACH","ignoreList":[]}
+{"version":3,"names":["_nitro","require","_NitroSQLiteError","_interopRequireDefault","e","__esModule","default","execute","dbName","query","params","nativeResult","HybridNitroSQLite","buildJSQueryResult","error","NitroSQLiteError","fromError","executeAsync","result","resultWithRows","rows","_array","results","length","item","idx"],"sourceRoot":"../../../src","sources":["operations/execute.ts"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,iBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAAkD,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAG3C,SAASG,OAAOA,CACrBC,MAAc,EACdC,KAAa,EACbC,MAA0B,EACR;EAClB,IAAI;IACF,MAAMC,YAAY,GAAGC,wBAAiB,CAACL,OAAO,CAACC,MAAM,EAAEC,KAAK,EAAEC,MAAM,CAAC;IACrE,OAAOG,kBAAkB,CAAMF,YAAY,CAAC;EAC9C,CAAC,CAAC,OAAOG,KAAK,EAAE;IACd,MAAMC,yBAAgB,CAACC,SAAS,CAACF,KAAK,CAAC;EACzC;AACF;AAEO,eAAeG,YAAYA,CAChCT,MAAc,EACdC,KAAa,EACbC,MAA0B,EACC;EAC3B,IAAI;IACF,MAAMC,YAAY,GAAG,MAAMC,wBAAiB,CAACK,YAAY,CACvDT,MAAM,EACNC,KAAK,EACLC,MACF,CAAC;IACD,OAAOG,kBAAkB,CAAMF,YAAY,CAAC;EAC9C,CAAC,CAAC,OAAOG,KAAK,EAAE;IACd,MAAMC,yBAAgB,CAACC,SAAS,CAACF,KAAK,CAAC;EACzC;AACF;AAEA,SAASD,kBAAkBA,CACzBK,MAA8B,EACZ;EAClB,MAAMC,cAAc,GAAGD,MAA0B;EAEjDC,cAAc,CAACC,IAAI,GAAG;IACpBC,MAAM,EAAEH,MAAM,CAACI,OAAgB;IAC/BC,MAAM,EAAEL,MAAM,CAACI,OAAO,CAACC,MAAM;IAC7BC,IAAI,EAAGC,GAAW,IAAKP,MAAM,CAACI,OAAO,CAACG,GAAG;EAC3C,CAAC;EAED,OAAON,cAAc;;EAErB;EACA;EACA;EACA;EACA;EACA;EACA;AACF","ignoreList":[]}