react-native-nitro-sqlite 9.8.1 → 10.0.0

package/RNNitroSQLite.podspec

@@ -51,7 +51,11 @@ Pod::Spec.new do |s|
   s.homepage     = package["homepage"]
   s.license      = package["license"]
   s.authors      = package["author"]
-  s.platforms    = { :ios => min_ios_version_supported, :visionos => "1.0" }
+  s.platforms    = {
+    :ios => min_ios_version_supported,
+    :visionos => "1.0",
+    :osx => "10.13",
+  }
   s.source       = { :git => "https://github.com/margelo/react-native-nitro-sqlite.git", :tag => "#{s.version}" }
 
   # Opt-in vector search (NITRO_SQLITE_VEC=1); the companion pod compiles the sources.
@@ -59,9 +63,9 @@ Pod::Spec.new do |s|
   nitro_sqlite_vec_cpp = File.expand_path(File.join(__dir__, "..", "react-native-nitro-sqlite-vec", "cpp"))
 
   s.source_files = [
-    # Implementation (Swift)
+    # Apple platform implementation (Swift)
     "ios/**/*.{swift}",
-    # Autolinking/Registration (Objective-C++)
+    # Apple platform autolinking/registration (Objective-C++)
     "ios/**/*.{h,hpp,m,mm}",
     # Implementation (C++ objects)
     "cpp/**/*.{h,hpp,c,cpp}"

package/android/CMakeLists.txt

@@ -5,13 +5,14 @@ set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 20)
 
 add_definitions(
+  ${SQLITE_DEFAULT_FLAGS}
   ${SQLITE_FLAGS}
 )
 
 file(GLOB_RECURSE cpp_files RELATIVE ${CMAKE_SOURCE_DIR}
   "../cpp/**.c"
   "../cpp/**.cpp"
-  "cpp-adapter.cpp"
+  "RNNitroSQLiteAdapter.cpp"
 )
 
 # Create library "RNNitroSQLite" and add all C++ files to it
@@ -34,7 +35,7 @@ if(NITRO_SQLITE_VEC)
   message(STATUS "[react-native-nitro-sqlite] vector search ENABLED (sqlite-vec from ${NITRO_SQLITE_VEC_CPP_DIR})")
   set(NITRO_SQLITE_VEC_SOURCES
     "${NITRO_SQLITE_VEC_CPP_DIR}/sqlite-vec/sqlite-vec.c"
-    "${NITRO_SQLITE_VEC_CPP_DIR}/registerVectorExtensions.cpp"
+    "${NITRO_SQLITE_VEC_CPP_DIR}/NitroSQLiteVecRegisterVectorExtensions.cpp"
   )
   target_sources(${CMAKE_PROJECT_NAME} PRIVATE ${NITRO_SQLITE_VEC_SOURCES})
   # SQLITE_CORE: link against our bundled sqlite3; SQLITE_VEC_STATIC: drop Windows dllexport.

package/android/build.gradle

