fix: c++ hybrid objects not constructed properly

Author: chrispader

package/cpp/operations.cpp

@@ -11,6 +11,7 @@
 #include <sqlite3.h>
 #include <sstream>
 #include <unistd.h>
+#include "specs/HybridNitroSQLiteQueryResult.hpp"
 
 using namespace facebook;
 using namespace margelo::nitro;
@@ -121,7 +122,7 @@ void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
   }
 }
 
-SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::string& query,
+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) {
@@ -288,3 +286,4 @@ SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std:
 }
 
 } // namespace margelo::rnnitrosqlite
+

package/cpp/operations.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "types.hpp"
+#include "specs/HybridNitroSQLiteQueryResult.hpp"
 
 namespace margelo::rnnitrosqlite {
 
@@ -15,7 +16,7 @@ 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

@@ -10,6 +10,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include "HybridNitroSQLiteQueryResult.hpp"
 
 namespace margelo::nitro::rnnitrosqlite {
 
@@ -50,12 +51,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,
+std::shared_ptr<HybridNitroSQLiteQueryResultSpec> 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));
+  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,40 @@ 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) {
+    HybridNitroSQLiteQueryResult();
+    
+    _results = results;
+    _insertId = insertId;
+    _metadata = metadata;
+    
+    if (!_results.empty()) {
+      auto rows = _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());
+      _rows = NitroSQLiteQueryResultRows(std::move(rows), length, 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