expo-sqlite 11.8.0 → 12.1.0

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

@@ -25,10 +25,6 @@ public:
   // sqlite3 bindings
   int sqlite3_open(const std::string &dbPath);
   int sqlite3_close();
-  int sqlite3_enable_load_extension(int onoff);
-  int sqlite3_load_extension(const std::string &libPath,
-                             const std::string &entryProc);
-  void sqlite3_update_hook(bool enabled);
 
 private:
   explicit SQLite3Wrapper(jni::alias_ref<SQLite3Wrapper::jhybridobject> jThis)

package/android/src/main/java/expo/modules/sqlite/NativeDatabase.kt

@@ -0,0 +1,11 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.sqlite
+
+import expo.modules.kotlin.sharedobjects.SharedRef
+
+internal class NativeDatabase(val dbName: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
+  override fun equals(other: Any?): Boolean {
+    return other is NativeDatabase && this.ref == other.ref
+  }
+}

package/android/src/main/java/expo/modules/sqlite/NativeDatabaseBinding.kt

@@ -0,0 +1,79 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.sqlite
+
+import com.facebook.jni.HybridData
+import expo.modules.core.interfaces.DoNotStrip
+
+private typealias UpdateListener = (dbName: String, tableName: String, operationType: Int, rowID: Long) -> Unit
+
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+internal class NativeDatabaseBinding {
+  @DoNotStrip
+  private val mHybridData: HybridData
+
+  private var mUpdateListener: UpdateListener? = null
+
+  init {
+    mHybridData = initHybrid()
+  }
+
+  /**
+   * Enable data change notifications
+   */
+  fun enableUpdateHook(listener: UpdateListener) {
+    sqlite3_update_hook(true)
+    mUpdateListener = listener
+  }
+
+  /**
+   * Disable data change notifications
+   */
+  fun disableUpdateHook() {
+    mUpdateListener = null
+    sqlite3_update_hook(false)
+  }
+
+  // region sqlite3 bindings
+
+  external fun sqlite3_changes(): Int
+  external fun sqlite3_close(): Int
+  external fun sqlite3_db_filename(dbName: String): String
+  external fun sqlite3_enable_load_extension(onoff: Int): Int
+  external fun sqlite3_exec(source: String): Int
+  external fun sqlite3_get_autocommit(): Int
+  external fun sqlite3_last_insert_rowid(): Long
+  external fun sqlite3_load_extension(libPath: String, entryProc: String): Int
+  external fun sqlite3_open(dbPath: String): Int
+  external fun sqlite3_prepare_v2(source: String, statement: NativeStatementBinding): Int
+  private external fun sqlite3_update_hook(enabled: Boolean) // Keeps it private internally and uses `enableUpdateHook` publicly
+
+  external fun convertSqlLiteErrorToString(): String
+
+  // endregion
+
+  // region internals
+
+  private external fun initHybrid(): HybridData
+
+  @Suppress("unused")
+  @DoNotStrip
+  private fun onUpdate(action: Int, dbName: String, tableName: String, rowId: Long) {
+    mUpdateListener?.invoke(dbName, tableName, action, rowId)
+  }
+
+  // endregion
+
+  companion object {
+    init {
+      System.loadLibrary("expo-sqlite")
+    }
+
+    // These error code should be synced with sqlite3.h
+    const val SQLITE_OK = 0
+
+    const val SQLITE_ROW = 100
+    const val SQLITE_DONE = 101
+  }
+}

package/android/src/main/java/expo/modules/sqlite/NativeStatement.kt

@@ -0,0 +1,11 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.sqlite
+
+import expo.modules.kotlin.sharedobjects.SharedRef
+
+internal class NativeStatement : SharedRef<NativeStatementBinding>(NativeStatementBinding()) {
+  override fun equals(other: Any?): Boolean {
+    return other is NativeStatement && this.ref == other.ref
+  }
+}

package/android/src/main/java/expo/modules/sqlite/NativeStatementBinding.kt