@@ -73,6 +73,7 @@ file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { rea
 def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
 def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
 
+apply from: file('sqlite-flags.gradle')
 def SQLITE_FLAGS = rootProject.properties['nitroSqliteFlags']
 
 // Opt-in: resolve the companion's cpp dir so CMake compiles its sqlite-vec into this library.
@@ -122,6 +123,7 @@ android {
         arguments "-DANDROID_STL=c++_shared",
           "-DANDROID_TOOLCHAIN=clang",
           "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
+          "-DSQLITE_DEFAULT_FLAGS=${nitroSqliteDefaultFlags.join(';')}",
           "-DSQLITE_FLAGS='${SQLITE_FLAGS ? SQLITE_FLAGS : ''}'",
           "-DNITRO_SQLITE_VEC=${NITRO_SQLITE_VEC_ENABLED ? 'ON' : 'OFF'}",
           "-DNITRO_SQLITE_VEC_CPP_DIR=${NITRO_SQLITE_VEC_CPP_DIR}",

package/android/sqlite-flags.gradle

@@ -0,0 +1,47 @@
+import groovy.json.JsonSlurper
+
+project.ext.resolveNitroSqliteDefaultFlags = { File appPackageFile, String customFlags ->
+  def appPackage = appPackageFile.exists() ? new JsonSlurper().parse(appPackageFile) : [:]
+  def appConfig = appPackage.get("nitroSQLite", [:])
+
+  if (!(appConfig instanceof Map)) {
+    throw new GradleException("nitroSQLite in package.json must be an object")
+  }
+
+  def readBooleanFlag = { String name ->
+    def value = appConfig.get(name, true)
+    if (!(value instanceof Boolean)) {
+      throw new GradleException("nitroSQLite.${name} in package.json must be true or false")
+    }
+    value
+  }
+
+  def threadSafe = readBooleanFlag("threadSafe")
+  def performanceMode = readBooleanFlag("performanceMode")
+  def customFlagNames = (customFlags =~ /-D([A-Za-z_][A-Za-z0-9_]*)/).collect { it[1] }.toSet()
+
+  def defaultFlags = [threadSafe ? '-DSQLITE_THREADSAFE=1' : '-DSQLITE_THREADSAFE=0']
+  if (performanceMode) {
+    defaultFlags += [
+      "-DSQLITE_DQS=0",
+      "-DSQLITE_DEFAULT_MEMSTATUS=0",
+      "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1",
+      "-DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1",
+      "-DSQLITE_MAX_EXPR_DEPTH=0",
+      "-DSQLITE_OMIT_DEPRECATED=1",
+      "-DSQLITE_OMIT_PROGRESS_CALLBACK=1",
+      "-DSQLITE_OMIT_SHARED_CACHE=1",
+      "-DSQLITE_USE_ALLOCA=1",
+    ]
+  }
+
+  // Preserve nitroSqliteFlags as an override for individual compile definitions.
+  defaultFlags.findAll { flag ->
+    def name = flag.substring(2).split("=")[0]
+    !customFlagNames.contains(name) && !(name == "SQLITE_THREADSAFE" && customFlagNames.contains("THREADSAFE"))
+  }
+}
+
+def appPackageFile = new File(rootProject.projectDir.parentFile, "package.json")
+def customFlags = (rootProject.findProperty("nitroSqliteFlags") ?: "").toString()
+project.ext.nitroSqliteDefaultFlags = resolveNitroSqliteDefaultFlags(appPackageFile, customFlags)

package/cpp/NitroSQLiteDatabaseConnections.cpp

@@ -0,0 +1,306 @@
+#include "NitroSQLiteDatabaseConnections.hpp"
+#include "NitroSQLiteDatabaseMigration.hpp"
+#include "NitroSQLiteException.hpp"
+#include <filesystem>
+#include <memory>
+#include <stdexcept>
+#include <unordered_map>
+#include <vector>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+namespace fs = std::filesystem;
+
+namespace {
+
+  constexpr const char* kIndependentPrefix = "nitro-sqlite:";
+
+  int readOnlyAuthorizer(void*, int action, const char*, const char*, const char*, const char*) {
+    return action == SQLITE_ATTACH ? SQLITE_DENY : SQLITE_OK;
+  }
+
+  struct IndependentId {
+    fs::path physicalPath;
+    bool readOnly;
+  };
+
+  std::optional<IndependentId> parseIndependentId(const std::string& key) {
+    if (key.empty() || key.front() != '\0' || key.compare(1, std::char_traits<char>::length(kIndependentPrefix), kIndependentPrefix) != 0) {
+      return std::nullopt;
+    }
+    const auto separator = key.find('\0', 1);
+    if (separator == std::string::npos || separator + 2 >= key.size()) {
+      return std::nullopt;
+    }
+    const char mode = key[separator + 1];
+    if (mode != 'r' && mode != 'w') {
+      return std::nullopt;
+    }
+    return IndependentId{fs::path(key.substr(separator + 2)), mode == 'r'};
+  }
+
+  std::string connectionLabel(const std::string& key) {
+    const auto independent = parseIndependentId(key);
+    if (independent) {
+      return independent->physicalPath.string();
+    }
+    return key.find('\0') == std::string::npos ? key : "invalid connection ID";
+  }
+
+  template <typename Predicate>
+  bool anyDatabasePath(sqlite3* database, Predicate&& predicate) {
+    sqlite3_stmt* rawStatement = nullptr;
+    const int prepared = sqlite3_prepare_v2(database, "PRAGMA database_list", -1, &rawStatement, nullptr);
+    std::unique_ptr<sqlite3_stmt, decltype(&sqlite3_finalize)> statement(rawStatement, sqlite3_finalize);
+    if (prepared != SQLITE_OK) {
+      throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(database));
+    }
+    int result;
+    while ((result = sqlite3_step(statement.get())) == SQLITE_ROW) {
+      const auto* rawPath = reinterpret_cast<const char*>(sqlite3_column_text(statement.get(), 2));
+      if (rawPath != nullptr && rawPath[0] != '\0' && predicate(fs::path(rawPath))) {
+        return true;
+      }
+    }
+    if (result != SQLITE_DONE) {
+      throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(database));
+    }
+    return false;
+  }
+
+  bool sameFile(const fs::path& first, const fs::path& second) {
+    std::error_code error;
+    if (fs::equivalent(first, second, error) && !error) {
+      return true;
+    }
+    return canonicalDatabasePath(first) == canonicalDatabasePath(second);
+  }
+
+} // namespace
+
+SQLiteConnection::SQLiteConnection(std::string connectionName, fs::path path, bool isReadOnly, sqlite3* handle)
+    : name(std::move(connectionName)), physicalPath(canonicalDatabasePath(path)), readOnly(isReadOnly), database(handle) {}
+
+SQLiteConnection::~SQLiteConnection() {
+  close();
+}
+
+void SQLiteConnection::close() noexcept {
+  std::lock_guard lock(mutex);
+  if (database == nullptr) {
+    return;
+  }
+  sqlite3_close_v2(database);
+  database = nullptr;
+}
+
+void DatabaseConnections::open(const std::string& key, const fs::path& path, bool readOnly) {
+  std::lock_guard lock(lifecycleMutex);
+  validateDatabaseName(key);
+  if (connections.contains(key)) {
+    throw NitroSQLiteException::DatabaseAlreadyOpen(key);
+  }
+  openKey(key, path, readOnly);
+}
+
+std::string DatabaseConnections::openIndependent(const fs::path& path, bool readOnly) {
+  std::lock_guard lock(lifecycleMutex);
+  if (path.string().find('\0') != std::string::npos) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, "Database path contains a NUL byte");
+  }
+  if (sqlite3_threadsafe() == 0) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened,
+                               "Independent connections require a thread-safe SQLite build");
+  }
+  // NUL cannot occur in a filesystem name. The ID cannot collide with a legacy database key.
+  const auto physicalPath = canonicalDatabasePath(path);
+  const std::string key = std::string(1, '\0') + kIndependentPrefix + std::to_string(++nextConnectionId) + std::string(1, '\0') +
+                          (readOnly ? "r" : "w") + physicalPath.string();
+  openKey(key, path, readOnly);
+  return key;
+}
+
+void DatabaseConnections::openKey(const std::string& key, const fs::path& path, bool readOnly) {
+  if (path.string().find('\0') != std::string::npos) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, "Database path contains a NUL byte");
+  }
+  const auto physicalPath = canonicalDatabasePath(path);
+  const int flags = (readOnly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE) | SQLITE_OPEN_FULLMUTEX;
+  sqlite3* rawDatabase = nullptr;
+  const int result = sqlite3_open_v2(physicalPath.string().c_str(), &rawDatabase, flags, nullptr);
+  std::unique_ptr<sqlite3, decltype(&sqlite3_close_v2)> database(rawDatabase, sqlite3_close_v2);
+  if (result != SQLITE_OK) {
+    const std::string message = rawDatabase == nullptr ? sqlite3_errstr(result) : sqlite3_errmsg(rawDatabase);
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, message);
+  }
+  if (readOnly) {
+    sqlite3_set_authorizer(database.get(), readOnlyAuthorizer, nullptr);
+  }
+  auto connection = std::make_shared<SQLiteConnection>(connectionLabel(key), physicalPath, readOnly, database.get());
+  database.release();
+  connections.emplace(key, std::move(connection));
+}
+
+void DatabaseConnections::close(const std::string& key) {
+  std::lock_guard lock(lifecycleMutex);
+  const auto found = connections.find(key);
+  if (found == connections.end()) {
+    throw NitroSQLiteException::DatabaseNotOpen(connectionLabel(key));
+  }
+  auto connection = std::move(found->second);
+  connections.erase(found);
+  connection->close();
+}
+
+void DatabaseConnections::closeAll() {
+  std::lock_guard lock(lifecycleMutex);
+  for (auto& [key, connection] : connections) {
+    connection->close();
+  }
+  connections.clear();
+}
+
+SQLiteConnectionPtr DatabaseConnections::get(const std::string& key) {
+  std::lock_guard lock(lifecycleMutex);
+  const auto found = connections.find(key);
+  if (found == connections.end()) {
+    throw NitroSQLiteException::DatabaseNotOpen(connectionLabel(key));
+  }
+  return found->second;
+}
+
+bool DatabaseConnections::isOpen(const std::string& key) {
+  std::lock_guard lock(lifecycleMutex);
+  return connections.contains(key);
+}
+
+std::optional<fs::path> DatabaseConnections::physicalPathForKey(const std::string& key) {
+  std::lock_guard lock(lifecycleMutex);
+  const auto live = connections.find(key);
+  if (live != connections.end()) {
+    return live->second->physicalPath;
+  }
+  const auto independent = parseIndependentId(key);
+  return independent ? std::optional<fs::path>(independent->physicalPath) : std::nullopt;
+}
+
+std::optional<fs::path> DatabaseConnections::findLivePath(const fs::path& first, const fs::path& second) {
+  std::optional<fs::path> found;
+  withConnectionsLocked([&]() {
+    for (const auto& [_, connection] : connections) {
+      if (connection->database == nullptr) {
+        continue;
+      }
+      anyDatabasePath(connection->database, [&](const fs::path& candidate) {
+        if (sameFile(candidate, first)) {
+          found = first;
+          return true;
+        }
+        if (sameFile(candidate, second)) {
+          found = second;
+          return true;
+        }
+        return false;
+      });
+      if (found) {
+        return;
+      }
+    }
+  });
+  return found;
+}
+
+void DatabaseConnections::withConnectionsLocked(const std::function<void()>& action) {
+  std::lock_guard lifecycleLock(lifecycleMutex);
+  std::vector<std::unique_lock<std::recursive_mutex>> locks;
+  locks.reserve(connections.size());
+  for (const auto& [_, connection] : connections) {
+    locks.emplace_back(connection->mutex);
+  }
+  action();
+}
+
+void DatabaseConnections::drop(const std::string& dbName, const fs::path& path, const std::optional<std::string>& connectionId,
+                               const std::optional<fs::path>& otherPath) {
+  std::lock_guard lifecycleLock(lifecycleMutex);
+  validateDatabaseName(dbName);
+  const auto target = canonicalDatabasePath(path);
+  if (!fs::exists(target)) {
+    throw NitroSQLiteException::DatabaseFileNotFound(target.string());
+  }
+  const auto key = connectionId.value_or(dbName);
+  const auto live = connections.find(key);
+  const auto independent = connectionId ? parseIndependentId(*connectionId) : std::nullopt;
+  if (connectionId && !independent) {
+    throw NitroSQLiteException::DatabaseNotOpen(connectionLabel(key));
+  }
+  if (independent && (!sameFile(independent->physicalPath, target) || independent->readOnly)) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, independent->readOnly
+                                                                                ? "A read-only connection cannot delete a database"
+                                                                                : "Connection targets a different database file");
+  }
+  if (live != connections.end()) {
+    if (!sameFile(live->second->physicalPath, target)) {
+      throw NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, "Connection targets a different database file");
+    }
+    if (live->second->readOnly) {
+      throw NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, "A read-only connection cannot delete a database");
+    }
+  }
+
+  const SQLiteConnectionPtr connectionToClose = live == connections.end() ? nullptr : live->second;
+  withConnectionsLocked([&]() {
+    if (isPathInUse(target, key) || (otherPath && isPathInUse(*otherPath, key))) {
+      throw NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, "Database is in use by another connection");
+    }
+    if (!fs::exists(target)) {
+      throw NitroSQLiteException::DatabaseFileNotFound(target.string());
+    }
+    if (connectionToClose) {
+      close(key);
+    }
+    if (!removeDatabaseFiles(target.filename().string(), target.parent_path())) {
+      throw NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, "Could not remove database files");
+    }
+    if (otherPath) {
+      removeDatabaseFiles(otherPath->filename().string(), otherPath->parent_path());
+    }
+  });
+}
+
+bool DatabaseConnections::isPathInUse(const fs::path& path, const std::string& excludedKey) const {
+  for (const auto& [key, connection] : connections) {
+    if (key == excludedKey) {
+      continue;
+    }
+    if (connection->database == nullptr) {
+      continue;
+    }
+    if (anyDatabasePath(connection->database, [&](const fs::path& candidate) { return sameFile(candidate, path); })) {
+      return true;
+    }
+  }
+  return false;
+}
+
+DatabaseConnections& databaseConnections() {
+  static DatabaseConnections registry;
+  return registry;
+}
+
+void validateDatabaseName(const std::string& dbName) {
+  if (dbName.find('\0') != std::string::npos) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, "Database name contains a NUL byte");
+  }
+}
+
+fs::path canonicalDatabasePath(const fs::path& path) {
+  std::error_code error;
+  auto canonical = fs::weakly_canonical(path, error);
+  if (!error) {
+    return canonical;
+  }
+  return fs::absolute(path).lexically_normal();
+}
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/NitroSQLiteDatabaseConnections.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <filesystem>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <queue>
+#include <sqlite3.h>
+#include <string>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+/** One native SQLite handle, its file identity, and its operation locks. */
+struct SQLiteConnection final : std::enable_shared_from_this<SQLiteConnection> {
+  SQLiteConnection(std::string name, std::filesystem::path physicalPath, bool readOnly, sqlite3* database);
+  ~SQLiteConnection();
+
+  SQLiteConnection(const SQLiteConnection&) = delete;
+  SQLiteConnection& operator=(const SQLiteConnection&) = delete;
+
+  /** Close the native handle. References to this connection may remain alive. */
+  void close() noexcept;
+  /** Submit an operation to this connection's native FIFO worker. */
+  void enqueueAsync(std::function<void()> operation);
+
+  const std::string name;
+  const std::filesystem::path physicalPath;
+  const bool readOnly;
+  sqlite3* database;
+  std::recursive_mutex mutex;
+
+private:
+  void drainAsync();
+
+  std::mutex asyncQueueMutex;
+  std::queue<std::function<void()>> asyncQueue;
+  bool asyncWorkerRunning = false;
+};
+
+/** Shared ownership of a native connection across pending operations. */
+using SQLiteConnectionPtr = std::shared_ptr<SQLiteConnection>;
+
+/** Registry of default database names and opaque independent connection IDs. */
+class DatabaseConnections final {
+public:
+  // Callers hold this while resolving or migrating a database path. It is recursive because
+  // open, attach and drop take it again after path resolution.
+  std::recursive_mutex lifecycleMutex;
+
+  /** Open a name-based default connection. An existing key is an error. */
+  void open(const std::string& key, const std::filesystem::path& path, bool readOnly);
+  /** Open a separate handle to @p path and return its opaque connection ID. */
+  std::string openIndependent(const std::filesystem::path& path, bool readOnly);
+  /** Close the handle identified by a default name or independent ID. */
+  void close(const std::string& key);
+  /** Close all registered handles. */
+  void closeAll();
+  /** Return a live connection or throw if @p key is unknown. */
+  SQLiteConnectionPtr get(const std::string& key);
+  /** Check whether @p key still identifies an open connection. */
+  bool isOpen(const std::string& key);
+  /** Resolve the file path for a registered or encoded independent key. */
+  std::optional<std::filesystem::path> physicalPathForKey(const std::string& key);
+  /** Find an open connection using either candidate path. */
+  std::optional<std::filesystem::path> findLivePath(const std::filesystem::path& first, const std::filesystem::path& second);
+  /** Run @p action while holding the lifecycle and every connection lock. */
+  void withConnectionsLocked(const std::function<void()>& action);
+  /** Delete a database after checking that no other connection or attachment uses it. */
+  void drop(const std::string& dbName, const std::filesystem::path& path, const std::optional<std::string>& connectionId,
+            const std::optional<std::filesystem::path>& otherPath = std::nullopt);
+
+private:
+  void openKey(const std::string& key, const std::filesystem::path& path, bool readOnly);
+  bool isPathInUse(const std::filesystem::path& path, const std::string& excludedKey) const;
+
+  std::map<std::string, SQLiteConnectionPtr> connections;
+  unsigned long long nextConnectionId = 0;
+};
+
+DatabaseConnections& databaseConnections();
+std::filesystem::path canonicalDatabasePath(const std::filesystem::path& path);
+void validateDatabaseName(const std::string& dbName);
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{databaseMigration.cpp → NitroSQLiteDatabaseMigration.cpp}

