Sound storage with SQLite

android/app/src/main/java/com/zulipmobile/generated/BasePackageList.java

@@ -12,6 +12,7 @@ public List<Package> getPackageList() {
         new expo.modules.filesystem.FileSystemPackage(),
         new expo.modules.imageloader.ImageLoaderPackage(),
         new expo.modules.screenorientation.ScreenOrientationPackage(),
+        new expo.modules.sqlite.SQLitePackage(),
         new expo.modules.webbrowser.WebBrowserPackage()
     );
   }

docs/THIRDPARTY

@@ -20,13 +20,6 @@ Files: *
 Copyright: 2016-2021 Kandra Labs, Inc., and contributors
 License: Apache-2
 
-Files: src/redux-persist-migrate/index.js
-Copyright: 2016-2017 Zack Story and contributors, 2018-2021 Kandra Labs, Inc.,
- and contributors
-License: Apache-2
-Comment:
- Upstream is licensed as MIT.
-
 Files: src/third/react-native/*
 Copyright: Facebook, Inc., and its affiliates
 License: MIT

flow-typed/expo-sqlite_vx.x.x.js

@@ -0,0 +1,197 @@
+// `flowgen --no-inexact --interface-records node_modules/expo-sqlite/build/SQLite.types.d.ts`
+// with s/export type/declare export type/g, and as noted with "Zulip fix" below
+declare module 'expo-sqlite/build/SQLite.types' {
+  /**
+   * Flowtype definitions for SQLite.types
+   * Generated by Flowgen from a Typescript Definition
+   * Flowgen v1.14.1
+   */
+
+   declare export type Window = {|
+    openDatabase?: (
+      name: string,
+      version: string,
+      displayName: string,
+      estimatedSize: number,
+      creationCallback?: DatabaseCallback
+    ) => Database,
+  |};
+  declare export 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.
+   */
+  declare export type Database = {|
+    version: string,
+
+    /**
+     * 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,
+  |};
+  declare export type SQLTransactionCallback = (transaction: SQLTransaction) => void;
+  declare export 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.
+   */
+  declare export type SQLTransaction = {|
+    /**
+     * 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?: $ReadOnlyArray<number | string>, // Zulip fix
+      callback?: SQLStatementCallback,
+      errorCallback?: SQLStatementErrorCallback
+    ): void,
+  |};
+  declare export type SQLStatementCallback = (
+    transaction: SQLTransaction,
+    resultSet: SQLResultSet
+  ) => void;
+  declare export type SQLStatementErrorCallback = (
+    transaction: SQLTransaction,
+    error: SQLError
+  ) => boolean;
+  declare export 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,
+  |};
+  declare export type 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[],
+  |};
+  declare export class SQLError {
+    static UNKNOWN_ERR: number;
+    static DATABASE_ERR: number;
+    static VERSION_ERR: number;
+    static TOO_LARGE_ERR: number;
+    static QUOTA_ERR: number;
+    static SYNTAX_ERR: number;
+    static CONSTRAINT_ERR: number;
+    static TIMEOUT_ERR: number;
+    code: number;
+    message: string;
+  }
+  declare export type WebSQLDatabase = {|
+    ...$Exact<Database>,
+
+    exec(queries: Query[], readOnly: boolean, callback: SQLiteCallback): void,
+  |};
+  declare export type Query = {|
+    sql: string,
+    args: mixed[],
+  |};
+  declare export type ResultSetError = {|
+    error: Error,
+  |};
+  /**
+   * `ResultSet` objects are returned through second parameter of the `success` callback for the
+   * `tx.executeSql()` method on a `SQLTransaction` (see above).
+   */
+  declare export 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,
+    |}[],
+  |};
+  declare export type SQLiteCallback = (
+    error?: Error | null,
+    resultSet?: (ResultSetError | ResultSet)[]
+  ) => void;
+}
+
+// `flowgen --no-inexact --interface-records node_modules/expo-sqlite/build/SQLite.d.ts`
+// with imports fixed up
+declare module 'expo-sqlite/build/SQLite' {
+  /**
+   * Flowtype definitions for SQLite
+   * Generated by Flowgen from a Typescript Definition
+   * Flowgen v1.14.1
+   */
+
+  import type { WebSQLDatabase } from "expo-sqlite/build/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
+   */
+  declare export function openDatabase(
+    name: string,
+    version?: string,
+    description?: string,
+    size?: number,
+    callback?: (db: WebSQLDatabase) => void
+  ): WebSQLDatabase;
+}
+
+declare module 'expo-sqlite' {
+  declare export * from 'expo-sqlite/build/SQLite';
+  declare export * from 'expo-sqlite/build/SQLite.types';
+}

jest.config.js

