@react-native-firebase/app 20.0.0 → 20.2.0

package/lib/internal/web/memidb/FDBFactory.js

@@ -0,0 +1,256 @@
+import FDBDatabase from './FDBDatabase.js';
+import FDBOpenDBRequest from './FDBOpenDBRequest.js';
+import FDBVersionChangeEvent from './FDBVersionChangeEvent.js';
+import cmp from './lib/cmp.js';
+import Database from './lib/Database.js';
+import enforceRange from './lib/enforceRange.js';
+import { AbortError, VersionError } from './lib/errors.js';
+import FakeEvent from './lib/FakeEvent.js';
+import { queueTask } from './lib/scheduling.js';
+const waitForOthersClosedDelete = (databases, name, openDatabases, cb) => {
+  const anyOpen = openDatabases.some(openDatabase2 => {
+    return !openDatabase2._closed && !openDatabase2._closePending;
+  });
+  if (anyOpen) {
+    queueTask(() => waitForOthersClosedDelete(databases, name, openDatabases, cb));
+    return;
+  }
+  databases.delete(name);
+  cb(null);
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-deleting-a-database
+const deleteDatabase = (databases, name, request, cb) => {
+  try {
+    const db = databases.get(name);
+    if (db === undefined) {
+      cb(null);
+      return;
+    }
+    db.deletePending = true;
+    const openDatabases = db.connections.filter(connection => {
+      return !connection._closed && !connection._closePending;
+    });
+    for (const openDatabase2 of openDatabases) {
+      if (!openDatabase2._closePending) {
+        const event = new FDBVersionChangeEvent('versionchange', {
+          newVersion: null,
+          oldVersion: db.version,
+        });
+        openDatabase2.dispatchEvent(event);
+      }
+    }
+    const anyOpen = openDatabases.some(openDatabase3 => {
+      return !openDatabase3._closed && !openDatabase3._closePending;
+    });
+    if (request && anyOpen) {
+      const event = new FDBVersionChangeEvent('blocked', {
+        newVersion: null,
+        oldVersion: db.version,
+      });
+      request.dispatchEvent(event);
+    }
+    waitForOthersClosedDelete(databases, name, openDatabases, cb);
+  } catch (err) {
+    cb(err);
+  }
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-running-a-versionchange-transaction
+const runVersionchangeTransaction = (connection, version, request, cb) => {
+  connection._runningVersionchangeTransaction = true;
+  const oldVersion = connection.version;
+  const openDatabases = connection._rawDatabase.connections.filter(otherDatabase => {
+    return connection !== otherDatabase;
+  });
+  for (const openDatabase2 of openDatabases) {
+    if (!openDatabase2._closed && !openDatabase2._closePending) {
+      const event = new FDBVersionChangeEvent('versionchange', {
+        newVersion: version,
+        oldVersion,
+      });
+      openDatabase2.dispatchEvent(event);
+    }
+  }
+  const anyOpen = openDatabases.some(openDatabase3 => {
+    return !openDatabase3._closed && !openDatabase3._closePending;
+  });
+  if (anyOpen) {
+    const event = new FDBVersionChangeEvent('blocked', {
+      newVersion: version,
+      oldVersion,
+    });
+    request.dispatchEvent(event);
+  }
+  const waitForOthersClosed = () => {
+    const anyOpen2 = openDatabases.some(openDatabase2 => {
+      return !openDatabase2._closed && !openDatabase2._closePending;
+    });
+    if (anyOpen2) {
+      queueTask(waitForOthersClosed);
+      return;
+    }
+
+    // Set the version of database to version. This change is considered part of the transaction, and so if the
+    // transaction is aborted, this change is reverted.
+    connection._rawDatabase.version = version;
+    connection.version = version;
+
+    // Get rid of this setImmediate?
+    const transaction = connection.transaction(connection.objectStoreNames, 'versionchange');
+    request.result = connection;
+    request.readyState = 'done';
+    request.transaction = transaction;
+    transaction._rollbackLog.push(() => {
+      connection._rawDatabase.version = oldVersion;
+      connection.version = oldVersion;
+    });
+    const event = new FDBVersionChangeEvent('upgradeneeded', {
+      newVersion: version,
+      oldVersion,
+    });
+    request.dispatchEvent(event);
+    transaction.addEventListener('error', () => {
+      connection._runningVersionchangeTransaction = false;
+      // throw arguments[0].target.error;
+      // console.log("error in versionchange transaction - not sure if anything needs to be done here", e.target.error.name);
+    });
+    transaction.addEventListener('abort', () => {
+      connection._runningVersionchangeTransaction = false;
+      request.transaction = null;
+      queueTask(() => {
+        cb(new AbortError());
+      });
+    });
+    transaction.addEventListener('complete', () => {
+      connection._runningVersionchangeTransaction = false;
+      request.transaction = null;
+      // Let other complete event handlers run before continuing
+      queueTask(() => {
+        if (connection._closePending) {
+          cb(new AbortError());
+        } else {
+          cb(null);
+        }
+      });
+    });
+  };
+  waitForOthersClosed();
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-opening-a-database
+const openDatabase = (databases, name, version, request, cb) => {
+  let db = databases.get(name);
+  if (db === undefined) {
+    db = new Database(name, 0);
+    databases.set(name, db);
+  }
+  if (version === undefined) {
+    version = db.version !== 0 ? db.version : 1;
+  }
+  if (db.version > version) {
+    return cb(new VersionError());
+  }
+  const connection = new FDBDatabase(db);
+  if (db.version < version) {
+    runVersionchangeTransaction(connection, version, request, err => {
+      if (err) {
+        // DO THIS HERE: ensure that connection is closed by running the steps for closing a database connection before these
+        // steps are aborted.
+        return cb(err);
+      }
+      cb(null, connection);
+    });
+  } else {
+    cb(null, connection);
+  }
+};
+class FDBFactory {
+  cmp = cmp;
+  _databases = new Map();
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBFactory-deleteDatabase-IDBOpenDBRequest-DOMString-name
+  deleteDatabase(name) {
+    const request = new FDBOpenDBRequest();
+    request.source = null;
+    queueTask(() => {
+      const db = this._databases.get(name);
+      const oldVersion = db !== undefined ? db.version : 0;
+      deleteDatabase(this._databases, name, request, err => {
+        if (err) {
+          request.error = new DOMException(err.message, err.name);
+          request.readyState = 'done';
+          const event = new FakeEvent('error', {
+            bubbles: true,
+            cancelable: true,
+          });
+          event.eventPath = [];
+          request.dispatchEvent(event);
+          return;
+        }
+        request.result = undefined;
+        request.readyState = 'done';
+        const event2 = new FDBVersionChangeEvent('success', {
+          newVersion: null,
+          oldVersion,
+        });
+        request.dispatchEvent(event2);
+      });
+    });
+    return request;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBFactory-open-IDBOpenDBRequest-DOMString-name-unsigned-long-long-version
+  open(name, version) {
+    if (arguments.length > 1 && version !== undefined) {
+      // Based on spec, not sure why "MAX_SAFE_INTEGER" instead of "unsigned long long", but it's needed to pass
+      // tests
+      version = enforceRange(version, 'MAX_SAFE_INTEGER');
+    }
+    if (version === 0) {
+      throw new TypeError();
+    }
+    const request = new FDBOpenDBRequest();
+    request.source = null;
+    queueTask(() => {
+      openDatabase(this._databases, name, version, request, (err, connection) => {
+        if (err) {
+          request.result = undefined;
+          request.readyState = 'done';
+          request.error = new DOMException(err.message, err.name);
+          const event = new FakeEvent('error', {
+            bubbles: true,
+            cancelable: true,
+          });
+          event.eventPath = [];
+          request.dispatchEvent(event);
+          return;
+        }
+        request.result = connection;
+        request.readyState = 'done';
+        const event2 = new FakeEvent('success');
+        event2.eventPath = [];
+        request.dispatchEvent(event2);
+      });
+    });
+    return request;
+  }
+
+  // https://w3c.github.io/IndexedDB/#dom-idbfactory-databases
+  databases() {
+    return new Promise(resolve => {
+      const result = [];
+      for (const [name, database] of this._databases) {
+        result.push({
+          name,
+          version: database.version,
+        });
+      }
+      resolve(result);
+    });
+  }
+  toString() {
+    return '[object IDBFactory]';
+  }
+}
+export default FDBFactory;

package/lib/internal/web/memidb/FDBIndex.js

@@ -0,0 +1,187 @@
+import FDBCursor from './FDBCursor.js';
+import FDBCursorWithValue from './FDBCursorWithValue.js';
+import FDBKeyRange from './FDBKeyRange.js';
+import FDBRequest from './FDBRequest.js';
+import enforceRange from './lib/enforceRange.js';
+import { ConstraintError, InvalidStateError, TransactionInactiveError } from './lib/errors.js';
+import FakeDOMStringList from './lib/FakeDOMStringList.js';
+import valueToKey from './lib/valueToKey.js';
+import valueToKeyRange from './lib/valueToKeyRange.js';
+const confirmActiveTransaction = index => {
+  if (index._rawIndex.deleted || index.objectStore._rawObjectStore.deleted) {
+    throw new InvalidStateError();
+  }
+  if (index.objectStore.transaction._state !== 'active') {
+    throw new TransactionInactiveError();
+  }
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#idl-def-IDBIndex
+class FDBIndex {
+  constructor(objectStore, rawIndex) {
+    this._rawIndex = rawIndex;
+    this._name = rawIndex.name;
+    this.objectStore = objectStore;
+    this.keyPath = rawIndex.keyPath;
+    this.multiEntry = rawIndex.multiEntry;
+    this.unique = rawIndex.unique;
+  }
+  get name() {
+    return this._name;
+  }
+
+  // https://w3c.github.io/IndexedDB/#dom-idbindex-name
+  set name(name) {
+    const transaction = this.objectStore.transaction;
+    if (!transaction.db._runningVersionchangeTransaction) {
+      throw new InvalidStateError();
+    }
+    if (transaction._state !== 'active') {
+      throw new TransactionInactiveError();
+    }
+    if (this._rawIndex.deleted || this.objectStore._rawObjectStore.deleted) {
+      throw new InvalidStateError();
+    }
+    name = String(name);
+    if (name === this._name) {
+      return;
+    }
+    if (this.objectStore.indexNames.contains(name)) {
+      throw new ConstraintError();
+    }
+    const oldName = this._name;
+    const oldIndexNames = [...this.objectStore.indexNames];
+    this._name = name;
+    this._rawIndex.name = name;
+    this.objectStore._indexesCache.delete(oldName);
+    this.objectStore._indexesCache.set(name, this);
+    this.objectStore._rawObjectStore.rawIndexes.delete(oldName);
+    this.objectStore._rawObjectStore.rawIndexes.set(name, this._rawIndex);
+    this.objectStore.indexNames = new FakeDOMStringList(
+      ...Array.from(this.objectStore._rawObjectStore.rawIndexes.keys())
+        .filter(indexName => {
+          const index = this.objectStore._rawObjectStore.rawIndexes.get(indexName);
+          return index && !index.deleted;
+        })
+        .sort(),
+    );
+    transaction._rollbackLog.push(() => {
+      this._name = oldName;
+      this._rawIndex.name = oldName;
+      this.objectStore._indexesCache.delete(name);
+      this.objectStore._indexesCache.set(oldName, this);
+      this.objectStore._rawObjectStore.rawIndexes.delete(name);
+      this.objectStore._rawObjectStore.rawIndexes.set(oldName, this._rawIndex);
+      this.objectStore.indexNames = new FakeDOMStringList(...oldIndexNames);
+    });
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-openCursor-IDBRequest-any-range-IDBCursorDirection-direction
+  openCursor(range, direction) {
+    confirmActiveTransaction(this);
+    if (range === null) {
+      range = undefined;
+    }
+    if (range !== undefined && !(range instanceof FDBKeyRange)) {
+      range = FDBKeyRange.only(valueToKey(range));
+    }
+    const request = new FDBRequest();
+    request.source = this;
+    request.transaction = this.objectStore.transaction;
+    const cursor = new FDBCursorWithValue(this, range, direction, request);
+    return this.objectStore.transaction._execRequestAsync({
+      operation: cursor._iterate.bind(cursor),
+      request,
+      source: this,
+    });
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-openKeyCursor-IDBRequest-any-range-IDBCursorDirection-direction
+  openKeyCursor(range, direction) {
+    confirmActiveTransaction(this);
+    if (range === null) {
+      range = undefined;
+    }
+    if (range !== undefined && !(range instanceof FDBKeyRange)) {
+      range = FDBKeyRange.only(valueToKey(range));
+    }
+    const request = new FDBRequest();
+    request.source = this;
+    request.transaction = this.objectStore.transaction;
+    const cursor = new FDBCursor(this, range, direction, request, true);
+    return this.objectStore.transaction._execRequestAsync({
+      operation: cursor._iterate.bind(cursor),
+      request,
+      source: this,
+    });
+  }
+  get(key) {
+    confirmActiveTransaction(this);
+    if (!(key instanceof FDBKeyRange)) {
+      key = valueToKey(key);
+    }
+    return this.objectStore.transaction._execRequestAsync({
+      operation: this._rawIndex.getValue.bind(this._rawIndex, key),
+      source: this,
+    });
+  }
+
+  // http://w3c.github.io/IndexedDB/#dom-idbindex-getall
+  getAll(query, count) {
+    if (arguments.length > 1 && count !== undefined) {
+      count = enforceRange(count, 'unsigned long');
+    }
+    confirmActiveTransaction(this);
+    const range = valueToKeyRange(query);
+    return this.objectStore.transaction._execRequestAsync({
+      operation: this._rawIndex.getAllValues.bind(this._rawIndex, range, count),
+      source: this,
+    });
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-getKey-IDBRequest-any-key
+  getKey(key) {
+    confirmActiveTransaction(this);
+    if (!(key instanceof FDBKeyRange)) {
+      key = valueToKey(key);
+    }
+    return this.objectStore.transaction._execRequestAsync({
+      operation: this._rawIndex.getKey.bind(this._rawIndex, key),
+      source: this,
+    });
+  }
+
+  // http://w3c.github.io/IndexedDB/#dom-idbindex-getallkeys
+  getAllKeys(query, count) {
+    if (arguments.length > 1 && count !== undefined) {
+      count = enforceRange(count, 'unsigned long');
+    }
+    confirmActiveTransaction(this);
+    const range = valueToKeyRange(query);
+    return this.objectStore.transaction._execRequestAsync({
+      operation: this._rawIndex.getAllKeys.bind(this._rawIndex, range, count),
+      source: this,
+    });
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-count-IDBRequest-any-key
+  count(key) {
+    confirmActiveTransaction(this);
+    if (key === null) {
+      key = undefined;
+    }
+    if (key !== undefined && !(key instanceof FDBKeyRange)) {
+      key = FDBKeyRange.only(valueToKey(key));
+    }
+    return this.objectStore.transaction._execRequestAsync({
+      operation: () => {
+        return this._rawIndex.count(key);
+      },
+      source: this,
+    });
+  }
+  toString() {
+    return '[object IDBIndex]';
+  }
+}
+export default FDBIndex;

package/lib/internal/web/memidb/FDBKeyRange.js

@@ -0,0 +1,71 @@
+import cmp from './lib/cmp.js';
+import { DataError } from './lib/errors.js';
+import valueToKey from './lib/valueToKey.js';
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#range-concept
+class FDBKeyRange {
+  static only(value) {
+    if (arguments.length === 0) {
+      throw new TypeError();
+    }
+    value = valueToKey(value);
+    return new FDBKeyRange(value, value, false, false);
+  }
+  static lowerBound(lower, open = false) {
+    if (arguments.length === 0) {
+      throw new TypeError();
+    }
+    lower = valueToKey(lower);
+    return new FDBKeyRange(lower, undefined, open, true);
+  }
+  static upperBound(upper, open = false) {
+    if (arguments.length === 0) {
+      throw new TypeError();
+    }
+    upper = valueToKey(upper);
+    return new FDBKeyRange(undefined, upper, true, open);
+  }
+  static bound(lower, upper, lowerOpen = false, upperOpen = false) {
+    if (arguments.length < 2) {
+      throw new TypeError();
+    }
+    const cmpResult = cmp(lower, upper);
+    if (cmpResult === 1 || (cmpResult === 0 && (lowerOpen || upperOpen))) {
+      throw new DataError();
+    }
+    lower = valueToKey(lower);
+    upper = valueToKey(upper);
+    return new FDBKeyRange(lower, upper, lowerOpen, upperOpen);
+  }
+  constructor(lower, upper, lowerOpen, upperOpen) {
+    this.lower = lower;
+    this.upper = upper;
+    this.lowerOpen = lowerOpen;
+    this.upperOpen = upperOpen;
+  }
+
+  // https://w3c.github.io/IndexedDB/#dom-idbkeyrange-includes
+  includes(key) {
+    if (arguments.length === 0) {
+      throw new TypeError();
+    }
+    key = valueToKey(key);
+    if (this.lower !== undefined) {
+      const cmpResult = cmp(this.lower, key);
+      if (cmpResult === 1 || (cmpResult === 0 && this.lowerOpen)) {
+        return false;
+      }
+    }
+    if (this.upper !== undefined) {
+      const cmpResult = cmp(this.upper, key);
+      if (cmpResult === -1 || (cmpResult === 0 && this.upperOpen)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  toString() {
+    return '[object IDBKeyRange]';
+  }
+}
+export default FDBKeyRange;