@firebase/firestore 4.7.14 → 4.7.15

package/dist/index.node.mjs

@@ -2,14 +2,14 @@ import { _getProvider, getApp, _removeServiceInstance, _registerComponent, regis
 import { Component } from '@firebase/component';
 import { Logger, LogLevel } from '@firebase/logger';
 import { inspect, TextEncoder, TextDecoder } from 'util';
-import { FirebaseError, isCloudWorkstation, deepEqual, pingServer, updateEmulatorBanner, createMockUserToken, getModularInstance, getDefaultEmulatorHostnameAndPort, getGlobal, isIndexedDBAvailable, getUA, isSafari } from '@firebase/util';
+import { FirebaseError, isCloudWorkstation, deepEqual, pingServer, updateEmulatorBanner, createMockUserToken, getModularInstance, getDefaultEmulatorHostnameAndPort, getGlobal, isIndexedDBAvailable, getUA, isSafari, isSafariOrWebkit } from '@firebase/util';
 import { randomBytes as randomBytes$1 } from 'crypto';
 import { Integer, Md5 } from '@firebase/webchannel-wrapper/bloom-blob';
 import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "4.7.14";
+const version$1 = "4.7.15";
 
 /**
  * @license
@@ -62,7 +62,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "11.7.3";
+const version = "11.8.0";
 
 /**
  * @license
@@ -3320,9 +3320,13 @@ const V15_STORES = [
 ];
 const V16_STORES = V15_STORES;
 const V17_STORES = [...V15_STORES, DbGlobalsStore];
+const V18_STORES = V17_STORES;
 /** Returns the object stores for the provided schema. */
 function getObjectStores(schemaVersion) {
-    if (schemaVersion === 17) {
+    if (schemaVersion === 18) {
+        return V18_STORES;
+    }
+    else if (schemaVersion === 17) {
         return V17_STORES;
     }
     else if (schemaVersion === 16) {
@@ -11183,46 +11187,69 @@ class IndexByteEncoder {
  */
 /** Represents an index entry saved by the SDK in persisted storage. */
 class IndexEntry {
-    constructor(indexId, documentKey, arrayValue, directionalValue) {
-        this.indexId = indexId;
-        this.documentKey = documentKey;
-        this.arrayValue = arrayValue;
-        this.directionalValue = directionalValue;
+    constructor(_indexId, _documentKey, _arrayValue, _directionalValue) {
+        this._indexId = _indexId;
+        this._documentKey = _documentKey;
+        this._arrayValue = _arrayValue;
+        this._directionalValue = _directionalValue;
     }
     /**
      * Returns an IndexEntry entry that sorts immediately after the current
      * directional value.
      */
     successor() {
-        const currentLength = this.directionalValue.length;
-        const newLength = currentLength === 0 || this.directionalValue[currentLength - 1] === 255
+        const currentLength = this._directionalValue.length;
+        const newLength = currentLength === 0 || this._directionalValue[currentLength - 1] === 255
             ? currentLength + 1
             : currentLength;
         const successor = new Uint8Array(newLength);
-        successor.set(this.directionalValue, 0);
+        successor.set(this._directionalValue, 0);
         if (newLength !== currentLength) {
-            successor.set([0], this.directionalValue.length);
+            successor.set([0], this._directionalValue.length);
         }
         else {
             ++successor[successor.length - 1];
         }
-        return new IndexEntry(this.indexId, this.documentKey, this.arrayValue, successor);
+        return new IndexEntry(this._indexId, this._documentKey, this._arrayValue, successor);
+    }
+    // Create a representation of the Index Entry as a DbIndexEntry
+    dbIndexEntry(uid, orderedDocumentKey, documentKey) {
+        return {
+            indexId: this._indexId,
+            uid,
+            arrayValue: encodeKeySafeBytes(this._arrayValue),
+            directionalValue: encodeKeySafeBytes(this._directionalValue),
+            orderedDocumentKey: encodeKeySafeBytes(orderedDocumentKey),
+            documentKey: documentKey.path.toArray()
+        };
+    }
+    // Create a representation of the Index Entry as a DbIndexEntryKey
+    dbIndexEntryKey(uid, orderedDocumentKey, documentKey) {
+        const entry = this.dbIndexEntry(uid, orderedDocumentKey, documentKey);
+        return [
+            entry.indexId,
+            entry.uid,
+            entry.arrayValue,
+            entry.directionalValue,
+            entry.orderedDocumentKey,
+            entry.documentKey
+        ];
     }
 }
 function indexEntryComparator(left, right) {
-    let cmp = left.indexId - right.indexId;
+    let cmp = left._indexId - right._indexId;
     if (cmp !== 0) {
         return cmp;
     }
-    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
+    cmp = compareByteArrays(left._arrayValue, right._arrayValue);
     if (cmp !== 0) {
         return cmp;
     }
-    cmp = compareByteArrays(left.directionalValue, right.directionalValue);
+    cmp = compareByteArrays(left._directionalValue, right._directionalValue);
     if (cmp !== 0) {
         return cmp;
     }
-    return DocumentKey.comparator(left.documentKey, right.documentKey);
+    return DocumentKey.comparator(left._documentKey, right._documentKey);
 }
 function compareByteArrays(left, right) {
     for (let i = 0; i < left.length && i < right.length; ++i) {
@@ -11233,6 +11260,53 @@ function compareByteArrays(left, right) {
     }
     return left.length - right.length;
 }
+/**
+ * Workaround for WebKit bug: https://bugs.webkit.org/show_bug.cgi?id=292721
+ * Create a key safe representation of Uint8Array values.
+ * If the browser is detected as Safari or WebKit, then
+ * the input array will be converted to "sortable byte string".
+ * Otherwise, the input array will be returned in its original type.
+ */
+function encodeKeySafeBytes(array) {
+    if (isSafariOrWebkit()) {
+        return encodeUint8ArrayToSortableString(array);
+    }
+    return array;
+}
+/**
+ * Reverts the key safe representation of Uint8Array (created by
+ * encodeKeySafeBytes) to a normal Uint8Array.
+ */
+function decodeKeySafeBytes(input) {
+    if (typeof input !== 'string') {
+        return input;
+    }
+    return decodeSortableStringToUint8Array(input);
+}
+/**
+ * Encodes a Uint8Array into a "sortable byte string".
+ * A "sortable byte string" sorts in the same order as the Uint8Array.
+ * This works because JS string comparison sorts strings based on code points.
+ */
+function encodeUint8ArrayToSortableString(array) {
+    let byteString = '';
+    for (let i = 0; i < array.length; i++) {
+        byteString += String.fromCharCode(array[i]);
+    }
+    return byteString;
+}
+/**
+ * Decodes a "sortable byte string" back into a Uint8Array.
+ * A "sortable byte string" is assumed to be created where each character's
+ * Unicode code point directly corresponds to a single byte value (0-255).
+ */
+function decodeSortableStringToUint8Array(byteString) {
+    const uint8array = new Uint8Array(byteString.length);
+    for (let i = 0; i < byteString.length; i++) {
+        uint8array[i] = byteString.charCodeAt(i);
+    }
+    return uint8array;
+}
 
 /**
  * @license
@@ -12255,25 +12329,11 @@ class IndexedDbIndexManager {
     }
     addIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
-        return indexEntries.put({
-            indexId: indexEntry.indexId,
-            uid: this.uid,
-            arrayValue: indexEntry.arrayValue,
-            directionalValue: indexEntry.directionalValue,
-            orderedDocumentKey: this.encodeDirectionalKey(fieldIndex, document.key),
-            documentKey: document.key.path.toArray()
-        });
+        return indexEntries.put(indexEntry.dbIndexEntry(this.uid, this.encodeDirectionalKey(fieldIndex, document.key), document.key));
     }
     deleteIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
-        return indexEntries.delete([
-            indexEntry.indexId,
-            this.uid,
-            indexEntry.arrayValue,
-            indexEntry.directionalValue,
-            this.encodeDirectionalKey(fieldIndex, document.key),
-            document.key.path.toArray()
-        ]);
+        return indexEntries.delete(indexEntry.dbIndexEntryKey(this.uid, this.encodeDirectionalKey(fieldIndex, document.key), document.key));
     }
     getExistingIndexEntries(transaction, documentKey, fieldIndex) {
         const indexEntries = indexEntriesStore(transaction);
@@ -12284,10 +12344,10 @@ class IndexedDbIndexManager {
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
-                this.encodeDirectionalKey(fieldIndex, documentKey)
+                encodeKeySafeBytes(this.encodeDirectionalKey(fieldIndex, documentKey))
             ])
         }, (_, entry) => {
-            results = results.add(new IndexEntry(fieldIndex.indexId, documentKey, entry.arrayValue, entry.directionalValue));
+            results = results.add(new IndexEntry(fieldIndex.indexId, documentKey, decodeKeySafeBytes(entry.arrayValue), decodeKeySafeBytes(entry.directionalValue)));
         })
             .next(() => results);
     }
@@ -12382,22 +12442,8 @@ class IndexedDbIndexManager {
             if (this.isRangeMatchable(bounds[i], bounds[i + 1])) {
                 return [];
             }
-            const lowerBound = [
-                bounds[i].indexId,
-                this.uid,
-                bounds[i].arrayValue,
-                bounds[i].directionalValue,
-                EMPTY_VALUE,
-                []
-            ];
-            const upperBound = [
-                bounds[i + 1].indexId,
-                this.uid,
-                bounds[i + 1].arrayValue,
-                bounds[i + 1].directionalValue,
-                EMPTY_VALUE,
-                []
-            ];
+            const lowerBound = bounds[i].dbIndexEntryKey(this.uid, EMPTY_VALUE, DocumentKey.empty());
+            const upperBound = bounds[i + 1].dbIndexEntryKey(this.uid, EMPTY_VALUE, DocumentKey.empty());
             ranges.push(IDBKeyRange.bound(lowerBound, upperBound));
         }
         return ranges;
@@ -14231,8 +14277,10 @@ function dbKeyComparator(l, r) {
  * 14. Add overlays.
  * 15. Add indexing support.
  * 16. Parse timestamp strings before creating index entries.
+ * 17. TODO(tomandersen)
+ * 18. Encode key safe representations of IndexEntry in DbIndexEntryStore.
  */
-const SCHEMA_VERSION = 17;
+const SCHEMA_VERSION = 18;
 
 /**
  * @license
@@ -15888,6 +15936,21 @@ class SchemaConverter {
                 createGlobalsStore(db);
             });
         }
+        if (fromVersion < 18 && toVersion >= 18) {
+            // Clear the IndexEntryStores on WebKit and Safari to remove possibly
+            // corrupted index entries
+            if (isSafariOrWebkit()) {
+                p = p
+                    .next(() => {
+                    const indexStateStore = txn.objectStore(DbIndexStateStore);
+                    indexStateStore.clear();
+                })
+                    .next(() => {
+                    const indexEntryStore = txn.objectStore(DbIndexEntryStore);
+                    indexEntryStore.clear();
+                });
+            }
+        }
         return p;
     }
     addDocumentGlobal(txn) {