@react-native-firebase/app 20.1.0 → 20.2.1

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

@@ -0,0 +1,503 @@
+import FDBKeyRange from './FDBKeyRange.js';
+import FDBObjectStore from './FDBObjectStore.js';
+import cmp from './lib/cmp.js';
+import {
+  DataError,
+  InvalidAccessError,
+  InvalidStateError,
+  ReadOnlyError,
+  TransactionInactiveError,
+} from './lib/errors.js';
+import extractKey from './lib/extractKey.js';
+import valueToKey from './lib/valueToKey.js';
+const getEffectiveObjectStore = cursor => {
+  if (cursor.source instanceof FDBObjectStore) {
+    return cursor.source;
+  }
+  return cursor.source.objectStore;
+};
+
+// This takes a key range, a list of lower bounds, and a list of upper bounds and combines them all into a single key
+// range. It does not handle gt/gte distinctions, because it doesn't really matter much anyway, since for next/prev
+// cursor iteration it'd also have to look at values to be precise, which would be complicated. This should get us 99%
+// of the way there.
+const makeKeyRange = (range, lowers, uppers) => {
+  // Start with bounds from range
+  let lower = range !== undefined ? range.lower : undefined;
+  let upper = range !== undefined ? range.upper : undefined;
+
+  // Augment with values from lowers and uppers
+  for (const lowerTemp of lowers) {
+    if (lowerTemp === undefined) {
+      continue;
+    }
+    if (lower === undefined || cmp(lower, lowerTemp) === 1) {
+      lower = lowerTemp;
+    }
+  }
+  for (const upperTemp of uppers) {
+    if (upperTemp === undefined) {
+      continue;
+    }
+    if (upper === undefined || cmp(upper, upperTemp) === -1) {
+      upper = upperTemp;
+    }
+  }
+  if (lower !== undefined && upper !== undefined) {
+    return FDBKeyRange.bound(lower, upper);
+  }
+  if (lower !== undefined) {
+    return FDBKeyRange.lowerBound(lower);
+  }
+  if (upper !== undefined) {
+    return FDBKeyRange.upperBound(upper);
+  }
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#cursor
+class FDBCursor {
+  _gotValue = false;
+  _position = undefined; // Key of previously returned record
+  _objectStorePosition = undefined;
+  _keyOnly = false;
+  _key = undefined;
+  _primaryKey = undefined;
+  constructor(source, range, direction = 'next', request, keyOnly = false) {
+    this._range = range;
+    this._source = source;
+    this._direction = direction;
+    this._request = request;
+    this._keyOnly = keyOnly;
+  }
+
+  // Read only properties
+  get source() {
+    return this._source;
+  }
+  set source(val) {
+    /* For babel */
+  }
+  get request() {
+    return this._request;
+  }
+  set request(val) {
+    /* For babel */
+  }
+  get direction() {
+    return this._direction;
+  }
+  set direction(val) {
+    /* For babel */
+  }
+  get key() {
+    return this._key;
+  }
+  set key(val) {
+    /* For babel */
+  }
+  get primaryKey() {
+    return this._primaryKey;
+  }
+  set primaryKey(val) {
+    /* For babel */
+  }
+
+  // https://w3c.github.io/IndexedDB/#iterate-a-cursor
+  _iterate(key, primaryKey) {
+    const sourceIsObjectStore = this.source instanceof FDBObjectStore;
+
+    // Can't use sourceIsObjectStore because TypeScript
+    const records =
+      this.source instanceof FDBObjectStore
+        ? this.source._rawObjectStore.records
+        : this.source._rawIndex.records;
+    let foundRecord;
+    if (this.direction === 'next') {
+      const range = makeKeyRange(this._range, [key, this._position], []);
+      for (const record of records.values(range)) {
+        const cmpResultKey = key !== undefined ? cmp(record.key, key) : undefined;
+        const cmpResultPosition =
+          this._position !== undefined ? cmp(record.key, this._position) : undefined;
+        if (key !== undefined) {
+          if (cmpResultKey === -1) {
+            continue;
+          }
+        }
+        if (primaryKey !== undefined) {
+          if (cmpResultKey === -1) {
+            continue;
+          }
+          const cmpResultPrimaryKey = cmp(record.value, primaryKey);
+          if (cmpResultKey === 0 && cmpResultPrimaryKey === -1) {
+            continue;
+          }
+        }
+        if (this._position !== undefined && sourceIsObjectStore) {
+          if (cmpResultPosition !== 1) {
+            continue;
+          }
+        }
+        if (this._position !== undefined && !sourceIsObjectStore) {
+          if (cmpResultPosition === -1) {
+            continue;
+          }
+          if (cmpResultPosition === 0 && cmp(record.value, this._objectStorePosition) !== 1) {
+            continue;
+          }
+        }
+        if (this._range !== undefined) {
+          if (!this._range.includes(record.key)) {
+            continue;
+          }
+        }
+        foundRecord = record;
+        break;
+      }
+    } else if (this.direction === 'nextunique') {
+      // This could be done without iterating, if the range was defined slightly better (to handle gt/gte cases).
+      // But the performance difference should be small, and that wouldn't work anyway for directions where the
+      // value needs to be used (like next and prev).
+      const range = makeKeyRange(this._range, [key, this._position], []);
+      for (const record of records.values(range)) {
+        if (key !== undefined) {
+          if (cmp(record.key, key) === -1) {
+            continue;
+          }
+        }
+        if (this._position !== undefined) {
+          if (cmp(record.key, this._position) !== 1) {
+            continue;
+          }
+        }
+        if (this._range !== undefined) {
+          if (!this._range.includes(record.key)) {
+            continue;
+          }
+        }
+        foundRecord = record;
+        break;
+      }
+    } else if (this.direction === 'prev') {
+      const range = makeKeyRange(this._range, [], [key, this._position]);
+      for (const record of records.values(range, 'prev')) {
+        const cmpResultKey = key !== undefined ? cmp(record.key, key) : undefined;
+        const cmpResultPosition =
+          this._position !== undefined ? cmp(record.key, this._position) : undefined;
+        if (key !== undefined) {
+          if (cmpResultKey === 1) {
+            continue;
+          }
+        }
+        if (primaryKey !== undefined) {
+          if (cmpResultKey === 1) {
+            continue;
+          }
+          const cmpResultPrimaryKey = cmp(record.value, primaryKey);
+          if (cmpResultKey === 0 && cmpResultPrimaryKey === 1) {
+            continue;
+          }
+        }
+        if (this._position !== undefined && sourceIsObjectStore) {
+          if (cmpResultPosition !== -1) {
+            continue;
+          }
+        }
+        if (this._position !== undefined && !sourceIsObjectStore) {
+          if (cmpResultPosition === 1) {
+            continue;
+          }
+          if (cmpResultPosition === 0 && cmp(record.value, this._objectStorePosition) !== -1) {
+            continue;
+          }
+        }
+        if (this._range !== undefined) {
+          if (!this._range.includes(record.key)) {
+            continue;
+          }
+        }
+        foundRecord = record;
+        break;
+      }
+    } else if (this.direction === 'prevunique') {
+      let tempRecord;
+      const range = makeKeyRange(this._range, [], [key, this._position]);
+      for (const record of records.values(range, 'prev')) {
+        if (key !== undefined) {
+          if (cmp(record.key, key) === 1) {
+            continue;
+          }
+        }
+        if (this._position !== undefined) {
+          if (cmp(record.key, this._position) !== -1) {
+            continue;
+          }
+        }
+        if (this._range !== undefined) {
+          if (!this._range.includes(record.key)) {
+            continue;
+          }
+        }
+        tempRecord = record;
+        break;
+      }
+      if (tempRecord) {
+        foundRecord = records.get(tempRecord.key);
+      }
+    }
+    let result;
+    if (!foundRecord) {
+      this._key = undefined;
+      if (!sourceIsObjectStore) {
+        this._objectStorePosition = undefined;
+      }
+
+      // "this instanceof FDBCursorWithValue" would be better and not require (this as any), but causes runtime
+      // error due to circular dependency.
+      if (!this._keyOnly && this.toString() === '[object IDBCursorWithValue]') {
+        this.value = undefined;
+      }
+      result = null;
+    } else {
+      this._position = foundRecord.key;
+      if (!sourceIsObjectStore) {
+        this._objectStorePosition = foundRecord.value;
+      }
+      this._key = foundRecord.key;
+      if (sourceIsObjectStore) {
+        this._primaryKey = structuredClone(foundRecord.key);
+        if (!this._keyOnly && this.toString() === '[object IDBCursorWithValue]') {
+          this.value = structuredClone(foundRecord.value);
+        }
+      } else {
+        this._primaryKey = structuredClone(foundRecord.value);
+        if (!this._keyOnly && this.toString() === '[object IDBCursorWithValue]') {
+          if (this.source instanceof FDBObjectStore) {
+            // Can't use sourceIsObjectStore because TypeScript
+            throw new Error('This should never happen');
+          }
+          const value = this.source.objectStore._rawObjectStore.getValue(foundRecord.value);
+          this.value = structuredClone(value);
+        }
+      }
+      this._gotValue = true;
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      result = this;
+    }
+    return result;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-update-IDBRequest-any-value
+  update(value) {
+    if (value === undefined) {
+      throw new TypeError();
+    }
+    const effectiveObjectStore = getEffectiveObjectStore(this);
+    const effectiveKey = Object.hasOwn(this.source, '_rawIndex') ? this.primaryKey : this._position;
+    const transaction = effectiveObjectStore.transaction;
+    if (transaction._state !== 'active') {
+      throw new TransactionInactiveError();
+    }
+    if (transaction.mode === 'readonly') {
+      throw new ReadOnlyError();
+    }
+    if (effectiveObjectStore._rawObjectStore.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!(this.source instanceof FDBObjectStore) && this.source._rawIndex.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!this._gotValue || !Object.hasOwn(this, 'value')) {
+      throw new InvalidStateError();
+    }
+    const clone = structuredClone(value);
+    if (effectiveObjectStore.keyPath !== null) {
+      let tempKey;
+      try {
+        tempKey = extractKey(effectiveObjectStore.keyPath, clone);
+      } catch (err) {
+        /* Handled immediately below */
+      }
+      if (cmp(tempKey, effectiveKey) !== 0) {
+        throw new DataError();
+      }
+    }
+    const record = {
+      key: effectiveKey,
+      value: clone,
+    };
+    return transaction._execRequestAsync({
+      operation: effectiveObjectStore._rawObjectStore.storeRecord.bind(
+        effectiveObjectStore._rawObjectStore,
+        record,
+        false,
+        transaction._rollbackLog,
+      ),
+      source: this,
+    });
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-advance-void-unsigned-long-count
+  advance(count) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new TypeError();
+    }
+    const effectiveObjectStore = getEffectiveObjectStore(this);
+    const transaction = effectiveObjectStore.transaction;
+    if (transaction._state !== 'active') {
+      throw new TransactionInactiveError();
+    }
+    if (effectiveObjectStore._rawObjectStore.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!(this.source instanceof FDBObjectStore) && this.source._rawIndex.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!this._gotValue) {
+      throw new InvalidStateError();
+    }
+    if (this._request) {
+      this._request.readyState = 'pending';
+    }
+    transaction._execRequestAsync({
+      operation: () => {
+        let result;
+        for (let i = 0; i < count; i++) {
+          result = this._iterate();
+
+          // Not sure why this is needed
+          if (!result) {
+            break;
+          }
+        }
+        return result;
+      },
+      request: this._request,
+      source: this.source,
+    });
+    this._gotValue = false;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-continue-void-any-key
+  continue(key) {
+    const effectiveObjectStore = getEffectiveObjectStore(this);
+    const transaction = effectiveObjectStore.transaction;
+    if (transaction._state !== 'active') {
+      throw new TransactionInactiveError();
+    }
+    if (effectiveObjectStore._rawObjectStore.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!(this.source instanceof FDBObjectStore) && this.source._rawIndex.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!this._gotValue) {
+      throw new InvalidStateError();
+    }
+    if (key !== undefined) {
+      key = valueToKey(key);
+      const cmpResult = cmp(key, this._position);
+      if (
+        (cmpResult <= 0 && (this.direction === 'next' || this.direction === 'nextunique')) ||
+        (cmpResult >= 0 && (this.direction === 'prev' || this.direction === 'prevunique'))
+      ) {
+        throw new DataError();
+      }
+    }
+    if (this._request) {
+      this._request.readyState = 'pending';
+    }
+    transaction._execRequestAsync({
+      operation: this._iterate.bind(this, key),
+      request: this._request,
+      source: this.source,
+    });
+    this._gotValue = false;
+  }
+
+  // hthttps://w3c.github.io/IndexedDB/#dom-idbcursor-continueprimarykey
+  continuePrimaryKey(key, primaryKey) {
+    const effectiveObjectStore = getEffectiveObjectStore(this);
+    const transaction = effectiveObjectStore.transaction;
+    if (transaction._state !== 'active') {
+      throw new TransactionInactiveError();
+    }
+    if (effectiveObjectStore._rawObjectStore.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!(this.source instanceof FDBObjectStore) && this.source._rawIndex.deleted) {
+      throw new InvalidStateError();
+    }
+    if (
+      this.source instanceof FDBObjectStore ||
+      (this.direction !== 'next' && this.direction !== 'prev')
+    ) {
+      throw new InvalidAccessError();
+    }
+    if (!this._gotValue) {
+      throw new InvalidStateError();
+    }
+
+    // Not sure about this
+    if (key === undefined || primaryKey === undefined) {
+      throw new DataError();
+    }
+    key = valueToKey(key);
+    const cmpResult = cmp(key, this._position);
+    if (
+      (cmpResult === -1 && this.direction === 'next') ||
+      (cmpResult === 1 && this.direction === 'prev')
+    ) {
+      throw new DataError();
+    }
+    const cmpResult2 = cmp(primaryKey, this._objectStorePosition);
+    if (cmpResult === 0) {
+      if (
+        (cmpResult2 <= 0 && this.direction === 'next') ||
+        (cmpResult2 >= 0 && this.direction === 'prev')
+      ) {
+        throw new DataError();
+      }
+    }
+    if (this._request) {
+      this._request.readyState = 'pending';
+    }
+    transaction._execRequestAsync({
+      operation: this._iterate.bind(this, key, primaryKey),
+      request: this._request,
+      source: this.source,
+    });
+    this._gotValue = false;
+  }
+  delete() {
+    const effectiveObjectStore = getEffectiveObjectStore(this);
+    const effectiveKey = Object.hasOwn(this.source, '_rawIndex') ? this.primaryKey : this._position;
+    const transaction = effectiveObjectStore.transaction;
+    if (transaction._state !== 'active') {
+      throw new TransactionInactiveError();
+    }
+    if (transaction.mode === 'readonly') {
+      throw new ReadOnlyError();
+    }
+    if (effectiveObjectStore._rawObjectStore.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!(this.source instanceof FDBObjectStore) && this.source._rawIndex.deleted) {
+      throw new InvalidStateError();
+    }
+    if (!this._gotValue || !Object.hasOwn(this, 'value')) {
+      throw new InvalidStateError();
+    }
+    return transaction._execRequestAsync({
+      operation: effectiveObjectStore._rawObjectStore.deleteRecord.bind(
+        effectiveObjectStore._rawObjectStore,
+        effectiveKey,
+        transaction._rollbackLog,
+      ),
+      source: this,
+    });
+  }
+  toString() {
+    return '[object IDBCursor]';
+  }
+}
+export default FDBCursor;

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

@@ -0,0 +1,11 @@
+import FDBCursor from './FDBCursor.js';
+class FDBCursorWithValue extends FDBCursor {
+  value = undefined;
+  constructor(source, range, direction, request) {
+    super(source, range, direction, request);
+  }
+  toString() {
+    return '[object IDBCursorWithValue]';
+  }
+}
+export default FDBCursorWithValue;

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

@@ -0,0 +1,172 @@
+import FDBTransaction from './FDBTransaction.js';
+import {
+  ConstraintError,
+  InvalidAccessError,
+  InvalidStateError,
+  NotFoundError,
+  TransactionInactiveError,
+} from './lib/errors.js';
+import FakeDOMStringList from './lib/FakeDOMStringList.js';
+import FakeEventTarget from './lib/FakeEventTarget.js';
+import ObjectStore from './lib/ObjectStore.js';
+import { queueTask } from './lib/scheduling.js';
+import validateKeyPath from './lib/validateKeyPath.js';
+const confirmActiveVersionchangeTransaction = database => {
+  if (!database._runningVersionchangeTransaction) {
+    throw new InvalidStateError();
+  }
+
+  // Find the latest versionchange transaction
+  const transactions = database._rawDatabase.transactions.filter(tx => {
+    return tx.mode === 'versionchange';
+  });
+  const transaction = transactions[transactions.length - 1];
+  if (!transaction || transaction._state === 'finished') {
+    throw new InvalidStateError();
+  }
+  if (transaction._state !== 'active') {
+    throw new TransactionInactiveError();
+  }
+  return transaction;
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#database-closing-steps
+const closeConnection = connection => {
+  connection._closePending = true;
+  const transactionsComplete = connection._rawDatabase.transactions.every(transaction => {
+    return transaction._state === 'finished';
+  });
+  if (transactionsComplete) {
+    connection._closed = true;
+    connection._rawDatabase.connections = connection._rawDatabase.connections.filter(
+      otherConnection => {
+        return connection !== otherConnection;
+      },
+    );
+  } else {
+    queueTask(() => {
+      closeConnection(connection);
+    });
+  }
+};
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#database-interface
+class FDBDatabase extends FakeEventTarget {
+  _closePending = false;
+  _closed = false;
+  _runningVersionchangeTransaction = false;
+  constructor(rawDatabase) {
+    super();
+    this._rawDatabase = rawDatabase;
+    this._rawDatabase.connections.push(this);
+    this.name = rawDatabase.name;
+    this.version = rawDatabase.version;
+    this.objectStoreNames = new FakeDOMStringList(
+      ...Array.from(rawDatabase.rawObjectStores.keys()).sort(),
+    );
+  }
+
+  // http://w3c.github.io/IndexedDB/#dom-idbdatabase-createobjectstore
+  createObjectStore(name, options = {}) {
+    if (name === undefined) {
+      throw new TypeError();
+    }
+    const transaction = confirmActiveVersionchangeTransaction(this);
+    const keyPath = options !== null && options.keyPath !== undefined ? options.keyPath : null;
+    const autoIncrement =
+      options !== null && options.autoIncrement !== undefined ? options.autoIncrement : false;
+    if (keyPath !== null) {
+      validateKeyPath(keyPath);
+    }
+    if (this._rawDatabase.rawObjectStores.has(name)) {
+      throw new ConstraintError();
+    }
+    if (autoIncrement && (keyPath === '' || Array.isArray(keyPath))) {
+      throw new InvalidAccessError();
+    }
+    const objectStoreNames = [...this.objectStoreNames];
+    transaction._rollbackLog.push(() => {
+      const objectStore = this._rawDatabase.rawObjectStores.get(name);
+      if (objectStore) {
+        objectStore.deleted = true;
+      }
+      this.objectStoreNames = new FakeDOMStringList(...objectStoreNames);
+      transaction._scope.delete(name);
+      this._rawDatabase.rawObjectStores.delete(name);
+    });
+    const rawObjectStore = new ObjectStore(this._rawDatabase, name, keyPath, autoIncrement);
+    this.objectStoreNames._push(name);
+    this.objectStoreNames._sort();
+    transaction._scope.add(name);
+    this._rawDatabase.rawObjectStores.set(name, rawObjectStore);
+    transaction.objectStoreNames = new FakeDOMStringList(...this.objectStoreNames);
+    return transaction.objectStore(name);
+  }
+  deleteObjectStore(name) {
+    if (name === undefined) {
+      throw new TypeError();
+    }
+    const transaction = confirmActiveVersionchangeTransaction(this);
+    const store = this._rawDatabase.rawObjectStores.get(name);
+    if (store === undefined) {
+      throw new NotFoundError();
+    }
+    this.objectStoreNames = new FakeDOMStringList(
+      ...Array.from(this.objectStoreNames).filter(objectStoreName => {
+        return objectStoreName !== name;
+      }),
+    );
+    transaction.objectStoreNames = new FakeDOMStringList(...this.objectStoreNames);
+    transaction._rollbackLog.push(() => {
+      store.deleted = false;
+      this._rawDatabase.rawObjectStores.set(name, store);
+      this.objectStoreNames._push(name);
+      this.objectStoreNames._sort();
+    });
+    store.deleted = true;
+    this._rawDatabase.rawObjectStores.delete(name);
+    transaction._objectStoresCache.delete(name);
+  }
+  transaction(storeNames, mode) {
+    mode = mode !== undefined ? mode : 'readonly';
+    if (mode !== 'readonly' && mode !== 'readwrite' && mode !== 'versionchange') {
+      throw new TypeError('Invalid mode: ' + mode);
+    }
+    const hasActiveVersionchange = this._rawDatabase.transactions.some(transaction => {
+      return (
+        transaction._state === 'active' &&
+        transaction.mode === 'versionchange' &&
+        transaction.db === this
+      );
+    });
+    if (hasActiveVersionchange) {
+      throw new InvalidStateError();
+    }
+    if (this._closePending) {
+      throw new InvalidStateError();
+    }
+    if (!Array.isArray(storeNames)) {
+      storeNames = [storeNames];
+    }
+    if (storeNames.length === 0 && mode !== 'versionchange') {
+      throw new InvalidAccessError();
+    }
+    for (const storeName of storeNames) {
+      if (!this.objectStoreNames.contains(storeName)) {
+        throw new NotFoundError('No objectStore named ' + storeName + ' in this database');
+      }
+    }
+    const tx = new FDBTransaction(storeNames, mode, this);
+    this._rawDatabase.transactions.push(tx);
+    this._rawDatabase.processTransactions(); // See if can start right away (async)
+
+    return tx;
+  }
+  close() {
+    closeConnection(this);
+  }
+  toString() {
+    return '[object IDBDatabase]';
+  }
+}
+export default FDBDatabase;