feat: Use new Nitro null types

example/ios/Podfile.lock

@@ -8,7 +8,7 @@ PODS:
   - hermes-engine (0.82.1):
     - hermes-engine/Pre-built (= 0.82.1)
   - hermes-engine/Pre-built (0.82.1)
-  - NitroModules (0.27.2):
+  - NitroModules (0.32.0):
     - boost
     - DoubleConversion
     - fast_float
@@ -2778,7 +2778,7 @@ SPEC CHECKSUMS:
   fmt: a40bb5bd0294ea969aaaba240a927bd33d878cdd
   glog: 5683914934d5b6e4240e497e0f4a3b42d1854183
   hermes-engine: 273e30e7fb618279934b0b95ffab60ecedb7acf5
-  NitroModules: 18d9127f80848a1d12ed4bf59d14a6d816a720d8
+  NitroModules: 5ab248c0c4bc0a440414c0a8509dbad55cc7da6c
   RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
   RCTDeprecation: f17e2ebc07876ca9ab8eb6e4b0a4e4647497ae3a
   RCTRequired: e2c574c1b45231f7efb0834936bd609d75072b63

example/package.json

@@ -22,7 +22,7 @@
     "expo-status-bar": "^1.12.1",
     "react": "19.1.1",
     "react-native": "0.82.1",
-    "react-native-nitro-modules": "0.27.2",
+    "react-native-nitro-modules": "*",
     "react-native-nitro-sqlite": "*",
     "react-native-safe-area-context": "^5.5.2",
     "react-native-screens": "^4.18.0",

package.json

@@ -35,7 +35,7 @@
     "patch-package": "^8.0.0",
     "react": "19.1.1",
     "react-native": "0.82.1",
-    "react-native-nitro-modules": "0.27.2"
+    "react-native-nitro-modules": "0.32.0"
   },
   "devDependencies": {
     "@babel/core": "^7.28.5",
@@ -62,7 +62,7 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "jest": "^30.2.0",
-    "nitro-codegen": "0.27.2",
+    "nitrogen": "0.32.0",
     "prettier": "^3.6.2",
     "release-it": "^17.10.0",
     "typeorm": "0.3.27",

package/cpp/operations.cpp

@@ -105,7 +105,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));
@@ -191,7 +191,7 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
             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 +205,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>();

package/cpp/specs/HybridNitroSQLite.cpp

@@ -1,5 +1,5 @@
 #include "HybridNitroSQLite.hpp"
-#include "HybridNativeQueryResult.hpp"
+#include "HybridNitroSQLiteQueryResult.hpp"
 #include "NitroSQLiteException.hpp"
 #include "importSqlFile.hpp"
 #include "logs.hpp"
@@ -50,31 +50,32 @@ void HybridNitroSQLite::detach(const std::string& mainDbName, const std::string&
   sqliteDetachDb(mainDbName, alias);
 };
 
-using ExecuteQueryResult = std::shared_ptr<HybridNativeQueryResultSpec>;
+using ExecuteQueryResult = std::shared_ptr<HybridNitroSQLiteQueryResultSpec>;
 
 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));
+  return std::make_shared<HybridNitroSQLiteQueryResult>(std::move(result));
 };
 
-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;
-  });
+  return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::async(
+      [=, this]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> {
+        auto result = execute(dbName, query, params);
+        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);
   return BatchQueryResult(result.rowsAffected);
 };
 
 std::shared_ptr<Promise<BatchQueryResult>> HybridNitroSQLite::executeBatchAsync(const std::string& dbName,
-                                                                                const std::vector<NativeBatchQueryCommand>& batchParams) {
+                                                                                const std::vector<BatchQueryCommand>& batchParams) {
   return Promise<BatchQueryResult>::async([=, this]() -> BatchQueryResult {
     auto result = executeBatch(dbName, batchParams);
     return result;

package/cpp/specs/HybridNitroSQLite.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "HybridNativeQueryResultSpec.hpp"
+#include "HybridNitroSQLiteQueryResultSpec.hpp"
 #include "HybridNitroSQLiteSpec.hpp"
 #include "types.hpp"
 
@@ -28,15 +28,15 @@ class HybridNitroSQLite : public HybridNitroSQLiteSpec {
 
   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/specs/HybridNitroSQLiteQueryResult.cpp

@@ -0,0 +1,49 @@
+#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 {
+
+std::optional<double> HybridNitroSQLiteQueryResult::getInsertId() {
+  return _result.insertId;
+}
+
+double HybridNitroSQLiteQueryResult::getRowsAffected() {
+  return _result.rowsAffected;
+}
+
+SQLiteQueryResults HybridNitroSQLiteQueryResult::getResults() {
+  return _result.results;
+};
+
+std::optional<NitroSQLiteQueryResultRows> HybridNitroSQLiteQueryResult::getRows() {
+  if (_result.results.empty()) {
+    return std::nullopt;
+  }
+
+  auto rows = _result.results;
+
+  // Create the item function that returns a Promise
+  auto itemFunction = [rows](double idx) -> std::shared_ptr<Promise<std::optional<SQLiteQueryResultRow>>> {
+    return Promise<std::optional<SQLiteQueryResultRow>>::async([rows, idx]() -> std::optional<SQLiteQueryResultRow> {
+      const auto index = static_cast<size_t>(idx);
+      if (index >= rows.size()) {
+        return std::nullopt;
+      }
+      return rows[index];
+    });
+  };
+
+  const auto length = static_cast<double>(rows.size());
+  return NitroSQLiteQueryResultRows(std::move(rows), length, itemFunction);
+}
+
+std::optional<SQLiteQueryTableMetadata> HybridNitroSQLiteQueryResult::getMetadata() {
+  return _result.metadata;
+}
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/specs/HybridNativeQueryResult.hpp → package/cpp/specs/HybridNitroSQLiteQueryResult.hpp

@@ -1,17 +1,17 @@
 #pragma once
 
-#include "HybridNativeQueryResultSpec.hpp"
+#include "HybridNitroSQLiteQueryResultSpec.hpp"
 #include "types.hpp"
 #include <map>
 
 using namespace margelo::rnnitrosqlite;
 
 namespace margelo::nitro::rnnitrosqlite {
 
-class HybridNativeQueryResult : public HybridNativeQueryResultSpec {
+class HybridNitroSQLiteQueryResult : public HybridNitroSQLiteQueryResultSpec {
 public:
-  HybridNativeQueryResult() : HybridObject(TAG) {}
-  HybridNativeQueryResult(SQLiteExecuteQueryResult&& result) : HybridObject(TAG), _result(std::move(result)) {}
+  HybridNitroSQLiteQueryResult() : HybridObject(TAG) {}
+  HybridNitroSQLiteQueryResult(SQLiteExecuteQueryResult&& result) : HybridObject(TAG), _result(std::move(result)) {}
 
 private:
   SQLiteExecuteQueryResult _result;
@@ -21,6 +21,7 @@ class HybridNativeQueryResult : public HybridNativeQueryResultSpec {
   std::optional<double> getInsertId() override;
   double getRowsAffected() override;
   SQLiteQueryResults getResults() override;
+  std::optional<NitroSQLiteQueryResultRows> getRows() override;
   std::optional<SQLiteQueryTableMetadata> getMetadata() override;
 };
 

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) {

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,11 +10,11 @@ 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;