react-native-nitro-sqlite 9.1.11 → 9.2.1

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Tue Oct 07 18:18:23 WEST 2025
+gradle.version=8.9

package/android/CMakeLists.txt

@@ -66,7 +66,6 @@ endif()
 target_compile_options(
   ${CMAKE_PROJECT_NAME}
   PRIVATE
-  -DLOG_TAG=\"ReactNative\"
   -fexceptions
   -frtti
   -fstack-protector-all

package/android/build.gradle

@@ -140,8 +140,8 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
   }
 
   sourceSets {

package/cpp/NitroSQLiteException.hpp

@@ -1,8 +1,12 @@
 #pragma once
 
-#include <string>
-#include <iostream>
 #include <exception>
+#include <iostream>
+#include <string>
+#include <optional>
+
+const std::string NITRO_SQLITE_EXCEPTION_PREFIX = "[NativeNitroSQLiteException]";
+
 
 enum NitroSQLiteExceptionType {
   UnknownError,
@@ -15,14 +19,13 @@ enum NitroSQLiteExceptionType {
 };
 
 inline std::unordered_map<NitroSQLiteExceptionType, std::string> exceptionTypeStrings = {
-  {UnknownError, "UnknownError"},
-  {DatabaseCannotBeOpened, "DatabaseCannotBeOpened"},
-  {DatabaseNotOpen, "DatabaseNotOpen"},
-  {UnableToAttachToDatabase, "UnableToAttachToDatabase"},
-  {SqlExecutionError, "SqlExecutionError"},
-  {CouldNotLoadFile, "CouldNotLoadFile"},
-  {NoBatchCommandsProvided, "NoBatchCommandsProvided"}
-};
+    {UnknownError, "UnknownError"},
+    {DatabaseCannotBeOpened, "DatabaseCannotBeOpened"},
+    {DatabaseNotOpen, "DatabaseNotOpen"},
+    {UnableToAttachToDatabase, "UnableToAttachToDatabase"},
+    {SqlExecutionError, "SqlExecutionError"},
+    {CouldNotLoadFile, "CouldNotLoadFile"},
+    {NoBatchCommandsProvided, "NoBatchCommandsProvided"}};
 
 inline std::string typeToString(NitroSQLiteExceptionType type) {
   return exceptionTypeStrings[type];
@@ -30,11 +33,11 @@ inline std::string typeToString(NitroSQLiteExceptionType type) {
 
 class NitroSQLiteException : public std::exception {
 public:
-  explicit NitroSQLiteException(const char* message): NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
-  explicit NitroSQLiteException(const std::string& message): NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
+  explicit NitroSQLiteException(const char* message) : NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
+  explicit NitroSQLiteException(const std::string& message) : NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
   NitroSQLiteException(const NitroSQLiteExceptionType& type, const char* message) : NitroSQLiteException(type, std::string(message)) {}
   NitroSQLiteException(const NitroSQLiteExceptionType& type, const std::string& message)
-    : _exceptionString("[" + typeToString(type) + "] " + message) {}
+      : _exceptionString(NITRO_SQLITE_EXCEPTION_PREFIX + "[" + typeToString(type) + "] " + message) {}
 
 private:
   const std::string _exceptionString;

package/cpp/importSqlFile.cpp

@@ -3,10 +3,10 @@
  */
 
 #include "importSqlFile.hpp"
-#include <fstream>
-#include <iostream>
 #include "NitroSQLiteException.hpp"
 #include "operations.hpp"
+#include <fstream>
+#include <iostream>
 
 namespace margelo::rnnitrosqlite {
 

package/cpp/logs.hpp

@@ -1,37 +1,39 @@
+#pragma once
+
+#define NITRO_SQLITE_LOG_TAG "react-native-nitro-sqlite"
+
 #ifdef ANDROID
 // LOGS ANDROID
 #include <android/log.h>
-#define LOG_TAG "react-native-nitro-sqlite"
-#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, NITRO_SQLITE_LOG_TAG, __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, NITRO_SQLITE_LOG_TAG, __VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, NITRO_SQLITE_LOG_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, NITRO_SQLITE_LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, NITRO_SQLITE_LOG_TAG, __VA_ARGS__)
 #define LOGSIMPLE(...)
 #else
 // LOGS NO ANDROID
 #include <stdio.h>
-#define LOG_TAG "react-native-nitro-sqlite"
 #define LOGV(...)                                                                                                                          \
   printf("  ");                                                                                                                            \
   printf(__VA_ARGS__);                                                                                                                     \
-  printf("\t -  <%s> \n", LOG_TAG);
+  printf("\t -  <%s> \n", NITRO_SQLITE_LOG_TAG);
 #define LOGD(...)                                                                                                                          \
   printf("  ");                                                                                                                            \
   printf(__VA_ARGS__);                                                                                                                     \
-  printf("\t -  <%s> \n", LOG_TAG);
+  printf("\t -  <%s> \n", NITRO_SQLITE_LOG_TAG);
 #define LOGI(...)                                                                                                                          \
   printf("  ");                                                                                                                            \
   printf(__VA_ARGS__);                                                                                                                     \
-  printf("\t -  <%s> \n", LOG_TAG);
+  printf("\t -  <%s> \n", NITRO_SQLITE_LOG_TAG);
 #define LOGW(...)                                                                                                                          \
   printf("  * Warning: ");                                                                                                                 \
   printf(__VA_ARGS__);                                                                                                                     \
-  printf("\t -  <%s> \n", LOG_TAG);
+  printf("\t -  <%s> \n", NITRO_SQLITE_LOG_TAG);
 #define LOGE(...)                                                                                                                          \
   printf("  *** Error:  ");                                                                                                                \
   printf(__VA_ARGS__);                                                                                                                     \
-  printf("\t -  <%s> \n", LOG_TAG);
+  printf("\t -  <%s> \n", NITRO_SQLITE_LOG_TAG);
 #define LOGSIMPLE(...)                                                                                                                     \
   printf(" ");                                                                                                                             \
   printf(__VA_ARGS__);

package/cpp/operations.cpp

@@ -1,16 +1,16 @@
 #include "operations.hpp"
+#include "NitroSQLiteException.hpp"
 #include "logs.hpp"
 #include "utils.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <cmath>
 #include <ctime>
 #include <iostream>
-#include <optional>
 #include <map>
+#include <optional>
 #include <sqlite3.h>
 #include <sstream>
 #include <unistd.h>
-#include "NitroSQLiteException.hpp"
 
 using namespace facebook;
 using namespace margelo::nitro;
@@ -59,7 +59,7 @@ void sqliteCloseAll() {
 }
 
 void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, const std::string& databaseToAttach,
-                              const std::string& alias) {
+                    const std::string& alias) {
   /**
    * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
    * */
@@ -69,7 +69,8 @@ void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, c
   try {
     sqliteExecuteLiteral(mainDBName, statement);
   } catch (NitroSQLiteException& e) {
-    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase, mainDBName + " was unable to attach another database: " + std::string(e.what()));
+    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase,
+                               mainDBName + " was unable to attach another database: " + std::string(e.what()));
   }
 }
 
@@ -82,7 +83,8 @@ void sqliteDetachDb(const std::string& mainDBName, const std::string& alias) {
   try {
     sqliteExecuteLiteral(mainDBName, statement);
   } catch (NitroSQLiteException& e) {
-    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase, mainDBName + " was unable to detach database: " + std::string(e.what()));
+    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase,
+                               mainDBName + " was unable to detach database: " + std::string(e.what()));
   }
 }
 
