fix: Keep hybrid object data (#255)

* fix: c++ hybrid objects not constructed properly

* fix: remove `buildJsQueryResult` and simplify types

* chore: update Claude permissions

* fix: properly construct `HybridNitroSQLiteQueryResult`

* chore: lint cpp

Author: chrispader

.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(grep:*)"
+    ]
+  }
+}

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/operations.cpp

@@ -1,6 +1,7 @@
 #include "operations.hpp"
 #include "NitroSQLiteException.hpp"
 #include "logs.hpp"
+#include "specs/HybridNitroSQLiteQueryResult.hpp"
 #include "utils.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <cmath>
@@ -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);
   }
@@ -229,10 +230,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 "specs/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/specs/HybridNitroSQLite.cpp

@@ -50,12 +50,9 @@ void HybridNitroSQLite::detach(const std::string& mainDbName, const std::string&
   sqliteDetachDb(mainDbName, alias);
 };
 
-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<HybridNitroSQLiteQueryResult>(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<HybridNitroSQLiteQueryResultSpec>>>

package/cpp/specs/HybridNitroSQLiteQueryResult.cpp

@@ -9,41 +9,23 @@
 namespace margelo::nitro::rnnitrosqlite {
 
 std::optional<double> HybridNitroSQLiteQueryResult::getInsertId() {
-  return _result.insertId;
+  return _insertId;
 }
 
 double HybridNitroSQLiteQueryResult::getRowsAffected() {
-  return _result.rowsAffected;
+  return _rowsAffected;
 }
 
 SQLiteQueryResults HybridNitroSQLiteQueryResult::getResults() {
-  return _result.results;
+  return _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);
+  return _rows;
 }
 
 std::optional<SQLiteQueryTableMetadata> HybridNitroSQLiteQueryResult::getMetadata() {
-  return _result.metadata;
+  return _metadata;
 }
 
 } // namespace margelo::nitro::rnnitrosqlite

package/cpp/specs/HybridNitroSQLiteQueryResult.hpp

@@ -11,10 +11,39 @@ namespace margelo::nitro::rnnitrosqlite {
 class HybridNitroSQLiteQueryResult : public HybridNitroSQLiteQueryResultSpec {
 public:
   HybridNitroSQLiteQueryResult() : HybridObject(TAG) {}
-  HybridNitroSQLiteQueryResult(SQLiteExecuteQueryResult&& result) : HybridObject(TAG), _result(std::move(result)) {}
+  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) {
+    if (_results.empty()) {
+      // Empty rows: empty vector, length 0, item callback always returns null
+      auto emptyItem = [](double /* idx */) -> std::shared_ptr<Promise<std::optional<SQLiteQueryResultRow>>> {
+        return Promise<std::optional<SQLiteQueryResultRow>>::async([]() -> std::optional<SQLiteQueryResultRow> { return std::nullopt; });
+      };
+      _rows = NitroSQLiteQueryResultRows(SQLiteQueryResults{}, 0.0, std::move(emptyItem));
+      return;
+    }
+
+    auto rows = _results;
+    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());
+    _rows = NitroSQLiteQueryResultRows(std::move(rows), length, std::move(itemFunction));
+  }
 
 private:
-  SQLiteExecuteQueryResult _result;
+  std::optional<double> _insertId;
+  double _rowsAffected;
+  SQLiteQueryResults _results;
+  std::optional<NitroSQLiteQueryResultRows> _rows;
+  std::optional<SQLiteQueryTableMetadata> _metadata;
 
 public:
   // Properties

package/cpp/sqliteExecuteBatch.cpp

@@ -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/types.hpp

@@ -18,16 +18,7 @@ using SQLiteQueryTableMetadata = std::unordered_map<std::string, NitroSQLiteQuer
 
 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/src/operations/execute.ts

@@ -1,5 +1,4 @@
 import { HybridNitroSQLite } from '../nitro'
-import type { NitroSQLiteQueryResult } from '../specs/NitroSQLiteQueryResult.nitro'
 import type { QueryResult, QueryResultRow, SQLiteQueryParams } from '../types'
 import NitroSQLiteError from '../NitroSQLiteError'
 
@@ -10,7 +9,7 @@ export function execute<Row extends QueryResultRow = never>(
 ): QueryResult<Row> {
   try {
     const result = HybridNitroSQLite.execute(dbName, query, params)
-    return buildJsQueryResult<Row>(result)
+    return result as QueryResult<Row>
   } catch (error) {
     throw NitroSQLiteError.fromError(error)
   }
@@ -23,25 +22,8 @@ export async function executeAsync<Row extends QueryResultRow = never>(
 ): Promise<QueryResult<Row>> {
   try {
     const result = await HybridNitroSQLite.executeAsync(dbName, query, params)
-    return buildJsQueryResult<Row>(result)
+    return result as QueryResult<Row>
   } catch (error) {
     throw NitroSQLiteError.fromError(error)
   }
 }
-
-function buildJsQueryResult<Row extends QueryResultRow = never>(
-  result: NitroSQLiteQueryResult,
-): QueryResult<Row> {
-  const data = result.results as Row[]
-
-  return {
-    ...result,
-    insertId: result.insertId,
-    rowsAffected: result.rowsAffected,
-    rows: {
-      _array: data,
-      length: data.length,
-      item: (idx: number) => data[idx],
-    },
-  } as QueryResult<Row>
-}