expo-sqlite 11.7.1 → 12.0.0

package/CHANGELOG.md

@@ -10,6 +10,37 @@
 
 ### 💡 Others
 
+## 12.0.0 — 2023-11-06
+
+### 🛠 Breaking changes
+
+- Bumped iOS deployment target to 13.4. ([#25063](https://github.com/expo/expo/pull/25063) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+- Remove CRSQLite support on legacy API. ([#25092](https://github.com/expo/expo/pull/25092) by [@kudo](https://github.com/kudo))
+
+### 🎉 New features
+
+- Added Android implementation for `sqlite/next` APIs. ([#25021](https://github.com/expo/expo/pull/25021) by [@kudo](https://github.com/kudo))
+- Added the `useSQLiteContext` hook that can be used across components. ([#25129](https://github.com/expo/expo/pull/25129) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- [ios] Fix some issues for `sqlite/next`. ([#25022](https://github.com/expo/expo/pull/25022) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- [Android] Removed the package included SQLite source and download in build time. ([#25186](https://github.com/expo/expo/pull/25186) by [@kudo](https://github.com/kudo))
+
+## 11.8.0 — 2023-10-17
+
+### 🛠 Breaking changes
+
+- Dropped support for Android SDK 21 and 22. ([#24201](https://github.com/expo/expo/pull/24201) by [@behenate](https://github.com/behenate))
+
+### 🎉 New features
+
+- [Android] Rewrite implementations from low-level SQLite bindings. ([#24730](https://github.com/expo/expo/pull/24730) by [@kudo](https://github.com/kudo))
+- Introduced `expo-sqlite/next` new APIs. ([#24812](https://github.com/expo/expo/pull/24812) by [@kudo](https://github.com/kudo))
+
 ## 11.7.1 — 2023-09-18
 
 ### 🐛 Bug fixes

package/android/CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.4.1)
+
+project(expo-sqlite)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 17)
+set(PACKAGE_NAME "expo-sqlite")
+set(BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
+
+set(SRC_DIR "${CMAKE_SOURCE_DIR}/src/main/cpp")
+file(GLOB SOURCES "${SRC_DIR}/*.cpp")
+
+add_library(
+  ${PACKAGE_NAME}
+  SHARED
+  ${SOURCES}
+  "${SQLITE3_SRC_DIR}/sqlite3.c"
+)
+
+target_include_directories(
+  ${PACKAGE_NAME}
+  PRIVATE
+  ${SRC_DIR}
+  "${SQLITE3_SRC_DIR}"
+)
+
+find_library(LOG_LIB log)
+find_package(fbjni REQUIRED CONFIG)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  fbjni::fbjni
+  android
+)

package/android/build.gradle

@@ -1,17 +1,33 @@
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
+apply plugin: 'de.undercouch.download'
 
 group = 'host.exp.exponent'
-version = '11.7.1'
+version = '12.0.0'
 
-buildscript {
-  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-  if (expoModulesCorePlugin.exists()) {
-    apply from: expoModulesCorePlugin
-    applyKotlinExpoModulesCorePlugin()
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+if (expoModulesCorePlugin.exists()) {
+  apply from: expoModulesCorePlugin
+  applyKotlinExpoModulesCorePlugin()
+  // Remove this check, but keep the contents after SDK49 support is dropped
+  if (safeExtGet("expoProvidesDefaultConfig", false)) {
+    useExpoPublishing()
+    useCoreDependencies()
   }
+}
+
+def SQLITE_VERSION = '3420000'
+def customDownloadsDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
+def downloadsDir = customDownloadsDir ? new File(customDownloadsDir) : new File("$buildDir/downloads")
+def SQLITE3_SRC_DIR = new File("$buildDir/sqlite3_src")
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
 
+buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
   ext.safeExtGet = { prop, fallback ->
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -32,26 +48,48 @@ buildscript {
 
   dependencies {
     classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+    classpath("de.undercouch:gradle-download-task:5.5.0")
   }
 }
 
-afterEvaluate {
-  publishing {
-    publications {
-      release(MavenPublication) {
-        from components.release
+// Remove this if and it's contents, when support for SDK49 is dropped
+if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+  afterEvaluate {
+    publishing {
+      publications {
+        release(MavenPublication) {
+          from components.release
+        }
       }
-    }
-    repositories {
-      maven {
-        url = mavenLocal().url
+      repositories {
+        maven {
+          url = mavenLocal().url
+        }
       }
     }
   }
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    compileSdkVersion safeExtGet("compileSdkVersion", 33)
+
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 23)
+      targetSdkVersion safeExtGet("targetSdkVersion", 33)
+    }
+
+    publishing {
+      singleVariant("release") {
+        withSourcesJar()
+      }
+    }
+
+    lintOptions {
+      abortOnError false
+    }
+  }
 
   def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
   if (agpVersion.tokenize('.')[0].toInteger() < 8) {
@@ -67,25 +105,72 @@ android {
 
   namespace "expo.modules.sqlite"
   defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 18
-    versionName "11.7.1"
-  }
-  lintOptions {
-    abortOnError false
+    versionName "12.0.0"
+
+    externalNativeBuild {
+      cmake {
+        abiFilters (*reactNativeArchitectures())
+        arguments "-DANDROID_STL=c++_shared",
+          "-DSQLITE3_SRC_DIR=${SQLITE3_SRC_DIR}"
+      }
+    }
   }
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
     }
   }
+  buildFeatures {
+    prefab true
+  }
 }
 
 dependencies {
-  implementation project(':expo-modules-core')
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  }
+
+  compileOnly 'com.facebook.fbjni:fbjni:0.3.0'
+}
+
+def createNativeDepsDirectories = tasks.register('createNativeDepsDirectories') {
+  downloadsDir.mkdirs()
+  SQLITE3_SRC_DIR.mkdirs()
+}
+
+def downloadSQLite = tasks.create('downloadSQLite', Download) {
+  dependsOn(createNativeDepsDirectories)
+  src("https://www.sqlite.org/2023/sqlite-amalgamation-${SQLITE_VERSION}.zip")
+  onlyIfNewer(true)
+  overwrite(false)
+  dest(new File(downloadsDir, "sqlite-amalgamation-${SQLITE_VERSION}.zip"))
+}
 
-  implementation 'com.github.alanjhughes:sqlite-android:0.0.3'
-  implementation "androidx.sqlite:sqlite-ktx:2.3.1"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+def prepareSQLite = tasks.register('prepareSQLite', Copy) {
+  dependsOn(downloadSQLite)
+  from(zipTree(downloadSQLite.dest))
+  into(SQLITE3_SRC_DIR)
+  eachFile {
+    // flatten files
+    path = name
+  }
+}
+
+void nativeBuildDependsOn(project, dependsOnTask) {
+  def buildTasks = project.tasks.findAll { task ->
+    def taskName = task.name
+    if (taskName.contains("Clean")) { return false }
+    if (taskName.contains("externalNative") || taskName.contains("CMake") || taskName.contains("generateJsonModel")) {
+      return true
+    }
+    return false
+  }
+  buildTasks.forEach { task -> task.dependsOn(dependsOnTask) }
+}
+
+afterEvaluate {
+  nativeBuildDependsOn(project, prepareSQLite)
 }

package/android/src/main/cpp/NativeDatabaseBinding.cpp

@@ -0,0 +1,142 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#include "NativeDatabaseBinding.h"
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+namespace {
+
+constexpr char TAG[] = "expo-sqlite";
+
+} // namespace
+
+// static
+void NativeDatabaseBinding::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", NativeDatabaseBinding::initHybrid),
+      makeNativeMethod("sqlite3_changes",
+                       NativeDatabaseBinding::sqlite3_changes),
+      makeNativeMethod("sqlite3_close", NativeDatabaseBinding::sqlite3_close),
+      makeNativeMethod("sqlite3_db_filename",
+                       NativeDatabaseBinding::sqlite3_db_filename),
+      makeNativeMethod("sqlite3_enable_load_extension",
+                       NativeDatabaseBinding::sqlite3_enable_load_extension),
+      makeNativeMethod("sqlite3_exec", NativeDatabaseBinding::sqlite3_exec),
+      makeNativeMethod("sqlite3_get_autocommit",
+                       NativeDatabaseBinding::sqlite3_get_autocommit),
+      makeNativeMethod("sqlite3_last_insert_rowid",
+                       NativeDatabaseBinding::sqlite3_last_insert_rowid),
+      makeNativeMethod("sqlite3_load_extension",
+                       NativeDatabaseBinding::sqlite3_load_extension),
+      makeNativeMethod("sqlite3_open", NativeDatabaseBinding::sqlite3_open),
+      makeNativeMethod("sqlite3_prepare_v2",
+                       NativeDatabaseBinding::sqlite3_prepare_v2),
+      makeNativeMethod("sqlite3_update_hook",
+                       NativeDatabaseBinding::sqlite3_update_hook),
+      makeNativeMethod("convertSqlLiteErrorToString",
+                       NativeDatabaseBinding::convertSqlLiteErrorToString),
+  });
+}
+
+int NativeDatabaseBinding::sqlite3_changes() { return ::sqlite3_changes(db); }
+
+int NativeDatabaseBinding::sqlite3_close() {
+  // Not setting `db = nullptr` here because we may need the db pointer to get
+  // error messages if sqlite3_close has errors.
+  return ::sqlite3_close(db);
+}
+
+std::string
+NativeDatabaseBinding::sqlite3_db_filename(const std::string &dbName) {
+  return ::sqlite3_db_filename(db, dbName.c_str());
+}
+
+int NativeDatabaseBinding::sqlite3_enable_load_extension(int onoff) {
+  return ::sqlite3_enable_load_extension(db, onoff);
+}
+
+int NativeDatabaseBinding::sqlite3_exec(const std::string &source) {
+  char *error;
+  int ret = ::sqlite3_exec(db, source.c_str(), nullptr, nullptr, &error);
+  if (ret != SQLITE_OK && error) {
+    std::string errorString(error);
+    ::sqlite3_free(error);
+    jni::throwNewJavaException(SQLiteErrorException::create(errorString).get());
+  }
+  return ret;
+}
+
+int NativeDatabaseBinding::sqlite3_get_autocommit() {
+  return ::sqlite3_get_autocommit(db);
+}
+
+int64_t NativeDatabaseBinding::sqlite3_last_insert_rowid() {
+  return ::sqlite3_last_insert_rowid(db);
+}
+
+int NativeDatabaseBinding::sqlite3_load_extension(
+    const std::string &libPath, const std::string &entryProc) {
+  char *error;
+  int ret =
+      ::sqlite3_load_extension(db, libPath.c_str(), entryProc.c_str(), &error);
+  if (ret != SQLITE_OK && error) {
+    std::string errorString(error);
+    ::sqlite3_free(error);
+    jni::throwNewJavaException(SQLiteErrorException::create(errorString).get());
+  }
+  return ret;
+}
+
+int NativeDatabaseBinding::sqlite3_open(const std::string &dbPath) {
+  return ::sqlite3_open(dbPath.c_str(), &db);
+}
+
+int NativeDatabaseBinding::sqlite3_prepare_v2(
+    const std::string &source,
+    jni::alias_ref<NativeStatementBinding::javaobject> statement) {
+  NativeStatementBinding *cStatement = cthis(statement);
+  return ::sqlite3_prepare_v2(db, source.c_str(), source.size(),
+                              &cStatement->stmt, nullptr);
+}
+
+void NativeDatabaseBinding::sqlite3_update_hook(bool enabled) {
+  if (enabled) {
+    ::sqlite3_update_hook(db, NativeDatabaseBinding::OnUpdateHook, this);
+  } else {
+    ::sqlite3_update_hook(db, nullptr, nullptr);
+  }
+}
+
+jni::local_ref<jni::JString>
+NativeDatabaseBinding::convertSqlLiteErrorToString() {
+  int code = sqlite3_errcode(db);
+  const char *message = sqlite3_errmsg(db);
+  std::string result("Error code ");
+  result += code;
+  result += ": ";
+  result += message;
+  return jni::make_jstring(result);
+}
+
+// static
+jni::local_ref<NativeDatabaseBinding::jhybriddata>
+NativeDatabaseBinding::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+// static
+void NativeDatabaseBinding::OnUpdateHook(void *arg, int action,
+                                         char const *dbName,
+                                         char const *tableName,
+                                         sqlite3_int64 rowId) {
+  NativeDatabaseBinding *pThis = reinterpret_cast<NativeDatabaseBinding *>(arg);
+  static const auto method =
+      jni::findClassStatic("expo/modules/sqlite/NativeDatabaseBinding")
+          ->getMethod<void(jint, jstring, jstring, jlong)>("onUpdate");
+  method(pThis->javaPart_, action, jni::make_jstring(dbName).get(),
+         jni::make_jstring(tableName).get(), rowId);
+}
+
+} // namespace expo

package/android/src/main/cpp/NativeDatabaseBinding.h

@@ -0,0 +1,75 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <string>
+
+#include "NativeStatementBinding.h"
+#include "sqlite3.h"
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+class NativeDatabaseBinding : public jni::HybridClass<NativeDatabaseBinding> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lexpo/modules/sqlite/NativeDatabaseBinding;";
+
+  static void registerNatives();
+
+  // sqlite3 bindings
+  int sqlite3_changes();
+  int sqlite3_close();
+  std::string sqlite3_db_filename(const std::string &dbName);
+  int sqlite3_enable_load_extension(int onoff);
+  int sqlite3_exec(const std::string &source);
+  int sqlite3_get_autocommit();
+  int64_t sqlite3_last_insert_rowid();
+  int sqlite3_load_extension(const std::string &libPath,
+                             const std::string &entryProc);
+  int sqlite3_open(const std::string &dbPath);
+  int sqlite3_prepare_v2(
+      const std::string &source,
+      jni::alias_ref<NativeStatementBinding::javaobject> statement);
+  void sqlite3_update_hook(bool enabled);
+
+  // helpers
+  jni::local_ref<jni::JString> convertSqlLiteErrorToString();
+
+private:
+  explicit NativeDatabaseBinding(
+      jni::alias_ref<NativeDatabaseBinding::jhybridobject> jThis)
+      : javaPart_(jni::make_global(jThis)) {}
+
+private:
+  static jni::local_ref<jhybriddata>
+  initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+  static void OnUpdateHook(void *arg, int action, char const *dbName,
+                           char const *tableName, sqlite3_int64 rowId);
+
+private:
+  friend HybridBase;
+
+  jni::global_ref<NativeDatabaseBinding::javaobject> javaPart_;
+  sqlite3 *db;
+};
+
+/**
+ * A convenient wrapper for the Kotlin SQLiteErrorException.
+ */
+class SQLiteErrorException
+    : public jni::JavaClass<SQLiteErrorException, CodedException> {
+public:
+  static auto constexpr kJavaDescriptor =
+      "Lexpo/modules/sqlite/SQLiteErrorException;";
+
+  static jni::local_ref<SQLiteErrorException>
+  create(const std::string &message) {
+    return SQLiteErrorException::newInstance(jni::make_jstring(message));
+  }
+};
+
+} // namespace expo

package/android/src/main/cpp/NativeStatementBinding.cpp

@@ -0,0 +1,146 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#include "NativeStatementBinding.h"
+
+#include <android/log.h>
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+namespace {
+
+constexpr char TAG[] = "expo-sqlite";
+
+} // namespace
+
+// static
+void NativeStatementBinding::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", NativeStatementBinding::initHybrid),
+      makeNativeMethod("sqlite3_bind_parameter_index",
+                       NativeStatementBinding::sqlite3_bind_parameter_index),
+      makeNativeMethod("sqlite3_column_count",
+                       NativeStatementBinding::sqlite3_column_count),
+      makeNativeMethod("sqlite3_column_name",
+                       NativeStatementBinding::sqlite3_column_name),
+      makeNativeMethod("sqlite3_finalize",
+                       NativeStatementBinding::sqlite3_finalize),
+      makeNativeMethod("sqlite3_reset", NativeStatementBinding::sqlite3_reset),
+      makeNativeMethod("sqlite3_step", NativeStatementBinding::sqlite3_step),
+      makeNativeMethod("bindStatementParam",
+                       NativeStatementBinding::bindStatementParam),
+      makeNativeMethod("getRow", NativeStatementBinding::getRow),
+  });
+}
+
+int NativeStatementBinding::sqlite3_bind_parameter_index(
+    const std::string &name) {
+  return ::sqlite3_bind_parameter_index(stmt, name.c_str());
+}
+
+int NativeStatementBinding::sqlite3_column_count() {
+  return ::sqlite3_column_count(stmt);
+}
+
+std::string NativeStatementBinding::sqlite3_column_name(int index) {
+  return ::sqlite3_column_name(stmt, index);
+}
+
+int NativeStatementBinding::sqlite3_finalize() {
+  return ::sqlite3_finalize(stmt);
+}
+
+int NativeStatementBinding::sqlite3_reset() { return ::sqlite3_reset(stmt); }
+
+int NativeStatementBinding::sqlite3_step() { return ::sqlite3_step(stmt); }
+
+int NativeStatementBinding::bindStatementParam(
+    int index, jni::alias_ref<jni::JObject> param) {
+  static const auto integerClass = jni::JInteger::javaClassStatic();
+  static const auto longClass = jni::JLong::javaClassStatic();
+  static const auto doubleClass = jni::JDouble::javaClassStatic();
+  static const auto stringClass = jni::JString::javaClassStatic();
+  static const auto booleanClass = jni::JBoolean::javaClassStatic();
+
+  int ret = -1;
+  if (param == nullptr) {
+    ret = sqlite3_bind_null(stmt, index);
+  } else if (param->isInstanceOf(integerClass)) {
+    ret = sqlite3_bind_int(stmt, index,
+                           jni::static_ref_cast<jni::JInteger>(param)->value());
+  } else if (param->isInstanceOf(longClass)) {
+    ret = sqlite3_bind_int64(stmt, index,
+                             jni::static_ref_cast<jni::JLong>(param)->value());
+  } else if (param->isInstanceOf(doubleClass)) {
+    ret = sqlite3_bind_double(
+        stmt, index, jni::static_ref_cast<jni::JDouble>(param)->value());
+  } else if (param->isInstanceOf(booleanClass)) {
+    ret = sqlite3_bind_int(
+        stmt, index,
+        jni::static_ref_cast<jni::JBoolean>(param)->value() ? 1 : 0);
+  } else {
+    std::string stringArg;
+    if (param->isInstanceOf(stringClass)) {
+      stringArg = jni::static_ref_cast<jni::JString>(param)->toStdString();
+    } else {
+      stringArg = param->toString();
+    }
+    ret = sqlite3_bind_text(stmt, index, stringArg.c_str(), stringArg.length(),
+                            SQLITE_TRANSIENT);
+  }
+  return ret;
+}
+
+jni::local_ref<ArrayMap<jni::JString, jni::JObject>>
+NativeStatementBinding::getRow() {
+  int columnCount = sqlite3_column_count();
+  auto row = ArrayMap<jni::JString, jni::JObject>::create(columnCount);
+  for (int i = 0; i < columnCount; ++i) {
+    auto name = sqlite3_column_name(i);
+    auto value = getColumnValue(i);
+    row->put(jni::make_jstring(name), value);
+  }
+  return row;
+}
+
+// static
+jni::local_ref<NativeStatementBinding::jhybriddata>
+NativeStatementBinding::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+jni::local_ref<jni::JObject> NativeStatementBinding::getColumnValue(int index) {
+  int type = ::sqlite3_column_type(stmt, index);
+  switch (type) {
+  case SQLITE_INTEGER: {
+    return jni::JLong::valueOf(sqlite3_column_int64(stmt, index));
+  }
+  case SQLITE_FLOAT: {
+    return jni::JDouble::valueOf(sqlite3_column_double(stmt, index));
+  }
+  case SQLITE_TEXT: {
+    std::string text(
+        reinterpret_cast<const char *>(sqlite3_column_text(stmt, index)),
+        static_cast<size_t>(sqlite3_column_bytes(stmt, index)));
+    return jni::make_jstring(text);
+  }
+  case SQLITE_BLOB: {
+    JNIEnv *env = jni::Environment::current();
+    return jni::adopt_local(env->NewString(
+        reinterpret_cast<const jchar *>(sqlite3_column_blob(stmt, index)),
+        static_cast<size_t>(sqlite3_column_bytes(stmt, index))));
+  }
+  case SQLITE_NULL: {
+    return nullptr;
+  }
+  default: {
+    std::string errorMessage =
+        "Unsupported parameter type: " + std::to_string(type);
+    jni::throwNewJavaException(
+        InvalidConvertibleException::create(errorMessage).get());
+  }
+  }
+}
+
+} // namespace expo