@photostructure/sqlite 0.0.1 → 0.2.1

package/src/upstream/sqlite3ext.h

@@ -368,6 +368,10 @@ struct sqlite3_api_routines {
   int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
   /* Version 3.50.0 and later */
   int (*setlk_timeout)(sqlite3*,int,int);
+  /* Version 3.51.0 and later */
+  int (*set_errmsg)(sqlite3*,int,const char*);
+  int (*db_status64)(sqlite3*,int,sqlite3_int64*,sqlite3_int64*,int);
+  
 };
 
 /*
@@ -703,6 +707,9 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_set_clientdata         sqlite3_api->set_clientdata
 /* Version 3.50.0 and later */
 #define sqlite3_setlk_timeout          sqlite3_api->setlk_timeout
+/* Version 3.51.0 and later */
+#define sqlite3_set_errmsg             sqlite3_api->set_errmsg
+#define sqlite3_db_status64            sqlite3_api->db_status64
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
 
 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)

package/src/user_function.cpp

@@ -2,25 +2,49 @@
 
 #include <climits>
 #include <cmath>
+#include <limits>
 #include <stdexcept>
 
 #include "sqlite_impl.h"
 
-namespace photostructure {
-namespace sqlite {
+namespace photostructure::sqlite {
 
 UserDefinedFunction::UserDefinedFunction(Napi::Env env, Napi::Function fn,
                                          DatabaseSync *db, bool use_bigint_args)
     : env_(env), fn_(Napi::Reference<Napi::Function>::New(fn, 1)), db_(db),
-      use_bigint_args_(use_bigint_args) {
-  // No need for SuppressDestruct when using reference count
+      use_bigint_args_(use_bigint_args), async_context_(nullptr) {
+  // Create async context for callbacks
+  const napi_status status = napi_async_init(
+      env, nullptr, Napi::String::New(env, "SQLiteUserFunction"),
+      &async_context_);
+  if (status != napi_ok) {
+    Napi::Error::New(env, "Failed to create async context")
+        .ThrowAsJavaScriptException();
+  }
 }
 
-UserDefinedFunction::~UserDefinedFunction() {
-  // Clean up the persistent function reference
-  if (!fn_.IsEmpty()) {
-    fn_.Reset();
+UserDefinedFunction::~UserDefinedFunction() noexcept {
+  // Check if environment is still valid before N-API operations.
+  // During shutdown, env_ may be torn down and N-API operations would crash.
+  // Try to create a handle scope - if this fails, env is invalid.
+  napi_handle_scope scope;
+  napi_status status = napi_open_handle_scope(env_, &scope);
+
+  if (status == napi_ok) {
+    // Safe to do N-API operations
+    if (!fn_.IsEmpty()) {
+      fn_.Reset();
+    }
+
+    if (async_context_ != nullptr) {
+      napi_async_destroy(env_, async_context_);
+      async_context_ = nullptr;
+    }
+
+    napi_close_handle_scope(env_, scope);
   }
+  // If status != napi_ok, env is invalid - skip cleanup.
+  // References will be leaked, but that's better than crashing.
 }
 
 void UserDefinedFunction::xFunc(sqlite3_context *ctx, int argc,
@@ -35,6 +59,7 @@ void UserDefinedFunction::xFunc(sqlite3_context *ctx, int argc,
 
   try {
     Napi::HandleScope scope(self->env_);
+    Napi::CallbackScope callback_scope(self->env_, self->async_context_);
 
     // Check if function reference is still valid
     if (self->fn_.IsEmpty()) {
@@ -68,34 +93,33 @@ void UserDefinedFunction::xFunc(sqlite3_context *ctx, int argc,
       js_args.push_back(js_val);
     }
 
-    // Call the JavaScript function
-    Napi::Value result = fn.Call(js_args);
+    // Call the JavaScript function with safer exception handling
+    napi_value js_result;
+    napi_value js_func = fn;
+    napi_value this_arg = self->env_.Undefined();
 
-    // Check if there's a pending exception after the call
-    if (self->env_.IsExceptionPending()) {
-      Napi::Error error = self->env_.GetAndClearPendingException();
-      std::string error_msg = error.Message();
-      try {
-        sqlite3_result_error(ctx, error_msg.c_str(),
-                             SafeCastToInt(error_msg.length()));
-      } catch (const std::overflow_error &) {
-        sqlite3_result_error(ctx, "Error message too long", -1);
+    napi_status status =
+        napi_call_function(self->env_, this_arg, js_func, js_args.size(),
+                           js_args.data(), &js_result);
+
+    if (status != napi_ok || self->env_.IsExceptionPending()) {
+      // Handle JavaScript exception by setting a generic SQLite error
+      if (self->env_.IsExceptionPending()) {
+        sqlite3_result_error(ctx, "JavaScript exception in user function", -1);
+      } else {
+        sqlite3_result_error(ctx, "Failed to call user function", -1);
       }
       return;
     }
 
+    Napi::Value result(self->env_, js_result);
+
     // Convert result back to SQLite
     self->JSValueToSqliteResult(ctx, result);
 
   } catch (const Napi::Error &e) {
-    // Handle JavaScript exceptions
-    std::string error_msg = e.Message();
-    try {
-      sqlite3_result_error(ctx, error_msg.c_str(),
-                           SafeCastToInt(error_msg.length()));
-    } catch (const std::overflow_error &) {
-      sqlite3_result_error(ctx, "Error message too long", -1);
-    }
+    // Handle JavaScript errors by setting a generic SQLite error
+    sqlite3_result_error(ctx, "JavaScript exception in user function", -1);
   } catch (const std::exception &e) {
     sqlite3_result_error(ctx, e.what(), -1);
   } catch (...) {
@@ -138,15 +162,20 @@ Napi::Value UserDefinedFunction::SqliteValueToJS(sqlite3_value *value) {
   }
 
   case SQLITE_TEXT: {
-    const unsigned char *text = sqlite3_value_text(value);
-    return Napi::String::New(env_, reinterpret_cast<const char *>(text));
+    const char *text =
+        reinterpret_cast<const char *>(sqlite3_value_text(value));
+    return Napi::String::New(env_, text ? text : "");
   }
 
   case SQLITE_BLOB: {
-    const void *blob_data = sqlite3_value_blob(value);
-    int blob_size = sqlite3_value_bytes(value);
-    return Napi::Buffer<uint8_t>::Copy(
-        env_, static_cast<const uint8_t *>(blob_data), blob_size);
+    const void *blob = sqlite3_value_blob(value);
+    int bytes = sqlite3_value_bytes(value);
+    if (blob && bytes > 0) {
+      return Napi::Buffer<uint8_t>::Copy(
+          env_, static_cast<const uint8_t *>(blob), static_cast<size_t>(bytes));
+    } else {
+      return Napi::Buffer<uint8_t>::New(env_, 0);
+    }
   }
 
   case SQLITE_NULL:
@@ -186,7 +215,8 @@ void UserDefinedFunction::JSValueToSqliteResult(sqlite3_context *ctx,
     // Check if it's an integer value
     // Note: We cast INT64_MIN/MAX to double to avoid implicit conversion
     // warnings
-    if (std::floor(num_val) == num_val &&
+    if (std::abs(num_val - std::floor(num_val)) <
+            std::numeric_limits<double>::epsilon() &&
         num_val >= static_cast<double>(INT64_MIN) &&
         num_val <= static_cast<double>(INT64_MAX)) {
       sqlite3_result_int64(ctx, static_cast<sqlite3_int64>(num_val));
@@ -201,7 +231,30 @@ void UserDefinedFunction::JSValueToSqliteResult(sqlite3_context *ctx,
     } catch (const std::overflow_error &) {
       sqlite3_result_error(ctx, "String value too long", -1);
     }
+  } else if (value.IsDataView()) {
+    // IMPORTANT: Check DataView BEFORE IsBuffer() because N-API's IsBuffer()
+    // returns true for ALL ArrayBufferViews (including DataView), but
+    // Buffer::As() doesn't work correctly for DataView (returns length=0).
+    // See: https://github.com/nodejs/node/pull/56227
+    Napi::DataView dataView = value.As<Napi::DataView>();
+    Napi::ArrayBuffer arrayBuffer = dataView.ArrayBuffer();
+    size_t byteOffset = dataView.ByteOffset();
+    size_t byteLength = dataView.ByteLength();
+
+    if (arrayBuffer.Data() != nullptr && byteLength > 0) {
+      const uint8_t *data =
+          static_cast<const uint8_t *>(arrayBuffer.Data()) + byteOffset;
+      try {
+        sqlite3_result_blob(ctx, data, SafeCastToInt(byteLength),
+                            SQLITE_TRANSIENT);
+      } catch (const std::overflow_error &) {
+        sqlite3_result_error(ctx, "DataView too large", -1);
+      }
+    } else {
+      sqlite3_result_zeroblob(ctx, 0);
+    }
   } else if (value.IsBuffer()) {
+    // Handles both Node.js Buffer and TypedArrays (Uint8Array, etc.)
     Napi::Buffer<uint8_t> buffer = value.As<Napi::Buffer<uint8_t>>();
     try {
       sqlite3_result_blob(ctx, buffer.Data(), SafeCastToInt(buffer.Length()),
@@ -221,5 +274,4 @@ void UserDefinedFunction::JSValueToSqliteResult(sqlite3_context *ctx,
   }
 }
 
-} // namespace sqlite
-} // namespace photostructure
+} // namespace photostructure::sqlite

package/src/user_function.h

@@ -17,7 +17,7 @@ class UserDefinedFunction {
 public:
   UserDefinedFunction(Napi::Env env, Napi::Function fn, DatabaseSync *db,
                       bool use_bigint_args);
-  ~UserDefinedFunction();
+  ~UserDefinedFunction() noexcept;
 
   // SQLite callback functions
   static void xFunc(sqlite3_context *ctx, int argc, sqlite3_value **argv);
@@ -28,6 +28,7 @@ private:
   Napi::FunctionReference fn_;
   DatabaseSync *db_;
   bool use_bigint_args_;
+  napi_async_context async_context_;
 
   // Helper methods
   Napi::Value SqliteValueToJS(sqlite3_value *value);