@@ -1,5 +1,5 @@
-#include "databaseMigration.hpp"
-#include "logs.hpp"
+#include "NitroSQLiteDatabaseMigration.hpp"
+#include "NitroSQLiteLogs.hpp"
 #include <array>
 #include <system_error>
 

package/cpp/{sqliteExecuteBatch.cpp → NitroSQLiteExecuteBatch.cpp}

@@ -1,12 +1,12 @@
 /**
  * SQL Batch execution implementation using default sqliteBridge implementation
  */
-#include "sqliteExecuteBatch.hpp"
+#include "NitroSQLiteExecuteBatch.hpp"
 #include "NitroSQLiteException.hpp"
-#include "operations.hpp"
+#include "NitroSQLiteOperations.hpp"
 #include <utility>
 
-namespace margelo::rnnitrosqlite {
+namespace margelo::nitro::rnnitrosqlite {
 
 std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryCommand>& batchParams) {
   auto commands = std::vector<BatchQuery>();
@@ -67,4 +67,4 @@ SQLiteOperationResult sqliteExecuteBatch(const SQLiteConnectionPtr& connection,
   }
 }
 
-} // namespace margelo::rnnitrosqlite
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{sqliteExecuteBatch.hpp → NitroSQLiteExecuteBatch.hpp}

