@photostructure/sqlite 0.0.1 → 0.2.0

package/src/shims/sqlite_errors.h

@@ -0,0 +1,162 @@
+#ifndef SRC_SHIMS_SQLITE_ERRORS_H_
+#define SRC_SHIMS_SQLITE_ERRORS_H_
+
+#include "../sqlite_exception.h"
+#include <napi.h>
+#include <sqlite3.h>
+#include <string>
+
+namespace node {
+
+// Helper function to get SQLite error code name
+inline const char *GetSqliteErrorCodeName(int code) {
+  switch (code) {
+  case SQLITE_OK:
+    return "SQLITE_OK";
+  case SQLITE_ERROR:
+    return "SQLITE_ERROR";
+  case SQLITE_INTERNAL:
+    return "SQLITE_INTERNAL";
+  case SQLITE_PERM:
+    return "SQLITE_PERM";
+  case SQLITE_ABORT:
+    return "SQLITE_ABORT";
+  case SQLITE_BUSY:
+    return "SQLITE_BUSY";
+  case SQLITE_LOCKED:
+    return "SQLITE_LOCKED";
+  case SQLITE_NOMEM:
+    return "SQLITE_NOMEM";
+  case SQLITE_READONLY:
+    return "SQLITE_READONLY";
+  case SQLITE_INTERRUPT:
+    return "SQLITE_INTERRUPT";
+  case SQLITE_IOERR:
+    return "SQLITE_IOERR";
+  case SQLITE_CORRUPT:
+    return "SQLITE_CORRUPT";
+  case SQLITE_NOTFOUND:
+    return "SQLITE_NOTFOUND";
+  case SQLITE_FULL:
+    return "SQLITE_FULL";
+  case SQLITE_CANTOPEN:
+    return "SQLITE_CANTOPEN";
+  case SQLITE_PROTOCOL:
+    return "SQLITE_PROTOCOL";
+  case SQLITE_EMPTY:
+    return "SQLITE_EMPTY";
+  case SQLITE_SCHEMA:
+    return "SQLITE_SCHEMA";
+  case SQLITE_TOOBIG:
+    return "SQLITE_TOOBIG";
+  case SQLITE_CONSTRAINT:
+    return "SQLITE_CONSTRAINT";
+  case SQLITE_MISMATCH:
+    return "SQLITE_MISMATCH";
+  case SQLITE_MISUSE:
+    return "SQLITE_MISUSE";
+  case SQLITE_NOLFS:
+    return "SQLITE_NOLFS";
+  case SQLITE_AUTH:
+    return "SQLITE_AUTH";
+  case SQLITE_FORMAT:
+    return "SQLITE_FORMAT";
+  case SQLITE_RANGE:
+    return "SQLITE_RANGE";
+  case SQLITE_NOTADB:
+    return "SQLITE_NOTADB";
+  case SQLITE_NOTICE:
+    return "SQLITE_NOTICE";
+  case SQLITE_WARNING:
+    return "SQLITE_WARNING";
+  case SQLITE_ROW:
+    return "SQLITE_ROW";
+  case SQLITE_DONE:
+    return "SQLITE_DONE";
+  default:
+    // For extended error codes, get the base error code
+    int baseCode = code & 0xFF;
+    return GetSqliteErrorCodeName(baseCode);
+  }
+}
+
+// Enhanced SQLite error that includes system errno information
+inline void ThrowEnhancedSqliteError(Napi::Env env, sqlite3 *db,
+                                     int sqlite_code,
+                                     const std::string &message) {
+  Napi::Error error = Napi::Error::New(env, message);
+
+  // Add SQLite error code information
+  error.Set("sqliteCode", Napi::Number::New(env, sqlite_code));
+
+  if (db) {
+    // Get extended error code (more specific than basic error code)
+    int extended_code = sqlite3_extended_errcode(db);
+    error.Set("sqliteExtendedCode", Napi::Number::New(env, extended_code));
+
+    // Get system errno if available (for I/O errors)
+    int sys_errno = sqlite3_system_errno(db);
+    if (sys_errno != 0) {
+      error.Set("systemErrno", Napi::Number::New(env, sys_errno));
+    }
+  }
+
+  // Set a standard error code property for compatibility
+  const char *code_name = GetSqliteErrorCodeName(sqlite_code);
+  error.Set("code", 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));
+  }
+
+  error.ThrowAsJavaScriptException();
+}
+
+// Database-aware version available when sqlite_impl.h is included
+// This will be specialized in sqlite_impl.cpp to avoid forward declaration
+// issues
+
+// Helper to create enhanced error from just a message (when we have the db
+// handle)
+inline void ThrowSqliteError(Napi::Env env, sqlite3 *db,
+                             const std::string &message) {
+  if (db) {
+    int errcode = sqlite3_errcode(db);
+    ThrowEnhancedSqliteError(env, db, errcode, message);
+  } else {
+    // Fallback to simple error when no db handle available
+    Napi::Error::New(env, message).ThrowAsJavaScriptException();
+  }
+}
+
+// Helper to throw from a SqliteException with captured error info
+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
+  error.Set("sqliteCode", Napi::Number::New(env, ex.sqlite_code()));
+  error.Set("sqliteExtendedCode", Napi::Number::New(env, ex.extended_code()));
+
+  if (ex.system_errno() != 0) {
+    error.Set("systemErrno", Napi::Number::New(env, ex.system_errno()));
+  }
+
+  // Set the error code name
+  const char *code_name = GetSqliteErrorCodeName(ex.sqlite_code());
+  error.Set("code", Napi::String::New(env, code_name));
+
+  // Also set the human-readable error string
+  if (!ex.error_string().empty()) {
+    error.Set("sqliteErrorString", Napi::String::New(env, ex.error_string()));
+  }
+
+  error.ThrowAsJavaScriptException();
+}
+
+} // namespace node
+
+#endif // SRC_SHIMS_SQLITE_ERRORS_H_

