@op-engineering/op-sqlite 2.0.8 → 2.0.9

package/cpp/bindings.cpp

@@ -35,7 +35,7 @@ bool invalidated = false;
 void clearState() {
   invalidated = true;
   // Will terminate all operations and database connections
-  sqliteCloseAll();
+  sqlite_close_all();
   // We then join all the threads before the context gets invalidated
   pool.restartPool();
 
@@ -81,7 +81,7 @@ void install(jsi::Runtime &rt,
       }
     }
 
-    BridgeResult result = sqliteOpenDb(dbName, path);
+    BridgeResult result = sqlite_open(dbName, path);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -115,7 +115,7 @@ void install(jsi::Runtime &rt,
     std::string databaseToAttach = args[1].asString(rt).utf8(rt);
     std::string alias = args[2].asString(rt).utf8(rt);
     BridgeResult result =
-        sqliteAttachDb(dbName, tempDocPath, databaseToAttach, alias);
+        sqlite_attach(dbName, tempDocPath, databaseToAttach, alias);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -137,7 +137,7 @@ void install(jsi::Runtime &rt,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
     std::string alias = args[1].asString(rt).utf8(rt);
-    BridgeResult result = sqliteDetachDb(dbName, alias);
+    BridgeResult result = sqlite_detach(dbName, alias);
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -158,7 +158,7 @@ void install(jsi::Runtime &rt,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
 
-    BridgeResult result = sqliteCloseDb(dbName);
+    BridgeResult result = sqlite_close(dbName);
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -190,7 +190,7 @@ void install(jsi::Runtime &rt,
       tempDocPath = tempDocPath + "/" + args[1].asString(rt).utf8(rt);
     }
 
-    BridgeResult result = sqliteRemoveDb(dbName, tempDocPath);
+    BridgeResult result = sqlite_remove(dbName, tempDocPath);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -213,7 +213,7 @@ void install(jsi::Runtime &rt,
     std::shared_ptr<std::vector<SmartHostObject>> metadata =
         std::make_shared<std::vector<SmartHostObject>>();
 
-    auto status = sqliteExecute(dbName, query, &params, &results, metadata);
+    auto status = sqlite_execute(dbName, query, &params, &results, metadata);
 
     if (status.type == SQLiteError) {
       throw std::runtime_error(status.message);
@@ -249,7 +249,7 @@ void install(jsi::Runtime &rt,
               std::make_shared<std::vector<SmartHostObject>>();
 
           auto status =
-              sqliteExecute(dbName, query, &params, &results, metadata);
+              sqlite_execute(dbName, query, &params, &results, metadata);
 
           if (invalidated) {
             return;
@@ -432,7 +432,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      unregisterUpdateHook(dbName);
+      sqlite_deregister_update_hook(dbName);
       return {};
     }
 
@@ -449,7 +449,7 @@ void install(jsi::Runtime &rt,
       if (operation != "DELETE") {
         std::string query = "SELECT * FROM " + tableName +
                             " where rowid = " + std::to_string(rowId) + ";";
-        sqliteExecute(dbName, query, &params, &results, metadata);
+        sqlite_execute(dbName, query, &params, &results, metadata);
       }
 
       invoker->invokeAsync(
@@ -474,7 +474,7 @@ void install(jsi::Runtime &rt,
           });
     };
 
-    registerUpdateHook(dbName, std::move(hook));
+    sqlite_register_update_hook(dbName, std::move(hook));
 
     return {};
   });
@@ -490,7 +490,7 @@ void install(jsi::Runtime &rt,
     auto dbName = args[0].asString(rt).utf8(rt);
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
     if (callback->isUndefined() || callback->isNull()) {
-      unregisterCommitHook(dbName);
+      sqlite_deregister_commit_hook(dbName);
       return {};
     }
     commitHooks[dbName] = callback;
@@ -500,7 +500,7 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    registerCommitHook(dbName, std::move(hook));
+    sqlite_register_commit_hook(dbName, std::move(hook));
 
     return {};
   });
@@ -517,7 +517,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      unregisterRollbackHook(dbName);
+      sqlite_deregister_rollback_hook(dbName);
       return {};
     }
     rollbackHooks[dbName] = callback;
@@ -527,7 +527,7 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    registerRollbackHook(dbName, std::move(hook));
+    sqlite_register_rollback_hook(dbName, std::move(hook));
     return {};
   });
 

