expo-sqlite 13.0.0 → 13.1.1

package/CHANGELOG.md

@@ -10,6 +10,16 @@
 
 ### 💡 Others
 
+## 13.1.1 — 2023-12-19
+
+_This version does not introduce any user-facing changes._
+
+## 13.1.0 — 2023-12-13
+
+### 🛠 Breaking changes
+
+- Refactor `expo-sqlite/next` API to be more React idiomatic. ([#25657](https://github.com/expo/expo/pull/25657) by [@kudo](https://github.com/kudo))
+
 ## 13.0.0 — 2023-12-12
 
 ### 🎉 New features

package/android/build.gradle

@@ -4,7 +4,7 @@ apply plugin: 'maven-publish'
 apply plugin: 'de.undercouch.download'
 
 group = 'host.exp.exponent'
-version = '13.0.0'
+version = '13.1.1'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -106,7 +106,7 @@ android {
   namespace "expo.modules.sqlite"
   defaultConfig {
     versionCode 18
-    versionName "13.0.0"
+    versionName "13.1.1"
 
     externalNativeBuild {
       cmake {

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

@@ -49,8 +49,8 @@ int NativeDatabaseBinding::sqlite3_close() {
 }
 
 std::string
-NativeDatabaseBinding::sqlite3_db_filename(const std::string &dbName) {
-  return ::sqlite3_db_filename(db, dbName.c_str());
+NativeDatabaseBinding::sqlite3_db_filename(const std::string &databaseName) {
+  return ::sqlite3_db_filename(db, databaseName.c_str());
 }
 
 int NativeDatabaseBinding::sqlite3_enable_load_extension(int onoff) {
@@ -128,14 +128,14 @@ NativeDatabaseBinding::initHybrid(jni::alias_ref<jhybridobject> jThis) {
 
 // static
 void NativeDatabaseBinding::OnUpdateHook(void *arg, int action,
-                                         char const *dbName,
+                                         char const *databaseName,
                                          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(),
+  method(pThis->javaPart_, action, jni::make_jstring(databaseName).get(),
          jni::make_jstring(tableName).get(), rowId);
 }
 

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

@@ -22,7 +22,7 @@ public:
   // sqlite3 bindings
   int sqlite3_changes();
   int sqlite3_close();
-  std::string sqlite3_db_filename(const std::string &dbName);
+  std::string sqlite3_db_filename(const std::string &databaseName);
   int sqlite3_enable_load_extension(int onoff);
   int sqlite3_exec(const std::string &source);
   int sqlite3_get_autocommit();
@@ -47,7 +47,7 @@ private:
   static jni::local_ref<jhybriddata>
   initHybrid(jni::alias_ref<jhybridobject> jThis);
 
-  static void OnUpdateHook(void *arg, int action, char const *dbName,
+  static void OnUpdateHook(void *arg, int action, char const *databaseName,
                            char const *tableName, sqlite3_int64 rowId);
 
 private:

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

@@ -20,6 +20,8 @@ void NativeStatementBinding::registerNatives() {
       makeNativeMethod("initHybrid", NativeStatementBinding::initHybrid),
       makeNativeMethod("sqlite3_bind_parameter_index",
                        NativeStatementBinding::sqlite3_bind_parameter_index),
+      makeNativeMethod("sqlite3_clear_bindings",
+                       NativeStatementBinding::sqlite3_clear_bindings),
       makeNativeMethod("sqlite3_column_count",
                        NativeStatementBinding::sqlite3_column_count),
       makeNativeMethod("sqlite3_column_name",
@@ -42,6 +44,10 @@ int NativeStatementBinding::sqlite3_bind_parameter_index(
   return ::sqlite3_bind_parameter_index(stmt, name.c_str());
 }
 
+int NativeStatementBinding::sqlite3_clear_bindings() {
+  return ::sqlite3_clear_bindings(stmt);
+}
+
 int NativeStatementBinding::sqlite3_column_count() {
   return ::sqlite3_column_count(stmt);
 }

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

@@ -22,6 +22,7 @@ public:
 
   // sqlite3 bindings
   int sqlite3_bind_parameter_index(const std::string &name);
+  int sqlite3_clear_bindings();
   int sqlite3_column_count();
   std::string sqlite3_column_name(int index);
   int sqlite3_finalize();

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

@@ -4,7 +4,7 @@ package expo.modules.sqlite
 
 import expo.modules.kotlin.sharedobjects.SharedRef
 
-internal class NativeDatabase(val dbName: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
+internal class NativeDatabase(val databaseName: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
   var isClosed = false
 
   override fun equals(other: Any?): Boolean {

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

@@ -5,7 +5,7 @@ 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
+private typealias UpdateListener = (databaseName: String, tableName: String, operationType: Int, rowID: Long) -> Unit
 
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
@@ -39,7 +39,7 @@ internal class NativeDatabaseBinding {
 
   external fun sqlite3_changes(): Int
   external fun sqlite3_close(): Int
-  external fun sqlite3_db_filename(dbName: String): String
+  external fun sqlite3_db_filename(databaseName: String): String
   external fun sqlite3_enable_load_extension(onoff: Int): Int
   external fun sqlite3_exec(source: String): Int
   external fun sqlite3_get_autocommit(): Int
@@ -59,8 +59,8 @@ internal class NativeDatabaseBinding {
 
   @Suppress("unused")
   @DoNotStrip
-  private fun onUpdate(action: Int, dbName: String, tableName: String, rowId: Long) {
-    mUpdateListener?.invoke(dbName, tableName, action, rowId)
+  private fun onUpdate(action: Int, databaseName: String, tableName: String, rowId: Long) {
+    mUpdateListener?.invoke(databaseName, tableName, action, rowId)
   }
 
   // endregion

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

@@ -5,8 +5,8 @@ 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>
+internal typealias SQLiteColumnNames = ArrayList<String>
+internal typealias SQLiteColumnValues = ArrayList<Any>
 
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
@@ -21,6 +21,7 @@ internal class NativeStatementBinding {
   // region sqlite3 bindings
 
   external fun sqlite3_bind_parameter_index(name: String): Int
+  external fun sqlite3_clear_bindings(): Int
   external fun sqlite3_column_count(): Int
   external fun sqlite3_column_name(index: Int): String
   external fun sqlite3_finalize(): Int
@@ -28,8 +29,8 @@ internal class NativeStatementBinding {
   external fun sqlite3_step(): Int
 
   external fun bindStatementParam(index: Int, param: Any): Int
-  external fun getColumnNames(): ColumnNames
-  external fun getColumnValues(): ColumnValues
+  external fun getColumnNames(): SQLiteColumnNames
+  external fun getColumnValues(): SQLiteColumnValues
 
   // endregion
 

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

@@ -19,36 +19,36 @@ class SQLiteModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("ExpoSQLite")
 
-    AsyncFunction("exec") { dbName: String, queries: List<Query>, readOnly: Boolean ->
-      return@AsyncFunction execute(dbName, queries, readOnly)
+    AsyncFunction("exec") { databaseName: String, queries: List<Query>, readOnly: Boolean ->
+      return@AsyncFunction execute(databaseName, queries, readOnly)
     }
 
-    AsyncFunction("execRawQuery") { dbName: String, queries: List<Query>, readOnly: Boolean ->
-      return@AsyncFunction execute(dbName, queries, readOnly)
+    AsyncFunction("execRawQuery") { databaseName: String, queries: List<Query>, readOnly: Boolean ->
+      return@AsyncFunction execute(databaseName, queries, readOnly)
     }
 
-    AsyncFunction("close") { dbName: String ->
+    AsyncFunction("close") { databaseName: String ->
       cachedDatabase
-        .remove(dbName)
+        .remove(databaseName)
         ?.sqlite3_close()
     }
 
-    Function("closeSync") { dbName: String ->
+    Function("closeSync") { databaseName: String ->
       cachedDatabase
-        .remove(dbName)
+        .remove(databaseName)
         ?.sqlite3_close()
     }
 
-    AsyncFunction("deleteAsync") { dbName: String ->
-      if (cachedDatabase[dbName] != null) {
-        throw DeleteDatabaseException(dbName)
+    AsyncFunction("deleteAsync") { databaseName: String ->
+      if (cachedDatabase[databaseName] != null) {
+        throw DeleteDatabaseException(databaseName)
       }
-      val dbFile = File(pathForDatabaseName(dbName))
+      val dbFile = File(pathForDatabaseName(databaseName))
       if (!dbFile.exists()) {
-        throw DatabaseNotFoundException(dbName)
+        throw DatabaseNotFoundException(databaseName)
       }
       if (!dbFile.delete()) {
-        throw DeleteDatabaseFileException(dbName)
+        throw DeleteDatabaseFileException(databaseName)
       }
     }
 
@@ -66,28 +66,28 @@ class SQLiteModule : Module() {
     return "$directory${File.separator}$name"
   }
 
-  private fun openDatabase(dbName: String): SQLite3Wrapper? {
+  private fun openDatabase(databaseName: String): SQLite3Wrapper? {
     val path: String
     try {
-      path = pathForDatabaseName(dbName)
+      path = pathForDatabaseName(databaseName)
     } catch (_: IOException) {
       return null
     }
 
     if (File(path).exists()) {
-      cachedDatabase[dbName]?.let {
+      cachedDatabase[databaseName]?.let {
         return it
       }
     }
 
-    cachedDatabase.remove(dbName)
+    cachedDatabase.remove(databaseName)
     val db = SQLite3Wrapper.open(path) ?: return null
-    cachedDatabase[dbName] = db
+    cachedDatabase[databaseName] = db
     return db
   }
 
-  private fun execute(dbName: String, queries: List<Query>, readOnly: Boolean): List<Any> {
-    val db = openDatabase(dbName) ?: throw OpenDatabaseException(dbName)
+  private fun execute(databaseName: String, queries: List<Query>, readOnly: Boolean): List<Any> {
+    val db = openDatabase(databaseName) ?: throw OpenDatabaseException(databaseName)
     return queries.map { db.executeSql(it.sql, it.args, readOnly) }
   }
 

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

@@ -43,25 +43,25 @@ class SQLiteModuleNext : Module() {
       } catch (_: Throwable) {}
     }
 
-    AsyncFunction("deleteDatabaseAsync") { dbName: String ->
-      deleteDatabase(dbName)
+    AsyncFunction("deleteDatabaseAsync") { databaseName: String ->
+      deleteDatabase(databaseName)
     }
-    Function("deleteDatabaseSync") { dbName: String ->
-      deleteDatabase(dbName)
+    Function("deleteDatabaseSync") { databaseName: String ->
+      deleteDatabase(databaseName)
     }
 
     Class(NativeDatabase::class) {
-      Constructor { dbName: String, options: OpenDatabaseOptions ->
-        val dbPath = pathForDatabaseName(dbName)
+      Constructor { databaseName: String, options: OpenDatabaseOptions ->
+        val dbPath = pathForDatabaseName(databaseName)
 
         // Try to find opened database for fast refresh
-        findCachedDatabase { it.dbName == dbName && it.openOptions == options && !options.useNewConnection }?.let {
+        findCachedDatabase { it.databaseName == databaseName && it.openOptions == options && !options.useNewConnection }?.let {
           return@Constructor it
         }
 
-        val database = NativeDatabase(dbName, options)
+        val database = NativeDatabase(databaseName, options)
         if (database.ref.sqlite3_open(dbPath) != NativeDatabaseBinding.SQLITE_OK) {
-          throw OpenDatabaseException(dbName)
+          throw OpenDatabaseException(databaseName)
         }
         addCachedDatabase(database)
         return@Constructor database
@@ -119,18 +119,25 @@ class SQLiteModuleNext : Module() {
         return@Function run(statement, database, bindParams, bindBlobParams, shouldPassAsArray)
       }
 
-      AsyncFunction("getAsync") { statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean ->
-        return@AsyncFunction get(statement, database, bindParams, bindBlobParams, shouldPassAsArray)
+      AsyncFunction("stepAsync") { statement: NativeStatement, database: NativeDatabase ->
+        return@AsyncFunction step(statement, database)
       }
-      Function("getSync") { statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean ->
-        return@Function get(statement, database, bindParams, bindBlobParams, shouldPassAsArray)
+      Function("stepSync") { statement: NativeStatement, database: NativeDatabase ->
+        return@Function step(statement, database)
       }
 
-      AsyncFunction("getAllAsync") { statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean ->
-        return@AsyncFunction getAll(statement, database, bindParams, bindBlobParams, shouldPassAsArray)
+      AsyncFunction("getAllAsync") { statement: NativeStatement, database: NativeDatabase ->
+        return@AsyncFunction getAll(statement, database)
       }
-      Function("getAllSync") { statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean ->
-        return@Function getAll(statement, database, bindParams, bindBlobParams, shouldPassAsArray)
+      Function("getAllSync") { statement: NativeStatement, database: NativeDatabase ->
+        return@Function getAll(statement, database)
+      }
+
+      AsyncFunction("resetAsync") { statement: NativeStatement, database: NativeDatabase ->
+        return@AsyncFunction reset(statement, database)
+      }
+      Function("resetSync") { statement: NativeStatement, database: NativeDatabase ->
+        return@Function reset(statement, database)
       }
 
       AsyncFunction("getColumnNamesAsync") { statement: NativeStatement ->
@@ -142,13 +149,6 @@ class SQLiteModuleNext : Module() {
         return@Function statement.ref.getColumnNames()
       }
 
-      AsyncFunction("resetAsync") { statement: NativeStatement, database: NativeDatabase ->
-        return@AsyncFunction reset(statement, database)
-      }
-      Function("resetSync") { statement: NativeStatement, database: NativeDatabase ->
-        return@Function reset(statement, database)
-      }
-
       AsyncFunction("finalizeAsync") { statement: NativeStatement, database: NativeDatabase ->
         return@AsyncFunction finalize(statement, database)
       }
@@ -193,18 +193,30 @@ class SQLiteModuleNext : Module() {
   private fun prepareStatement(database: NativeDatabase, statement: NativeStatement, source: String) {
     maybeThrowForClosedDatabase(database)
     maybeThrowForFinalizedStatement(statement)
-    database.ref.sqlite3_prepare_v2(source, statement.ref)
+    if (database.ref.sqlite3_prepare_v2(source, statement.ref) != NativeDatabaseBinding.SQLITE_OK) {
+      throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+    }
     maybeAddCachedStatement(database, statement)
   }
 
   @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
-  private fun run(statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean): Map<String, Int> {
+  private fun run(statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean): Map<String, Any> {
     maybeThrowForClosedDatabase(database)
     maybeThrowForFinalizedStatement(statement)
+    statement.ref.sqlite3_reset()
+    statement.ref.sqlite3_clear_bindings()
     for ((key, param) in bindParams) {
       val index = getBindParamIndex(statement, key, shouldPassAsArray)
       if (index > 0) {
-        statement.ref.bindStatementParam(index, param)
+        // expo-modules-core AnyTypeConverter casts JavaScript Number to Kotlin Double,
+        // here to cast as Long if the value is an integer.
+        val normalizedParam =
+          if (param is Double && param.toDouble() % 1.0 == 0.0) {
+            param.toLong()
+          } else {
+            param
+          }
+        statement.ref.bindStatementParam(index, normalizedParam)
       }
     }
     for ((key, param) in bindBlobParams) {
@@ -218,29 +230,23 @@ class SQLiteModuleNext : Module() {
     if (ret != NativeDatabaseBinding.SQLITE_ROW && ret != NativeDatabaseBinding.SQLITE_DONE) {
       throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
     }
+    val firstRowValues: SQLiteColumnValues =
+      if (ret == NativeDatabaseBinding.SQLITE_ROW) {
+        statement.ref.getColumnValues()
+      } else {
+        arrayListOf()
+      }
     return mapOf(
-      "lastInsertRowid" to database.ref.sqlite3_last_insert_rowid().toInt(),
+      "lastInsertRowId" to database.ref.sqlite3_last_insert_rowid().toInt(),
       "changes" to database.ref.sqlite3_changes(),
+      "firstRowValues" to firstRowValues
     )
   }
 
   @Throws(AccessClosedResourceException::class, InvalidConvertibleException::class, SQLiteErrorException::class)
-  private fun get(statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean): ColumnValues? {
+  private fun step(statement: NativeStatement, database: NativeDatabase): SQLiteColumnValues? {
     maybeThrowForClosedDatabase(database)
     maybeThrowForFinalizedStatement(statement)
-    for ((key, param) in bindParams) {
-      val index = getBindParamIndex(statement, key, shouldPassAsArray)
-      if (index > 0) {
-        statement.ref.bindStatementParam(index, param)
-      }
-    }
-    for ((key, param) in bindBlobParams) {
-      val index = getBindParamIndex(statement, key, shouldPassAsArray)
-      if (index > 0) {
-        statement.ref.bindStatementParam(index, param)
-      }
-    }
-
     val ret = statement.ref.sqlite3_step()
     if (ret == NativeDatabaseBinding.SQLITE_ROW) {
       return statement.ref.getColumnValues()
@@ -252,23 +258,10 @@ class SQLiteModuleNext : Module() {
   }
 
   @Throws(AccessClosedResourceException::class, InvalidConvertibleException::class, SQLiteErrorException::class)
-  private fun getAll(statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any>, bindBlobParams: Map<String, ByteArray>, shouldPassAsArray: Boolean): List<ColumnValues> {
+  private fun getAll(statement: NativeStatement, database: NativeDatabase): List<SQLiteColumnValues> {
     maybeThrowForClosedDatabase(database)
     maybeThrowForFinalizedStatement(statement)
-    for ((key, param) in bindParams) {
-      val index = getBindParamIndex(statement, key, shouldPassAsArray)
-      if (index > 0) {
-        statement.ref.bindStatementParam(index, param)
-      }
-    }
-    for ((key, param) in bindBlobParams) {
-      val index = getBindParamIndex(statement, key, shouldPassAsArray)
-      if (index > 0) {
-        statement.ref.bindStatementParam(index, param)
-      }
-    }
-
-    val columnValuesList = mutableListOf<ColumnValues>()
+    val columnValuesList = mutableListOf<SQLiteColumnValues>()
     while (true) {
       val ret = statement.ref.sqlite3_step()
       if (ret == NativeDatabaseBinding.SQLITE_ROW) {
@@ -315,19 +308,19 @@ class SQLiteModuleNext : Module() {
   }
 
   private fun addUpdateHook(database: NativeDatabase) {
-    database.ref.enableUpdateHook { dbName, tableName, operationType, rowID ->
+    database.ref.enableUpdateHook { databaseName, tableName, operationType, rowID ->
       if (!hasListeners) {
         return@enableUpdateHook
       }
-      val dbFilePath = database.ref.sqlite3_db_filename(dbName)
+      val databaseFilePath = database.ref.sqlite3_db_filename(databaseName)
       sendEvent(
         "onDatabaseChange",
         bundleOf(
-          "dbName" to dbName,
-          "dbFilePath" to dbFilePath,
+          "databaseName" to databaseName,
+          "databaseFilePath" to databaseFilePath,
           "tableName" to tableName,
           "rowId" to rowID,
-          "typeId" to SQLAction.fromCode(operationType).value,
+          "typeId" to SQLAction.fromCode(operationType).value
         )
       )
     }
@@ -349,20 +342,20 @@ class SQLiteModuleNext : Module() {
     database.isClosed = true
   }
 
-  private fun deleteDatabase(dbName: String) {
-    findCachedDatabase { it.dbName == dbName }?.let {
-      throw DeleteDatabaseException(dbName)
+  private fun deleteDatabase(databaseName: String) {
+    findCachedDatabase { it.databaseName == databaseName }?.let {
+      throw DeleteDatabaseException(databaseName)
     }
 
-    if (dbName == MEMORY_DB_NAME) {
+    if (databaseName == MEMORY_DB_NAME) {
       return
     }
-    val dbFile = File(pathForDatabaseName(dbName))
+    val dbFile = File(pathForDatabaseName(databaseName))
     if (!dbFile.exists()) {
-      throw DatabaseNotFoundException(dbName)
+      throw DatabaseNotFoundException(databaseName)
     }
     if (!dbFile.delete()) {
-      throw DeleteDatabaseFileException(dbName)
+      throw DeleteDatabaseFileException(databaseName)
     }
   }
 

package/build/next/ExpoSQLiteNext.d.ts

@@ -1,10 +1,10 @@
-import { OpenOptions } from './NativeDatabase';
+import { SQLiteOpenOptions } from './NativeDatabase';
 declare const _default: {
     readonly name: string;
-    NativeDatabase(dbName: string, options?: OpenOptions): void;
+    NativeDatabase(databaseName: string, options?: SQLiteOpenOptions): void;
     NativeStatement(): void;
-    deleteDatabaseAsync(dbName: string): Promise<void>;
-    deleteDatabaseSync(dbName: string): void;
+    deleteDatabaseAsync(databaseName: string): Promise<void>;
+    deleteDatabaseSync(databaseName: string): void;
     addListener(): never;
     removeListeners(): never;
 };

package/build/next/ExpoSQLiteNext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoSQLiteNext.d.ts","sourceRoot":"","sources":["../../src/next/ExpoSQLiteNext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;;;2BAOtB,MAAM,YAAY,WAAW,GAAG,IAAI;uBAIxC,IAAI;gCAIW,MAAM,GAAG,QAAQ,IAAI,CAAC;+BAI7B,MAAM,GAAG,IAAI;;;;AAjB1C,wBA+BE"}
+{"version":3,"file":"ExpoSQLiteNext.d.ts","sourceRoot":"","sources":["../../src/next/ExpoSQLiteNext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;;;iCAOtB,MAAM,YAAY,iBAAiB,GAAG,IAAI;uBAIpD,IAAI;sCAIiB,MAAM,GAAG,QAAQ,IAAI,CAAC;qCAI7B,MAAM,GAAG,IAAI;;;;AAjBhD,wBA+BE"}

package/build/next/ExpoSQLiteNext.js

@@ -2,16 +2,16 @@ export default {
     get name() {
         return 'ExpoSQLiteNext';
     },
-    NativeDatabase(dbName, options) {
+    NativeDatabase(databaseName, options) {
         throw new Error('Unimplemented');
     },
     NativeStatement() {
         throw new Error('Unimplemented');
     },
-    async deleteDatabaseAsync(dbName) {
+    async deleteDatabaseAsync(databaseName) {
         throw new Error('Unimplemented');
     },
-    deleteDatabaseSync(dbName) {
+    deleteDatabaseSync(databaseName) {
         throw new Error('Unimplemented');
     },
     //#region EventEmitter implementations

package/build/next/ExpoSQLiteNext.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoSQLiteNext.js","sourceRoot":"","sources":["../../src/next/ExpoSQLiteNext.ts"],"names":[],"mappings":"AAEA,eAAe;IACb,IAAI,IAAI;QACN,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,cAAc,CAAC,MAAc,EAAE,OAAqB;QAClD,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,eAAe;QACb,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,MAAc;QACtC,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,kBAAkB,CAAC,MAAc;QAC/B,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,sCAAsC;IAEtC,WAAW;QACT,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IACD,eAAe;QACb,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,YAAY;CACb,CAAC","sourcesContent":["import { OpenOptions } from './NativeDatabase';\n\nexport default {\n  get name(): string {\n    return 'ExpoSQLiteNext';\n  },\n\n  NativeDatabase(dbName: string, options?: OpenOptions): void {\n    throw new Error('Unimplemented');\n  },\n\n  NativeStatement(): void {\n    throw new Error('Unimplemented');\n  },\n\n  async deleteDatabaseAsync(dbName: string): Promise<void> {\n    throw new Error('Unimplemented');\n  },\n\n  deleteDatabaseSync(dbName: string): void {\n    throw new Error('Unimplemented');\n  },\n\n  //#region EventEmitter implementations\n\n  addListener() {\n    throw new Error('Unimplemented');\n  },\n  removeListeners() {\n    throw new Error('Unimplemented');\n  },\n\n  //#endregion\n};\n"]}
+{"version":3,"file":"ExpoSQLiteNext.js","sourceRoot":"","sources":["../../src/next/ExpoSQLiteNext.ts"],"names":[],"mappings":"AAEA,eAAe;IACb,IAAI,IAAI;QACN,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,cAAc,CAAC,YAAoB,EAAE,OAA2B;QAC9D,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,eAAe;QACb,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,YAAoB;QAC5C,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,kBAAkB,CAAC,YAAoB;QACrC,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,sCAAsC;IAEtC,WAAW;QACT,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IACD,eAAe;QACb,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,YAAY;CACb,CAAC","sourcesContent":["import { SQLiteOpenOptions } from './NativeDatabase';\n\nexport default {\n  get name(): string {\n    return 'ExpoSQLiteNext';\n  },\n\n  NativeDatabase(databaseName: string, options?: SQLiteOpenOptions): void {\n    throw new Error('Unimplemented');\n  },\n\n  NativeStatement(): void {\n    throw new Error('Unimplemented');\n  },\n\n  async deleteDatabaseAsync(databaseName: string): Promise<void> {\n    throw new Error('Unimplemented');\n  },\n\n  deleteDatabaseSync(databaseName: string): void {\n    throw new Error('Unimplemented');\n  },\n\n  //#region EventEmitter implementations\n\n  addListener() {\n    throw new Error('Unimplemented');\n  },\n  removeListeners() {\n    throw new Error('Unimplemented');\n  },\n\n  //#endregion\n};\n"]}

package/build/next/NativeDatabase.d.ts

@@ -3,7 +3,7 @@ import { NativeStatement } from './NativeStatement';
  * A class that represents an instance of the SQLite database.
  */
 export declare class NativeDatabase {
-    constructor(dbName: string, options?: OpenOptions);
+    constructor(databaseName: string, options?: SQLiteOpenOptions);
     initAsync(): Promise<void>;
     isInTransactionAsync(): Promise<boolean>;
     closeAsync(): Promise<void>;
@@ -18,14 +18,14 @@ export declare class NativeDatabase {
 /**
  * Options for opening a database.
  */
-export interface OpenOptions {
+export interface SQLiteOpenOptions {
     /**
      * Whether to enable the CR-SQLite extension.
      * @default false
      */
     enableCRSQLite?: boolean;
     /**
-     * Whether to call the [`sqlite3_update_hook`](https://www.sqlite.org/c3ref/update_hook.html) function and enable the `onDatabaseChange` events. You can later subscribe to the change events by [`addDatabaseChangeListener`](#sqliteadddatabasechangelistenerlistener).
+     * Whether to call the [`sqlite3_update_hook()`](https://www.sqlite.org/c3ref/update_hook.html) function and enable the `onDatabaseChange` events. You can later subscribe to the change events by [`addDatabaseChangeListener`](#sqliteadddatabasechangelistenerlistener).
      * @default false
      */
     enableChangeListener?: boolean;

package/build/next/NativeDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeDatabase.d.ts","sourceRoot":"","sources":["../../src/next/NativeDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;gBACrB,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW;IAI1C,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAC1B,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC;IACxC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAC3B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IACxC,YAAY,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAMxF,QAAQ,IAAI,IAAI;IAChB,mBAAmB,IAAI,OAAO;IAC9B,SAAS,IAAI,IAAI;IACjB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAC9B,WAAW,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe;CAGtF;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;CACjD"}
+{"version":3,"file":"NativeDatabase.d.ts","sourceRoot":"","sources":["../../src/next/NativeDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;gBACrB,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB;IAItD,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAC1B,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC;IACxC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAC3B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IACxC,YAAY,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAMxF,QAAQ,IAAI,IAAI;IAChB,mBAAmB,IAAI,OAAO;IAC9B,SAAS,IAAI,IAAI;IACjB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAC9B,WAAW,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe;CAGtF;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;CACjD"}

package/build/next/NativeDatabase.js.map

@@ -1 +1 @@
-{"version":3,"file":"NativeDatabase.js","sourceRoot":"","sources":["../../src/next/NativeDatabase.ts"],"names":[],"mappings":"","sourcesContent":["import { NativeStatement } from './NativeStatement';\n\n/**\n * A class that represents an instance of the SQLite database.\n */\nexport declare class NativeDatabase {\n  constructor(dbName: string, options?: OpenOptions);\n\n  //#region Asynchronous API\n\n  public initAsync(): Promise<void>;\n  public isInTransactionAsync(): Promise<boolean>;\n  public closeAsync(): Promise<void>;\n  public execAsync(source: string): Promise<void>;\n  public prepareAsync(nativeStatement: NativeStatement, source: string): Promise<NativeStatement>;\n\n  //#endregion\n\n  //#region Synchronous API\n\n  public initSync(): void;\n  public isInTransactionSync(): boolean;\n  public closeSync(): void;\n  public execSync(source: string): void;\n  public prepareSync(nativeStatement: NativeStatement, source: string): NativeStatement;\n\n  //#endregion\n}\n\n/**\n * Options for opening a database.\n */\nexport interface OpenOptions {\n  /**\n   * Whether to enable the CR-SQLite extension.\n   * @default false\n   */\n  enableCRSQLite?: boolean;\n\n  /**\n   * Whether to call the [`sqlite3_update_hook`](https://www.sqlite.org/c3ref/update_hook.html) function and enable the `onDatabaseChange` events. You can later subscribe to the change events by [`addDatabaseChangeListener`](#sqliteadddatabasechangelistenerlistener).\n   * @default false\n   */\n  enableChangeListener?: boolean;\n\n  /**\n   * Whether to create new connection even if connection with the same database name exists in cache.\n   * @default false\n   */\n  useNewConnection?: boolean;\n\n  /**\n   * Finalized unclosed statements automatically when the database is closed.\n   * @default true\n   * @hidden\n   */\n  finalizeUnusedStatementsBeforeClosing?: boolean;\n}\n"]}
+{"version":3,"file":"NativeDatabase.js","sourceRoot":"","sources":["../../src/next/NativeDatabase.ts"],"names":[],"mappings":"","sourcesContent":["import { NativeStatement } from './NativeStatement';\n\n/**\n * A class that represents an instance of the SQLite database.\n */\nexport declare class NativeDatabase {\n  constructor(databaseName: string, options?: SQLiteOpenOptions);\n\n  //#region Asynchronous API\n\n  public initAsync(): Promise<void>;\n  public isInTransactionAsync(): Promise<boolean>;\n  public closeAsync(): Promise<void>;\n  public execAsync(source: string): Promise<void>;\n  public prepareAsync(nativeStatement: NativeStatement, source: string): Promise<NativeStatement>;\n\n  //#endregion\n\n  //#region Synchronous API\n\n  public initSync(): void;\n  public isInTransactionSync(): boolean;\n  public closeSync(): void;\n  public execSync(source: string): void;\n  public prepareSync(nativeStatement: NativeStatement, source: string): NativeStatement;\n\n  //#endregion\n}\n\n/**\n * Options for opening a database.\n */\nexport interface SQLiteOpenOptions {\n  /**\n   * Whether to enable the CR-SQLite extension.\n   * @default false\n   */\n  enableCRSQLite?: boolean;\n\n  /**\n   * Whether to call the [`sqlite3_update_hook()`](https://www.sqlite.org/c3ref/update_hook.html) function and enable the `onDatabaseChange` events. You can later subscribe to the change events by [`addDatabaseChangeListener`](#sqliteadddatabasechangelistenerlistener).\n   * @default false\n   */\n  enableChangeListener?: boolean;\n\n  /**\n   * Whether to create new connection even if connection with the same database name exists in cache.\n   * @default false\n   */\n  useNewConnection?: boolean;\n\n  /**\n   * Finalized unclosed statements automatically when the database is closed.\n   * @default true\n   * @hidden\n   */\n  finalizeUnusedStatementsBeforeClosing?: boolean;\n}\n"]}