package/src/shims/util.h

@@ -10,16 +10,41 @@
 namespace node {
 
 // Environment class for Node.js context
+// Note: This class is a shim for upstream Node.js code compatibility.
+// It's not actively used in our implementation but provides the interface.
 class Environment {
+private:
+  using InstanceMap =
+      std::unordered_map<napi_env, std::unique_ptr<Environment>>;
+
+  // Thread-local storage accessor - the thread_local is on the variable, not
+  // the return type
+  static InstanceMap &GetInstances() {
+    static thread_local InstanceMap instances;
+    return instances;
+  }
+
+  // Cleanup hook called when napi_env is destroyed
+  static void CleanupHook(void *arg) {
+    napi_env env = static_cast<napi_env>(arg);
+    InstanceMap &instances = GetInstances();
+    auto it = instances.find(env);
+    if (it != instances.end()) {
+      instances.erase(it);
+    }
+  }
+
 public:
   static Environment *GetCurrent(Napi::Env env) {
-    // Store per-environment instances
-    static thread_local std::unordered_map<napi_env,
-                                           std::unique_ptr<Environment>>
-        instances;
+    InstanceMap &instances = GetInstances();
     auto it = instances.find(env);
     if (it == instances.end()) {
       auto result = instances.emplace(env, std::make_unique<Environment>(env));
+
+      // Register cleanup hook to remove this entry when env is destroyed
+      // This prevents memory leaks when worker threads terminate
+      napi_add_env_cleanup_hook(env, CleanupHook, static_cast<void *>(env));
+
       return result.first->second.get();
     }
     return it->second.get();

package/src/sql-tag-store.ts

@@ -0,0 +1,140 @@
+import { LRUCache } from "./lru-cache";
+import { DatabaseSyncInstance } from "./types/database-sync-instance";
+import type { StatementSyncInstance } from "./types/statement-sync-instance";
+
+/**
+ * Default capacity for the statement cache.
+ * Matches Node.js SQLTagStore default.
+ */
+const DEFAULT_CAPACITY = 1000;
+
+/**
+ * SQLTagStore provides cached prepared statements via tagged template syntax.
+ *
+ * @example
+ * ```js
+ * const sql = db.createTagStore();
+ * sql.run`INSERT INTO users VALUES (${id}, ${name})`;
+ * const user = sql.get`SELECT * FROM users WHERE id = ${id}`;
+ * ```
+ */
+export class SQLTagStore {
+  private readonly database: DatabaseSyncInstance;
+  private readonly cache: LRUCache<string, StatementSyncInstance>;
+  private readonly maxCapacity: number;
+
+  constructor(db: DatabaseSyncInstance, capacity: number = DEFAULT_CAPACITY) {
+    if (!db.isOpen) {
+      throw new Error("Database is not open");
+    }
+    this.database = db;
+    this.maxCapacity = capacity;
+    this.cache = new LRUCache(capacity);
+  }
+
+  /**
+   * Returns the associated database instance.
+   */
+  get db(): DatabaseSyncInstance {
+    return this.database;
+  }
+
+  /**
+   * Returns the maximum capacity of the statement cache.
+   */
+  get capacity(): number {
+    return this.maxCapacity;
+  }
+
+  /**
+   * Returns the current number of cached statements.
+   */
+  size(): number {
+    return this.cache.size();
+  }
+
+  /**
+   * Clears all cached statements.
+   */
+  clear(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Execute an INSERT, UPDATE, DELETE or other statement that doesn't return rows.
+   * Returns an object with `changes` and `lastInsertRowid`.
+   */
+  run(
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+  ): { changes: number; lastInsertRowid: number | bigint } {
+    const stmt = this.getOrPrepare(strings);
+    return stmt.run(...values);
+  }
+
+  /**
+   * Execute a query and return the first row, or undefined if no rows.
+   */
+  get(strings: TemplateStringsArray, ...values: unknown[]): unknown {
+    const stmt = this.getOrPrepare(strings);
+    return stmt.get(...values);
+  }
+
+  /**
+   * Execute a query and return all rows as an array.
+   */
+  all(strings: TemplateStringsArray, ...values: unknown[]): unknown[] {
+    const stmt = this.getOrPrepare(strings);
+    return stmt.all(...values);
+  }
+
+  /**
+   * Execute a query and return an iterator over the rows.
+   */
+  iterate(
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+  ): IterableIterator<unknown> {
+    const stmt = this.getOrPrepare(strings);
+    return stmt.iterate(...values);
+  }
+
+  /**
+   * 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");
+    }
+
+    const sql = this.buildSQL(strings);
+
+    // Check cache - evict if finalized
+    const cached = this.cache.get(sql);
+    if (cached) {
+      if (!cached.finalized) {
+        return cached;
+      }
+      // Statement was finalized externally - remove from cache
+      this.cache.delete(sql);
+    }
+
+    // Prepare new statement and cache it
+    const stmt = this.database.prepare(sql);
+    this.cache.set(sql, stmt);
+    return stmt;
+  }
+
+  /**
+   * Build the SQL string by joining template parts with `?` placeholders.
+   */
+  private buildSQL(strings: TemplateStringsArray): string {
+    let sql = strings[0] ?? "";
+    for (let i = 1; i < strings.length; i++) {
+      // eslint-disable-next-line security/detect-object-injection -- Index is from controlled for-loop
+      sql += "?" + (strings[i] ?? "");
+    }
+    return sql;
+  }
+}

package/src/sqlite_exception.h

@@ -0,0 +1,49 @@
+#ifndef SRC_SQLITE_EXCEPTION_H_
+#define SRC_SQLITE_EXCEPTION_H_
+
+#include <exception>
+#include <sqlite3.h>
+#include <string>
+
+namespace photostructure {
+namespace sqlite {
+
+// Custom exception that captures SQLite error information at the point of error
+class SqliteException : public std::exception {
+public:
+  SqliteException(sqlite3 *db, int result_code, const std::string &message)
+      : message_(message), sqlite_code_(result_code), extended_code_(0),
+        system_errno_(0) {
+
+    if (db) {
+      // Capture error codes immediately while they're still valid
+      extended_code_ = sqlite3_extended_errcode(db);
+      system_errno_ = sqlite3_system_errno(db);
+    }
+
+    // Get the error string for the code
+    const char *err_str = sqlite3_errstr(result_code);
+    if (err_str) {
+      error_string_ = err_str;
+    }
+  }
+
+  const char *what() const noexcept override { return message_.c_str(); }
+
+  int sqlite_code() const { return sqlite_code_; }
+  int extended_code() const { return extended_code_; }
+  int system_errno() const { return system_errno_; }
+  const std::string &error_string() const { return error_string_; }
+
+private:
+  std::string message_;
+  std::string error_string_;
+  int sqlite_code_;
+  int extended_code_;
+  int system_errno_;
+};
+
+} // namespace sqlite
+} // namespace photostructure
+
+#endif // SRC_SQLITE_EXCEPTION_H_