package/cpp/bridge.cpp

@@ -2,10 +2,8 @@
 #include "DumbHostObject.h"
 #include "SmartHostObject.h"
 #include "logs.h"
+#include "utils.h"
 #include <ctime>
-#include <sstream>
-#include <sys/stat.h>
-#include <unistd.h>
 #include <unordered_map>
 #include <variant>
 
@@ -31,63 +29,16 @@ std::unordered_map<std::string, std::function<void(std::string dbName)>>
         std::unordered_map<std::string,
                            std::function<void(std::string dbName)>>();
 
-bool folder_exists(const std::string &foldername) {
-  struct stat buffer;
-  return (stat(foldername.c_str(), &buffer) == 0);
-}
-
-/**
- * Portable wrapper for mkdir. Internally used by mkdir()
- * @param[in] path the full path of the directory to create.
- * @return zero on success, otherwise -1.
- */
-int _mkdir(const char *path) {
-#if _POSIX_C_SOURCE
-  return mkdir(path);
-#else
-  return mkdir(path, 0755); // not sure if this works on mac
-#endif
-}
-
-/**
- * Recursive, portable wrapper for mkdir.
- * @param[in] path the full path of the directory to create.
- * @return zero on success, otherwise -1.
- */
-int mkdir(const char *path) {
-  std::string current_level = "/";
-  std::string level;
-  std::stringstream ss(path);
-  // First line is empty because it starts with /User
-  getline(ss, level, '/');
-  // split path using slash as a separator
-  while (getline(ss, level, '/')) {
-    current_level += level; // append folder to the current level
-    // create current level
-    if (!folder_exists(current_level) && _mkdir(current_level.c_str()) != 0)
-      return -1;
-
-    current_level += "/"; // don't forget to append a slash
-  }
-
-  return 0;
-}
-
-inline bool file_exists(const std::string &path) {
-  struct stat buffer;
-  return (stat(path.c_str(), &buffer) == 0);
-}
-
 std::string get_db_path(std::string const dbName, std::string const lastPath) {
   if (lastPath == ":memory:") {
     return lastPath;
   }
-  mkdir(lastPath.c_str());
+  mkdir(lastPath);
   return lastPath + "/" + dbName;
 }
 