@@ -101,7 +103,7 @@ void sqliteRemoveDb(const std::string& dbName, const std::string& docPath) {
 
 void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
   for (int valueIndex = 0; valueIndex < values.size(); valueIndex++) {
-    int sqliteIndex = valueIndex+1;
+    int sqliteIndex = valueIndex + 1;
     SQLiteValue value = values.at(valueIndex);
     if (std::holds_alternative<SQLiteNullValue>(value)) {
       sqlite3_bind_null(statement, sqliteIndex);
@@ -119,7 +121,8 @@ void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
   }
 }
 
-SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) {
+SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::string& query,
+                                       const std::optional<SQLiteQueryParams>& params) {
   if (dbMap.count(dbName) == 0) {
     throw NitroSQLiteException::DatabaseNotOpen(dbName);
   }
@@ -196,21 +199,21 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
         results.push_back(std::move(row));
         break;
       case SQLITE_DONE:
-          i = 0;
-          count = sqlite3_column_count(statement);
-          while (i < count) {
-            column_name = sqlite3_column_name(statement, i);
-            const char* tp = sqlite3_column_decltype(statement, i);
-            column_declared_type = mapSQLiteTypeToColumnType(tp);
-            auto columnMeta = SQLiteQueryColumnMetadata(std::move(column_name), std::move(column_declared_type), i);
-
-            if (!metadata) {
-              metadata = std::make_optional<SQLiteQueryTableMetadata>();
-            }
-            metadata->insert({column_name, columnMeta});
-            i++;
+        i = 0;
+        count = sqlite3_column_count(statement);
+        while (i < count) {
+          column_name = sqlite3_column_name(statement, i);
+          const char* tp = sqlite3_column_decltype(statement, i);
+          column_declared_type = mapSQLiteTypeToColumnType(tp);
+          auto columnMeta = SQLiteQueryColumnMetadata(std::move(column_name), std::move(column_declared_type), i);
+
+          if (!metadata) {
+            metadata = std::make_optional<SQLiteQueryTableMetadata>();
           }
-          isConsuming = false;
+          metadata->insert({column_name, columnMeta});
+          i++;
+        }
+        isConsuming = false;
         break;
       default:
         isFailed = true;
@@ -226,12 +229,10 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
 
   int rowsAffected = sqlite3_changes(db);
   long long latestInsertRowId = sqlite3_last_insert_rowid(db);
-  return {
-    .rowsAffected = rowsAffected,
-    .insertId = static_cast<double>(latestInsertRowId),
-    .results = std::move(results),
-    .metadata = std::move(metadata)
-  };
+  return {.rowsAffected = rowsAffected,
+          .insertId = static_cast<double>(latestInsertRowId),
+          .results = std::move(results),
+          .metadata = std::move(metadata)};
 }
 
 SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std::string& query) {
@@ -256,7 +257,7 @@ SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std:
   bool isConsuming = true;
   bool isFailed = false;
 
-  int result, i, count, column_type;
+  int result;
   std::string column_name;
 
   while (isConsuming) {

package/cpp/operations.hpp

@@ -11,7 +11,7 @@ void sqliteCloseDb(const std::string& dbName);
 void sqliteRemoveDb(const std::string& dbName, const std::string& docPath);
 
 void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, const std::string& databaseToAttach,
-                              const std::string& alias);
+                    const std::string& alias);
 
 void sqliteDetachDb(const std::string& mainDBName, const std::string& alias);
 