@@ -0,0 +1,41 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.sqlite
+
+import com.facebook.jni.HybridData
+import expo.modules.core.interfaces.DoNotStrip
+
+internal typealias ColumnNames = ArrayList<String>
+internal typealias ColumnValues = ArrayList<Any>
+
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+internal class NativeStatementBinding {
+  @DoNotStrip
+  private val mHybridData: HybridData
+
+  init {
+    mHybridData = initHybrid()
+  }
+
+  // region sqlite3 bindings
+
+  external fun sqlite3_bind_parameter_index(name: String): Int
+  external fun sqlite3_column_count(): Int
+  external fun sqlite3_column_name(index: Int): String
+  external fun sqlite3_finalize(): Int
+  external fun sqlite3_reset(): Int
+  external fun sqlite3_step(): Int
+
+  external fun bindStatementParam(index: Int, param: Any): Int
+  external fun getColumnNames(): ColumnNames
+  external fun getColumnValues(): ColumnValues
+
+  // endregion
+
+  // region internals
+
+  private external fun initHybrid(): HybridData
+
+  // endregion
+}

package/android/src/main/java/expo/modules/sqlite/SQLExceptions.kt

@@ -1,15 +1,26 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
 package expo.modules.sqlite
 
+import expo.modules.core.interfaces.DoNotStrip
 import expo.modules.kotlin.exception.CodedException
 
-class OpenDatabaseException(name: String) :
-  CodedException("Unable to delete database '$name' that is currently open. Close it prior to deletion.")
+internal class OpenDatabaseException(name: String) :
+  CodedException("Could not open database - name[$name]")
 
-class DatabaseNotFoundException(name: String) :
+internal class DatabaseNotFoundException(name: String) :
   CodedException("Database '$name' not found")
 
-class DeleteDatabaseException(name: String) :
+internal class DeleteDatabaseException(name: String) :
+  CodedException("Unable to delete database '$name' that is currently open. Close it prior to deletion.")
+
+internal class DeleteDatabaseFileException(name: String) :
   CodedException("Unable to delete the database file for '$name' database")
 
-class SQLiteException(message: String?, cause: Throwable?) :
-  CodedException(SQLiteModule::class.java.simpleName, message, cause)
+@DoNotStrip
+internal class SQLiteErrorException(message: String) :
+  CodedException("ERR_INTERNAL_SQLITE_ERROR", message, null)
+
+@DoNotStrip
+internal class InvalidConvertibleException(message: String) :
+  CodedException(message)

package/android/src/main/java/expo/modules/sqlite/SQLRecords.kt

@@ -1,19 +1,32 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
 package expo.modules.sqlite
 
 import expo.modules.kotlin.records.Field
 import expo.modules.kotlin.records.Record
 import expo.modules.kotlin.types.Enumerable
 