-BridgeResult sqliteOpenDb(std::string const dbName,
-                          std::string const lastPath) {
+BridgeResult sqlite_open(std::string const &dbName,
+                         std::string const &lastPath) {
   std::string dbPath = get_db_path(dbName, lastPath);
 
   int sqlOpenFlags =
@@ -106,7 +57,7 @@ BridgeResult sqliteOpenDb(std::string const dbName,
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
-BridgeResult sqliteCloseDb(std::string const dbName) {
+BridgeResult sqlite_close(std::string const &dbName) {
 
   if (dbMap.count(dbName) == 0) {
     return {
@@ -126,10 +77,10 @@ BridgeResult sqliteCloseDb(std::string const dbName) {
   };
 }
 
-BridgeResult sqliteAttachDb(std::string const mainDBName,
-                            std::string const docPath,
-                            std::string const databaseToAttach,
-                            std::string const alias) {
+BridgeResult sqlite_attach(std::string const &mainDBName,
+                           std::string const &docPath,
+                           std::string const &databaseToAttach,
+                           std::string const &alias) {
   /**
    * There is no need to check if mainDBName is opened because
    * sqliteExecuteLiteral will do that.
@@ -137,7 +88,7 @@ BridgeResult sqliteAttachDb(std::string const mainDBName,
   std::string dbPath = get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
-  BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
+  BridgeResult result = sqlite_execute_literal(mainDBName, statement);
 
   if (result.type == SQLiteError) {
     return {
@@ -151,14 +102,14 @@ BridgeResult sqliteAttachDb(std::string const mainDBName,
   };
 }
 
-BridgeResult sqliteDetachDb(std::string const mainDBName,
-                            std::string const alias) {
+BridgeResult sqlite_detach(std::string const &mainDBName,
+                           std::string const &alias) {
   /**
    * There is no need to check if mainDBName is opened because
    * sqliteExecuteLiteral will do that.
    * */
   std::string statement = "DETACH DATABASE " + alias;
-  BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
+  BridgeResult result = sqlite_execute_literal(mainDBName, statement);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -171,10 +122,10 @@ BridgeResult sqliteDetachDb(std::string const mainDBName,
   };
 }
 
-BridgeResult sqliteRemoveDb(std::string const dbName,
-                            std::string const docPath) {
+BridgeResult sqlite_remove(std::string const &dbName,
+                           std::string const &docPath) {
   if (dbMap.count(dbName) == 1) {
-    BridgeResult closeResult = sqliteCloseDb(dbName);
+    BridgeResult closeResult = sqlite_close(dbName);
     if (closeResult.type == SQLiteError) {
       return closeResult;
     }
@@ -230,7 +181,7 @@ void sqlite_bind_statement(sqlite3_stmt *statement,
 }
 
 BridgeResult sqlite_execute_prepared_statement(
-    std::string const dbName, sqlite3_stmt *statement,
+    std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
   if (dbMap.find(dbName) == dbMap.end()) {
@@ -368,7 +319,7 @@ BridgeResult sqlite_execute_prepared_statement(
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
+sqlite3_stmt *sqlite_prepare_statement(std::string const &dbName,
                                        std::string const &query) {
   if (dbMap.find(dbName) == dbMap.end()) {
     throw std::runtime_error("Database not opened");
@@ -392,10 +343,10 @@ sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
 }
 
 BridgeResult
-sqliteExecute(std::string const dbName, std::string const &query,
-              const std::vector<JSVariant> *params,
-              std::vector<DumbHostObject> *results,
-              std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
+sqlite_execute(std::string const &dbName, std::string const &query,
+               const std::vector<JSVariant> *params,
+               std::vector<DumbHostObject> *results,
+               std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
 
   if (dbMap.find(dbName) == dbMap.end()) {
     return {.type = SQLiteError,
@@ -427,7 +378,7 @@ sqliteExecute(std::string const dbName, std::string const &query,
           .message = "[op-sqlite] SQL statement error:" +
                      std::to_string(statementStatus) +
                      " description:" + std::string(message) +
-                     "see error codes: https://www.sqlite.org/rescode.html",
+                     ". See error codes: https://www.sqlite.org/rescode.html",
       };
     }
 
@@ -567,8 +518,8 @@ sqliteExecute(std::string const dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-BridgeResult sqliteExecuteLiteral(std::string const dbName,
-                                  std::string const &query) {
+BridgeResult sqlite_execute_literal(std::string const &dbName,
+                                    std::string const &query) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -621,7 +572,7 @@ BridgeResult sqliteExecuteLiteral(std::string const dbName,
   return {SQLiteOk, "", changedRowCount};
 }
 
-void sqliteCloseAll() {
+void sqlite_close_all() {
   for (auto const &x : dbMap) {
     // Interrupt will make all pending operations to fail with SQLITE_INTERRUPT
     // The ongoing work from threads will then fail ASAP
@@ -632,7 +583,7 @@ void sqliteCloseAll() {
   dbMap.clear();
 }
 
-std::string operationToString(int operation_type) {
+std::string operation_to_string(int operation_type) {
   switch (operation_type) {
   case SQLITE_INSERT:
     return "INSERT";
@@ -652,12 +603,12 @@ void update_callback(void *dbName, int operation_type, char const *database,
                      char const *table, sqlite3_int64 rowid) {
   std::string &strDbName = *(static_cast<std::string *>(dbName));
   auto callback = updateCallbackMap[strDbName];
-  callback(strDbName, std::string(table), operationToString(operation_type),
+  callback(strDbName, std::string(table), operation_to_string(operation_type),
            static_cast<int>(rowid));
 }
 
-BridgeResult registerUpdateHook(
-    std::string const dbName,
+BridgeResult sqlite_register_update_hook(
+    std::string const &dbName,
     std::function<void(std::string dbName, std::string tableName,
                        std::string operation, int rowId)> const callback) {
   if (dbMap.count(dbName) == 0) {
@@ -680,7 +631,7 @@ BridgeResult registerUpdateHook(
   return {SQLiteOk};
 }
 
-BridgeResult unregisterUpdateHook(std::string const dbName) {
+BridgeResult sqlite_deregister_update_hook(std::string const &dbName) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -701,9 +652,9 @@ int commit_callback(void *dbName) {
   return 0;
 }
 
-BridgeResult
-registerCommitHook(std::string const dbName,
-                   std::function<void(std::string dbName)> const callback) {
+BridgeResult sqlite_register_commit_hook(
+    std::string const &dbName,
+    std::function<void(std::string dbName)> const callback) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -724,7 +675,7 @@ registerCommitHook(std::string const dbName,
   return {SQLiteOk};
 }
 
-BridgeResult unregisterCommitHook(std::string const dbName) {
+BridgeResult sqlite_deregister_commit_hook(std::string const &dbName) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -742,9 +693,9 @@ void rollback_callback(void *dbName) {
   callback(strDbName);
 }
 
-BridgeResult
-registerRollbackHook(std::string const dbName,
-                     std::function<void(std::string dbName)> const callback) {
+BridgeResult sqlite_register_rollback_hook(
+    std::string const &dbName,
+    std::function<void(std::string dbName)> const callback) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -765,7 +716,7 @@ registerRollbackHook(std::string const dbName,
   return {SQLiteOk};
 }
 
-BridgeResult unregisterRollbackHook(std::string const dbName) {
+BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }

package/cpp/bridge.h

@@ -12,54 +12,54 @@ namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-BridgeResult sqliteOpenDb(std::string const dbName, std::string const dbPath);
+BridgeResult sqlite_open(std::string const &dbName, std::string const &dbPath);
 
-BridgeResult sqliteCloseDb(std::string const dbName);
+BridgeResult sqlite_close(std::string const &dbName);
 
-BridgeResult sqliteRemoveDb(std::string const dbName,
-                            std::string const docPath);
+BridgeResult sqlite_remove(std::string const &dbName,
+                           std::string const &docPath);
 
-BridgeResult sqliteAttachDb(std::string const mainDBName,
-                            std::string const docPath,
-                            std::string const databaseToAttach,
-                            std::string const alias);
+BridgeResult sqlite_attach(std::string const &mainDBName,
+                           std::string const &docPath,
+                           std::string const &databaseToAttach,
+                           std::string const &alias);
 
-BridgeResult sqliteDetachDb(std::string const mainDBName,
-                            std::string const alias);
+BridgeResult sqlite_detach(std::string const &mainDBName,
+                           std::string const &alias);
 
 BridgeResult
-sqliteExecute(std::string const dbName, std::string const &query,
-              const std::vector<JSVariant> *params,
-              std::vector<DumbHostObject> *results,
-              std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+sqlite_execute(std::string const &dbName, std::string const &query,
+               const std::vector<JSVariant> *params,
+               std::vector<DumbHostObject> *results,
+               std::shared_ptr<std::vector<SmartHostObject>> metadatas);
 
-BridgeResult sqliteExecuteLiteral(std::string const dbName,
-                                  std::string const &query);
+BridgeResult sqlite_execute_literal(std::string const &dbName,
+                                    std::string const &query);
 
-void sqliteCloseAll();
+void sqlite_close_all();
 
-BridgeResult registerUpdateHook(
-    std::string const dbName,
+BridgeResult sqlite_register_update_hook(
+    std::string const &dbName,
     std::function<void(std::string dbName, std::string tableName,
                        std::string operation, int rowId)> const callback);
-BridgeResult unregisterUpdateHook(std::string const dbName);
-BridgeResult
-registerCommitHook(std::string const dbName,
-                   std::function<void(std::string dbName)> const callback);
-BridgeResult unregisterCommitHook(std::string const dbName);
-BridgeResult
-registerRollbackHook(std::string const dbName,
-                     std::function<void(std::string dbName)> const callback);
-BridgeResult unregisterRollbackHook(std::string const dbName);
-
-sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
+BridgeResult sqlite_deregister_update_hook(std::string const &dbName);
+BridgeResult sqlite_register_commit_hook(
+    std::string const &dbName,
+    std::function<void(std::string dbName)> const callback);
+BridgeResult sqlite_deregister_commit_hook(std::string const &dbName);
+BridgeResult sqlite_register_rollback_hook(
+    std::string const &dbName,
+    std::function<void(std::string dbName)> const callback);
+BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName);
+
+sqlite3_stmt *sqlite_prepare_statement(std::string const &dbName,
                                        std::string const &query);
 
 void sqlite_bind_statement(sqlite3_stmt *statement,
                            const std::vector<JSVariant> *params);
 
 BridgeResult sqlite_execute_prepared_statement(
-    std::string const dbName, sqlite3_stmt *statement,
+    std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> metadatas);
 } // namespace opsqlite

package/cpp/sqlbatchexecutor.cpp

@@ -57,15 +57,15 @@ BatchResult sqliteExecuteBatch(std::string dbName,
 
   try {
     int affectedRows = 0;
-    sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+    sqlite_execute_literal(dbName, "BEGIN EXCLUSIVE TRANSACTION");
     for (int i = 0; i < commandCount; i++) {
       auto command = commands->at(i);
       // We do not provide a datastructure to receive query data because we
       // don't need/want to handle this results in a batch execution
-      auto result = sqliteExecute(dbName, command.sql, command.params.get(),
-                                  nullptr, nullptr);
+      auto result = sqlite_execute(dbName, command.sql, command.params.get(),
+                                   nullptr, nullptr);
       if (result.type == SQLiteError) {
-        sqliteExecuteLiteral(dbName, "ROLLBACK");
+        sqlite_execute_literal(dbName, "ROLLBACK");
         return BatchResult{
             .type = SQLiteError,
             .message = result.message,
@@ -74,14 +74,14 @@ BatchResult sqliteExecuteBatch(std::string dbName,
         affectedRows += result.affectedRows;
       }
     }
-    sqliteExecuteLiteral(dbName, "COMMIT");
+    sqlite_execute_literal(dbName, "COMMIT");
     return BatchResult{
         .type = SQLiteOk,
         .affectedRows = affectedRows,
         .commands = static_cast<int>(commandCount),
     };
   } catch (std::exception &exc) {
-    sqliteExecuteLiteral(dbName, "ROLLBACK");
+    sqlite_execute_literal(dbName, "ROLLBACK");
     return BatchResult{
         .type = SQLiteError,
         .message = exc.what(),

package/cpp/utils.cpp

@@ -3,6 +3,9 @@
 #include "bridge.h"
 #include <fstream>
 #include <iostream>
+#include <sstream>
+#include <sys/stat.h>
+#include <unistd.h>
 
 namespace opsqlite {
 
@@ -191,12 +194,12 @@ BatchResult importSQLFile(std::string dbName, std::string fileLocation) {
     try {
       int affectedRows = 0;
       int commands = 0;
-      sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+      sqlite_execute_literal(dbName, "BEGIN EXCLUSIVE TRANSACTION");
       while (std::getline(sqFile, line, '\n')) {
         if (!line.empty()) {
-          BridgeResult result = sqliteExecuteLiteral(dbName, line);
+          BridgeResult result = sqlite_execute_literal(dbName, line);
           if (result.type == SQLiteError) {
-            sqliteExecuteLiteral(dbName, "ROLLBACK");
+            sqlite_execute_literal(dbName, "ROLLBACK");
             sqFile.close();
             return {SQLiteError, result.message, 0, commands};
           } else {
@@ -206,11 +209,11 @@ BatchResult importSQLFile(std::string dbName, std::string fileLocation) {
         }
       }
       sqFile.close();
-      sqliteExecuteLiteral(dbName, "COMMIT");
+      sqlite_execute_literal(dbName, "COMMIT");
       return {SQLiteOk, "", affectedRows, commands};
     } catch (...) {
       sqFile.close();
-      sqliteExecuteLiteral(dbName, "ROLLBACK");
+      sqlite_execute_literal(dbName, "ROLLBACK");
       return {SQLiteError,
               "[op-sqlite][loadSQLFile] Unexpected error, transaction was "
               "rolledback",
@@ -221,4 +224,19 @@ BatchResult importSQLFile(std::string dbName, std::string fileLocation) {
   }
 }
 
+bool folder_exists(const std::string &foldername) {
+  struct stat buffer;
+  return (stat(foldername.c_str(), &buffer) == 0);
+}
+
+bool file_exists(const std::string &path) {
+  struct stat buffer;
+  return (stat(path.c_str(), &buffer) == 0);
+}
+
+int mkdir(std::string const &path) {
+  std::filesystem::create_directories(path);
+  return 0;
+}
+
 } // namespace opsqlite

package/cpp/utils.h

@@ -43,6 +43,12 @@ jsi::Value createResult(jsi::Runtime &rt, BridgeResult status,
 
 BatchResult importSQLFile(std::string dbName, std::string fileLocation);
 
+int mkdir(const std::string &path);
+
+bool folder_exists(const std::string &foldername);
+
+bool file_exists(const std::string &path);
+
 } // namespace opsqlite
 
 #endif /* utils_h */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",