@photostructure/sqlite 0.0.1 → 0.2.0

package/src/aggregate_function.h

@@ -4,8 +4,11 @@
 #include <napi.h>
 #include <sqlite3.h>
 
+#include <atomic>
 #include <memory>
+#include <mutex>
 #include <string>
+#include <unordered_map>
 
 namespace photostructure {
 namespace sqlite {
@@ -13,6 +16,20 @@ namespace sqlite {
 // Forward declarations
 class DatabaseSync;
 
+// Thread-safe external storage for N-API values
+// This solves the problem of storing N-API objects in SQLite-allocated memory
+class ValueStorage {
+private:
+  static std::unordered_map<int32_t, Napi::Reference<Napi::Value>> storage_;
+  static std::mutex mutex_;
+  static std::atomic<int32_t> next_id_;
+
+public:
+  static int32_t Store(Napi::Env env, Napi::Value value);
+  static Napi::Value Get(Napi::Env env, int32_t id);
+  static void Remove(int32_t id);
+};
+
 class CustomAggregate {
 public:
   explicit CustomAggregate(Napi::Env env, DatabaseSync *db,
@@ -29,63 +46,57 @@ public:
   static void xDestroy(void *self);
 
 private:
-  struct AggregateData {
-    // Store value as raw C++ data instead of JavaScript objects
-    enum ValueType {
-      TYPE_NULL,
-      TYPE_UNDEFINED,
-      TYPE_NUMBER,
-      TYPE_STRING,
-      TYPE_BOOLEAN,
-      TYPE_BIGINT,
-      TYPE_OBJECT // For complex objects, we'll need special handling
-    } value_type;
-
+  // Comprehensive aggregate value storage (no Napi::Reference)
+  struct AggregateValue {
+    enum Type {
+      NUMBER,
+      STRING,
+      BIGINT,
+      BOOLEAN,
+      NULL_VAL,
+      OBJECT_JSON,
+      BUFFER
+    };
+    Type type;
+    bool is_initialized;
     union {
-      double number_val;
-      bool boolean_val;
-      int64_t bigint_val;
+      double number_value;
+      bool bool_value;
+      int64_t bigint_value;
     };
-    std::string string_val;                  // For strings
-    Napi::Reference<Napi::Value> object_ref; // For complex objects (fallback)
+    char string_buffer[4096]; // Fixed-size buffer for string data (POD) -
+                              // increased for complex JSON
+    size_t string_length;     // Length of string data
+
+    // No constructor needed - this must be POD for SQLite context
+  };
 
+  // Simplified aggregate data structure matching Node.js pattern
+  // Uses external storage to avoid N-API object lifetime issues
+  struct AggregateData {
+    int32_t value_id; // Reference to external storage
     bool initialized;
     bool is_window;
-    bool first_call; // True if this is the first call and we need to
-                     // initialize with start value
-
-    // Default constructor
-    AggregateData()
-        : value_type(TYPE_NULL), number_val(0.0), initialized(false),
-          is_window(false), first_call(false) {}
-
-    // Destructor to properly clean up Napi::Reference
-    ~AggregateData() {
-      if (value_type == TYPE_OBJECT && !object_ref.IsEmpty()) {
-        object_ref.Reset();
-      }
-    }
   };
 
-  // Helper methods
+  // Helper methods - mirroring Node.js implementation exactly
   static void xStepBase(sqlite3_context *ctx, int argc, sqlite3_value **argv,
-                        bool use_inverse);
-  static void xValueBase(sqlite3_context *ctx, bool finalize);
+                        Napi::Reference<Napi::Function> CustomAggregate::*mptr);
+  static void xValueBase(sqlite3_context *ctx, bool is_final);
+
+  // Helper method for safe JSON serialization with circular reference handling
+  static std::string SafeJsonStringify(Napi::Env env, Napi::Value value);
+  static void DestroyAggregateData(sqlite3_context *ctx);
 
   AggregateData *GetAggregate(sqlite3_context *ctx);
   Napi::Value SqliteValueToJS(sqlite3_value *value);
   void JSValueToSqliteResult(sqlite3_context *ctx, Napi::Value value);
   Napi::Value GetStartValue();
 
-  // New methods for raw C++ value handling
-  void StoreJSValueAsRaw(AggregateData *agg, Napi::Value value);
-  Napi::Value RawValueToJS(AggregateData *agg);
-
   Napi::Env env_;
-  DatabaseSync *db_;
   bool use_bigint_args_;
 
-  // Storage for start value - handle primitives differently
+  // Storage for start value - handle primitives and objects
   enum StartValueType {
     PRIMITIVE_NULL,
     PRIMITIVE_UNDEFINED,
@@ -93,7 +104,8 @@ private:
     PRIMITIVE_STRING,
     PRIMITIVE_BOOLEAN,
     PRIMITIVE_BIGINT,
-    OBJECT
+    OBJECT,
+    FUNCTION
   };
   StartValueType start_type_;
   double number_value_;
@@ -101,13 +113,16 @@ private:
   bool boolean_value_;
   int64_t bigint_value_;
   Napi::Reference<Napi::Value> object_ref_;
+  Napi::Reference<Napi::Function> start_fn_;
 
+  // Function references
   Napi::Reference<Napi::Function> step_fn_;
   Napi::Reference<Napi::Function> inverse_fn_;
   Napi::Reference<Napi::Function> result_fn_;
 
-  // Async context for callbacks
+  // Async context for callbacks (created lazily)
   napi_async_context async_context_;
+  napi_async_context GetAsyncContext();
 };
 
 } // namespace sqlite

package/src/binding.cpp

@@ -1,20 +1,19 @@
-#include <memory>
 #include <mutex>
 #include <napi.h>
 #include <set>
 
 #include "sqlite_impl.h"
 
-namespace photostructure {
-namespace sqlite {
+namespace photostructure::sqlite {
 
 // Cleanup function for worker termination
-void CleanupAddonData(napi_env env, void *finalize_data, void *finalize_hint) {
-  AddonData *addon_data = static_cast<AddonData *>(finalize_data);
+void CleanupAddonData([[maybe_unused]] napi_env env, void *finalize_data,
+                      [[maybe_unused]] void *finalize_hint) {
+  auto *addon_data = static_cast<AddonData *>(finalize_data);
 
   // Clean up any remaining database connections
   {
-    std::lock_guard<std::mutex> lock(addon_data->mutex);
+    const std::lock_guard<std::mutex> mutex_lock(addon_data->mutex);
     addon_data->databases.clear();
   }
 
@@ -38,7 +37,7 @@ void CleanupAddonData(napi_env env, void *finalize_data, void *finalize_hint) {
 // Helper to get addon data for current environment
 AddonData *GetAddonData(napi_env env) {
   void *data = nullptr;
-  napi_status status = napi_get_instance_data(env, &data);
+  const napi_status status = napi_get_instance_data(env, &data);
   if (status != napi_ok || data == nullptr) {
     return nullptr;
   }
@@ -48,8 +47,8 @@ AddonData *GetAddonData(napi_env env) {
 // Register a database instance for cleanup tracking
 void RegisterDatabaseInstance(Napi::Env env, DatabaseSync *database) {
   AddonData *addon_data = GetAddonData(env);
-  if (addon_data) {
-    std::lock_guard<std::mutex> lock(addon_data->mutex);
+  if (addon_data != nullptr) {
+    const std::lock_guard<std::mutex> mutex_lock(addon_data->mutex);
     addon_data->databases.insert(database);
   }
 }
@@ -57,8 +56,8 @@ void RegisterDatabaseInstance(Napi::Env env, DatabaseSync *database) {
 // Unregister a database instance
 void UnregisterDatabaseInstance(Napi::Env env, DatabaseSync *database) {
   AddonData *addon_data = GetAddonData(env);
-  if (addon_data) {
-    std::lock_guard<std::mutex> lock(addon_data->mutex);
+  if (addon_data != nullptr) {
+    const std::lock_guard<std::mutex> mutex_lock(addon_data->mutex);
     addon_data->databases.erase(database);
   }
 }
@@ -141,15 +140,119 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   constants.Set("SQLITE_CHANGESET_FOREIGN_KEY",
                 Napi::Number::New(env, SQLITE_CHANGESET_FOREIGN_KEY));
 
+  // Authorization result codes
+  constants.Set("SQLITE_OK", Napi::Number::New(env, SQLITE_OK));
+  constants.Set("SQLITE_DENY", Napi::Number::New(env, SQLITE_DENY));
+  constants.Set("SQLITE_IGNORE", Napi::Number::New(env, SQLITE_IGNORE));
+
+  // Authorization action codes
+  constants.Set("SQLITE_CREATE_INDEX",
+                Napi::Number::New(env, SQLITE_CREATE_INDEX));
+  constants.Set("SQLITE_CREATE_TABLE",
+                Napi::Number::New(env, SQLITE_CREATE_TABLE));
+  constants.Set("SQLITE_CREATE_TEMP_INDEX",
+                Napi::Number::New(env, SQLITE_CREATE_TEMP_INDEX));
+  constants.Set("SQLITE_CREATE_TEMP_TABLE",
+                Napi::Number::New(env, SQLITE_CREATE_TEMP_TABLE));
+  constants.Set("SQLITE_CREATE_TEMP_TRIGGER",
+                Napi::Number::New(env, SQLITE_CREATE_TEMP_TRIGGER));
+  constants.Set("SQLITE_CREATE_TEMP_VIEW",
+                Napi::Number::New(env, SQLITE_CREATE_TEMP_VIEW));
+  constants.Set("SQLITE_CREATE_TRIGGER",
+                Napi::Number::New(env, SQLITE_CREATE_TRIGGER));
+  constants.Set("SQLITE_CREATE_VIEW",
+                Napi::Number::New(env, SQLITE_CREATE_VIEW));
+  constants.Set("SQLITE_DELETE", Napi::Number::New(env, SQLITE_DELETE));
+  constants.Set("SQLITE_DROP_INDEX", Napi::Number::New(env, SQLITE_DROP_INDEX));
+  constants.Set("SQLITE_DROP_TABLE", Napi::Number::New(env, SQLITE_DROP_TABLE));
+  constants.Set("SQLITE_DROP_TEMP_INDEX",
+                Napi::Number::New(env, SQLITE_DROP_TEMP_INDEX));
+  constants.Set("SQLITE_DROP_TEMP_TABLE",
+                Napi::Number::New(env, SQLITE_DROP_TEMP_TABLE));
+  constants.Set("SQLITE_DROP_TEMP_TRIGGER",
+                Napi::Number::New(env, SQLITE_DROP_TEMP_TRIGGER));
+  constants.Set("SQLITE_DROP_TEMP_VIEW",
+                Napi::Number::New(env, SQLITE_DROP_TEMP_VIEW));
+  constants.Set("SQLITE_DROP_TRIGGER",
+                Napi::Number::New(env, SQLITE_DROP_TRIGGER));
+  constants.Set("SQLITE_DROP_VIEW", Napi::Number::New(env, SQLITE_DROP_VIEW));
+  constants.Set("SQLITE_INSERT", Napi::Number::New(env, SQLITE_INSERT));
+  constants.Set("SQLITE_PRAGMA", Napi::Number::New(env, SQLITE_PRAGMA));
+  constants.Set("SQLITE_READ", Napi::Number::New(env, SQLITE_READ));
+  constants.Set("SQLITE_SELECT", Napi::Number::New(env, SQLITE_SELECT));
+  constants.Set("SQLITE_TRANSACTION",
+                Napi::Number::New(env, SQLITE_TRANSACTION));
+  constants.Set("SQLITE_UPDATE", Napi::Number::New(env, SQLITE_UPDATE));
+  constants.Set("SQLITE_ATTACH", Napi::Number::New(env, SQLITE_ATTACH));
+  constants.Set("SQLITE_DETACH", Napi::Number::New(env, SQLITE_DETACH));
+  constants.Set("SQLITE_ALTER_TABLE",
+                Napi::Number::New(env, SQLITE_ALTER_TABLE));
+  constants.Set("SQLITE_REINDEX", Napi::Number::New(env, SQLITE_REINDEX));
+  constants.Set("SQLITE_ANALYZE", Napi::Number::New(env, SQLITE_ANALYZE));
+  constants.Set("SQLITE_CREATE_VTABLE",
+                Napi::Number::New(env, SQLITE_CREATE_VTABLE));
+  constants.Set("SQLITE_DROP_VTABLE",
+                Napi::Number::New(env, SQLITE_DROP_VTABLE));
+  constants.Set("SQLITE_FUNCTION", Napi::Number::New(env, SQLITE_FUNCTION));
+  constants.Set("SQLITE_SAVEPOINT", Napi::Number::New(env, SQLITE_SAVEPOINT));
+  constants.Set("SQLITE_COPY", Napi::Number::New(env, SQLITE_COPY));
+  constants.Set("SQLITE_RECURSIVE", Napi::Number::New(env, SQLITE_RECURSIVE));
+
   exports.Set("constants", constants);
 
-  // TODO: Add backup function
+  // Add standalone backup() function (Node.js API compatibility)
+  // Signature: backup(sourceDb, destination, options?) -> Promise
+  Napi::Function backupFunc = Napi::Function::New(
+      env,
+      [](const Napi::CallbackInfo &info) -> Napi::Value {
+        Napi::Env env = info.Env();
+
+        // Validate and unwrap DatabaseSync instance
+        DatabaseSync *db = nullptr;
+        if (info.Length() >= 1 && info[0].IsObject()) {
+          try {
+            db = DatabaseSync::Unwrap(info[0].As<Napi::Object>());
+          } catch (...) {
+            // Fall through to error below
+          }
+        }
+        if (db == nullptr) {
+          Napi::TypeError::New(
+              env, "The \"sourceDb\" argument must be a DatabaseSync object")
+              .ThrowAsJavaScriptException();
+          return env.Undefined();
+        }
+
+        // Validate destination path is provided
+        if (info.Length() < 2) {
+          Napi::TypeError::New(env, "The \"destination\" argument is required")
+              .ThrowAsJavaScriptException();
+          return env.Undefined();
+        }
+
+        // Delegate to instance method: db.backup(destination, options?)
+        std::vector<napi_value> args;
+        for (size_t i = 1; i < info.Length(); i++) {
+          args.push_back(info[i]);
+        }
+        Napi::Function backupMethod =
+            db->Value().Get("backup").As<Napi::Function>();
+        return backupMethod.Call(db->Value(), args);
+      },
+      "backup");
+
+  // Set function name and length properties (Node.js compatibility)
+  backupFunc.DefineProperty(Napi::PropertyDescriptor::Value(
+      "name", Napi::String::New(env, "backup"), napi_enumerable));
+  backupFunc.DefineProperty(Napi::PropertyDescriptor::Value(
+      "length", Napi::Number::New(env, 2), napi_enumerable));
+
+  exports.Set("backup", backupFunc);
 
   return exports;
 }
 
-} // namespace sqlite
-} // namespace photostructure
+} // namespace photostructure::sqlite
 
 // Module initialization function
 Napi::Object InitSqlite(Napi::Env env, Napi::Object exports) {

package/src/dirname.ts

@@ -1,4 +1,4 @@
-import { getCallerDirname } from "./stack_path";
+import { getCallerDirname } from "./stack-path";
 
 // Thanks to tsup shims, __dirname should always be defined except when run by
 // jest (which will use the stack_path shim)