feat: implement Nitro's getExternalMemorySize

Author: chrispader

package/cpp/specs/HybridNitroSQLite.cpp

@@ -91,4 +91,12 @@ std::shared_ptr<Promise<FileLoadResult>> HybridNitroSQLite::loadFileAsync(const
   });
 };
 
+size_t HybridNitroSQLite::getExternalMemorySize() noexcept {
+  // The HybridNitroSQLite instance itself does not own any heavy external
+  // memory. Database connections are tracked globally in `dbMap`.
+  // We still report the size of this instance so the JS GC can take it
+  // into account when estimating native memory pressure.
+  return sizeof(*this);
+}
+
 } // namespace margelo::nitro::rnnitrosqlite

package/cpp/specs/HybridNitroSQLite.hpp

@@ -40,6 +40,16 @@ class HybridNitroSQLite : public HybridNitroSQLiteSpec {
 
   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;
+
+  /**
+   * Approximate the native memory used by this Hybrid Object.
+   *
+   * This object itself does not own any large external resources – database
+   * connections are handled by the shared `dbMap` in `operations.cpp`.
+   * We still report the size of this C++ instance so the JS GC can account
+   * for the object when it is retained from JS.
+   */
+  size_t getExternalMemorySize() noexcept override;
 };
 
 inline std::string HybridNitroSQLite::docPath = "";

package/cpp/specs/HybridNitroSQLiteQueryResult.cpp

@@ -8,6 +8,98 @@
 
 namespace margelo::nitro::rnnitrosqlite {
 
+namespace {
+
+/**
+ * Compute the approximate external memory size of a single SQLiteValue.
+ *
+ * We only need to account for heap allocations that can actually put
+ * pressure on the JS GC – in practice, that means:
+ * - `std::string` contents,
+ * - `ArrayBuffer` instances (object + underlying bytes).
+ *
+ * Other variants (`NullType`, `bool`, `double`) are small and live inline.
+ */
+size_t getValueExternalMemorySize(const SQLiteValue& value) {
+  if (std::holds_alternative<std::string>(value)) {
+    const auto& stringValue = std::get<std::string>(value);
+    return stringValue.capacity();
+  }
+
+  if (std::holds_alternative<std::shared_ptr<ArrayBuffer>>(value)) {
+    const auto& buffer = std::get<std::shared_ptr<ArrayBuffer>>(value);
+    if (!buffer) {
+      return 0;
+    }
+
+    const auto bufferSize = buffer->size();
+    return sizeof(*buffer.get()) + bufferSize;
+  }
+
+  return 0;
+}
+
+/**
+ * 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 size = 0;
+
+  for (const auto& entry : row) {
+    const auto& columnName = entry.first;
+    const auto& value = entry.second;
+
+    size += columnName.capacity();
+    size += getValueExternalMemorySize(value);
+  }
+
+  return size;
+}
+
+/**
+ * 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 = 0;
+
+  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& entry : metadata) {
+    const auto& columnName = entry.first;
+    const auto& columnMeta = entry.second;
+
+    size += columnName.capacity();
+    size += columnMeta.name.capacity();
+  }
+
+  return size;
+}
+
+} // namespace
+
 std::optional<double> HybridNitroSQLiteQueryResult::getInsertId() {
   return _insertId;
 }
@@ -24,4 +116,16 @@ std::optional<SQLiteQueryTableMetadata> HybridNitroSQLiteQueryResult::getMetadat
   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/specs/HybridNitroSQLiteQueryResult.hpp

@@ -27,6 +27,21 @@ class HybridNitroSQLiteQueryResult : public HybridNitroSQLiteQueryResultSpec {
   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