@photostructure/sqlite 0.3.0 → 0.5.0

package/src/shims/node_errors.h

@@ -11,25 +11,33 @@ namespace node {
 inline void THROW_ERR_INVALID_STATE(Napi::Env env,
                                     const char *message = nullptr) {
   const char *msg = message ? message : "Invalid state";
-  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+  Napi::Error error = Napi::Error::New(env, msg);
+  error.Set("code", Napi::String::New(env, "ERR_INVALID_STATE"));
+  error.ThrowAsJavaScriptException();
 }
 
 inline void THROW_ERR_INVALID_ARG_TYPE(Napi::Env env,
                                        const char *message = nullptr) {
   const char *msg = message ? message : "Invalid argument type";
-  Napi::TypeError::New(env, msg).ThrowAsJavaScriptException();
+  Napi::TypeError error = Napi::TypeError::New(env, msg);
+  error.Set("code", Napi::String::New(env, "ERR_INVALID_ARG_TYPE"));
+  error.ThrowAsJavaScriptException();
 }
 
 inline void THROW_ERR_OUT_OF_RANGE(Napi::Env env,
                                    const char *message = nullptr) {
   const char *msg = message ? message : "Value out of range";
-  Napi::RangeError::New(env, msg).ThrowAsJavaScriptException();
+  Napi::RangeError error = Napi::RangeError::New(env, msg);
+  error.Set("code", Napi::String::New(env, "ERR_OUT_OF_RANGE"));
+  error.ThrowAsJavaScriptException();
 }
 
 inline void THROW_ERR_INVALID_ARG_VALUE(Napi::Env env,
                                         const char *message = nullptr) {
   const char *msg = message ? message : "Invalid argument value";
-  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+  Napi::Error error = Napi::Error::New(env, msg);
+  error.Set("code", Napi::String::New(env, "ERR_INVALID_ARG_VALUE"));
+  error.ThrowAsJavaScriptException();
 }
 
 inline void THROW_ERR_SQLITE_ERROR(Napi::Env env,
@@ -37,7 +45,9 @@ inline void THROW_ERR_SQLITE_ERROR(Napi::Env env,
   // Check for both null and empty string - on Windows (MSVC),
   // std::exception::what() can sometimes return an empty string
   const char *msg = (message && message[0] != '\0') ? message : "SQLite error";
-  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+  Napi::Error error = Napi::Error::New(env, msg);
+  error.Set("code", Napi::String::New(env, "ERR_SQLITE_ERROR"));
+  error.ThrowAsJavaScriptException();
 }
 
 // Database-aware version available when sqlite_impl.h is included
@@ -45,24 +55,33 @@ inline void THROW_ERR_SQLITE_ERROR(Napi::Env env,
 // issues
 
 inline void THROW_ERR_CONSTRUCT_CALL_REQUIRED(Napi::Env env) {
-  Napi::TypeError::New(env, "Class constructor cannot be invoked without 'new'")
-      .ThrowAsJavaScriptException();
+  Napi::TypeError error = Napi::TypeError::New(
+      env, "Class constructor cannot be invoked without 'new'");
+  error.Set("code", Napi::String::New(env, "ERR_CONSTRUCT_CALL_REQUIRED"));
+  error.ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_ILLEGAL_CONSTRUCTOR(Napi::Env env) {
+  Napi::TypeError error = Napi::TypeError::New(env, "Illegal constructor");
+  error.Set("code", Napi::String::New(env, "ERR_ILLEGAL_CONSTRUCTOR"));
+  error.ThrowAsJavaScriptException();
 }
 
 inline void THROW_ERR_INVALID_URL_SCHEME(Napi::Env env,
-                                         const char *scheme = nullptr) {
-  std::string msg = "Invalid URL scheme";
-  if (scheme) {
-    msg += ": ";
-    msg += scheme;
-  }
-  Napi::TypeError::New(env, msg).ThrowAsJavaScriptException();
+                                         const char * /*scheme*/ = nullptr) {
+  // Message must match Node.js exactly
+  Napi::TypeError error =
+      Napi::TypeError::New(env, "The URL must be of scheme file:");
+  error.Set("code", Napi::String::New(env, "ERR_INVALID_URL_SCHEME"));
+  error.ThrowAsJavaScriptException();
 }
 
 inline void THROW_ERR_LOAD_SQLITE_EXTENSION(Napi::Env env,
                                             const char *message = nullptr) {
   const char *msg = message ? message : "Failed to load SQLite extension";
-  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+  Napi::Error error = Napi::Error::New(env, msg);
+  error.Set("code", Napi::String::New(env, "ERR_LOAD_SQLITE_EXTENSION"));
+  error.ThrowAsJavaScriptException();
 }
 
 // Macro wrappers for compatibility (removed to avoid conflicts)

package/src/shims/sqlite_errors.h

@@ -81,6 +81,14 @@ inline const char *GetSqliteErrorCodeName(int code) {
 }
 
 // Enhanced SQLite error that includes system errno information
+// Error format matches Node.js node:sqlite for API compatibility:
+// - code: 'ERR_SQLITE_ERROR' (constant, matches Node.js)
+// - errcode: number (SQLite error code, matches Node.js)
+// - errstr: string (SQLite error string, matches Node.js)
+// We also add extra properties for enhanced debugging:
+// - sqliteCode: number (same as errcode, for backward compat)
+// - sqliteExtendedCode: number (extended SQLite error code)
+// - sqliteErrorString: string (same as errstr, for backward compat)
 inline void ThrowEnhancedSqliteError(Napi::Env env, sqlite3 *db,
                                      int sqlite_code,
                                      const std::string &message) {
@@ -89,7 +97,16 @@ inline void ThrowEnhancedSqliteError(Napi::Env env, sqlite3 *db,
   // truncated or corrupted error messages
   Napi::Error error = Napi::Error::New(env, message.c_str());
 
-  // Add SQLite error code information
+  // Node.js compatible properties
+  error.Set("code", Napi::String::New(env, "ERR_SQLITE_ERROR"));
+  error.Set("errcode", Napi::Number::New(env, sqlite_code));
+
+  const char *err_str = sqlite3_errstr(sqlite_code);
+  if (err_str) {
+    error.Set("errstr", Napi::String::New(env, err_str));
+  }
+
+  // Our enhanced properties (for backward compatibility and debugging)
   error.Set("sqliteCode", Napi::Number::New(env, sqlite_code));
 
   if (db) {
@@ -104,12 +121,11 @@ inline void ThrowEnhancedSqliteError(Napi::Env env, sqlite3 *db,
     }
   }
 
-  // Set a standard error code property for compatibility
+  // Keep original code name as sqliteCodeName for debugging
   const char *code_name = GetSqliteErrorCodeName(sqlite_code);
-  error.Set("code", Napi::String::New(env, code_name));
+  error.Set("sqliteCodeName", Napi::String::New(env, code_name));
 
   // Also set the human-readable error string
-  const char *err_str = sqlite3_errstr(sqlite_code);
   if (err_str) {
     error.Set("sqliteErrorString", Napi::String::New(env, err_str));
   }
@@ -126,7 +142,9 @@ inline void ThrowEnhancedSqliteError(Napi::Env env, sqlite3 *db,
 inline void ThrowSqliteError(Napi::Env env, sqlite3 *db,
                              const std::string &message) {
   if (db) {
-    int errcode = sqlite3_errcode(db);
+    // Use extended error code (e.g., 1555 for SQLITE_CONSTRAINT_PRIMARYKEY)
+    // instead of basic code (e.g., 19 for SQLITE_CONSTRAINT) to match Node.js
+    int errcode = sqlite3_extended_errcode(db);
     ThrowEnhancedSqliteError(env, db, errcode, message);
   } else {
     // Fallback to simple error when no db handle available
@@ -136,12 +154,20 @@ inline void ThrowSqliteError(Napi::Env env, sqlite3 *db,
 }
 
 // Helper to throw from a SqliteException with captured error info
+// Uses same format as ThrowEnhancedSqliteError for consistency
 inline void
 ThrowFromSqliteException(Napi::Env env,
                          const photostructure::sqlite::SqliteException &ex) {
   Napi::Error error = Napi::Error::New(env, ex.what());
 
-  // Add all captured error information
+  // Node.js compatible properties
+  error.Set("code", Napi::String::New(env, "ERR_SQLITE_ERROR"));
+  error.Set("errcode", Napi::Number::New(env, ex.sqlite_code()));
+  if (!ex.error_string().empty()) {
+    error.Set("errstr", Napi::String::New(env, ex.error_string().c_str()));
+  }
+
+  // Our enhanced properties (for backward compatibility and debugging)
   error.Set("sqliteCode", Napi::Number::New(env, ex.sqlite_code()));
   error.Set("sqliteExtendedCode", Napi::Number::New(env, ex.extended_code()));
 
@@ -149,9 +175,9 @@ ThrowFromSqliteException(Napi::Env env,
     error.Set("systemErrno", Napi::Number::New(env, ex.system_errno()));
   }
 
-  // Set the error code name
+  // Keep original code name as sqliteCodeName for debugging
   const char *code_name = GetSqliteErrorCodeName(ex.sqlite_code());
-  error.Set("code", Napi::String::New(env, code_name));
+  error.Set("sqliteCodeName", Napi::String::New(env, code_name));
 
   // Also set the human-readable error string
   // Use c_str() explicitly to avoid potential ABI issues on Windows ARM

package/src/sql-tag-store.ts

@@ -25,7 +25,9 @@ export class SQLTagStore {
 
   constructor(db: DatabaseSyncInstance, capacity: number = DEFAULT_CAPACITY) {
     if (!db.isOpen) {
-      throw new Error("Database is not open");
+      const err = new Error("database is not open");
+      (err as NodeJS.ErrnoException).code = "ERR_INVALID_STATE";
+      throw err;
     }
     this.database = db;
     this.maxCapacity = capacity;
@@ -101,23 +103,18 @@ export class SQLTagStore {
 
   /**
    * Get a cached statement or prepare a new one.
-   * If a cached statement has been finalized, it's evicted and a new one is prepared.
    */
   private getOrPrepare(strings: TemplateStringsArray): StatementSyncInstance {
     if (!this.database.isOpen) {
-      throw new Error("Database is not open");
+      throw new Error("database is not open");
     }
 
     const sql = this.buildSQL(strings);
 
-    // Check cache - evict if finalized
+    // Check cache
     const cached = this.cache.get(sql);
     if (cached) {
-      if (!cached.finalized) {
-        return cached;
-      }
-      // Statement was finalized externally - remove from cache
-      this.cache.delete(sql);
+      return cached;
     }
 
     // Prepare new statement and cache it