-data class Query(
+internal data class Query(
   @Field
   val sql: String,
   @Field
   val args: List<Any?>
 ) : Record
 
-enum class SqlAction(val value: String) : Enumerable {
+internal enum class SQLAction(val value: String) : Enumerable {
   INSERT("insert"),
   UPDATE("update"),
   DELETE("delete"),
-  UNKNOWN("unknown")
+  UNKNOWN("unknown");
+
+  companion object {
+    fun fromCode(value: Int): SQLAction {
+      return when (value) {
+        9 -> DELETE
+        18 -> INSERT
+        23 -> UPDATE
+        else -> UNKNOWN
+      }
+    }
+  }
 }

package/android/src/main/java/expo/modules/sqlite/SQLite3Wrapper.kt

@@ -3,16 +3,12 @@ package expo.modules.sqlite
 import com.facebook.jni.HybridData
 import expo.modules.core.interfaces.DoNotStrip
 
-private typealias UpdateListener = (tableName: String, operationType: Int, rowID: Long) -> Unit
-
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
 class SQLite3Wrapper private constructor() {
   @DoNotStrip
   private val mHybridData: HybridData
 
-  private var mUpdateListener: UpdateListener? = null
-
   init {
     mHybridData = initHybrid()
   }
@@ -22,43 +18,17 @@ class SQLite3Wrapper private constructor() {
    */
   external fun executeSql(sql: String, args: List<Any?>, readOnly: Boolean): List<Any>
 
-  /**
-   * Enable data change notifications
-   */
-  fun enableUpdateHook(listener: UpdateListener) {
-    sqlite3_update_hook(true)
-    mUpdateListener = listener
-  }
-
-  /**
-   * Disable data change notifications
-   */
-  fun disableUpdateHook() {
-    mUpdateListener = null
-    sqlite3_update_hook(false)
-  }
-
   // region sqlite3 bindings
 
   external fun sqlite3_open(dbPath: String): Int
   external fun sqlite3_close(): Int
 
-  external fun sqlite3_enable_load_extension(onoff: Int): Int
-  external fun sqlite3_load_extension(libPath: String, entryProc: String): Int
-
-  private external fun sqlite3_update_hook(enabled: Boolean)
-
   // endregion
 
   // region internals
 
   private external fun initHybrid(): HybridData
 
-  @DoNotStrip
-  private fun onUpdate(action: Int, dbName: String, tableName: String, rowId: Long) {
-    mUpdateListener?.invoke(tableName, action, rowId)
-  }
-
   // endregion
 
   companion object {

package/android/src/main/java/expo/modules/sqlite/SQLiteHelpers.kt

@@ -22,82 +22,3 @@ internal fun ensureDirExists(dir: File): File {
   }
   return dir
 }
-
-internal fun pluginResultsToPrimitiveData(results: List<SQLiteModule.SQLitePluginResult>): List<Any> {
-  return results.map { convertPluginResultToArray(it) }
-}
-
-private fun convertPluginResultToArray(result: SQLiteModule.SQLitePluginResult): List<Any?> {
-  val rowsContent = result.rows.map { row ->
-    row.map { value ->
-      when (value) {
-        null -> null
-        is String -> value
-        is Boolean -> value
-        else -> (value as Number).toDouble()
-      }
-    }
-  }
-
-  return arrayListOf(
-    result.error?.message,
-    result.insertId.toInt(),
-    result.rowsAffected,
-    result.columns,
-    rowsContent
-  )
-}
-
-private fun isPragma(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "pragma")
-}
-
-private fun isSelectCTE(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "with") && containsCaseInsensitive(str, "select")
-}
-
-private fun isPragmaReadOnly(str: String): Boolean {
-  return isPragma(str) && !str.contains('=')
-}
-
-internal fun isSelect(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "select") || isSelectCTE(str) || isPragmaReadOnly(str)
-}
-
-internal fun isInsert(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "insert")
-}
-
-internal fun isUpdate(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "update")
-}
-
-internal fun isDelete(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "delete")
-}
-
-private fun startsWithCaseInsensitive(str: String, substr: String): Boolean {
-  return str.trimStart().startsWith(substr, true)
-}
-
-private fun containsCaseInsensitive(str: String, substr: String): Boolean {
-  return str.trimStart().contains(substr, true)
-}
-
-internal fun convertParamsToStringArray(paramArrayArg: List<Any?>): Array<String?> {
-  return paramArrayArg.map { param ->
-    when (param) {
-      is String -> unescapeBlob(param)
-      is Boolean -> if (param) "1" else "0"
-      is Double -> param.toString()
-      null -> null
-      else -> throw ClassCastException("Could not find proper SQLite data type for argument: $")
-    }
-  }.toTypedArray()
-}
-
-private fun unescapeBlob(str: String): String {
-  return str.replace("\u0001\u0001", "\u0000")
-    .replace("\u0001\u0002", "\u0001")
-    .replace("\u0002\u0002", "\u0002")
-}

package/android/src/main/java/expo/modules/sqlite/SQLiteModule.kt

