@op-engineering/op-sqlite 3.0.7 → 5.0.0

package/android/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.9.0)
 
 set (PACKAGE_NAME "op-sqlite")
 set (CMAKE_VERBOSE_MAKEFILE ON)
-set (CMAKE_CXX_STANDARD 17)
+set (CMAKE_CXX_STANDARD 20)
 set (BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
 
  include_directories(
@@ -43,7 +43,7 @@ if (OP_SQLITE_USE_SQLCIPHER)
   target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlcipher/sqlite3.h ../cpp/sqlcipher/sqlite3.c)
 
   add_definitions(
-    -DOP_SQLITE_USE_SQLCIPHER
+    -DOP_SQLITE_USE_SQLCIPHER=1
     -DSQLITE_HAS_CODEC
     -DSQLITE_TEMP_STORE=2
   )
@@ -53,9 +53,15 @@ else()
  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlite3.h ../cpp/sqlite3.c)
 endif()
 
+if (OP_SQLITE_USE_CRSQLITE)
+  add_definitions(
+    -DOP_SQLITE_USE_CRSQLITE=1
+  )
+endif()
+
 set_target_properties(
   ${PACKAGE_NAME} PROPERTIES
-  CXX_STANDARD 17
+  CXX_STANDARD 20
   CXX_EXTENSIONS OFF
   POSITION_INDEPENDENT_CODE ON
 )
@@ -64,7 +70,6 @@ find_package(ReactAndroid REQUIRED CONFIG)
 find_package(fbjni REQUIRED CONFIG)
 find_library(LOG_LIB log)
 