package/cpp/specs/HybridNativeQueryResult.hpp

@@ -11,7 +11,7 @@ namespace margelo::nitro::rnnitrosqlite {
 class HybridNativeQueryResult : public HybridNativeQueryResultSpec {
 public:
   HybridNativeQueryResult() : HybridObject(TAG) {}
-  HybridNativeQueryResult(SQLiteExecuteQueryResult&& result): HybridObject(TAG), _result(std::move(result)) {}
+  HybridNativeQueryResult(SQLiteExecuteQueryResult&& result) : HybridObject(TAG), _result(std::move(result)) {}
 
 private:
   SQLiteExecuteQueryResult _result;

package/cpp/specs/HybridNitroSQLite.cpp

@@ -1,11 +1,11 @@
 #include "HybridNitroSQLite.hpp"
 #include "HybridNativeQueryResult.hpp"
 #include "NitroSQLiteException.hpp"
+#include "importSqlFile.hpp"
 #include "logs.hpp"
 #include "macros.hpp"
-#include "sqliteExecuteBatch.hpp"
-#include "importSqlFile.hpp"
 #include "operations.hpp"
+#include "sqliteExecuteBatch.hpp"
 #include <iostream>
 #include <map>
 #include <string>
@@ -53,13 +53,13 @@ void HybridNitroSQLite::detach(const std::string& mainDbName, const std::string&
 using ExecuteQueryResult = std::shared_ptr<HybridNativeQueryResultSpec>;
 
 ExecuteQueryResult HybridNitroSQLite::execute(const std::string& dbName, const std::string& query,
-                                             const std::optional<SQLiteQueryParams>& params) {
+                                              const std::optional<SQLiteQueryParams>& params) {
   SQLiteExecuteQueryResult result = sqliteExecute(dbName, query, params);
   return std::make_shared<HybridNativeQueryResult>(std::move(result));
 };
 
-std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query,
-                                                                                                       const std::optional<SQLiteQueryParams>& params) {
+std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>>
+HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) {
   return Promise<std::shared_ptr<HybridNativeQueryResultSpec>>::async([=, this]() -> std::shared_ptr<HybridNativeQueryResultSpec> {
     auto result = execute(dbName, query, params);
     return result;

package/cpp/specs/HybridNitroSQLite.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "HybridNitroSQLiteSpec.hpp"
 #include "HybridNativeQueryResultSpec.hpp"
+#include "HybridNitroSQLiteSpec.hpp"
 #include "types.hpp"
 
 using namespace margelo::rnnitrosqlite;
@@ -13,28 +13,31 @@ public:
   HybridNitroSQLite() : HybridObject(TAG) {}
 
 public:
-    static std::string docPath;
+  static std::string docPath;
 
 public:
   // Methods
   void open(const std::string& dbName, const std::optional<std::string>& location) override;
-  
+
   void close(const std::string& dbName) override;
-  
+
   void drop(const std::string& dbName, const std::optional<std::string>& location) override;
-  
+
   void attach(const std::string& mainDbName, const std::string& dbNameToAttach, const std::string& alias,
               const std::optional<std::string>& location) override;
-  
+
   void detach(const std::string& mainDbName, const std::string& alias) override;
-  
-  std::shared_ptr<HybridNativeQueryResultSpec> execute(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
-  
-  std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
-  
+
+  std::shared_ptr<HybridNativeQueryResultSpec> execute(const std::string& dbName, const std::string& query,
+                                                       const std::optional<SQLiteQueryParams>& params) override;
+
+  std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>>
+  executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
+
   BatchQueryResult executeBatch(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& commands) override;
-  std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName, const std::vector<NativeBatchQueryCommand>& commands) override;
-  
+  std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName,
+                                                               const std::vector<NativeBatchQueryCommand>& commands) override;
+
   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;
 };

package/cpp/sqliteExecuteBatch.cpp

@@ -2,9 +2,9 @@
  * SQL Batch execution implementation using default sqliteBridge implementation
  */
 #include "sqliteExecuteBatch.hpp"
+#include "NitroSQLiteException.hpp"
 #include "operations.hpp"
 #include <utility>
-#include "NitroSQLiteException.hpp"
 
 namespace margelo::rnnitrosqlite {
 

package/cpp/types.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <string>
-#include <NitroModules/ArrayBuffer.hpp>
-#include "SQLiteQueryColumnMetadata.hpp"
 #include "ColumnType.hpp"
 #include "SQLiteNullValue.hpp"
+#include "SQLiteQueryColumnMetadata.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
 
 using namespace margelo::nitro;
 using namespace margelo::nitro::rnnitrosqlite;

package/cpp/utils.hpp

@@ -1,8 +1,7 @@
 #pragma once
 
-
-#include <sys/stat.h>
 #include <string>
+#include <sys/stat.h>
 
 namespace margelo::rnnitrosqlite {
 
@@ -58,4 +57,4 @@ std::string get_db_path(const std::string& dbName, const std::string& docPath) {
   return docPath + "/" + dbName;
 }
 
-}
+} // namespace margelo::rnnitrosqlite

package/lib/commonjs/DatabaseQueue.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.closeDatabase = closeDatabase;
+exports.closeDatabaseQueue = closeDatabaseQueue;
+exports.getDatabaseQueue = getDatabaseQueue;
+exports.isDatabaseOpen = isDatabaseOpen;
+exports.openDatabase = openDatabase;
+exports.openDatabaseQueue = openDatabaseQueue;
+exports.queueOperationAsync = queueOperationAsync;
+exports.startOperationSync = startOperationSync;
+exports.throwIfDatabaseIsNotOpen = throwIfDatabaseIsNotOpen;
+var _NitroSQLiteError = _interopRequireDefault(require("./NitroSQLiteError.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const databaseQueues = new Map();
+function openDatabaseQueue(dbName) {
+  if (isDatabaseOpen(dbName)) {
+    throw new _NitroSQLiteError.default(`Database ${dbName} is already open. There is already a connection to the database.`);
+  }
+  databaseQueues.set(dbName, {
+    queue: [],
+    inProgress: false
+  });
+}
+function closeDatabaseQueue(dbName) {
+  const databaseQueue = getDatabaseQueue(dbName);
+  if (databaseQueue.inProgress || databaseQueue.queue.length > 0) {
+    console.warn(`Database queue for ${dbName} has operations in the queue. Closing anyway.`);
+  }
+  databaseQueues.delete(dbName);
+}
+function isDatabaseOpen(dbName) {
+  return databaseQueues.has(dbName);
+}
+function throwIfDatabaseIsNotOpen(dbName) {
+  if (!isDatabaseOpen(dbName)) throw new _NitroSQLiteError.default(`Database ${dbName} is not open. There is no connection to the database.`);
+}
+function getDatabaseQueue(dbName) {
+  throwIfDatabaseIsNotOpen(dbName);
+  const queue = databaseQueues.get(dbName);
+  return queue;
+}
+function openDatabase(dbName) {
+  databaseQueues.set(dbName, {
+    queue: [],
+    inProgress: false
+  });
+}
+function closeDatabase(dbName) {
+  databaseQueues.delete(dbName);
+}
+function queueOperationAsync(dbName, callback) {
+  const databaseQueue = getDatabaseQueue(dbName);
+  return new Promise((resolve, reject) => {
+    async function start() {
+      try {
+        const result = await callback();
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      } finally {
+        databaseQueue.inProgress = false;
+        startOperationAsync(dbName);
+      }
+    }
+    const operation = {
+      start
+    };
+    databaseQueue.queue.push(operation);
+    startOperationAsync(dbName);
+  });
+}
+function startOperationAsync(dbName) {
+  const queue = getDatabaseQueue(dbName);
+
+  // Queue is empty or in progress. Bail out.
+  if (queue.inProgress || queue.queue.length === 0) {
+    return;
+  }
+  queue.inProgress = true;
+  const operation = queue.queue.shift();
+  setImmediate(() => {
+    operation.start();
+  });
+}
+function startOperationSync(dbName, callback) {
+  const databaseQueue = getDatabaseQueue(dbName);
+
+  // Database is busy - cannot execute synchronously
+  if (databaseQueue.inProgress || databaseQueue.queue.length > 0) {
+    throw new _NitroSQLiteError.default(`Cannot run synchronous operation on database. Database ${dbName} is busy with another operation.`);
+  }
+
+  // Execute synchronously
+  databaseQueue.inProgress = true;
+  try {
+    return callback();
+  } finally {
+    databaseQueue.inProgress = false;
+  }
+}
+//# sourceMappingURL=DatabaseQueue.js.map

package/lib/commonjs/DatabaseQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NitroSQLiteError","_interopRequireDefault","require","e","__esModule","default","databaseQueues","Map","openDatabaseQueue","dbName","isDatabaseOpen","NitroSQLiteError","set","queue","inProgress","closeDatabaseQueue","databaseQueue","getDatabaseQueue","length","console","warn","delete","has","throwIfDatabaseIsNotOpen","get","openDatabase","closeDatabase","queueOperationAsync","callback","Promise","resolve","reject","start","result","error","startOperationAsync","operation","push","shift","setImmediate","startOperationSync"],"sourceRoot":"../../src","sources":["DatabaseQueue.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/NitroSQLiteError.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const NITRO_SQLITE_ERROR_NAME = 'NitroSQLiteError';
+
+/**
+ * Custom error class for NitroSQLite operations
+ * Extends the native Error class with proper prototype chain and error handling
+ */
+class NitroSQLiteError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = NITRO_SQLITE_ERROR_NAME;
+
+    // Maintains proper prototype chain for instanceof checks
+    Object.setPrototypeOf(this, NitroSQLiteError.prototype);
+  }
+
+  /**
+   * Converts an unknown error to a NitroSQLiteError
+   * Preserves stack traces and error causes when available
+   */
+  static fromError(error) {
+    if (error instanceof NitroSQLiteError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const nitroSQLiteError = new NitroSQLiteError(error.message, {
+        cause: error.cause
+      });
+
+      // Preserve original stack trace if available
+      if (error.stack) {
+        nitroSQLiteError.stack = error.stack;
+      }
+      return nitroSQLiteError;
+    }
+    if (typeof error === 'string') {
+      return new NitroSQLiteError(error);
+    }
+    return new NitroSQLiteError('Unknown error occurred', {
+      cause: error
+    });
+  }
+}
+exports.default = NitroSQLiteError;
+//# sourceMappingURL=NitroSQLiteError.js.map

package/lib/commonjs/NitroSQLiteError.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NITRO_SQLITE_ERROR_NAME","NitroSQLiteError","Error","constructor","message","options","name","Object","setPrototypeOf","prototype","fromError","error","nitroSQLiteError","cause","stack","exports","default"],"sourceRoot":"../../src","sources":["NitroSQLiteError.ts"],"mappings":";;;;;;AAAA,MAAMA,uBAAuB,GAAG,kBAA2B;;AAE3D;AACA;AACA;AACA;AACe,MAAMC,gBAAgB,SAASC,KAAK,CAAC;EAClDC,WAAWA,CAACC,OAAe,EAAEC,OAAsB,EAAE;IACnD,KAAK,CAACD,OAAO,EAAEC,OAAO,CAAC;IACvB,IAAI,CAACC,IAAI,GAAGN,uBAAuB;;IAEnC;IACAO,MAAM,CAACC,cAAc,CAAC,IAAI,EAAEP,gBAAgB,CAACQ,SAAS,CAAC;EACzD;;EAEA;AACF;AACA;AACA;EACE,OAAOC,SAASA,CAACC,KAAc,EAAoB;IACjD,IAAIA,KAAK,YAAYV,gBAAgB,EAAE;MACrC,OAAOU,KAAK;IACd;IAEA,IAAIA,KAAK,YAAYT,KAAK,EAAE;MAC1B,MAAMU,gBAAgB,GAAG,IAAIX,gBAAgB,CAACU,KAAK,CAACP,OAAO,EAAE;QAC3DS,KAAK,EAAEF,KAAK,CAACE;MACf,CAAC,CAAC;;MAEF;MACA,IAAIF,KAAK,CAACG,KAAK,EAAE;QACfF,gBAAgB,CAACE,KAAK,GAAGH,KAAK,CAACG,KAAK;MACtC;MACA,OAAOF,gBAAgB;IACzB;IAEA,IAAI,OAAOD,KAAK,KAAK,QAAQ,EAAE;MAC7B,OAAO,IAAIV,gBAAgB,CAACU,KAAK,CAAC;IACpC;IAEA,OAAO,IAAIV,gBAAgB,CAAC,wBAAwB,EAAE;MACpDY,KAAK,EAAEF;IACT,CAAC,CAAC;EACJ;AACF;AAACI,OAAA,CAAAC,OAAA,GAAAf,gBAAA","ignoreList":[]}

package/lib/commonjs/index.js

@@ -10,6 +10,12 @@ Object.defineProperty(exports, "NITRO_SQLITE_NULL", {
   }
 });
 exports.NitroSQLite = void 0;
+Object.defineProperty(exports, "NitroSQLiteError", {
+  enumerable: true,
+  get: function () {
+    return _NitroSQLiteError.default;
+  }
+});
 Object.defineProperty(exports, "enableSimpleNullHandling", {
   enumerable: true,
   get: function () {
@@ -46,8 +52,10 @@ var _session = require("./operations/session.js");
 var _execute = require("./operations/execute.js");
 var _OnLoad = require("./OnLoad");
 var _executeBatch = require("./operations/executeBatch.js");
-var _typeORM = require("./typeORM.js");
 var _nullHandling = require("./nullHandling.js");
+var _NitroSQLiteError = _interopRequireDefault(require("./NitroSQLiteError.js"));
+var _typeORM = require("./typeORM.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 (0, _OnLoad.init)();
 const NitroSQLite = exports.NitroSQLite = {
   ..._nitro.HybridNitroSQLite,

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_transaction","require","_nitro","_session","_execute","_OnLoad","_executeBatch","_typeORM","_nullHandling","init","NitroSQLite","exports","HybridNitroSQLite","native","open","transaction","execute","executeAsync","executeBatch","executeBatchAsync"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,aAAA,GAAAL,OAAA;AAEA,IAAAM,QAAA,GAAAN,OAAA;AAmBA,IAAAO,aAAA,GAAAP,OAAA;AAjBA,IAAAQ,YAAI,EAAC,CAAC;AAEC,MAAMC,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzB,GAAGE,wBAAiB;EACpBC,MAAM,EAAED,wBAAiB;EACzB;EACA;EACAE,IAAI,EAAJA,aAAI;EACJ;EACAC,WAAW,EAAXA,wBAAW;EACXC,OAAO,EAAPA,gBAAO;EACPC,YAAY,EAAZA,qBAAY;EACZC,YAAY,EAAZA,0BAAY;EACZC,iBAAiB,EAAjBA;AACF,CAAC","ignoreList":[]}
+{"version":3,"names":["_transaction","require","_nitro","_session","_execute","_OnLoad","_executeBatch","_nullHandling","_NitroSQLiteError","_interopRequireDefault","_typeORM","e","__esModule","default","init","NitroSQLite","exports","HybridNitroSQLite","native","open","transaction","execute","executeAsync","executeBatch","executeBatchAsync"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,aAAA,GAAAL,OAAA;AAmBA,IAAAM,aAAA,GAAAN,OAAA;AAMA,IAAAO,iBAAA,GAAAC,sBAAA,CAAAR,OAAA;AAEA,IAAAS,QAAA,GAAAT,OAAA;AAAyC,SAAAQ,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAzBzC,IAAAG,YAAI,EAAC,CAAC;AAEC,MAAMC,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzB,GAAGE,wBAAiB;EACpBC,MAAM,EAAED,wBAAiB;EACzB;EACA;EACAE,IAAI,EAAJA,aAAI;EACJ;EACAC,WAAW,EAAXA,wBAAW;EACXC,OAAO,EAAPA,gBAAO;EACPC,YAAY,EAAZA,qBAAY;EACZC,YAAY,EAAZA,0BAAY;EACZC,iBAAiB,EAAjBA;AACF,CAAC","ignoreList":[]}