@@ -2,9 +2,7 @@
 package expo.modules.sqlite
 
 import android.content.Context
-import android.util.Log
 import androidx.collection.ArrayMap
-import androidx.core.os.bundleOf
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
@@ -14,7 +12,6 @@ import java.util.*
 
 class SQLiteModule : Module() {
   private val cachedDatabase = ArrayMap<String, SQLite3Wrapper>()
-  private var hasListeners = false
 
   private val context: Context
     get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
@@ -22,8 +19,6 @@ class SQLiteModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("ExpoSQLite")
 
-    Events("onDatabaseChange")
-
     AsyncFunction("exec") { dbName: String, queries: List<Query>, readOnly: Boolean ->
       return@AsyncFunction execute(dbName, queries, readOnly)
     }
@@ -46,28 +41,19 @@ class SQLiteModule : Module() {
 
     AsyncFunction("deleteAsync") { dbName: String ->
       if (cachedDatabase[dbName] != null) {
-        throw OpenDatabaseException(dbName)
+        throw DeleteDatabaseException(dbName)
       }
       val dbFile = File(pathForDatabaseName(dbName))
       if (!dbFile.exists()) {
         throw DatabaseNotFoundException(dbName)
       }
       if (!dbFile.delete()) {
-        throw DeleteDatabaseException(dbName)
+        throw DeleteDatabaseFileException(dbName)
       }
     }
 
-    OnStartObserving {
-      hasListeners = true
-    }
-
-    OnStopObserving {
-      hasListeners = false
-    }
-
     OnDestroy {
       cachedDatabase.values.forEach {
-        it.executeSql("SELECT crsql_finalize()", emptyList(), false)
         it.sqlite3_close()
       }
     }
@@ -96,50 +82,15 @@ class SQLiteModule : Module() {
 
     cachedDatabase.remove(dbName)
     val db = SQLite3Wrapper.open(path) ?: return null
-    loadExtensions(db)
-    addUpdateListener(db)
     cachedDatabase[dbName] = db
     return db
   }
 
-  private fun loadExtensions(db: SQLite3Wrapper) {
-    var errCode = db.sqlite3_enable_load_extension(1)
-    if (errCode != SQLite3Wrapper.SQLITE_OK) {
-      Log.e(TAG, "Failed to enable sqlite3 extensions - errCode[$errCode]")
-      return
-    }
-    errCode = db.sqlite3_load_extension("libcrsqlite", "sqlite3_crsqlite_init")
-    if (errCode != SQLite3Wrapper.SQLITE_OK) {
-      Log.e(TAG, "Failed to load crsqlite extension - errCode[$errCode]")
-    }
-  }
-
   private fun execute(dbName: String, queries: List<Query>, readOnly: Boolean): List<Any> {
     val db = openDatabase(dbName) ?: throw OpenDatabaseException(dbName)
     return queries.map { db.executeSql(it.sql, it.args, readOnly) }
   }
 
-  private fun addUpdateListener(db: SQLite3Wrapper) {
-    db.enableUpdateHook { tableName: String, operationType: Int, rowID: Long ->
-      if (!hasListeners) {
-        return@enableUpdateHook
-      }
-      sendEvent(
-        "onDatabaseChange",
-        bundleOf(
-          "tableName" to tableName,
-          "rowId" to rowID,
-          "typeId" to when (operationType) {
-            9 -> SqlAction.DELETE.value
-            18 -> SqlAction.INSERT.value
-            23 -> SqlAction.UPDATE.value
-            else -> SqlAction.UNKNOWN.value
-          }
-        )
-      )
-    }
-  }
-
   internal class SQLitePluginResult(
     val rows: Array<Array<Any?>>,
     val columns: Array<String?>,
@@ -147,8 +98,4 @@ class SQLiteModule : Module() {
     val insertId: Long,
     val error: Throwable?
   )
-
-  companion object {
-    private val TAG = SQLiteModule::class.java.simpleName
-  }
 }