@@ -4,13 +4,10 @@
 #pragma once
 
 #include "BatchQueryCommand.hpp"
-#include "types.hpp"
+#include "NitroSQLiteTypes.hpp"
 #include <memory>
 
-using namespace facebook;
-using namespace margelo::nitro;
-
-namespace margelo::rnnitrosqlite {
+namespace margelo::nitro::rnnitrosqlite {
 
 struct SQLiteConnection;
 
@@ -31,4 +28,4 @@ std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryComman
 SQLiteOperationResult sqliteExecuteBatch(const std::string& dbName, const std::vector<BatchQuery>& commands);
 SQLiteOperationResult sqliteExecuteBatch(const std::shared_ptr<SQLiteConnection>& connection, const std::vector<BatchQuery>& commands);
 
-} // namespace margelo::rnnitrosqlite
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{importSqlFile.cpp → NitroSQLiteImportSqlFile.cpp}

@@ -2,13 +2,13 @@
  * SQL File Loader implementation
  */
 
-#include "importSqlFile.hpp"
+#include "NitroSQLiteImportSqlFile.hpp"
 #include "NitroSQLiteException.hpp"
-#include "operations.hpp"
+#include "NitroSQLiteOperations.hpp"
 #include <fstream>
 #include <iostream>
 
-namespace margelo::rnnitrosqlite {
+namespace margelo::nitro::rnnitrosqlite {
 
 SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string& fileLocation) {
   return importSqlFile(sqliteGetOpenDatabase(dbName), fileLocation);
@@ -50,4 +50,4 @@ SQLiteOperationResult importSqlFile(const SQLiteConnectionPtr& connection, const
   }
 }
 
-} // namespace margelo::rnnitrosqlite
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{importSqlFile.hpp → NitroSQLiteImportSqlFile.hpp}

@@ -6,14 +6,14 @@
 
 #pragma once
 
-#include "types.hpp"
+#include "NitroSQLiteTypes.hpp"
 #include <memory>
 
-namespace margelo::rnnitrosqlite {
+namespace margelo::nitro::rnnitrosqlite {
 
 struct SQLiteConnection;
 
 SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string& fileLocation);
 SQLiteOperationResult importSqlFile(const std::shared_ptr<SQLiteConnection>& connection, const std::string& fileLocation);
 
-} // namespace margelo::rnnitrosqlite
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{macros.hpp → NitroSQLiteMacros.hpp}

@@ -1,5 +1,5 @@
-#ifndef macros_h
-#define macros_h
+#ifndef NITRO_SQLITE_MACROS_HPP
+#define NITRO_SQLITE_MACROS_HPP
 
 #define HOSTFN(name, basecount)                                                                                                            \
 jsi::Function::createFromHostFunction( \
@@ -10,4 +10,4 @@ basecount, \
 
 #define JSIFN(capture) capture(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count)->jsi::Value
 
-#endif /* macros_h */
+#endif /* NITRO_SQLITE_MACROS_HPP */