Adds failOnCreate option

android/build.gradle

@@ -89,6 +89,10 @@ if(useLibsql && useTurso) {
   throw new GradleException("[OP-SQLITE] Error: libsql and turso backends are mutually exclusive.")
 }
 
+if(useLibsql && useCRSQLite) {
+  throw new GradleException("[OP-SQLITE] Error: You cannot use crsqlite with libsql.")
+}
+
 if(useSQLCipher) {
   println "[OP-SQLITE] using sqlcipher."
 } else if(useTurso) {

cpp/DBHostObject.cpp

@@ -217,23 +217,20 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &db_name,
 
 DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                            std::string &db_name, std::string &path,
-                           bool readOnly,
-                           std::string &crsqlite_path,
-                           std::string &sqlite_vec_path,
+                           bool readOnly, bool failOnCreate,
                            std::string &encryption_key)
     : base_path(base_path), db_name(db_name), delete_db_name(db_name) {
   thread_pool = std::make_shared<ThreadPool>();
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-  db = opsqlite_open(db_name, path, readOnly, crsqlite_path, sqlite_vec_path,
-                     encryption_key);
+  db = opsqlite_open(db_name, path, readOnly, failOnCreate, encryption_key);
 #elif OP_SQLITE_USE_LIBSQL
   if (readOnly) {
     throw std::runtime_error("libsql does not support read-only databases.");
   }
-  db = opsqlite_libsql_open(db_name, path, crsqlite_path);
+  db = opsqlite_libsql_open(db_name, path, failOnCreate);
 #else
-  db = opsqlite_open(db_name, path, readOnly, crsqlite_path, sqlite_vec_path);
+  db = opsqlite_open(db_name, path, readOnly, failOnCreate);
 #endif
   create_jsi_functions(rt);
 };

cpp/DBHostObject.hpp

@@ -45,8 +45,8 @@ class JSI_EXPORT DBHostObject : public jsi::HostObject {
 public:
   // Normal constructor shared between all backends
   DBHostObject(jsi::Runtime &rt, std::string &base_path, std::string &db_name,
-               std::string &path, bool readOnly, std::string &crsqlite_path,
-               std::string &sqlite_vec_path, std::string &encryption_key);
+               std::string &path, bool readOnly, bool failOnCreate,
+               std::string &encryption_key);
 
 #ifdef OP_SQLITE_USE_LIBSQL
   // Constructor for remoteOpen, purely for remote databases

cpp/OPSqlite.cpp

@@ -61,6 +61,7 @@ void install(jsi::Runtime &rt,
     std::string location;
     std::string encryption_key;
     bool readOnly = false;
+    bool failOnCreate = false;
 
     if (options.hasProperty(rt, "location")) {
       location = options.getProperty(rt, "location").asString(rt).utf8(rt);
@@ -75,6 +76,10 @@ void install(jsi::Runtime &rt,
       readOnly = options.getProperty(rt, "readOnly").asBool();
     }
 
+    if (options.hasProperty(rt, "failOnCreate")) {
+      failOnCreate = options.getProperty(rt, "failOnCreate").asBool();
+    }
+
     if (!location.empty()) {
       if (location == ":memory:") {
         path = ":memory:";
@@ -86,7 +91,7 @@ void install(jsi::Runtime &rt,
     }
 
     std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, path, name, path, readOnly, _crsqlite_path, _sqlite_vec_path, encryption_key);
+        rt, path, name, path, readOnly, failOnCreate, encryption_key);
     dbs.emplace_back(db);
     return jsi::Object::createFromHostObject(rt, db);
   });
@@ -228,7 +233,7 @@ void expoUpdatesWorkaround(const char *base_path) {
   std::string path = std::string(base_path);
   // Open a DB before anything else so that expo-updates does not mess up the
   // configuration
-  opsqlite_libsql_open("__dummy", path, "");
+  opsqlite_libsql_open("__dummy", path, false);
 #endif
 }
 

cpp/bridge.cpp

