expo-sqlite 9.1.0 → 10.0.1

package/CHANGELOG.md

@@ -8,6 +8,38 @@
 
 ### 🐛 Bug fixes
 
+### 💡 Others
+
+## 10.0.1 — 2021-10-01
+
+_This version does not introduce any user-facing changes._
+
+## 10.0.0 — 2021-09-28
+
+### 🛠 Breaking changes
+
+- Dropped support for iOS 11.0 ([#14383](https://github.com/expo/expo/pull/14383) by [@cruzach](https://github.com/cruzach))
+
+### 🐛 Bug fixes
+
+- Fix building errors from use_frameworks! in Podfile. ([#14523](https://github.com/expo/expo/pull/14523) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- Converted Android code to Kotlin ([#13724](https://github.com/expo/expo/pull/13724) by [@ixf](https://github.com/ixf))
+- Added missing `_array` typing to `SQLResultSetRowList`/`ResultSet` return object. ([#13826](https://github.com/expo/expo/pull/13826) by [@bbarthec](https://github.com/bbarthec))
+
+## 9.2.0 — 2021-06-16
+
+### 🐛 Bug fixes
+
+- Enable kotlin in all modules. ([#12716](https://github.com/expo/expo/pull/12716) by [@wschurman](https://github.com/wschurman))
+
+### 💡 Others
+
+- Migrated from `unimodules-file-system-interface` to `expo-modules-core`.
+- Build Android code using Java 8 to fix Android instrumented test build error. ([#12939](https://github.com/expo/expo/pull/12939) by [@kudo](https://github.com/kudo))
+
 ## 9.1.0 — 2021-03-10
 
 ### 🎉 New features

package/android/build.gradle

@@ -1,12 +1,23 @@
 apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
 apply plugin: 'maven'
 
 group = 'host.exp.exponent'
-version = '9.1.0'
+version = '10.0.1'
 
-// Simple helper that allows the root project to override versions declared by this library.
-def safeExtGet(prop, fallback) {
-  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+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
+  }
+
+  repositories {
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.4.21')}")
+  }
 }
 
 // Upload android library to maven with javadoc and android sources
@@ -37,25 +48,24 @@ uploadArchives {
 android {
   compileSdkVersion safeExtGet("compileSdkVersion", 30)
 
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 30)
     versionCode 18
-    versionName "9.1.0"
+    versionName "10.0.1"
   }
   lintOptions {
     abortOnError false
   }
 }
 
-if (new File(rootProject.projectDir.parentFile, 'package.json').exists()) {
-  apply from: project(":unimodules-core").file("../unimodules-core.gradle")
-} else {
-  throw new GradleException(
-      "'unimodules-core.gradle' was not found in the usual React Native dependency location. " +
-          "This package can only be used in such projects. Are you sure you've installed the dependencies properly?")
-}
-
 dependencies {
-  unimodule "unimodules-core"
+  implementation project(':expo-modules-core')
+
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.4.21')}"
 }

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

@@ -0,0 +1,96 @@
+package expo.modules.sqlite
+
+import java.io.File
+import java.io.IOException
+import java.util.ArrayList
+
+@Throws(IOException::class)
+internal fun ensureDirExists(dir: File): File {
+  if (!dir.isDirectory) {
+    if (dir.isFile) {
+      throw IOException("Path '$dir' points to a file, but must point to a directory.")
+    }
+    if (!dir.mkdirs()) {
+      var additionalErrorMessage = ""
+      if (dir.exists()) {
+        additionalErrorMessage = "Path already points to a non-normal file."
+      }
+      if (dir.parentFile == null) {
+        additionalErrorMessage = "Parent directory is null."
+      }
+      throw IOException("Couldn't create directory '$dir'. $additionalErrorMessage")
+    }
+  }
+  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 isPragmaReadOnly(str: String): Boolean {
+  return isPragma(str) && !str.contains('=')
+}
+
+internal fun isSelect(str: String): Boolean {
+  return startsWithCaseInsensitive(str, "select") || 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)
+}
+
+internal fun convertParamsToStringArray(paramArrayArg: ArrayList<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

@@ -0,0 +1,164 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+package expo.modules.sqlite
+
+import android.content.Context
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import expo.modules.core.ExportedModule
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+import java.io.File
+import java.io.IOException
+import java.util.*
+
+private val TAG = SQLiteModule::class.java.simpleName
+private val EMPTY_ROWS = arrayOf<Array<Any?>>()
+private val EMPTY_COLUMNS = arrayOf<String?>()
+private val EMPTY_RESULT = SQLiteModule.SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, 0, 0, null)
+private val DATABASES: MutableMap<String, SQLiteDatabase?> = HashMap()
+
+class SQLiteModule(private val mContext: Context) : ExportedModule(mContext) {
+  override fun getName(): String {
+    return "ExponentSQLite"
+  }
+
+  @ExpoMethod
+  fun exec(dbName: String, queries: ArrayList<ArrayList<Any>>, readOnly: Boolean, promise: Promise) {
+    try {
+      val db = getDatabase(dbName)
+      val results = queries.map { sqlQuery ->
+        val sql = sqlQuery[0] as String
+        val bindArgs = convertParamsToStringArray(sqlQuery[1] as ArrayList<Any?>)
+        try {
+          if (isSelect(sql)) {
+            doSelectInBackgroundAndPossiblyThrow(sql, bindArgs, db)
+          } else { // update/insert/delete
+            if (readOnly) {
+              SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, 0, 0, ReadOnlyException())
+            } else {
+              doUpdateInBackgroundAndPossiblyThrow(sql, bindArgs, db)
+            }
+          }
+        } catch (e: Throwable) {
+          SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, 0, 0, e)
+        }
+      }
+      val data = pluginResultsToPrimitiveData(results)
+      promise.resolve(data)
+    } catch (e: Exception) {
+      promise.reject("SQLiteError", e)
+    }
+  }
+
+  @ExpoMethod
+  fun close(dbName: String, promise: Promise) {
+    DATABASES
+      .remove(dbName)
+      ?.close()
+    promise.resolve(null)
+  }
+
+  // do a update/delete/insert operation
+  private fun doUpdateInBackgroundAndPossiblyThrow(
+    sql: String,
+    bindArgs: Array<String?>?,
+    db: SQLiteDatabase
+  ): SQLitePluginResult {
+    return db.compileStatement(sql).use { statement ->
+      if (bindArgs != null) {
+        for (i in bindArgs.size downTo 1) {
+          if (bindArgs[i - 1] == null) {
+            statement.bindNull(i)
+          } else {
+            statement.bindString(i, bindArgs[i - 1])
+          }
+        }
+      }
+      if (isInsert(sql)) {
+        val insertId = statement.executeInsert()
+        val rowsAffected = if (insertId >= 0) 1 else 0
+        SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, rowsAffected, insertId, null)
+      } else if (isDelete(sql) || isUpdate(sql)) {
+        val rowsAffected = statement.executeUpdateDelete()
+        SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, rowsAffected, 0, null)
+      } else {
+        // in this case, we don't need rowsAffected or insertId, so we can have a slight
+        // perf boost by just executing the query
+        statement.execute()
+        EMPTY_RESULT
+      }
+    }
+  }
+
+  // do a select operation
+  private fun doSelectInBackgroundAndPossiblyThrow(
+    sql: String,
+    bindArgs: Array<String?>,
+    db: SQLiteDatabase
+  ): SQLitePluginResult {
+    return db.rawQuery(sql, bindArgs).use { cursor ->
+      val numRows = cursor.count
+      if (numRows == 0) {
+        return EMPTY_RESULT
+      }
+      val numColumns = cursor.columnCount
+      val columnNames = cursor.columnNames
+      val rows: Array<Array<Any?>> = Array(numRows) { arrayOfNulls(numColumns) }
+      var i = 0
+      while (cursor.moveToNext()) {
+        val row = rows[i]
+        for (j in 0 until numColumns) {
+          row[j] = getValueFromCursor(cursor, j, cursor.getType(j))
+        }
+        rows[i] = row
+        i++
+      }
+      SQLitePluginResult(rows, columnNames, 0, 0, null)
+    }
+  }
+
+  private fun getValueFromCursor(cursor: Cursor, index: Int, columnType: Int): Any? {
+    return when (columnType) {
+      Cursor.FIELD_TYPE_FLOAT -> cursor.getDouble(index)
+      Cursor.FIELD_TYPE_INTEGER -> cursor.getLong(index)
+      Cursor.FIELD_TYPE_BLOB ->
+        // convert byte[] to binary string; it's good enough, because
+        // WebSQL doesn't support blobs anyway
+        String(cursor.getBlob(index))
+      Cursor.FIELD_TYPE_STRING -> cursor.getString(index)
+      else -> null
+    }
+  }
+
+  @Throws(IOException::class)
+  private fun pathForDatabaseName(name: String): String {
+    val directory = File("${mContext.filesDir}${File.separator}SQLite")
+    ensureDirExists(directory)
+    return "$directory${File.separator}$name"
+  }
+
+  @Throws(IOException::class)
+  private fun getDatabase(name: String): SQLiteDatabase {
+    var database: SQLiteDatabase? = null
+    val path = pathForDatabaseName(name)
+    if (File(path).exists()) {
+      database = DATABASES[name]
+    }
+    if (database == null) {
+      DATABASES.remove(name)
+      database = SQLiteDatabase.openOrCreateDatabase(path, null)
+      DATABASES[name] = database
+    }
+    return database!!
+  }
+
+  internal class SQLitePluginResult(
+    val rows: Array<Array<Any?>>,
+    val columns: Array<String?>,
+    val rowsAffected: Int,
+    val insertId: Long,
+    val error: Throwable?
+  )
+
+  private class ReadOnlyException : Exception("could not prepare statement (23 not authorized)")
+}

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

@@ -0,0 +1,11 @@
+package expo.modules.sqlite
+
+import android.content.Context
+import expo.modules.core.BasePackage
+import expo.modules.core.ExportedModule
+
+class SQLitePackage : BasePackage() {
+  override fun createExportedModules(context: Context): List<ExportedModule> {
+    return listOf(SQLiteModule(context))
+  }
+}

package/build/SQLite.d.ts

@@ -1,3 +1,16 @@
 import './polyfillNextTick';
 import { WebSQLDatabase } from './SQLite.types';
+/**
+ * Open a database, creating it if it doesn't exist, and return a `Database` object. On disk,
+ * the database will be created under the app's [documents directory](../filesystem), i.e.
+ * `${FileSystem.documentDirectory}/SQLite/${name}`.
+ * > The `version`, `description` and `size` arguments are ignored, but are accepted by the function
+ * for compatibility with the WebSQL specification.
+ * @param name Name of the database file to open.
+ * @param version
+ * @param description
+ * @param size
+ * @param callback
+ * @return
+ */
 export declare function openDatabase(name: string, version?: string, description?: string, size?: number, callback?: (db: WebSQLDatabase) => void): WebSQLDatabase;

package/build/SQLite.js

@@ -1,21 +1,22 @@
 import './polyfillNextTick';
 import customOpenDatabase from '@expo/websql/custom';
-import { NativeModulesProxy } from '@unimodules/core';
+import { NativeModulesProxy } from 'expo-modules-core';
 import zipObject from 'lodash/zipObject';
 import { Platform } from 'react-native';
 const { ExponentSQLite } = NativeModulesProxy;
 class SQLiteDatabase {
+    _name;
+    _closed = false;
     constructor(name) {
-        this._closed = false;
         this._name = name;
     }
     exec(queries, readOnly, callback) {
         if (this._closed) {
             throw new Error(`The SQLite database is closed`);
         }
-        ExponentSQLite.exec(this._name, queries.map(_serializeQuery), readOnly).then(nativeResultSets => {
+        ExponentSQLite.exec(this._name, queries.map(_serializeQuery), readOnly).then((nativeResultSets) => {
             callback(null, nativeResultSets.map(_deserializeResultSet));
-        }, error => {
+        }, (error) => {
             // TODO: make the native API consistently reject with an error, not a string or other type
             callback(error instanceof Error ? error : new Error(error));
         });
@@ -38,7 +39,7 @@ function _deserializeResultSet(nativeResult) {
     return {
         insertId,
         rowsAffected,
-        rows: rows.map(row => zipObject(columns, row)),
+        rows: rows.map((row) => zipObject(columns, row)),
     };
 }
 function _escapeBlob(data) {
@@ -61,6 +62,20 @@ function addExecMethod(db) {
     };
     return db;
 }
+// @needsAudit @docsMissing
+/**
+ * Open a database, creating it if it doesn't exist, and return a `Database` object. On disk,
+ * the database will be created under the app's [documents directory](../filesystem), i.e.
+ * `${FileSystem.documentDirectory}/SQLite/${name}`.
+ * > The `version`, `description` and `size` arguments are ignored, but are accepted by the function
+ * for compatibility with the WebSQL specification.
+ * @param name Name of the database file to open.
+ * @param version
+ * @param description
+ * @param size
+ * @param callback
+ * @return
+ */
 export function openDatabase(name, version = '1.0', description = name, size = 1, callback) {
     if (name === undefined) {
         throw new TypeError(`The database name must not be undefined`);

package/build/SQLite.js.map

@@ -1 +1 @@
-{"version":3,"file":"SQLite.js","sourceRoot":"","sources":["../src/SQLite.ts"],"names":[],"mappings":"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","sourcesContent":["import './polyfillNextTick';\n\nimport customOpenDatabase from '@expo/websql/custom';\nimport { NativeModulesProxy } from '@unimodules/core';\nimport zipObject from 'lodash/zipObject';\nimport { Platform } from 'react-native';\n\nimport { Query, SQLiteCallback, ResultSet, ResultSetError, WebSQLDatabase } from './SQLite.types';\n\nconst { ExponentSQLite } = NativeModulesProxy;\n\nclass SQLiteDatabase {\n  _name: string;\n  _closed: boolean = false;\n\n  constructor(name: string) {\n    this._name = name;\n  }\n\n  exec(queries: Query[], readOnly: boolean, callback: SQLiteCallback): void {\n    if (this._closed) {\n      throw new Error(`The SQLite database is closed`);\n    }\n\n    ExponentSQLite.exec(this._name, queries.map(_serializeQuery), readOnly).then(\n      nativeResultSets => {\n        callback(null, nativeResultSets.map(_deserializeResultSet));\n      },\n      error => {\n        // TODO: make the native API consistently reject with an error, not a string or other type\n        callback(error instanceof Error ? error : new Error(error));\n      }\n    );\n  }\n\n  close() {\n    this._closed = true;\n    ExponentSQLite.close(this._name);\n  }\n}\n\nfunction _serializeQuery(query: Query): [string, unknown[]] {\n  return [query.sql, Platform.OS === 'android' ? query.args.map(_escapeBlob) : query.args];\n}\n\nfunction _deserializeResultSet(nativeResult): ResultSet | ResultSetError {\n  const [errorMessage, insertId, rowsAffected, columns, rows] = nativeResult;\n  // TODO: send more structured error information from the native module so we can better construct\n  // a SQLException object\n  if (errorMessage !== null) {\n    return { error: new Error(errorMessage) } as ResultSetError;\n  }\n\n  return {\n    insertId,\n    rowsAffected,\n    rows: rows.map(row => zipObject(columns, row)),\n  };\n}\n\nfunction _escapeBlob<T>(data: T): T {\n  if (typeof data === 'string') {\n    /* eslint-disable no-control-regex */\n    return data\n      .replace(/\\u0002/g, '\\u0002\\u0002')\n      .replace(/\\u0001/g, '\\u0001\\u0002')\n      .replace(/\\u0000/g, '\\u0001\\u0001') as any;\n    /* eslint-enable no-control-regex */\n  } else {\n    return data;\n  }\n}\n\nconst _openExpoSQLiteDatabase = customOpenDatabase(SQLiteDatabase);\n\nfunction addExecMethod(db: any): WebSQLDatabase {\n  db.exec = (queries: Query[], readOnly: boolean, callback: SQLiteCallback): void => {\n    db._db.exec(queries, readOnly, callback);\n  };\n  return db;\n}\n\nexport function openDatabase(\n  name: string,\n  version: string = '1.0',\n  description: string = name,\n  size: number = 1,\n  callback?: (db: WebSQLDatabase) => void\n): WebSQLDatabase {\n  if (name === undefined) {\n    throw new TypeError(`The database name must not be undefined`);\n  }\n  const db = _openExpoSQLiteDatabase(name, version, description, size, callback);\n  const dbWithExec = addExecMethod(db);\n  return dbWithExec;\n}\n"]}
+{"version":3,"file":"SQLite.js","sourceRoot":"","sources":["../src/SQLite.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAE5B,OAAO,kBAAkB,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,SAAS,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAIxC,MAAM,EAAE,cAAc,EAAE,GAAG,kBAAkB,CAAC;AAE9C,MAAM,cAAc;IAClB,KAAK,CAAS;IACd,OAAO,GAAY,KAAK,CAAC;IAEzB,YAAY,IAAY;QACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,IAAI,CAAC,OAAgB,EAAE,QAAiB,EAAE,QAAwB;QAChE,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;SAClD;QAED,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,CAAC,IAAI,CAC1E,CAAC,gBAAgB,EAAE,EAAE;YACnB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC,CAAC;QAC9D,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;YACR,0FAA0F;YAC1F,QAAQ,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9D,CAAC,CACF,CAAC;IACJ,CAAC;IAED,KAAK;QACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;CACF;AAED,SAAS,eAAe,CAAC,KAAY;IACnC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC3F,CAAC;AAED,SAAS,qBAAqB,CAAC,YAAY;IACzC,MAAM,CAAC,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,YAAY,CAAC;IAC3E,iGAAiG;IACjG,wBAAwB;IACxB,IAAI,YAAY,KAAK,IAAI,EAAE;QACzB,OAAO,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,YAAY,CAAC,EAAoB,CAAC;KAC7D;IAED,OAAO;QACL,QAAQ;QACR,YAAY;QACZ,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;KACjD,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAI,IAAO;IAC7B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,qCAAqC;QACrC,OAAO,IAAI;aACR,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC;aAClC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC;aAClC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAQ,CAAC;QAC7C,oCAAoC;KACrC;SAAM;QACL,OAAO,IAAI,CAAC;KACb;AACH,CAAC;AAED,MAAM,uBAAuB,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC;AAEnE,SAAS,aAAa,CAAC,EAAO;IAC5B,EAAE,CAAC,IAAI,GAAG,CAAC,OAAgB,EAAE,QAAiB,EAAE,QAAwB,EAAQ,EAAE;QAChF,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC,CAAC;IACF,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,2BAA2B;AAC3B;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,UAAkB,KAAK,EACvB,cAAsB,IAAI,EAC1B,OAAe,CAAC,EAChB,QAAuC;IAEvC,IAAI,IAAI,KAAK,SAAS,EAAE;QACtB,MAAM,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAC;KAChE;IACD,MAAM,EAAE,GAAG,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC/E,MAAM,UAAU,GAAG,aAAa,CAAC,EAAE,CAAC,CAAC;IACrC,OAAO,UAAU,CAAC;AACpB,CAAC","sourcesContent":["import './polyfillNextTick';\n\nimport customOpenDatabase from '@expo/websql/custom';\nimport { NativeModulesProxy } from 'expo-modules-core';\nimport zipObject from 'lodash/zipObject';\nimport { Platform } from 'react-native';\n\nimport { Query, SQLiteCallback, ResultSet, ResultSetError, WebSQLDatabase } from './SQLite.types';\n\nconst { ExponentSQLite } = NativeModulesProxy;\n\nclass SQLiteDatabase {\n  _name: string;\n  _closed: boolean = false;\n\n  constructor(name: string) {\n    this._name = name;\n  }\n\n  exec(queries: Query[], readOnly: boolean, callback: SQLiteCallback): void {\n    if (this._closed) {\n      throw new Error(`The SQLite database is closed`);\n    }\n\n    ExponentSQLite.exec(this._name, queries.map(_serializeQuery), readOnly).then(\n      (nativeResultSets) => {\n        callback(null, nativeResultSets.map(_deserializeResultSet));\n      },\n      (error) => {\n        // TODO: make the native API consistently reject with an error, not a string or other type\n        callback(error instanceof Error ? error : new Error(error));\n      }\n    );\n  }\n\n  close() {\n    this._closed = true;\n    ExponentSQLite.close(this._name);\n  }\n}\n\nfunction _serializeQuery(query: Query): [string, unknown[]] {\n  return [query.sql, Platform.OS === 'android' ? query.args.map(_escapeBlob) : query.args];\n}\n\nfunction _deserializeResultSet(nativeResult): ResultSet | ResultSetError {\n  const [errorMessage, insertId, rowsAffected, columns, rows] = nativeResult;\n  // TODO: send more structured error information from the native module so we can better construct\n  // a SQLException object\n  if (errorMessage !== null) {\n    return { error: new Error(errorMessage) } as ResultSetError;\n  }\n\n  return {\n    insertId,\n    rowsAffected,\n    rows: rows.map((row) => zipObject(columns, row)),\n  };\n}\n\nfunction _escapeBlob<T>(data: T): T {\n  if (typeof data === 'string') {\n    /* eslint-disable no-control-regex */\n    return data\n      .replace(/\\u0002/g, '\\u0002\\u0002')\n      .replace(/\\u0001/g, '\\u0001\\u0002')\n      .replace(/\\u0000/g, '\\u0001\\u0001') as any;\n    /* eslint-enable no-control-regex */\n  } else {\n    return data;\n  }\n}\n\nconst _openExpoSQLiteDatabase = customOpenDatabase(SQLiteDatabase);\n\nfunction addExecMethod(db: any): WebSQLDatabase {\n  db.exec = (queries: Query[], readOnly: boolean, callback: SQLiteCallback): void => {\n    db._db.exec(queries, readOnly, callback);\n  };\n  return db;\n}\n\n// @needsAudit @docsMissing\n/**\n * Open a database, creating it if it doesn't exist, and return a `Database` object. On disk,\n * the database will be created under the app's [documents directory](../filesystem), i.e.\n * `${FileSystem.documentDirectory}/SQLite/${name}`.\n * > The `version`, `description` and `size` arguments are ignored, but are accepted by the function\n * for compatibility with the WebSQL specification.\n * @param name Name of the database file to open.\n * @param version\n * @param description\n * @param size\n * @param callback\n * @return\n */\nexport function openDatabase(\n  name: string,\n  version: string = '1.0',\n  description: string = name,\n  size: number = 1,\n  callback?: (db: WebSQLDatabase) => void\n): WebSQLDatabase {\n  if (name === undefined) {\n    throw new TypeError(`The database name must not be undefined`);\n  }\n  const db = _openExpoSQLiteDatabase(name, version, description, size, callback);\n  const dbWithExec = addExecMethod(db);\n  return dbWithExec;\n}\n"]}

package/build/SQLite.types.d.ts

@@ -1,40 +1,76 @@
 export interface Window {
     openDatabase?: (name: string, version: string, displayName: string, estimatedSize: number, creationCallback?: DatabaseCallback) => Database;
 }
-export interface DatabaseCallback {
-    (database: Database): void;
-}
+export declare type DatabaseCallback = (database: Database) => void;
+/**
+ * `Database` objects are returned by calls to `SQLite.openDatabase()`. Such an object represents a
+ * connection to a database on your device.
+ */
 export interface Database {
     version: string;
-    transaction(callback: SQLTransactionCallback, errorCallback?: SQLTransactionErrorCallback, successCallback?: SQLVoidCallback): void;
-    readTransaction(callback: SQLTransactionCallback, errorCallback?: SQLTransactionErrorCallback, successCallback?: SQLVoidCallback): void;
-}
-export interface SQLVoidCallback {
-    (): void;
-}
-export interface SQLTransactionCallback {
-    (transaction: SQLTransaction): void;
-}
-export interface SQLTransactionErrorCallback {
-    (error: SQLError): void;
+    /**
+     * Execute a database transaction.
+     * @param callback A function representing the transaction to perform. Takes a Transaction
+     * (see below) as its only parameter, on which it can add SQL statements to execute.
+     * @param errorCallback Called if an error occurred processing this transaction. Takes a single
+     * parameter describing the error.
+     * @param successCallback Called when the transaction has completed executing on the database.
+     */
+    transaction(callback: SQLTransactionCallback, errorCallback?: SQLTransactionErrorCallback, successCallback?: () => void): void;
+    readTransaction(callback: SQLTransactionCallback, errorCallback?: SQLTransactionErrorCallback, successCallback?: () => void): void;
 }
+export declare type SQLTransactionCallback = (transaction: SQLTransaction) => void;
+export declare type SQLTransactionErrorCallback = (error: SQLError) => void;
+/**
+ * A `SQLTransaction` object is passed in as a parameter to the `callback` parameter for the
+ * `db.transaction()` method on a `Database` (see above). It allows enqueuing SQL statements to
+ * perform in a database transaction.
+ */
 export interface SQLTransaction {
-    executeSql(sqlStatement: string, args?: any[], callback?: SQLStatementCallback, errorCallback?: SQLStatementErrorCallback): void;
+    /**
+     * Enqueue a SQL statement to execute in the transaction. Authors are strongly recommended to make
+     * use of the `?` placeholder feature of the method to avoid against SQL injection attacks, and to
+     * never construct SQL statements on the fly.
+     * @param sqlStatement A string containing a database query to execute expressed as SQL. The string
+     * may contain `?` placeholders, with values to be substituted listed in the `arguments` parameter.
+     * @param args An array of values (numbers or strings) to substitute for `?` placeholders in the
+     * SQL statement.
+     * @param callback Called when the query is successfully completed during the transaction. Takes
+     * two parameters: the transaction itself, and a `ResultSet` object (see below) with the results
+     * of the query.
+     * @param errorCallback Called if an error occurred executing this particular query in the
+     * transaction. Takes two parameters: the transaction itself, and the error object.
+     */
+    executeSql(sqlStatement: string, args?: (number | string)[], callback?: SQLStatementCallback, errorCallback?: SQLStatementErrorCallback): void;
 }
-export interface SQLStatementCallback {
-    (transaction: SQLTransaction, resultSet: SQLResultSet): void;
-}
-export interface SQLStatementErrorCallback {
-    (transaction: SQLTransaction, error: SQLError): boolean;
-}
-export interface SQLResultSet {
-    insertId: number;
+export declare type SQLStatementCallback = (transaction: SQLTransaction, resultSet: SQLResultSet) => void;
+export declare type SQLStatementErrorCallback = (transaction: SQLTransaction, error: SQLError) => boolean;
+export declare type SQLResultSet = {
+    /**
+     * The row ID of the row that the SQL statement inserted into the database, if a row was inserted.
+     */
+    insertId?: number;
+    /**
+     * The number of rows that were changed by the SQL statement.
+     */
     rowsAffected: number;
     rows: SQLResultSetRowList;
-}
+};
 export interface SQLResultSetRowList {
+    /**
+     * The number of rows returned by the query.
+     */
     length: number;
+    /**
+     * Returns the row with the given `index`. If there is no such row, returns `null`.
+     * @param index Index of row to get.
+     */
     item(index: number): any;
+    /**
+     * The actual array of rows returned by the query. Can be used directly instead of
+     * getting rows through rows.item().
+     */
+    _array: any[];
 }
 export declare class SQLError {
     static UNKNOWN_ERR: number;
@@ -55,14 +91,24 @@ export declare type Query = {
     sql: string;
     args: unknown[];
 };
-export interface ResultSetError {
+export declare type ResultSetError = {
     error: Error;
-}
-export interface ResultSet {
+};
+/**
+ * `ResultSet` objects are returned through second parameter of the `success` callback for the
+ * `tx.executeSql()` method on a `SQLTransaction` (see above).
+ */
+export declare type ResultSet = {
+    /**
+     * The row ID of the row that the SQL statement inserted into the database, if a row was inserted.
+     */
     insertId?: number;
+    /**
+     * The number of rows that were changed by the SQL statement.
+     */
     rowsAffected: number;
     rows: {
         [column: string]: any;
     }[];
-}
+};
 export declare type SQLiteCallback = (error?: Error | null, resultSet?: (ResultSetError | ResultSet)[]) => void;

package/build/SQLite.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"SQLite.types.js","sourceRoot":"","sources":["../src/SQLite.types.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,8CAA8C;AAC9C,gDAAgD;AAChD,2DAA2D;AAC3D,EAAE;AACF,0EAA0E","sourcesContent":["// Definitions copied from `@types/websql` as we want\n// to expose a custom version of the API that:\n// - uses primitive `string` instead of `String`\n// - excludes some methods that are not exposed by our API.\n//\n// Original definitions by: TeamworkGuy2 <https://github.com/TeamworkGuy2>\n\nexport interface Window {\n  openDatabase?: (\n    name: string,\n    version: string,\n    displayName: string,\n    estimatedSize: number,\n    creationCallback?: DatabaseCallback\n  ) => Database;\n}\n\nexport interface DatabaseCallback {\n  (database: Database): void;\n}\n\nexport interface Database {\n  version: string;\n\n  transaction(\n    callback: SQLTransactionCallback,\n    errorCallback?: SQLTransactionErrorCallback,\n    successCallback?: SQLVoidCallback\n  ): void;\n\n  readTransaction(\n    callback: SQLTransactionCallback,\n    errorCallback?: SQLTransactionErrorCallback,\n    successCallback?: SQLVoidCallback\n  ): void;\n}\n\nexport interface SQLVoidCallback {\n  (): void;\n}\n\nexport interface SQLTransactionCallback {\n  (transaction: SQLTransaction): void;\n}\n\nexport interface SQLTransactionErrorCallback {\n  (error: SQLError): void;\n}\n\nexport interface SQLTransaction {\n  executeSql(\n    sqlStatement: string,\n    args?: any[],\n    callback?: SQLStatementCallback,\n    errorCallback?: SQLStatementErrorCallback\n  ): void;\n}\n\nexport interface SQLStatementCallback {\n  (transaction: SQLTransaction, resultSet: SQLResultSet): void;\n}\n\nexport interface SQLStatementErrorCallback {\n  (transaction: SQLTransaction, error: SQLError): boolean;\n}\n\nexport interface SQLResultSet {\n  insertId: number;\n  rowsAffected: number;\n  rows: SQLResultSetRowList;\n}\n\nexport interface SQLResultSetRowList {\n  length: number;\n  item(index: number): any;\n}\n\nexport declare class SQLError {\n  static UNKNOWN_ERR: number;\n  static DATABASE_ERR: number;\n  static VERSION_ERR: number;\n  static TOO_LARGE_ERR: number;\n  static QUOTA_ERR: number;\n  static SYNTAX_ERR: number;\n  static CONSTRAINT_ERR: number;\n  static TIMEOUT_ERR: number;\n\n  code: number;\n  message: string;\n}\n\nexport interface WebSQLDatabase extends Database {\n  exec(queries: Query[], readOnly: boolean, callback: SQLiteCallback): void;\n}\n\nexport type Query = { sql: string; args: unknown[] };\n\nexport interface ResultSetError {\n  error: Error;\n}\nexport interface ResultSet {\n  insertId?: number;\n  rowsAffected: number;\n  rows: { [column: string]: any }[];\n}\n\nexport type SQLiteCallback = (\n  error?: Error | null,\n  resultSet?: (ResultSetError | ResultSet)[]\n) => void;\n"]}
+{"version":3,"file":"SQLite.types.js","sourceRoot":"","sources":["../src/SQLite.types.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,8CAA8C;AAC9C,gDAAgD;AAChD,2DAA2D;AAC3D,EAAE;AACF,0EAA0E","sourcesContent":["// Definitions copied from `@types/websql` as we want\n// to expose a custom version of the API that:\n// - uses primitive `string` instead of `String`\n// - excludes some methods that are not exposed by our API.\n//\n// Original definitions by: TeamworkGuy2 <https://github.com/TeamworkGuy2>\n\n// @docsMissing\nexport interface Window {\n  openDatabase?: (\n    name: string,\n    version: string,\n    displayName: string,\n    estimatedSize: number,\n    creationCallback?: DatabaseCallback\n  ) => Database;\n}\n\n// @docsMissing\nexport type DatabaseCallback = (database: Database) => void;\n\n// @needsAudit @docsMissing\n/**\n * `Database` objects are returned by calls to `SQLite.openDatabase()`. Such an object represents a\n * connection to a database on your device.\n */\nexport interface Database {\n  version: string;\n\n  /**\n   * Execute a database transaction.\n   * @param callback A function representing the transaction to perform. Takes a Transaction\n   * (see below) as its only parameter, on which it can add SQL statements to execute.\n   * @param errorCallback Called if an error occurred processing this transaction. Takes a single\n   * parameter describing the error.\n   * @param successCallback Called when the transaction has completed executing on the database.\n   */\n  transaction(\n    callback: SQLTransactionCallback,\n    errorCallback?: SQLTransactionErrorCallback,\n    successCallback?: () => void\n  ): void;\n\n  readTransaction(\n    callback: SQLTransactionCallback,\n    errorCallback?: SQLTransactionErrorCallback,\n    successCallback?: () => void\n  ): void;\n}\n\n// @docsMissing\nexport type SQLTransactionCallback = (transaction: SQLTransaction) => void;\n\n// @docsMissing\nexport type SQLTransactionErrorCallback = (error: SQLError) => void;\n\n// @needsAudit\n/**\n * A `SQLTransaction` object is passed in as a parameter to the `callback` parameter for the\n * `db.transaction()` method on a `Database` (see above). It allows enqueuing SQL statements to\n * perform in a database transaction.\n */\nexport interface SQLTransaction {\n  /**\n   * Enqueue a SQL statement to execute in the transaction. Authors are strongly recommended to make\n   * use of the `?` placeholder feature of the method to avoid against SQL injection attacks, and to\n   * never construct SQL statements on the fly.\n   * @param sqlStatement A string containing a database query to execute expressed as SQL. The string\n   * may contain `?` placeholders, with values to be substituted listed in the `arguments` parameter.\n   * @param args An array of values (numbers or strings) to substitute for `?` placeholders in the\n   * SQL statement.\n   * @param callback Called when the query is successfully completed during the transaction. Takes\n   * two parameters: the transaction itself, and a `ResultSet` object (see below) with the results\n   * of the query.\n   * @param errorCallback Called if an error occurred executing this particular query in the\n   * transaction. Takes two parameters: the transaction itself, and the error object.\n   */\n  executeSql(\n    sqlStatement: string,\n    args?: (number | string)[],\n    callback?: SQLStatementCallback,\n    errorCallback?: SQLStatementErrorCallback\n  ): void;\n}\n\n// @docsMissing\nexport type SQLStatementCallback = (transaction: SQLTransaction, resultSet: SQLResultSet) => void;\n\n// @docsMissing\nexport type SQLStatementErrorCallback = (transaction: SQLTransaction, error: SQLError) => boolean;\n\n// @needsAudit\nexport type SQLResultSet = {\n  /**\n   * The row ID of the row that the SQL statement inserted into the database, if a row was inserted.\n   */\n  insertId?: number;\n  /**\n   * The number of rows that were changed by the SQL statement.\n   */\n  rowsAffected: number;\n  rows: SQLResultSetRowList;\n};\n\n// @needsAudit\nexport interface SQLResultSetRowList {\n  /**\n   * The number of rows returned by the query.\n   */\n  length: number;\n  /**\n   * Returns the row with the given `index`. If there is no such row, returns `null`.\n   * @param index Index of row to get.\n   */\n  item(index: number): any;\n  /**\n   * The actual array of rows returned by the query. Can be used directly instead of\n   * getting rows through rows.item().\n   */\n  _array: any[];\n}\n\n// @docsMissing\nexport declare class SQLError {\n  static UNKNOWN_ERR: number;\n  static DATABASE_ERR: number;\n  static VERSION_ERR: number;\n  static TOO_LARGE_ERR: number;\n  static QUOTA_ERR: number;\n  static SYNTAX_ERR: number;\n  static CONSTRAINT_ERR: number;\n  static TIMEOUT_ERR: number;\n\n  code: number;\n  message: string;\n}\n\n// @docsMissing\nexport interface WebSQLDatabase extends Database {\n  exec(queries: Query[], readOnly: boolean, callback: SQLiteCallback): void;\n}\n\n// @docsMissing\nexport type Query = { sql: string; args: unknown[] };\n\n// @docsMissing\nexport type ResultSetError = {\n  error: Error;\n};\n\n// @needsAudit\n/**\n * `ResultSet` objects are returned through second parameter of the `success` callback for the\n * `tx.executeSql()` method on a `SQLTransaction` (see above).\n */\nexport type ResultSet = {\n  /**\n   * The row ID of the row that the SQL statement inserted into the database, if a row was inserted.\n   */\n  insertId?: number;\n  /**\n   * The number of rows that were changed by the SQL statement.\n   */\n  rowsAffected: number;\n  rows: { [column: string]: any }[];\n};\n\n// @docsMissing\nexport type SQLiteCallback = (\n  error?: Error | null,\n  resultSet?: (ResultSetError | ResultSet)[]\n) => void;\n"]}

package/build/SQLite.web.js

@@ -1,4 +1,4 @@
-import { UnavailabilityError } from '@unimodules/core';
+import { UnavailabilityError } from 'expo-modules-core';
 export function openDatabase(name, version = '1.0', description = name, size = 1, callback) {
     const typedWindow = window;
     if ('openDatabase' in typedWindow && typedWindow.openDatabase) {

package/build/SQLite.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"SQLite.web.js","sourceRoot":"","sources":["../src/SQLite.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAIvD,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,UAAkB,KAAK,EACvB,cAAsB,IAAI,EAC1B,OAAe,CAAC,EAChB,QAA2B;IAE3B,MAAM,WAAW,GAAW,MAAgB,CAAC;IAC7C,IAAI,cAAc,IAAI,WAAW,IAAI,WAAW,CAAC,YAAY,EAAE;QAC7D,OAAO,WAAW,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;KAC7E;IACD,MAAM,IAAI,mBAAmB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAC1D,CAAC","sourcesContent":["import { UnavailabilityError } from '@unimodules/core';\n\nimport { Window, DatabaseCallback } from './SQLite.types';\n\nexport function openDatabase(\n  name: string,\n  version: string = '1.0',\n  description: string = name,\n  size: number = 1,\n  callback?: DatabaseCallback\n) {\n  const typedWindow: Window = window as Window;\n  if ('openDatabase' in typedWindow && typedWindow.openDatabase) {\n    return typedWindow.openDatabase(name, version, description, size, callback);\n  }\n  throw new UnavailabilityError('window', 'openDatabase');\n}\n"]}
+{"version":3,"file":"SQLite.web.js","sourceRoot":"","sources":["../src/SQLite.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAIxD,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,UAAkB,KAAK,EACvB,cAAsB,IAAI,EAC1B,OAAe,CAAC,EAChB,QAA2B;IAE3B,MAAM,WAAW,GAAW,MAAgB,CAAC;IAC7C,IAAI,cAAc,IAAI,WAAW,IAAI,WAAW,CAAC,YAAY,EAAE;QAC7D,OAAO,WAAW,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;KAC7E;IACD,MAAM,IAAI,mBAAmB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAC1D,CAAC","sourcesContent":["import { UnavailabilityError } from 'expo-modules-core';\n\nimport { Window, DatabaseCallback } from './SQLite.types';\n\nexport function openDatabase(\n  name: string,\n  version: string = '1.0',\n  description: string = name,\n  size: number = 1,\n  callback?: DatabaseCallback\n) {\n  const typedWindow: Window = window as Window;\n  if ('openDatabase' in typedWindow && typedWindow.openDatabase) {\n    return typedWindow.openDatabase(name, version, description, size, callback);\n  }\n  throw new UnavailabilityError('window', 'openDatabase');\n}\n"]}

package/ios/EXSQLite/EXSQLite.h

@@ -1,8 +1,8 @@
 // Copyright 2015-present 650 Industries. All rights reserved.
 
-#import <UMCore/UMExportedModule.h>
-#import <UMCore/UMModuleRegistryConsumer.h>
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
 
-@interface EXSQLite : UMExportedModule <UMModuleRegistryConsumer>
+@interface EXSQLite : EXExportedModule <EXModuleRegistryConsumer>
 
 @end