@op-engineering/op-sqlite 0.0.0-resolution-test

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2021 Oscar Franco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+![benchmark](benchmark2.jpg)
+
+Created by [@ospfranco](https://twitter.com/ospfranco). **Please consider sponsoring!**.
+
+OP-SQLite has grown large to cover a lot of plugins, sqlite versions and APIs. Please read the full documentation before opening an issue.
+
+[Open the docs](https://op-engineering.github.io/op-sqlite/)
+
+Join the Discord:
+
+https://discord.gg/W9XmqCQCKP
+
+Some of the big supported features:
+
+- Vanilla sqlite
+- Libsql is supported as a compilation target
+- SQLCipher is supported as a compilation target
+- FTS5 plugin
+- Rtree plugin
+- cr-sqlite plugin
+- sqlite-vec plugin
+- Reactive queries
+- Custom tokenizers
+- Load runtime extensions
+- JSONB support
+
+It also contains a simple [Key-Value store](https://op-engineering.github.io/op-sqlite/docs/key_value_storage) you can use without adding one more dependency to your app.
+
+# License
+
+MIT License.

package/android/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>android_</name>
+	<comment>Project android_ created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+</projectDescription>

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,13 @@
+arguments=
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(VERSION(6.0))
+connection.project.dir=
+eclipse.preferences.version=1
+gradle.user.home=
+java.home=/Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true

package/android/CMakeLists.txt

@@ -0,0 +1,141 @@
+project(OPSQLite)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME "op-sqlite")
+
+include_directories(
+  ../cpp
+  ../cpp/sqlcipher
+  ../cpp/libsql
+)
+
+add_definitions(
+  ${SQLITE_FLAGS}
+)
+
+add_library(
+  ${PACKAGE_NAME}
+  SHARED
+  ../cpp/bindings.cpp
+  ../cpp/utils.cpp
+  ../cpp/OPThreadPool.cpp
+  ../cpp/SmartHostObject.cpp
+  ../cpp/PreparedStatementHostObject.cpp
+  ../cpp/DumbHostObject.cpp
+  ../cpp/DBHostObject.cpp
+  cpp-adapter.cpp
+)
+
+if (USE_SQLCIPHER)
+  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlcipher/sqlite3.h ../cpp/sqlcipher/sqlite3.c ../cpp/bridge.cpp ../cpp/bridge.h)
+
+  add_definitions(
+    -DOP_SQLITE_USE_SQLCIPHER=1
+    -DSQLITE_HAS_CODEC
+    -DSQLITE_TEMP_STORE=2
+  )
+  
+  find_package(openssl REQUIRED CONFIG)
+elseif (USE_LIBSQL)
+  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/libsql/bridge.cpp)
+  
+  add_definitions(
+    -DOP_SQLITE_USE_LIBSQL=1
+  )
+else()
+ target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlite3.h ../cpp/sqlite3.c ../cpp/bridge.cpp ../cpp/bridge.h)
+endif()
+
+if (USE_CRSQLITE)
+  add_definitions(
+    -DOP_SQLITE_USE_CRSQLITE=1
+  )
+endif()
+
+if (USE_SQLITE_VEC)
+  add_definitions(
+    -DOP_SQLITE_USE_SQLITE_VEC=1
+  )
+endif()
+
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
+find_library(LOG_LIB log)
+
+# Add user defined files
+if (USER_DEFINED_SOURCE_FILES)
+  target_sources(${PACKAGE_NAME} PRIVATE ${USER_DEFINED_SOURCE_FILES})
+
+  add_definitions("-DTOKENIZERS_HEADER_PATH=\"${USER_DEFINED_TOKENIZERS_HEADER_PATH}\"")
+endif()
+
+if (USE_SQLCIPHER)
+  if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+      ${PACKAGE_NAME}
+      ${LOG_LIB}
+      ReactAndroid::reactnative
+      ReactAndroid::jsi
+      fbjni::fbjni
+      openssl::crypto
+    )
+  else()
+    target_link_libraries(
+      ${PACKAGE_NAME}
+      ${LOG_LIB}
+      fbjni::fbjni
+      ReactAndroid::jsi
+      ReactAndroid::turbomodulejsijni
+      ReactAndroid::react_nativemodule_core
+      android
+      openssl::crypto
+    )
+  endif()
+elseif (USE_LIBSQL)
+  cmake_path(SET LIBSQL ${CMAKE_CURRENT_SOURCE_DIR}/jniLibs/${ANDROID_ABI}/libsql_experimental.a NORMALIZE)
+  add_library(libsql STATIC IMPORTED)
+  set_target_properties(libsql PROPERTIES IMPORTED_LOCATION ${LIBSQL})
+
+  if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+      ${PACKAGE_NAME}
+      ${LOG_LIB}
+      ReactAndroid::reactnative
+      ReactAndroid::jsi
+      fbjni::fbjni
+      libsql
+    )
+  else()
+    target_link_libraries(
+      ${PACKAGE_NAME}
+      ${LOG_LIB}
+      fbjni::fbjni
+      ReactAndroid::jsi
+      ReactAndroid::turbomodulejsijni
+      ReactAndroid::react_nativemodule_core
+      android
+      libsql
+    )
+  endif()
+else ()
+  # if (REACTNATIVE_MERGED_SO)
+  if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+      ${PACKAGE_NAME}
+      ${LOG_LIB}
+      ReactAndroid::reactnative
+      ReactAndroid::jsi
+      fbjni::fbjni
+    )
+  else()
+    target_link_libraries(
+      ${PACKAGE_NAME}
+      ${LOG_LIB}
+      fbjni::fbjni
+      ReactAndroid::jsi
+      ReactAndroid::turbomodulejsijni
+      ReactAndroid::react_nativemodule_core
+      android
+    )
+  endif()
+endif()