@@ -81,14 +81,11 @@
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
 sqlite3 *opsqlite_open(std::string const &name, std::string const &path,
-                       bool readOnly, std::string const &crsqlite_path,
-                       std::string const &sqlite_vec_path,
+                       bool readOnly, bool failOnCreate,
                        std::string const &encryption_key) {
 #else
 sqlite3 *opsqlite_open(std::string const &name, std::string const &path,
-                       bool readOnly,
-                       [[maybe_unused]] std::string const &crsqlite_path,
-                       [[maybe_unused]] std::string const &sqlite_vec_path) {
+                       bool readOnly, bool failOnCreate) {
 #endif
   std::string final_path = opsqlite_get_db_path(name, path);
   char *errMsg;
@@ -98,7 +95,10 @@
   if (readOnly) {
     flags |= SQLITE_OPEN_READONLY;
   } else {
-    flags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+    flags |= SQLITE_OPEN_READWRITE;
+    if (!failOnCreate) {
+      flags |= SQLITE_OPEN_CREATE;
+    }
   }
 
   int status = sqlite3_open_v2(final_path.c_str(), &db, flags, nullptr);
@@ -135,7 +135,7 @@
 #ifdef OP_SQLITE_USE_CRSQLITE
   const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
 
-  sqlite3_load_extension(db, crsqlite_path.c_str(), crsqliteEntryPoint,
+  sqlite3_load_extension(db, _crsqlite_path.c_str(), crsqliteEntryPoint,
                          &errMsg);
 
   if (errMsg != nullptr) {
@@ -146,7 +146,7 @@
 #ifdef OP_SQLITE_USE_SQLITE_VEC
   const char *vec_entry_point = "sqlite3_vec_init";
 
-  sqlite3_load_extension(db, sqlite_vec_path.c_str(), vec_entry_point, &errMsg);
+  sqlite3_load_extension(db, _sqlite_vec_path.c_str(), vec_entry_point, &errMsg);
 
   if (errMsg != nullptr) {
     throw std::runtime_error(errMsg);
@@ -333,7 +333,7 @@
   if (isFailed) {
     throw std::runtime_error(
         "[op-sqlite] SQLite code: " + std::to_string(result) +
         " execution error: " + std::string(errorMessage));
   }
 
   int changedRowCount = sqlite3_changes(db);
@@ -654,7 +654,7 @@
   if (isFailed) {
     throw std::runtime_error(
         "[op-sqlite] SQLite error code: " + std::to_string(result) +
         ", description: " + std::string(errorMessage));
   }
 
   int changedRowCount = sqlite3_changes(db);
@@ -793,7 +793,7 @@
   if (isFailed) {
     throw std::runtime_error(
         "[op-sqlite] SQLite error code: " + std::to_string(step) +
         ", description: " + std::string(errorMessage));
   }
 
   int changedRowCount = sqlite3_changes(db);

cpp/bridge.hpp

@@ -22,19 +22,22 @@ typedef std::function<void(std::string dbName, std::string tableName,
 typedef std::function<void(std::string dbName)> CommitCallback;
 typedef std::function<void(std::string dbName)> RollbackCallback;
 
+// Paths to the optional loadable extensions, set once in install() and
+// shared by every subsequent open() call instead of being threaded through
+// as parameters.
+extern std::string _crsqlite_path;
+extern std::string _sqlite_vec_path;
+
 std::string opsqlite_get_db_path(std::string const &db_name,
                                  std::string const &location);
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
 sqlite3 *opsqlite_open(std::string const &dbName, std::string const &path,
-                       bool readOnly, std::string const &crsqlite_path,
-                       std::string const &sqlite_vec_path,
+                       bool readOnly, bool failOnCreate,
                        std::string const &encryption_key);
 #else
 sqlite3 *opsqlite_open(std::string const &name, std::string const &path,
-                       bool readOnly,
-                       [[maybe_unused]] std::string const &crsqlite_path,
-                       std::string const &sqlite_vec_path);
+                       bool readOnly, bool failOnCreate);
 #endif
 
 #ifdef OP_SQLITE_USE_TURSO

cpp/libsql/bridge.cpp

@@ -60,7 +60,7 @@
       .remote_encryption_key = remote_encryption_key.empty()
                                    ? nullptr
                                    : remote_encryption_key.c_str(),
       .sync_interval = sync_interval,
       .with_webpki = '1',
       .offline = offline,
   };
@@ -80,9 +80,16 @@
 }
 
 DB opsqlite_libsql_open(std::string const &name, std::string const &last_path,
-                        std::string const &crsqlitePath) {
+                        bool failOnCreate) {
   std::string path = opsqlite_get_db_path(name, last_path);
 
+  // libsql_open_file always creates the database file if it is missing,
+  // there is no "open existing only" flag, so failOnCreate is enforced up
+  // front by checking for the file's existence.
+  if (failOnCreate && path != ":memory:" && !std::filesystem::exists(path)) {
+    throw std::runtime_error("unable to open database file: " + path);
+  }
+
   int status;
   libsql_database_t db;
   libsql_connection_t c;
@@ -100,20 +107,6 @@
     throw std::runtime_error(err);
   }
 
-#ifdef OP_SQLITE_USE_CRSQLITE
-  const char *errMsg;
-  const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
-
-  status = libsql_load_extension(c, crsqlitePath.c_str(), crsqliteEntryPoint,
-                                 &errMsg);
-
-  if (status != 0) {
-    throw std::runtime_error(errMsg);
-  } else {
-    LOGI("Loaded CRSQlite successfully");
-  }
-#endif
-
   return {.db = db, .c = c};
 }
 

cpp/libsql/bridge.hpp

@@ -33,7 +33,7 @@ std::string opsqlite_get_db_path(std::string const &name,
                                  std::string const &location);
 
 DB opsqlite_libsql_open(std::string const &name, std::string const &path,
-                        std::string const &crsqlitePath);
+                        bool failOnCreate);
 
 DB opsqlite_libsql_open_remote(std::string const &url,
                                std::string const &auth_token);

cpp/turso_bridge.cpp

@@ -370,14 +370,23 @@ std::string opsqlite_get_db_path(std::string const &db_name,
 }
 
 sqlite3 *opsqlite_open(std::string const &name, std::string const &path,
-                       bool readOnly,
-                       [[maybe_unused]] std::string const &crsqlite_path,
-                       [[maybe_unused]] std::string const &sqlite_vec_path) {
+                       bool readOnly, bool failOnCreate) {
   if (readOnly) {
     throw std::runtime_error("turso does not support read-only databases.");
   }
   auto *handle = new TursoDbHandle();
   handle->path = opsqlite_get_db_path(name, path);
+
+  // Turso's API always creates the database file on open, there is no
+  // "open existing only" flag, so failOnCreate is enforced up front by
+  // checking for the file's existence.
+  if (failOnCreate && handle->path != ":memory:" &&
+      !std::filesystem::exists(handle->path)) {
+    std::string missing_path = handle->path;
+    delete handle;
+    throw std::runtime_error("unable to open database file: " + missing_path);
+  }
+
   setup_turso_temp_dir(handle->path);
 
   turso_database_config_t db_config = {

docs/docs/api.md

@@ -45,6 +45,23 @@ export const db = open({
 
 If you want to read more about securely storing your encryption key, [read this article](https://ospfranco.com/react-native-security-guide/). Again: **DO NOT OPEN MORE THAN ONE CONNECTION PER DATABASE**. Just export one single db connection for your entire application and reuse it everywhere.
 
+### Open Existing Only (failOnCreate)
+
+By default, `open()` creates the database file if it doesn't already exist. Pass `failOnCreate: true` to require the file to already exist; if it doesn't, the call throws instead of creating it. This is supported across all backends (plain SQLite3, SQLCipher, libsql and Turso).
+
+```tsx
+import { open } from '@op-engineering/op-sqlite';
+
+try {
+  const db = open({
+    name: 'myDb.sqlite',
+    failOnCreate: true,
+  });
+} catch (e) {
+  // The database file did not exist and was not created
+}
+```
+
 ### Remote and Sync Open (Libsql/Turso)
 
 For remote/sync scenarios, enable either the `libsql` or `turso` backend in your package configuration, then use `openRemote` or `openSync`.

docs/docs/changelog.md

@@ -0,0 +1,10 @@
+---
+sidebar_position: 11
+---
+
+# API Changes
+
+## 17.2.0
+
+- Added `failOnCreate` option to `open()`. When set to `true`, the database file must already exist; if it doesn't, `open()` throws instead of creating it. Implemented natively across all backends (plain SQLite3, SQLCipher, libsql and Turso). See the [Open Existing Only (failOnCreate)](./api.md#open-existing-only-failoncreate) section for usage.
+- Removed support for combining `crsqlite` with `libsql`. Enabling both in `package.json` now fails the build (iOS podspec and Android Gradle) with a clear error instead of silently loading the extension. If you relied on this combination, drop one of the two flags.