react-native-nitro-sqlite 9.8.2 → 10.0.0

package/cpp/hybridObjects/HybridNitroSQLite.cpp

@@ -1,25 +1,27 @@
 #include "HybridNitroSQLite.hpp"
+#include "../NitroSQLiteDatabaseMigration.hpp"
+#include "../NitroSQLiteException.hpp"
+#include "../NitroSQLiteExecuteBatch.hpp"
+#include "../NitroSQLiteImportSqlFile.hpp"
+#include "../NitroSQLiteLogs.hpp"
+#include "../NitroSQLiteMacros.hpp"
+#include "../NitroSQLiteOperations.hpp"
+#include "HybridNitroSQLitePreparedStatement.hpp"
 #include "HybridNitroSQLiteQueryResult.hpp"
-#include "NitroSQLiteException.hpp"
-#include "databaseMigration.hpp"
-#include "importSqlFile.hpp"
-#include "logs.hpp"
-#include "macros.hpp"
-#include "operations.hpp"
-#include "sqliteExecuteBatch.hpp"
 #include <exception>
 #include <filesystem>
 #include <iostream>
 #include <map>
 #include <optional>
 #include <string>
+#include <utility>
 #include <variant>
 #include <vector>
 
 namespace margelo::nitro::rnnitrosqlite {
 
 // Copy any JS-backed ArrayBuffers on the JS thread so they can be safely
-// accessed from the background thread used by Promise::async.
+// accessed from the connection's background worker.
 static std::optional<SQLiteQueryParams> copyArrayBufferParamsForBackground(const std::optional<SQLiteQueryParams>& params) {
   if (!params) {
     return std::nullopt;
@@ -59,7 +61,40 @@ static std::vector<BatchQuery> copyArrayBufferParamsForBackground(const std::vec
   return copiedCommands;
 }
 
+template <typename Result, typename Operation>
+static std::shared_ptr<Promise<Result>> enqueueConnectionOperation(const SQLiteConnectionPtr& connection, Operation&& operation) {
+  auto promise = Promise<Result>::create();
+  try {
+    connection->enqueueAsync([promise, operation = std::forward<Operation>(operation)]() mutable {
+      std::optional<Result> result;
+      try {
+        result.emplace(operation());
+      } catch (...) {
+        promise->reject(std::current_exception());
+        return;
+      }
+      // Resolving may dispatch to JavaScript and throw after the native promise
+      // has settled. Do not try to reject that same promise again.
+      try {
+        promise->resolve(std::move(*result));
+      } catch (...) {
+        if (promise->isPending()) {
+          promise->reject(std::current_exception());
+          return;
+        }
+        throw;
+      }
+    });
+  } catch (...) {
+    promise->reject(std::current_exception());
+  }
+  return promise;
+}
+
 const std::string getDocPath(const std::optional<std::string>& location) {
+  if (location && location->find('\0') != std::string::npos) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, "Database location contains a NUL byte");
+  }
   std::string tempDocPath = std::string(HybridNitroSQLite::docPath);
   if (location) {
     tempDocPath = tempDocPath + "/" + *location;
@@ -77,45 +112,92 @@ const std::string getOldDocPath(const std::optional<std::string>& location) {
   return oldDocPath;
 }
 
-const std::string getMigratedDocPath(const std::string& dbName, const std::optional<std::string>& location) {
+const std::string getMigratedDocPath(const std::string& dbName, const std::optional<std::string>& location, bool readOnly = false) {
   const auto currentDocPath = getDocPath(location);
   if (HybridNitroSQLite::migrationDocPath.empty()) {
     return currentDocPath;
   }
+  const auto oldDocPath = getOldDocPath(location);
+  std::string selectedPath;
+  databaseConnections().withConnectionsLocked([&]() {
+    const auto oldPath = std::filesystem::path(oldDocPath) / dbName;
+    const auto livePath = databaseConnections().findLivePath(oldPath, std::filesystem::path(currentDocPath) / dbName);
+    if (livePath) {
+      selectedPath = *livePath == oldPath ? oldDocPath : currentDocPath;
+    } else if (readOnly) {
+      selectedPath = std::filesystem::exists(std::filesystem::path(oldDocPath) / dbName) ? oldDocPath : currentDocPath;
+    } else {
+      selectedPath = migrateDatabase(dbName, oldDocPath, currentDocPath).string();
+    }
+  });
+  return selectedPath;
+}
 
-  return migrateDatabase(dbName, getOldDocPath(location), currentDocPath).string();
+void HybridNitroSQLite::open(const std::string& dbName, const std::optional<std::string>& location, std::optional<bool> readOnly) {
+  validateDatabaseName(dbName);
+  std::lock_guard lock(databaseConnections().lifecycleMutex);
+  if (databaseConnections().isOpen(dbName)) {
+    throw NitroSQLiteException::DatabaseAlreadyOpen(dbName);
+  }
+  const auto docPath = getMigratedDocPath(dbName, location, readOnly.value_or(false));
+  sqliteOpenDb(dbName, docPath, readOnly.value_or(false));
 }
 
-void HybridNitroSQLite::open(const std::string& dbName, const std::optional<std::string>& location) {
-  const auto docPath = getMigratedDocPath(dbName, location);
-  sqliteOpenDb(dbName, docPath);
+std::string HybridNitroSQLite::openConnection(const std::string& dbName, const std::optional<std::string>& location,
+                                              std::optional<bool> readOnly) {
+  validateDatabaseName(dbName);
+  if (sqlite3_threadsafe() == 0) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened,
+                               "Independent connections require a thread-safe SQLite build");
+  }
+  std::lock_guard lock(databaseConnections().lifecycleMutex);
+  const auto docPath = getMigratedDocPath(dbName, location, readOnly.value_or(false));
+  return sqliteOpenConnection(dbName, docPath, readOnly.value_or(false));
 }
 
 void HybridNitroSQLite::close(const std::string& dbName) {
   sqliteCloseDb(dbName);
 };
 
-void HybridNitroSQLite::drop(const std::string& dbName, const std::optional<std::string>& location) {
+bool HybridNitroSQLite::isConnectionOpen(const std::string& connectionId) {
+  return databaseConnections().isOpen(connectionId);
+}
+
+void HybridNitroSQLite::drop(const std::string& dbName, const std::optional<std::string>& location,
+                             const std::optional<std::string>& connectionId) {
+  validateDatabaseName(dbName);
+  std::lock_guard lock(databaseConnections().lifecycleMutex);
   const auto currentDocPath = getDocPath(location);
   if (migrationDocPath.empty()) {
-    sqliteRemoveDb(dbName, currentDocPath);
+    sqliteRemoveDb(dbName, currentDocPath, connectionId);
     return;
   }
 
   const auto oldDocPath = getOldDocPath(location);
+  const auto preferredPath = databaseConnections().physicalPathForKey(connectionId.value_or(dbName));
+  const auto currentPath = std::filesystem::path(currentDocPath) / dbName;
   std::error_code ec;
   const bool oldDatabaseExists = std::filesystem::exists(std::filesystem::path(oldDocPath) / dbName, ec);
   if (ec) {
     LOGW("Failed to inspect database %s in its old location: %s", dbName.c_str(), ec.message().c_str());
   }
 
-  sqliteRemoveDb(dbName, oldDatabaseExists || ec ? oldDocPath : currentDocPath);
-  removeDatabaseFiles(dbName, oldDocPath);
-  removeDatabaseFiles(dbName, currentDocPath);
+  // A stale copy in the old directory must not override the actual target of a live or
+  // recently closed independent connection.
+  std::error_code equivalentError;
+  const bool prefersCurrent = preferredPath && (std::filesystem::equivalent(*preferredPath, currentPath, equivalentError) ||
+                                                canonicalDatabasePath(*preferredPath) == canonicalDatabasePath(currentPath));
+  const bool useOldPath = !prefersCurrent && (preferredPath || oldDatabaseExists || ec);
+  sqliteRemoveDb(dbName, useOldPath ? oldDocPath : currentDocPath, connectionId, useOldPath ? currentDocPath : oldDocPath);
 };
 
 void HybridNitroSQLite::attach(const std::string& mainDbName, const std::string& dbNameToAttach, const std::string& alias,
                                const std::optional<std::string>& location) {
+  validateDatabaseName(dbNameToAttach);
+  std::lock_guard lock(databaseConnections().lifecycleMutex);
+  if (databaseConnections().get(mainDbName)->readOnly) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase, "Cannot attach a database to a read-only connection");
+  }
   const auto attachedDocPath = getMigratedDocPath(dbNameToAttach, location);
   sqliteAttachDb(mainDbName, attachedDocPath, dbNameToAttach, alias);
 };
@@ -139,13 +221,17 @@ HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& qu
     return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::rejected(std::current_exception());
   }
 
-  return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::async(
-      [connection, query, copiedParams]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> {
+  return enqueueConnectionOperation<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>(
+      connection, [connection, query, copiedParams]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> {
         auto result = sqliteExecute(connection, query, copiedParams);
         return result;
       });
 };
 
+std::shared_ptr<HybridNitroSQLitePreparedStatementSpec> HybridNitroSQLite::prepare(const std::string& dbName, const std::string& query) {
+  return std::make_shared<HybridNitroSQLitePreparedStatement>(sqlitePrepare(dbName, query));
+}
+
 BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& batchParams) {
   const auto commands = batchParamsToCommands(batchParams);
 
@@ -166,7 +252,7 @@ std::shared_ptr<Promise<BatchQueryResult>> HybridNitroSQLite::executeBatchAsync(
     return Promise<BatchQueryResult>::rejected(std::current_exception());
   }
 
-  return Promise<BatchQueryResult>::async([connection, copiedCommands]() -> BatchQueryResult {
+  return enqueueConnectionOperation<BatchQueryResult>(connection, [connection, copiedCommands]() -> BatchQueryResult {
     auto result = sqliteExecuteBatch(connection, copiedCommands);
     return BatchQueryResult(result.rowsAffected);
   });
@@ -184,7 +270,7 @@ std::shared_ptr<Promise<FileLoadResult>> HybridNitroSQLite::loadFileAsync(const
   } catch (...) {
     return Promise<FileLoadResult>::rejected(std::current_exception());
   }
-  return Promise<FileLoadResult>::async([connection, location]() -> FileLoadResult {
+  return enqueueConnectionOperation<FileLoadResult>(connection, [connection, location]() -> FileLoadResult {
     const auto result = importSqlFile(connection, location);
     return FileLoadResult(result.commands, result.rowsAffected);
   });

package/cpp/hybridObjects/HybridNitroSQLite.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
+#include "../NitroSQLiteTypes.hpp"
+#include "HybridNitroSQLitePreparedStatementSpec.hpp"
 #include "HybridNitroSQLiteQueryResultSpec.hpp"
 #include "HybridNitroSQLiteSpec.hpp"
-#include "types.hpp"
-
-using namespace margelo::rnnitrosqlite;
 
 namespace margelo::nitro::rnnitrosqlite {
 
+/** Native database operations exposed to JavaScript through the Nitro hybrid object. */
 class HybridNitroSQLite : public HybridNitroSQLiteSpec {
 public:
   HybridNitroSQLite() : HybridObject(TAG) {}
@@ -21,28 +21,72 @@ public:
 
 public:
   // Methods
-  void open(const std::string& dbName, const std::optional<std::string>& location) override;
+  /** Open the default connection, requiring an existing file in read-only mode. */
+  void open(const std::string& dbName, const std::optional<std::string>& location, std::optional<bool> readOnly) override;
+
+  /** Open a separate native handle and return an opaque ID for later calls. */
+  std::string openConnection(const std::string& dbName, const std::optional<std::string>& location, std::optional<bool> readOnly) override;
 
+  /** Close the named native database handle. */
   void close(const std::string& dbName) override;
 
-  void drop(const std::string& dbName, const std::optional<std::string>& location) override;
+  /** Check whether a connection name or ID still identifies an open handle. */
+  bool isConnectionOpen(const std::string& connectionId) override;
 
+  /** Delete a database, closing the specified connection when it is open. */
+  void drop(const std::string& dbName, const std::optional<std::string>& location, const std::optional<std::string>& connectionId) override;
+
+  /** Attach a database file to an open database.
+   * @param mainDbName Name of the open main database.
+   * @param dbNameToAttach File name of the database to attach.
+   * @param alias SQL schema name for the attached database.
+   * @param location Optional directory relative to the platform database root.
+   */
   void attach(const std::string& mainDbName, const std::string& dbNameToAttach, const std::string& alias,
               const std::optional<std::string>& location) override;
 
+  /** Detach the database identified by @p alias from @p mainDbName. */
   void detach(const std::string& mainDbName, const std::string& alias) override;
 
+  /** Execute one SQL statement on the calling thread.
+   * @param dbName Name of an open database.
+   * @param query SQL statement with optional positional placeholders.
+   * @param params Optional values bound to the placeholders.
+   * @return Native rows, affected row count, insert ID, and metadata.
+   */
   std::shared_ptr<HybridNitroSQLiteQueryResultSpec> execute(const std::string& dbName, const std::string& query,
                                                             const std::optional<SQLiteQueryParams>& params) override;
 
+  /** Execute one SQL statement on a background thread.
+   * @return A promise of the native query result.
+   */
   std::shared_ptr<Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>>
   executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
 
+  /** Prepare one SQL statement for repeated execution on an open connection. */
+  std::shared_ptr<HybridNitroSQLitePreparedStatementSpec> prepare(const std::string& dbName, const std::string& query) override;
+
+  /** Run a nonempty batch in one exclusive transaction on the calling thread.
+   * A failed command rolls back the batch.
+   * @return Total affected row count.
+   */
   BatchQueryResult executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
+  /** Run a nonempty batch in one exclusive transaction on a background thread.
+   * @return A promise of the total affected row count.
+   */
   std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName,
                                                                const std::vector<BatchQueryCommand>& commands) override;
 
+  /** Import a SQL file in one exclusive transaction on the calling thread.
+   * Each nonempty line is interpreted as one statement.
+   * @param location Path to the SQL file.
+   * @return Number of executed commands and affected rows.
+   */
   FileLoadResult loadFile(const std::string& dbName, const std::string& location) override;
+  /** Import a SQL file on a background thread.
+   * @param location Path to the SQL file.
+   * @return A promise of the command and affected row counts.
+   */
   std::shared_ptr<Promise<FileLoadResult>> loadFileAsync(const std::string& dbName, const std::string& location) override;
 };
 

package/cpp/hybridObjects/HybridNitroSQLitePreparedStatement.cpp

@@ -0,0 +1,59 @@
+#include "HybridNitroSQLitePreparedStatement.hpp"
+#include "HybridNitroSQLiteQueryResult.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+namespace {
+
+  std::optional<SQLiteQueryParams> copyArrayBufferParamsForBackground(const std::optional<SQLiteQueryParams>& params) {
+    if (!params) {
+      return std::nullopt;
+    }
+
+    SQLiteQueryParams copiedParams;
+    copiedParams.reserve(params->size());
+
+    for (const auto& value : *params) {
+      if (std::holds_alternative<std::shared_ptr<ArrayBuffer>>(value)) {
+        copiedParams.push_back(ArrayBuffer::copy(std::get<std::shared_ptr<ArrayBuffer>>(value)));
+      } else {
+        copiedParams.push_back(value);
+      }
+    }
+
+    return copiedParams;
+  }
+
+} // namespace
+
+HybridNitroSQLitePreparedStatement::HybridNitroSQLitePreparedStatement(std::shared_ptr<SQLitePreparedStatement> statement)
+    : HybridObject(TAG), _statement(std::move(statement)) {}
+
+std::shared_ptr<HybridNitroSQLiteQueryResultSpec>
+HybridNitroSQLitePreparedStatement::execute(const std::optional<SQLiteQueryParams>& params) {
+  return _statement->execute(params);
+}
+
+std::shared_ptr<Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>>
+HybridNitroSQLitePreparedStatement::executeAsync(const std::optional<SQLiteQueryParams>& params) {
+  const auto copiedParams = copyArrayBufferParamsForBackground(params);
+  const auto statement = _statement;
+
+  return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::async(
+      [statement, copiedParams]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> { return statement->execute(copiedParams); });
+}
+
+void HybridNitroSQLitePreparedStatement::finalize() {
+  _statement->finalize();
+}
+
+bool HybridNitroSQLitePreparedStatement::getIsFinalized() {
+  return _statement->isFinalized();
+}
+
+size_t HybridNitroSQLitePreparedStatement::getExternalMemorySize() noexcept {
+  return sizeof(*this) + _statement->getExternalMemorySize();
+}
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/hybridObjects/HybridNitroSQLitePreparedStatement.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "../NitroSQLiteOperations.hpp"
+#include "../NitroSQLiteTypes.hpp"
+#include "HybridNitroSQLitePreparedStatementSpec.hpp"
+#include <memory>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+/** Nitro hybrid object for a reusable native SQLite statement. */
+class HybridNitroSQLitePreparedStatement : public HybridNitroSQLitePreparedStatementSpec {
+public:
+  /** Wrap a prepared statement for calls from JavaScript. */
+  explicit HybridNitroSQLitePreparedStatement(std::shared_ptr<SQLitePreparedStatement> statement);
+
+  /** Execute with new bindings on the calling thread. */
+  std::shared_ptr<HybridNitroSQLiteQueryResultSpec> execute(const std::optional<SQLiteQueryParams>& params) override;
+  /** Execute with new bindings on a background thread. */
+  std::shared_ptr<Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>>
+  executeAsync(const std::optional<SQLiteQueryParams>& params) override;
+  /** Release the native statement. */
+  void finalize() override;
+  /** Check whether the native statement has been released. */
+  bool getIsFinalized() override;
+
+  /** Report native memory used by this hybrid object. */
+  size_t getExternalMemorySize() noexcept override;
+
+private:
+  std::shared_ptr<SQLitePreparedStatement> _statement;
+};
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/hybridObjects/HybridNitroSQLiteQueryResult.hpp

@@ -1,13 +1,12 @@
 #pragma once
 
+#include "../NitroSQLiteTypes.hpp"
 #include "HybridNitroSQLiteQueryResultSpec.hpp"
-#include "types.hpp"
 #include <map>
 
-using namespace margelo::rnnitrosqlite;
-
 namespace margelo::nitro::rnnitrosqlite {
 
+/** Native result object returned by a single SQL execution. */
 class HybridNitroSQLiteQueryResult : public HybridNitroSQLiteQueryResultSpec {
 public:
   HybridNitroSQLiteQueryResult() : HybridObject(TAG) {}
@@ -22,10 +21,13 @@ private:
   std::optional<SQLiteQueryTableMetadata> _metadata;
 
 public:
-  // Properties
+  /** Return the connection's last insert row ID, which may be from an earlier statement. */
   std::optional<double> getInsertId() override;
+  /** Return SQLite's latest row change count, which may be stale for a read-only query. */
   double getRowsAffected() override;
+  /** Return result rows keyed by column name. */
   SQLiteQueryResults getResults() override;
+  /** Return column metadata when available. */
   std::optional<SQLiteQueryTableMetadata> getMetadata() override;
 
   /**

package/ios/OnLoad.mm

@@ -1,7 +1,39 @@
 #import <Foundation/Foundation.h>
+#import <TargetConditionals.h>
 #import "RNNitroSQLite-Swift-Cxx-Umbrella.hpp"
 #import "HybridNitroSQLite.hpp"
 
+#if TARGET_OS_OSX
+static NSString *macOSDatabaseDirectory(void) {
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+  NSError *error = nil;
+  NSURL *applicationSupportURL = [fileManager URLForDirectory:NSApplicationSupportDirectory
+                                                      inDomain:NSUserDomainMask
+                                             appropriateForURL:nil
+                                                        create:YES
+                                                         error:&error];
+  if (applicationSupportURL == nil) {
+    @throw [NSException exceptionWithName:@"SQLiteInitializationException"
+                                   reason:[NSString stringWithFormat:@"Could not find the Application Support directory: %@", error]
+                                 userInfo:nil];
+  }
+
+  NSString *bundleIdentifier = [[NSBundle mainBundle] bundleIdentifier];
+  if (bundleIdentifier == nil) {
+    bundleIdentifier = [[NSProcessInfo processInfo] processName];
+  }
+
+  NSURL *databaseURL = [applicationSupportURL URLByAppendingPathComponent:bundleIdentifier isDirectory:YES];
+  if (![fileManager createDirectoryAtURL:databaseURL withIntermediateDirectories:YES attributes:nil error:&error]) {
+    @throw [NSException exceptionWithName:@"SQLiteInitializationException"
+                                   reason:[NSString stringWithFormat:@"Could not create the database directory: %@", error]
+                                 userInfo:nil];
+  }
+
+  return [databaseURL path];
+}
+#endif
+
 @interface OnLoad : NSObject
 @end
 
@@ -11,7 +43,7 @@ using namespace margelo::nitro;
 using namespace margelo::nitro::rnnitrosqlite;
 
 + (void)load {
-  // Get appGroupID value from Info.plist using key "AppGroup"
+  // Get appGroupID value from Info.plist using key "RNNitroSQLite_AppGroup".
   NSString *appGroupID = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"RNNitroSQLite_AppGroup"];
   NSString *documentPath;
 
@@ -21,7 +53,7 @@ using namespace margelo::nitro::rnnitrosqlite;
     NSURL *storeUrl = [fileManager containerURLForSecurityApplicationGroupIdentifier:appGroupID];
 
     if (storeUrl == nil) {
-      NSLog(@"Invalid AppGroup ID provided (%@). Check the value of \"AppGroup\" in your Info.plist file", appGroupID);
+      NSLog(@"Invalid App Group ID provided (%@). Check the value of \"RNNitroSQLite_AppGroup\" in your Info.plist file", appGroupID);
       @throw [NSException exceptionWithName:@"SQLiteInitializationException"
                                      reason:@"Error while initializing SQLite database (AppGroup)"
                                    userInfo:nil];
@@ -30,6 +62,9 @@ using namespace margelo::nitro::rnnitrosqlite;
 
     documentPath = [storeUrl path];
   } else {
+#if TARGET_OS_OSX
+    documentPath = macOSDatabaseDirectory();
+#else
     NSString *databaseLocation = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"RNNitroSQLite_DatabaseLocation"];
 
     if ([databaseLocation isEqualToString:@"ApplicationSupport"]) {
@@ -56,6 +91,7 @@ using namespace margelo::nitro::rnnitrosqlite;
       NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true);
       documentPath = [paths objectAtIndex:0];
     }
+#endif
   }
 
   HybridNitroSQLite::docPath = [documentPath UTF8String];

package/lib/commonjs/DatabaseQueue.js

@@ -8,24 +8,31 @@ exports.getDatabaseQueue = getDatabaseQueue;
 exports.isDatabaseOpen = isDatabaseOpen;
 exports.openDatabaseQueue = openDatabaseQueue;
 exports.queueOperationAsync = queueOperationAsync;
+exports.queueStatementAsync = queueStatementAsync;
 exports.startOperationSync = startOperationSync;
 exports.throwIfDatabaseIsNotOpen = throwIfDatabaseIsNotOpen;
 var _NitroSQLiteError = _interopRequireDefault(require("./NitroSQLiteError.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** Identity of a managed connection's operation queue. Application code should
+ * omit the optional queue key on package helpers; connections choose it for you.
+ */
+
 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.`);
+    throw new _NitroSQLiteError.default(`Database ${String(dbName)} is already open. There is already a connection to the database.`);
   }
   databaseQueues.set(dbName, {
     queue: [],
-    inProgress: false
+    inProgress: false,
+    activeStatements: 0,
+    draining: false
   });
 }
 function closeDatabaseQueue(dbName) {
   const databaseQueue = getDatabaseQueue(dbName);
   if (databaseQueue.inProgress || databaseQueue.queue.length > 0) {
-    throw new _NitroSQLiteError.default(`Cannot close database ${dbName}. The database is busy with another operation.`);
+    throw new _NitroSQLiteError.default(`Cannot close database ${String(dbName)}. The database is busy with another operation.`);
   }
   databaseQueues.delete(dbName);
 }
@@ -33,7 +40,7 @@ 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.`);
+  if (!isDatabaseOpen(dbName)) throw new _NitroSQLiteError.default(`Database ${String(dbName)} is not open. There is no connection to the database.`);
 }
 function getDatabaseQueue(dbName) {
   throwIfDatabaseIsNotOpen(dbName);
@@ -41,6 +48,12 @@ function getDatabaseQueue(dbName) {
   return queue;
 }
 function queueOperationAsync(dbName, callback) {
+  return enqueueOperation(dbName, 'exclusive', callback);
+}
+function queueStatementAsync(dbName, callback) {
+  return enqueueOperation(dbName, 'statement', callback);
+}
+function enqueueOperation(dbName, kind, callback) {
   const databaseQueue = getDatabaseQueue(dbName);
   return new Promise((resolve, reject) => {
     async function start() {
@@ -50,34 +63,56 @@ function queueOperationAsync(dbName, callback) {
       } catch (error) {
         reject(error);
       } finally {
-        databaseQueue.inProgress = false;
-        startOperationAsync(databaseQueue);
+        if (kind === 'statement') {
+          databaseQueue.activeStatements--;
+          if (databaseQueue.activeStatements === 0) {
+            databaseQueue.inProgress = false;
+          }
+        } else {
+          databaseQueue.inProgress = false;
+        }
+        startNextOperations(databaseQueue);
       }
     }
     const operation = {
+      kind,
       start
     };
     databaseQueue.queue.push(operation);
-    startOperationAsync(databaseQueue);
+    startNextOperations(databaseQueue);
   });
 }
-function startOperationAsync(queue) {
-  // Queue is empty or in progress. Bail out.
-  if (queue.inProgress || queue.queue.length === 0) {
+function startNextOperations(queue) {
+  if (queue.draining || queue.inProgress && queue.activeStatements === 0) {
     return;
   }
-  queue.inProgress = true;
-  const operation = queue.queue.shift();
-  setImmediate(() => {
-    operation.start();
-  });
+  queue.draining = true;
+  try {
+    while (queue.queue.length > 0) {
+      const exclusiveIndex = queue.queue.findIndex(operation => operation.kind === 'exclusive');
+      const statementCount = exclusiveIndex === -1 ? queue.queue.length : exclusiveIndex;
+      if (statementCount > 0) {
+        const statements = queue.queue.splice(0, statementCount);
+        queue.inProgress = true;
+        queue.activeStatements += statements.length;
+        for (const statement of statements) statement.start();
+        continue;
+      }
+      if (queue.activeStatements > 0) return;
+      queue.inProgress = true;
+      queue.queue.shift().start();
+      return;
+    }
+  } finally {
+    queue.draining = false;
+  }
 }
 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.`);
+    throw new _NitroSQLiteError.default(`Cannot run synchronous operation on database. Database ${String(dbName)} is busy with another operation.`);
   }
 
   // Execute synchronously
@@ -86,6 +121,7 @@ function startOperationSync(dbName, callback) {
     return callback();
   } finally {
     databaseQueue.inProgress = false;
+    startNextOperations(databaseQueue);
   }
 }
 //# sourceMappingURL=DatabaseQueue.js.map