@op-engineering/op-sqlite 2.0.22 → 3.0.1

package/android/CMakeLists.txt

@@ -6,9 +6,10 @@ set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 17)
 set (BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
 
-include_directories(
-  ../cpp
-)
+ include_directories(
+   ../cpp
+   ../cpp/sqlcipher
+ )
 
 add_definitions(
   ${SQLITE_FLAGS}
@@ -21,8 +22,6 @@ add_library(
   ../cpp/bridge.h
   ../cpp/bindings.cpp
   ../cpp/bindings.h
-  ../cpp/sqlite3.h
-  ../cpp/sqlite3.c
   ../cpp/utils.h
   ../cpp/utils.cpp
   ../cpp/ThreadPool.h
@@ -40,6 +39,20 @@ add_library(
   cpp-adapter.cpp
 )
 
+if (OP_SQLITE_USE_SQLCIPHER)
+  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlcipher/sqlite3.h ../cpp/sqlcipher/sqlite3.c)
+
+  add_definitions(
+    -DOP_SQLITE_USE_SQLCIPHER
+    -DSQLITE_HAS_CODEC
+    -DSQLITE_TEMP_STORE=2
+  )
+  
+  find_package(openssl REQUIRED CONFIG)
+else()
+ target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlite3.h ../cpp/sqlite3.c)
+endif()
+
 set_target_properties(
   ${PACKAGE_NAME} PROPERTIES
   CXX_STANDARD 17
@@ -49,12 +62,19 @@ set_target_properties(
 
 find_package(ReactAndroid REQUIRED CONFIG)
 find_package(fbjni REQUIRED CONFIG)
+find_library(LOG_LIB log)
+
 
 target_link_libraries(
   ${PACKAGE_NAME}
+  ${LOG_LIB}
   fbjni::fbjni
   ReactAndroid::jsi
   ReactAndroid::turbomodulejsijni
   ReactAndroid::react_nativemodule_core
   android
 )
+
+if (OP_SQLITE_USE_SQLCIPHER)
+  target_link_libraries(${PACKAGE_NAME} PRIVATE openssl::crypto)
+endif()

package/android/build.gradle

@@ -78,17 +78,23 @@ android {
         cmake {
             if(System.getenv("OP_SQLITE_PERF") == '1') {
               println "OP-SQLITE performance mode enabled! 🚀"
-              cFlags "-DSQLITE_DQS=0", "-DSQLITE_THREADSAFE=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"
+              cFlags  += ["-DSQLITE_DQS=0", "-DSQLITE_THREADSAFE=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"]
             }
             if(System.getenv("OP_SQLITE_PERF") == '2') {
               println "OP-SQLITE (thread safe) performance mode enabled! 🚀"
-              cFlags "-DSQLITE_DQS=0", "-DSQLITE_THREADSAFE=1", "-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"
+              cFlags += ["-DSQLITE_DQS=0", "-DSQLITE_THREADSAFE=1", "-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"]
             }
+
+            if(System.getenv("OP_SQLITE_USE_SQLCIPHER") == '1') {
+              println "OP-SQLITE using SQLCipher! 🔒"
+              cFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
+            }
+
             cppFlags "-O2", "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
             abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
-            arguments '-DANDROID_STL=c++_shared',
-              "-DSQLITE_FLAGS='${SQLITE_FLAGS ? SQLITE_FLAGS : ''}'",
-              "-DUSE_HERMES=${USE_HERMES}"
+            arguments "-DANDROID_STL=c++_shared",
+              "-DSQLITE_FLAGS='${SQLITE_FLAGS ? SQLITE_FLAGS : ''}'"
+              "-DOP_SQLITE_USE_SQLCIPHER='${System.getenv("OP_SQLITE_USE_SQLCIPHER") == '1'? 1 : 0}'"
             abiFilters (*reactNativeArchitectures())
         }
     }
@@ -134,10 +140,12 @@ repositories {
 }
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
-
 dependencies {
   implementation 'com.facebook.react:react-native'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  if (System.getenv("OP_SQLITE_USE_SQLCIPHER") == '1') {
+    implementation('com.android.ndk.thirdparty:openssl:1.1.1q-beta-1')
+  }
 }
 
 // Resolves "LOCAL_SRC_FILES points to a missing file, Check that libfb.so exists or that its path is correct".

package/cpp/bindings.cpp

@@ -8,7 +8,6 @@
 #include "sqlbatchexecutor.h"
 #include "utils.h"
 #include <iostream>
-#include <sqlite3.h>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -55,32 +54,50 @@ void install(jsi::Runtime &rt,
       throw std::runtime_error("[op-sqlite][open] database name is required");
     }
 
-    if (!args[0].isString()) {
-      throw std::runtime_error(
-          "[op-sqlite][open] database name must be a string");
-    }
-
-    std::string dbName = args[0].asString(rt).utf8(rt);
+    jsi::Object options = args[0].asObject(rt);
+    std::string dbName = options.getProperty(rt, "name").asString(rt).utf8(rt);
     std::string path = std::string(basePath);
+    std::string location;
+    std::string encryptionKey;
 
-    if (count > 1 && !args[1].isUndefined() && !args[1].isNull()) {
-      if (!args[1].isString()) {
-        throw std::runtime_error(
-            "[op-sqlite][open] database location must be a string");
-      }
+    if (options.hasProperty(rt, "location")) {
+      location = options.getProperty(rt, "location").asString(rt).utf8(rt);
+    }
 
-      std::string lastPath = args[1].asString(rt).utf8(rt);
+    if (options.hasProperty(rt, "encryptionKey")) {
+      encryptionKey =
+          options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
+    }
 
-      if (lastPath == ":memory:") {
+#ifdef OP_SQLITE_USE_SQLCIPHER
+    if (encryptionKey.empty()) {
+      throw std::runtime_error(
+          "[OP SQLite] using SQLCipher encryption key is required");
+    }
+//      TODO(osp) find a way to display the yellow box from c++
+#else
+    // if (!encryptionKey.empty()) {
+    //   //  RCTLogWarn(@"Your message")
+    //   throw std::runtime_error("[OP SQLite] SQLCipher is not enabled, "
+    //                            "encryption key is not allowed");
+    // }
+#endif
+
+    if (!location.empty()) {
+      if (location == ":memory:") {
         path = ":memory:";
-      } else if (lastPath.rfind("/", 0) == 0) {
-        path = lastPath;
+      } else if (location.rfind("/", 0) == 0) {
+        path = location;
       } else {
-        path = path + "/" + lastPath;
+        path = path + "/" + location;
       }
     }
 
+#ifdef OP_SQLITE_USE_SQLCIPHER
+    BridgeResult result = opsqlite_open(dbName, path, encryptionKey);
+#else
     BridgeResult result = opsqlite_open(dbName, path);
+#endif
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -618,6 +635,30 @@ void install(jsi::Runtime &rt,
     return {};
   });
 
+  auto get_db_path = HOSTFN("getDbPath", 2) {
+    std::string db_name = args[0].asString(rt).utf8(rt);
+    std::string path = std::string(basePath);
+    if (count > 1 && !args[1].isUndefined() && !args[1].isNull()) {
+      if (!args[1].isString()) {
+        throw std::runtime_error(
+            "[op-sqlite][open] database location must be a string");
+      }
+
+      std::string lastPath = args[1].asString(rt).utf8(rt);
+
+      if (lastPath == ":memory:") {
+        path = ":memory:";
+      } else if (lastPath.rfind("/", 0) == 0) {
+        path = lastPath;
+      } else {
+        path = path + "/" + lastPath;
+      }
+    }
+
+    auto result = opsqlite_get_db_path(db_name, path);
+    return jsi::String::createFromUtf8(rt, result);
+  });
+
   jsi::Object module = jsi::Object(rt);
 
   module.setProperty(rt, "open", std::move(open));
@@ -636,6 +677,7 @@ void install(jsi::Runtime &rt,
   module.setProperty(rt, "prepareStatement", std::move(prepare_statement));
   module.setProperty(rt, "loadExtension", std::move(load_extension));
   module.setProperty(rt, "executeRawAsync", std::move(execute_raw_async));
+  module.setProperty(rt, "getDbPath", std::move(get_db_path));
 
   rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
 }

package/cpp/bridge.cpp

@@ -30,8 +30,8 @@ inline void check_db_open(std::string const &db_name) {
 
 /// Returns the completely formed db path, but it also creates any sub-folders
 /// along the way
-std::string get_db_path(std::string const &db_name,
-                        std::string const &location) {
+std::string opsqlite_get_db_path(std::string const &db_name,
+                                 std::string const &location) {
 
   if (location == ":memory:") {
     return location;
@@ -41,9 +41,15 @@ std::string get_db_path(std::string const &db_name,
   return location + "/" + db_name;
 }
 
+#ifdef OP_SQLITE_USE_SQLCIPHER
 BridgeResult opsqlite_open(std::string const &dbName,
-                           std::string const &lastPath) {
-  std::string dbPath = get_db_path(dbName, lastPath);
+                           std::string const &last_path,
+                           std::string const &encryptionKey) {
+#else
+BridgeResult opsqlite_open(std::string const &dbName,
+                           std::string const &last_path) {
+#endif
+  std::string dbPath = opsqlite_get_db_path(dbName, last_path);
 
   int sqlOpenFlags =
       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
@@ -58,6 +64,11 @@ BridgeResult opsqlite_open(std::string const &dbName,
 
   dbMap[dbName] = db;
 
+#ifdef OP_SQLITE_USE_SQLCIPHER
+  opsqlite_execute(dbName, "PRAGMA key = '" + encryptionKey + "'", nullptr,
+                   nullptr, nullptr);
+#endif
+
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
@@ -80,7 +91,7 @@ BridgeResult opsqlite_attach(std::string const &mainDBName,
                              std::string const &docPath,
                              std::string const &databaseToAttach,
                              std::string const &alias) {
-  std::string dbPath = get_db_path(databaseToAttach, docPath);
+  std::string dbPath = opsqlite_get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
   BridgeResult result =
@@ -124,7 +135,7 @@ BridgeResult opsqlite_remove(std::string const &dbName,
     }
   }
 
-  std::string dbPath = get_db_path(dbName, docPath);
+  std::string dbPath = opsqlite_get_db_path(dbName, docPath);
 
   if (!file_exists(dbPath)) {
     return {.type = SQLiteError,
@@ -321,7 +332,7 @@ sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
 
   if (statementStatus == SQLITE_ERROR) {
     const char *message = sqlite3_errmsg(db);
-    throw std::runtime_error("[op-sqlite] SQL statement error: " +
+    throw std::runtime_error("[op-sqlite] SQL prepare statement error: " +
                              std::string(message));
   }
 
@@ -359,15 +370,15 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
       const char *message = sqlite3_errmsg(db);
       return {
           .type = SQLiteError,
-          .message = "[op-sqlite] SQL statement error:" +
-                     std::to_string(statementStatus) +
-                     " description:" + std::string(message) +
+          .message = "[op-sqlite] SQL statement error on opsqlite_execute:\n" +
+                     std::to_string(statementStatus) + " description:\n" +
+                     std::string(message) +
                      ". See error codes: https://www.sqlite.org/rescode.html",
       };
     }
 
-    // The statement did not fail to parse but there is nothing to do, just skip
-    // to the end
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
     if (statement == NULL) {
       continue;
     }
@@ -502,8 +513,8 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-/// Executes returning data in raw arrays, a small performance optimization for
-/// certain use cases
+/// Executes returning data in raw arrays, a small performance optimization
+/// for certain use cases
 BridgeResult
 opsqlite_execute_raw(std::string const &dbName, std::string const &query,
                      const std::vector<JSVariant> *params,
@@ -540,8 +551,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
       };
     }
 
-    // The statement did not fail to parse but there is nothing to do, just skip
-    // to the end
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
     if (statement == NULL) {
       continue;
     }
@@ -661,8 +672,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
 
 void opsqlite_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
+    // Interrupt will make all pending operations to fail with
+    // SQLITE_INTERRUPT The ongoing work from threads will then fail ASAP
     sqlite3_interrupt(x.second);
     // Each DB connection can then be safely interrupted
     sqlite3_close_v2(x.second);

package/cpp/bridge.h

@@ -19,8 +19,16 @@ 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;
 
+std::string opsqlite_get_db_path(std::string const &db_name,
+                                 std::string const &location);
+
+#ifdef OP_SQLITE_USE_SQLCIPHER
+BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath,
+                           std::string const &encryptionKey);
+#else
 BridgeResult opsqlite_open(std::string const &dbName,
                            std::string const &dbPath);
+#endif
 
 BridgeResult opsqlite_close(std::string const &dbName);