@@ -5,6 +5,7 @@
 const transformModulesWhitelist = [
   'expo-apple-authentication',
   'expo-application',
+  'expo-sqlite',
   'expo-web-browser',
   'react-native',
   '@react-native',

jest/jestSetup.js

@@ -67,6 +67,10 @@ jest.mock('react-native', () => {
   return ReactNative;
 });
 
+jest.mock('immediate', () => cb => Promise.resolve().then(cb));
+
+jest.mock('expo-sqlite', () => require('./mock-expo-sqlite'));
+
 /**
  * Boring mocks
  *

jest/mock-expo-sqlite.js

@@ -0,0 +1,112 @@
+// @flow strict-local
+//
+// TODO: this should probably go to expo-sqlite upstream.
+//
+// Not really so much a "mock" as a fourth platform-specific implementation:
+// this one for Node (and therefore for Jest), complementing upstream's for
+// Android, iOS, and web.
+//
+// OK, well, it's a mock in one respect: the databases are all in-memory.
+
+import type { Query, SQLiteCallback, WebSQLDatabase } from 'expo-sqlite';
+
+// We import this dependency of expo-sqlite directly, because we're
+// substituting for the expo-sqlite implementation that uses it.  (In a
+// future where expo-sqlite no longer used this dependency, we'd want to
+// make a similar change here, not keep using it.)
+/* eslint-disable import/no-extraneous-dependencies */
+// $FlowFixMe[untyped-import]
+import customOpenDatabase from '@expo/websql/custom';
+
+// $FlowFixMe[untyped-import]
+import sqlite3 from 'sqlite3';
+
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-void */
+
+const dbs = new Map();
+
+function openDb(name: string) {
+  const db = dbs.get(name);
+  if (db != null) {
+    return db;
+  }
+
+  const newDb = new sqlite3.Database(':memory:');
+  dbs.set(name, newDb);
+  return newDb;
+}
+
+class SQLiteDatabase {
+  _db: $FlowFixMe;
+  _closed: boolean = false;
+
+  constructor(name: string) {
+    this._db = openDb(name);
+  }
+
+  exec(queries: Query[], readOnly: boolean, callback: SQLiteCallback): void {
+    if (this._closed) {
+      throw new Error('already closed');
+    }
+
+    void this._exec(queries, callback);
+  }
+
+  async _exec(queries, callback) {
+    try {
+      const results = [];
+      for (const { sql, args } of queries) {
+        /* eslint-disable no-shadow */
+        const rows = await new Promise((resolve, reject) =>
+          this._db.all(sql, ...args, (err, rows) => (err ? reject(err) : resolve(rows))),
+        );
+
+        // TODO get rowsAffected and insertId.  This will mean calling
+        //   `this._db.run` instead of `this._db.all`:
+        //     https://github.com/mapbox/node-sqlite3/wiki/API#databaserunsql-param--callback
+        //   which on the other hand will mean it doesn't return rows.
+        //
+        //   The way the Android implementation makes the equivalent choice
+        //   is by checking if the statement looks like a SELECT.
+        //   The iOS implementation uses the SQLite C API, and ends up looking
+        //   more sensible.
+        //   Given what node-sqlite3 gives us, our best strategy is probably
+        //   the one in the Android implementation.
+        results.push({ rowsAffected: 0, rows });
+      }
+
+      callback(null, results);
+    } catch (e) {
+      callback(e);
+    }
+  }
+
+  close() {
+    this._closed = true;
+    this._db.close();
+  }
+}
+
+/** Not found in expo-sqlite itself, but helpful for tests. */
+export function deleteDatabase(name: string) {
+  const db = dbs.get(name);
+  if (!db) {
+    return;
+  }
+  db.close();
+  dbs.delete(name);
+}
+
+export function openDatabase(
+  name: string,
+  version?: string,
+  description?: string,
+  size?: number,
+  callback?: (db: WebSQLDatabase) => void,
+): WebSQLDatabase {
+  const db = customOpenDatabase(SQLiteDatabase)(name, version, description, size, callback);
+  db._db = new SQLiteDatabase(name);
+  db.exec = (...args) => db._db.exec(...args);
+  return db;
+}

package.json

@@ -38,6 +38,7 @@
     "expo-apple-authentication": "^3.2.1",
     "expo-application": "^3.2.0",
     "expo-screen-orientation": "^3.3.0",
+    "expo-sqlite": "9.1.0",
     "expo-web-browser": "^9.1.0",
     "immutable": "^4.0.0-rc.12",
     "invariant": "^2.2.4",
@@ -114,6 +115,7 @@
     "react-test-renderer": "17.0.1",
     "redux-mock-store": "^1.5.1",
     "rollup": "^2.26.5",
+    "sqlite3": "^5.0.2",
     "typescript": "~3.8.3",
     "yarn-deduplicate": "^3.0.0"
   }