-
 target_link_libraries(
   ${PACKAGE_NAME}
   ${LOG_LIB}

package/android/build.gradle

@@ -1,4 +1,5 @@
 import java.nio.file.Paths
+import groovy.json.JsonSlurper
 
 buildscript {
   repositories {
@@ -26,7 +27,39 @@ def isNewArchitectureEnabled() {
   return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
-def SQLITE_FLAGS = rootProject.properties['OPSQLiteFlags']
+def useSQLCipher = false
+def useCRSQLite = false
+def performanceMode = "0"
+def sqliteFlags = ""
+
+def packageJsonFile = new File("$rootDir/../package.json")
+def packageJson = new JsonSlurper().parseText(packageJsonFile.text)
+
+def opsqliteConfig = packageJson["op-sqlite"]
+if(opsqliteConfig) {
+  useSQLCipher = opsqliteConfig["sqlcipher"]
+  useCRSQLite = opsqliteConfig["crsqlite"]
+  performanceMode = opsqliteConfig["performanceMode"] ? opsqliteConfig["performanceMode"] : ""
+  sqliteFlags = opsqliteConfig["sqliteFlags"] ? opsqliteConfig["sqliteFlags"] : ""
+}
+
+if(useSQLCipher) {
+  println "[OP-SQLITE] using SQLCipher 🔒"
+} else {
+  println "[OP-SQLITE] using Vanilla SQLite"
+}
+
+if(useCRSQLite) {
+  println "[OP-SQLITE] using CR-SQLite 🤖"
+}
+
+if(performanceMode == "1") {
+  println "[OP-SQLITE] Thread unsafe performance mode enabled. Use only transactions! 🚀"
+}
+
+if(performanceMode == "2") {
+  println "[OP-SQLITE] Thread safe performance mode enabled! 🚀"
+}
 
 if (isNewArchitectureEnabled()) {
     apply plugin: "com.facebook.react"
@@ -48,8 +81,6 @@ def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["OPSQLite" + name]
 }
 
-def USE_HERMES = rootProject.ext.hermesEnabled
-
 android {
   
   compileSdkVersion safeExtGet("compileSdkVersion", 33)
@@ -69,32 +100,26 @@ android {
   }
 
   defaultConfig {
-    minSdkVersion 21 
+    minSdkVersion 23 
     targetSdkVersion safeExtGet('targetSdkVersion', 34)
     versionCode 1
     versionName "1.0"
     
     externalNativeBuild {
         cmake {
-            if(System.getenv("OP_SQLITE_PERF") == '1') {
-              println "OP-SQLITE performance mode enabled! 🚀"
+            if(performanceMode == '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! 🚀"
+            if(performanceMode == '2') {
               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 : ''}'"
-              "-DOP_SQLITE_USE_SQLCIPHER='${System.getenv("OP_SQLITE_USE_SQLCIPHER") == '1'? 1 : 0}'"
+              "-DSQLITE_FLAGS='$sqliteFlags'"
+              "-DOP_SQLITE_USE_SQLCIPHER='${useSQLCipher? 1 : 0}'"
+              "-DOP_SQLITE_USE_CRSQLITE='${useCRSQLite? 1 : 0}'"
             abiFilters (*reactNativeArchitectures())
         }
     }
@@ -127,9 +152,11 @@ android {
 
   sourceSets.main {
     java {
-      if (!isNewArchitectureEnabled()) {
+      // TODO removed the codegen config to allow the package to be built under bridgeless
+      // Once there is a stable API for C++ Turbo Modules, maybe this can be enabled again
+      // if (!isNewArchitectureEnabled()) {
         srcDirs += 'src/paper/java'
-      }
+      // }
     }
   }
 }

package/android/cpp-adapter.cpp

@@ -6,6 +6,9 @@
 #include <jsi/jsi.h>
 #include <typeinfo>
 
+// This file is not using raw jni but rather fbjni, do not change how the native
+// functions are registered
+// https://github.com/facebookincubator/fbjni/blob/main/docs/quickref.md
 struct OPSQLiteBridge : jni::JavaClass<OPSQLiteBridge> {
   static constexpr auto kJavaDescriptor = "Lcom/op/sqlite/OPSQLiteBridge;";
 
@@ -25,7 +28,8 @@ private:
     auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
     std::string dbPathStr = dbPath->toStdString();
 
-    opsqlite::install(*jsiRuntime, jsCallInvoker, dbPathStr.c_str());
+    opsqlite::install(*jsiRuntime, jsCallInvoker, dbPathStr.c_str(),
+                      "libcrsqlite");
   }
 
   static void clearStateNativeJsi(jni::alias_ref<jni::JObject> thiz) {

package/android/gradle.properties

@@ -1 +1 @@
-OPSQLite_kotlinVersion=1.8.0
+OPSQLite_kotlinVersion=1.9.22

package/android/src/main/java/com/op/sqlite/OPSQLiteBridge.kt

@@ -2,15 +2,17 @@ package com.op.sqlite
 
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.react.common.annotations.FrameworkAPI
 
+@OptIn(FrameworkAPI::class)
 class OPSQLiteBridge {
     private external fun installNativeJsi(
         jsContextNativePointer: Long,
         jsCallInvokerHolder: CallInvokerHolderImpl,
         docPath: String
     )
-
     private external fun clearStateNativeJsi()
+
     fun install(context: ReactContext) {
         val jsContextPointer = context.javaScriptContextHolder!!.get()
         val jsCallInvokerHolder =

package/android/src/main/java/com/op/sqlite/OPSQLiteModule.kt

@@ -1,27 +1,27 @@
 package com.op.sqlite
 
+import android.util.Log
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.ReactContextBaseJavaModule
 import java.io.File
 import java.io.FileOutputStream
 import java.io.InputStream
 import java.io.OutputStream
 
-@ReactModule(name = OPSQLiteModule.NAME)
-internal class OPSQLiteModule(context: ReactApplicationContext?) :
-    NativeOPSQLiteSpec(context) {
+//@ReactModule(name = OPSQLiteModule.NAME)
+internal class OPSQLiteModule(context: ReactApplicationContext?) : ReactContextBaseJavaModule(context) {
     override fun getName(): String {
         return NAME
     }
 
-    override fun getTypedExportedConstants(): MutableMap<String, Any> {
+    fun getTypedExportedConstants(): MutableMap<String, Any> {
         val constants: MutableMap<String, Any> = HashMap()
         val context = reactApplicationContext
-        val dbPath = context
-            .getDatabasePath("defaultDatabase")
-            .absolutePath
-            .replace("defaultDatabase", "")
+        val dbPath =
+                context.getDatabasePath("defaultDatabase")
+                        .absolutePath
+                        .replace("defaultDatabase", "")
         constants["ANDROID_DATABASE_PATH"] = dbPath
         val filesPath = context.filesDir.absolutePath
         constants["ANDROID_FILES_PATH"] = filesPath
@@ -32,32 +32,35 @@ internal class OPSQLiteModule(context: ReactApplicationContext?) :
         return constants
     }
 
+    override fun getConstants(): MutableMap<String, Any>? {
+        return getTypedExportedConstants()
+    }
+
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun install(): Boolean {
+    fun install(): Boolean {
         return try {
             OPSQLiteBridge.instance.install(reactApplicationContext)
             true
         } catch (exception: Exception) {
+            Log.e(NAME, "Install exception: $exception")
             false
         }
     }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun moveAssetsDatabase(name: String, extension: String): Boolean {
+    fun moveAssetsDatabase(name: String, extension: String): Boolean {
         val context = reactApplicationContext
         val assetsManager = context.assets
 
         try {
-
-//            val assets = assetsManager.list("");
             // Open the input stream for the asset file
             val inputStream: InputStream = assetsManager.open("custom/$name.$extension")
 
             // Create the output file in the documents directory
-            val databasesFolder = context
-                .getDatabasePath("defaultDatabase")
-                .absolutePath
-                .replace("defaultDatabase", "")
+            val databasesFolder =
+                    context.getDatabasePath("defaultDatabase")
+                            .absolutePath
+                            .replace("defaultDatabase", "")
 
             val outputFile = File(databasesFolder, "$name.$extension")
 
@@ -85,7 +88,8 @@ internal class OPSQLiteModule(context: ReactApplicationContext?) :
         }
     }
 
-    override fun onCatalystInstanceDestroy() {
+    override fun invalidate() {
+        super.invalidate()
         OPSQLiteBridge.instance.clearState()
     }
 
@@ -96,4 +100,4 @@ internal class OPSQLiteModule(context: ReactApplicationContext?) :
 
         const val NAME = "OPSQLite"
     }
-}
+}

package/android/src/main/java/com/op/sqlite/OPSQLitePackage.kt

@@ -1,31 +1,18 @@
 package com.op.sqlite
 
-import com.facebook.react.TurboReactPackage
+import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.model.ReactModuleInfoProvider
-import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.uimanager.ViewManager
 
-class OPSQLitePackage : TurboReactPackage() {
-    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-        if(name == OPSQLiteModule.NAME) {
-            return OPSQLiteModule(reactContext)
-        } else {
-            return null
-        }
+class OPSQLitePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf<NativeModule>(OPSQLiteModule(reactContext))
     }
 
-    override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
-        mapOf(
-                 OPSQLiteModule.NAME to ReactModuleInfo(
-                     OPSQLiteModule.NAME,
-                     OPSQLiteModule.NAME,
-                       false, // canOverrideExistingModule
-                       false, // needsEagerInit
-                       true, // hasConstants
-                       false, // isCxxModule
-                       true // isTurboModule
-                             )
-                      )
+    override fun createViewManagers(
+            reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
     }
-}
+}

package/cpp/DumbHostObject.cpp

@@ -27,6 +27,7 @@ DumbHostObject::getPropertyNames(jsi::Runtime &rt) {
 
 jsi::Value DumbHostObject::get(jsi::Runtime &rt,
                                const jsi::PropNameID &propNameID) {
+
   auto name = propNameID.utf8(rt);
   auto fields = metadata.get();
   for (int i = 0; i < fields->size(); i++) {

package/cpp/bindings.cpp

@@ -17,6 +17,7 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 
 std::string basePath;
+std::string crsqlitePath;
 std::shared_ptr<react::CallInvoker> invoker;
 ThreadPool pool;
 std::unordered_map<std::string, std::shared_ptr<jsi::Value>> updateHooks =
@@ -44,9 +45,11 @@ void clearState() {
 
 void install(jsi::Runtime &rt,
              std::shared_ptr<react::CallInvoker> jsCallInvoker,
-             const char *docPath) {
+             const char *docPath, const char *_crsqlitePath) {
+
   invalidated = false;
   basePath = std::string(docPath);
+  crsqlitePath = std::string(_crsqlitePath);
   invoker = jsCallInvoker;
 
   auto open = HOSTFN("open", 3) {
@@ -94,9 +97,10 @@ void install(jsi::Runtime &rt,
     }
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-    BridgeResult result = opsqlite_open(dbName, path, encryptionKey);
+    BridgeResult result =
+        opsqlite_open(dbName, path, crsqlitePath, encryptionKey);
 #else
-    BridgeResult result = opsqlite_open(dbName, path);
+    BridgeResult result = opsqlite_open(dbName, path, crsqlitePath);
 #endif
 
     if (result.type == SQLiteError) {

package/cpp/bindings.h

@@ -8,7 +8,7 @@ namespace opsqlite {
 
 void install(jsi::Runtime &rt,
              std::shared_ptr<react::CallInvoker> jsCallInvoker,
-             const char *docPath);
+             const char *docPath, const char *crsqlitePath);
 void clearState();
 
 } // namespace opsqlite

package/cpp/bridge.cpp

@@ -3,6 +3,7 @@
 #include "SmartHostObject.h"
 #include "logs.h"
 #include "utils.h"
+#include <iostream>
 #include <unordered_map>
 #include <variant>
 
@@ -11,6 +12,7 @@ namespace opsqlite {
 /// Maps to hold the different objects
 std::unordered_map<std::string, sqlite3 *> dbMap =
     std::unordered_map<std::string, sqlite3 *>();
+
 std::unordered_map<std::string, UpdateCallback> updateCallbackMap =
     std::unordered_map<std::string, UpdateCallback>();
 
@@ -26,7 +28,12 @@ inline void check_db_open(std::string const &db_name) {
   }
 }
 
-/// Start of api
+//            _____ _____
+//      /\   |  __ \_   _|
+//     /  \  | |__) || |
+//    / /\ \ |  ___/ | |
+//   / ____ \| |    _| |_
+//  /_/    \_\_|   |_____|
 
 /// Returns the completely formed db path, but it also creates any sub-folders
 /// along the way
@@ -44,10 +51,12 @@ std::string opsqlite_get_db_path(std::string const &db_name,
 #ifdef OP_SQLITE_USE_SQLCIPHER
 BridgeResult opsqlite_open(std::string const &dbName,
                            std::string const &last_path,
+                           std::string const &crsqlitePath,
                            std::string const &encryptionKey) {
 #else
 BridgeResult opsqlite_open(std::string const &dbName,
-                           std::string const &last_path) {
+                           std::string const &last_path,
+                           std::string const &crsqlitePath) {
 #endif
   std::string dbPath = opsqlite_get_db_path(dbName, last_path);
 
@@ -69,7 +78,22 @@ BridgeResult opsqlite_open(std::string const &dbName,
                    nullptr, nullptr);
 #endif
 
-  return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
+#ifdef OP_SQLITE_USE_CRSQLITE
+  char *errMsg;
+  const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
+
+  sqlite3_enable_load_extension(db, 1);
+
+  sqlite3_load_extension(db, crsqlitePath.c_str(), crsqliteEntryPoint, &errMsg);
+
+  if (errMsg != nullptr) {
+    return {.type = SQLiteError, .message = errMsg};
+  } else {
+    LOGI("Loaded CRSQlite successfully");
+  }
+#endif
+
+  return {.type = SQLiteOk, .affectedRows = 0};
 }
 
 BridgeResult opsqlite_close(std::string const &dbName) {
@@ -78,6 +102,11 @@ BridgeResult opsqlite_close(std::string const &dbName) {
 
   sqlite3 *db = dbMap[dbName];
 
+#ifdef OP_SQLITE_USE_CRSQLITE
+  opsqlite_execute(dbName, "select crsql_finalize();", nullptr, nullptr,
+                   nullptr);
+#endif
+
   sqlite3_close_v2(db);
 
   dbMap.erase(dbName);

package/cpp/bridge.h

@@ -24,10 +24,11 @@ std::string opsqlite_get_db_path(std::string const &db_name,
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
 BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath,
+                           std::string const &crsqlitePath,
                            std::string const &encryptionKey);
 #else
-BridgeResult opsqlite_open(std::string const &dbName,
-                           std::string const &dbPath);
+BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath,
+                           std::string const &crsqlitePath);
 #endif
 
 BridgeResult opsqlite_close(std::string const &dbName);

package/ios/OPSQLite.h

@@ -1,15 +1,15 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-#import <OPSQLiteSpec/OPSQLiteSpec.h>
-#else
+// #ifdef RCT_NEW_ARCH_ENABLED
+// #import <OPSQLiteSpec/OPSQLiteSpec.h>
+// #else
 #import <React/RCTBridge.h>
-#endif
+// #endif
 
 @interface OPSQLite : NSObject
-#ifdef RCT_NEW_ARCH_ENABLED
-                                   <NativeOPSQLiteSpec>
-#else
+// #ifdef RCT_NEW_ARCH_ENABLED
+//                                    <NativeOPSQLiteSpec>
+// #else
                                    <RCTBridgeModule>
-#endif
+// #endif
 
 @property(nonatomic, assign) BOOL setBridgeOnMainQueue;