package/android/build.gradle

@@ -0,0 +1,266 @@
+import java.nio.file.Paths
+import groovy.json.JsonSlurper
+
+buildscript {
+  repositories {
+    google()
+    gradlePluginPortal()
+  }
+
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["OPSQLite_kotlinVersion"]
+
+  dependencies {
+    classpath("com.android.tools.build:gradle:7.3.1")
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def resolveBuildType() {
+    Gradle gradle = getGradle()
+    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
+
+    return tskReqStr.contains('Release') ? 'release' : 'debug'
+}
+
+def isNewArchitectureEnabled() {
+  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def useSQLCipher = false
+def useLibsql = false
+def useCRSQLite = false
+def performanceMode = false
+def sqliteFlags = ""
+def enableFTS5 = false
+def useSqliteVec = false
+def enableRtree = false
+def tokenizers = []
+
+def isInsideNodeModules = rootDir.absolutePath.contains("node_modules")
+def packageJson
+
+if ( isInsideNodeModules ) {
+  def packageJsonFile = new File("$rootDir/../../../package.json")
+  packageJson = new JsonSlurper().parseText(packageJsonFile.text)
+} else {
+  def packageJsonFile = new File("$rootDir/../package.json")
+  packageJson = new JsonSlurper().parseText(packageJsonFile.text)
+}
+
+def opsqliteConfig = packageJson["op-sqlite"]
+if(opsqliteConfig) {
+  useSQLCipher = opsqliteConfig["sqlcipher"]
+  useCRSQLite = opsqliteConfig["crsqlite"]
+  useSqliteVec = opsqliteConfig["sqliteVec"]
+  performanceMode = opsqliteConfig["performanceMode"]
+  sqliteFlags = opsqliteConfig["sqliteFlags"] ? opsqliteConfig["sqliteFlags"] : ""
+  enableFTS5 = opsqliteConfig["fts5"]
+  useLibsql = opsqliteConfig["libsql"]
+  enableRtree = opsqliteConfig["rtree"]
+  tokenizers = opsqliteConfig["tokenizers"] ? opsqliteConfig["tokenizers"] : []
+}
+
+if(useSQLCipher) {
+  println "[OP-SQLITE] using SQLCipher 🔒"
+} else if(useLibsql) {
+  println "[OP-SQLITE] using libsql 📦"
+} else {
+  println "[OP-SQLITE] using Vanilla SQLite"
+}
+
+if(useCRSQLite) {
+  println "[OP-SQLITE] using CR-SQLite 🤖"
+}
+
+if(performanceMode) {
+  println "[OP-SQLITE] Performance mode enabled! 🚀"
+}
+
+if(enableFTS5) {
+  println "[OP-SQLITE] FTS5 enabled! 🔎"
+}
+
+if(enableRtree) {
+  println "[OP-SQLITE] RTree enabled! 🌲"
+}
+
+if(useSqliteVec) {
+    println "[OP-SQLITE] Sqlite Vec enabled! ↗️"
+}
+
+
+if (!tokenizers.isEmpty()) {
+  println "[OP-SQLITE] Tokenizers enabled! 🧾 Tokenizers: " + tokenizers
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: "kotlin-android"
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["OPSQLite" + name]
+}
+
+android {
+  
+  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+  namespace "com.op.sqlite"
+  
+  // Used to override the NDK path/version on internal CI or by allowing
+  // users to customize the NDK path/version from their root project (e.g. for M1 support)
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion rootProject.ext.ndkVersion
+  }
+
+  buildFeatures {
+    prefab true
+  }
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet('targetSdkVersion', 35)
+    versionCode 1
+    versionName "1.0"
+    
+    externalNativeBuild {
+        cmake {
+            if(useSQLCipher) {
+              cFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
+              cppFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
+            }
+            if(useLibsql) {
+              cFlags += "-DOP_SQLITE_USE_LIBSQL=1"
+              cppFlags += "-DOP_SQLITE_USE_LIBSQL=1"
+            }
+            if(useCRSQLite) {
+              cFlags += "-DOP_SQLITE_USE_CRSQLITE=1"
+              cppFlags += "-DOP_SQLITE_USE_CRSQLITE=1"
+            }
+            if(performanceMode) {
+              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(enableFTS5) {
+              cFlags += ["-DSQLITE_ENABLE_FTS5=1"]
+            }
+            if(enableRtree) {
+              cFlags += ["-DSQLITE_ENABLE_RTREE=1"]
+            }
+            if(useSqliteVec) {
+              cFlags += "-DOP_SQLITE_USE_SQLITE_VEC=1"
+              cppFlags += "-DOP_SQLITE_USE_SQLITE_VEC=1"
+            }
+
+            // This are zeroes because they will be passed as C flags, so they become falsy
+            def sourceFiles = 0
+            // def tokenizerInitStrings = 0
+            def tokenizersHeaderPath = 0
+            if (!tokenizers.isEmpty()) {
+              def sourceDir = isInsideNodeModules ? file("$rootDir/../../../c_sources") : file("$rootDir/../c_sources")
+              def destDir = file("$buildscript.sourceFile.parentFile/c_sources")
+              copy {
+                from sourceDir
+                into destDir
+                include "**/*.cpp", "**/*.h"
+              }
+              sourceFiles = fileTree(dir: destDir, include: ["**/*.cpp", "**/*.h"]).files.join(";")
+              tokenizersHeaderPath = "../c_sources/tokenizers.h" 
+            }
+
+            cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+            abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+            arguments "-DANDROID_STL=c++_shared",
+              "-DSQLITE_FLAGS='$sqliteFlags'",
+              "-DUSE_SQLCIPHER=${useSQLCipher ? 1 : 0}",
+              "-DUSE_CRSQLITE=${useCRSQLite ? 1 : 0}",
+              "-DUSE_LIBSQL=${useLibsql ? 1 : 0}",
+              "-DUSE_SQLITE_VEC=${useSqliteVec ? 1 : 0}",
+              "-DUSER_DEFINED_SOURCE_FILES=${sourceFiles}",
+              "-DUSER_DEFINED_TOKENIZERS_HEADER_PATH='${tokenizersHeaderPath}'"
+        }
+    }
+
+    packagingOptions {
+      doNotStrip resolveBuildType() == 'debug' ? "**/**/*.so" : ''
+      excludes = [
+              "META-INF",
+              "META-INF/**",
+              "**/libjsi.so",
+              "**/libreact_nativemodule_core.so",
+              "**/libturbomodulejsijni.so",
+              "**/libc++_shared.so",
+              "**/libfbjni.so",
+              "**/libreactnative.so",
+      ]
+    }
+    
+  }
+  
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  sourceSets.main {
+    java {
+      // 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'
+      // }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+dependencies {
+  implementation 'com.facebook.react:react-native'
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  if (useSQLCipher) {
+    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".
+tasks.whenTaskAdded { task ->
+  if (task.name.contains("configureCMakeDebug")) {
+    rootProject.getTasksByName("packageReactNdkDebugLibs", true).forEach {
+      task.dependsOn(it)
+    }
+  }
+  // We want to add a dependency for both configureCMakeRelease and configureCMakeRelWithDebInfo
+  if (task.name.contains("configureCMakeRel")) {
+    rootProject.getTasksByName("packageReactNdkReleaseLibs", true).forEach {
+      task.dependsOn(it)
+    }
+  }
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "opsqlite"
+    codegenJavaPackageName = "com.op.sqlite.example"
+  }
+}

package/android/c_sources/tokenizers.cpp

@@ -0,0 +1,88 @@
+#include "tokenizers.h"
+#include <cctype>
+#include <memory>
+#include <string>
+
+namespace opsqlite {
+
+fts5_api *fts5_api_from_db(sqlite3 *db) {
+  fts5_api *pRet = 0;
+  sqlite3_stmt *pStmt = 0;
+
+  if (SQLITE_OK == sqlite3_prepare_v2(db, "SELECT fts5(?1)", -1, &pStmt, 0)) {
+    sqlite3_bind_pointer(pStmt, 1, (void *)&pRet, "fts5_api_ptr", NULL);
+    sqlite3_step(pStmt);
+  }
+  sqlite3_finalize(pStmt);
+  return pRet;
+}
+
+class WordTokenizer {
+public:
+  WordTokenizer() = default;
+  ~WordTokenizer() = default;
+};
+
+// Define `xCreate`, which initializes the tokenizer
+int wordTokenizerCreate(void *pUnused, const char **azArg, int nArg,
+                        Fts5Tokenizer **ppOut) {
+  auto tokenizer = std::make_unique<WordTokenizer>();
+  *ppOut = reinterpret_cast<Fts5Tokenizer *>(
+      tokenizer.release()); // Cast to Fts5Tokenizer*
+  return SQLITE_OK;
+}
+
+// Define `xDelete`, which frees the tokenizer
+void wordTokenizerDelete(Fts5Tokenizer *pTokenizer) {
+  delete reinterpret_cast<WordTokenizer *>(pTokenizer);
+}
+
+// Define `xTokenize`, which performs the actual tokenization
+int wordTokenizerTokenize(Fts5Tokenizer *pTokenizer, void *pCtx, int flags,
+                          const char *pText, int nText,
+                          int (*xToken)(void *, int, const char *, int, int,
+                                        int)) {
+  int start = 0;
+  int i = 0;
+
+  while (i <= nText) {
+    if (i == nText || !std::isalnum(static_cast<unsigned char>(pText[i]))) {
+      if (start < i) { // Found a token
+        int rc = xToken(pCtx, 0, pText + start, i - start, start, i);
+        if (rc != SQLITE_OK)
+          return rc;
+      }
+      start = i + 1;
+    }
+    i++;
+  }
+  return SQLITE_OK;
+}
+
+int opsqlite_wordtokenizer_init(sqlite3 *db, char **error,
+                                sqlite3_api_routines const *api) {
+  fts5_tokenizer wordtokenizer = {wordTokenizerCreate, wordTokenizerDelete,
+                                  wordTokenizerTokenize};
+
+  fts5_api *ftsApi = (fts5_api *)fts5_api_from_db(db);
+  if (ftsApi == NULL)
+    return SQLITE_ERROR;
+
+  return ftsApi->xCreateTokenizer(ftsApi, "wordtokenizer", NULL, &wordtokenizer,
+                                  NULL);
+}
+
+int opsqlite_porter_init(sqlite3 *db, char **error,
+                         sqlite3_api_routines const *api) {
+  fts5_tokenizer porter_tokenizer = {wordTokenizerCreate, wordTokenizerDelete,
+                                     wordTokenizerTokenize};
+
+  fts5_api *ftsApi = (fts5_api *)fts5_api_from_db(db);
+  if (ftsApi == nullptr)
+    return SQLITE_ERROR;
+
+  return ftsApi->xCreateTokenizer(ftsApi, "portertokenizer", NULL,
+                                  &porter_tokenizer, NULL);
+}
+
+} // namespace opsqlite

package/android/c_sources/tokenizers.h

@@ -0,0 +1,15 @@
+#ifndef TOKENIZERS_H
+#define TOKENIZERS_H
+
+#define TOKENIZER_LIST opsqlite_wordtokenizer_init(db,&errMsg,nullptr);opsqlite_porter_init(db,&errMsg,nullptr);
+
+#include <sqlite3.h>
+
+namespace opsqlite {
+
+int opsqlite_wordtokenizer_init(sqlite3 *db, char **error, sqlite3_api_routines const *api);
+int opsqlite_porter_init(sqlite3 *db, char **error, sqlite3_api_routines const *api);
+
+} // namespace opsqlite
+
+#endif // TOKENIZERS_H

package/android/cpp-adapter.cpp

@@ -0,0 +1,46 @@
+#include "bindings.h"
+#include "logs.h"
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <typeinfo>
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+namespace jni = facebook::jni;
+
+// 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;";
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives(
+        {makeNativeMethod("installNativeJsi", OPSQLiteBridge::installNativeJsi),
+         makeNativeMethod("clearStateNativeJsi",
+                          OPSQLiteBridge::clearStateNativeJsi)});
+  }
+
+private:
+  static void installNativeJsi(
+      jni::alias_ref<jni::JObject> thiz, jlong jsiRuntimePtr,
+      jni::alias_ref<react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
+      jni::alias_ref<jni::JString> dbPath) {
+    auto jsiRuntime = reinterpret_cast<jsi::Runtime *>(jsiRuntimePtr);
+    auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+    std::string dbPathStr = dbPath->toStdString();
+
+    opsqlite::install(*jsiRuntime, jsCallInvoker, dbPathStr.c_str(),
+                      "libcrsqlite", "libsqlite_vec");
+  }
+
+  static void clearStateNativeJsi(jni::alias_ref<jni::JObject> thiz) {
+    opsqlite::invalidate();
+  }
+};
+
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+  return jni::initialize(vm, [] { OPSQLiteBridge::registerNatives(); });
+}

package/android/gradle.properties

@@ -0,0 +1 @@
+OPSQLite_kotlinVersion=1.9.22

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"/>

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

@@ -0,0 +1,37 @@
+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 =
+            context.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl
+        // Trick to get the base database path
+        val dbPath =
+            context.getDatabasePath("defaultDatabase").absolutePath.replace("defaultDatabase", "")
+        installNativeJsi(
+            jsContextPointer,
+            jsCallInvokerHolder,
+            dbPath
+        )
+    }
+
+    fun invalidate() {
+        clearStateNativeJsi()
+    }
+
+    companion object {
+        val instance = OPSQLiteBridge()
+    }
+}