Fix IndexDbIndexManager encoding of Uint8Array in Safari

Author: MarkDuckworth

common/api-review/util.api.md

@@ -317,6 +317,11 @@ export function isReactNative(): boolean;
 // @public
 export function isSafari(): boolean;
 
+// Warning: (ae-missing-release-tag) "isSafariOrWebkit" is exported by the package, but it is missing a release tag (@alpha, @beta, @public, or @internal)
+//
+// @public
+export function isSafariOrWebkit(): boolean;
+
 // Warning: (ae-missing-release-tag) "issuedAtTime" is exported by the package, but it is missing a release tag (@alpha, @beta, @public, or @internal)
 //
 // @public

packages/firestore/src/index/index_entry.ts

@@ -15,68 +15,107 @@
  * limitations under the License.
  */
 
+import { isSafariOrWebkit } from '@firebase/util';
+
+import { DbIndexEntry } from '../local/indexeddb_schema';
+import { DbIndexEntryKey } from '../local/indexeddb_sentinels';
 import { DocumentKey } from '../model/document_key';
 
 /** Represents an index entry saved by the SDK in persisted storage. */
 export class IndexEntry {
   constructor(
-    readonly indexId: number,
-    readonly documentKey: DocumentKey,
-    readonly arrayValue: Uint8Array,
-    readonly directionalValue: Uint8Array
+    readonly _indexId: number,
+    readonly _documentKey: DocumentKey,
+    readonly _arrayValue: Uint8Array | number[],
+    readonly _directionalValue: Uint8Array | number[]
   ) {}
 
   /**
    * Returns an IndexEntry entry that sorts immediately after the current
    * directional value.
    */
   successor(): IndexEntry {
-    const currentLength = this.directionalValue.length;
+    const currentLength = this._directionalValue.length;
     const newLength =
-      currentLength === 0 || this.directionalValue[currentLength - 1] === 255
+      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,
+      this._indexId,
+      this._documentKey,
+      this._arrayValue,
       successor
     );
   }
+
+  // Create a representation of the Index Entry as a DbIndexEntry
+  dbIndexEntry(
+    uid: string,
+    orderedDocumentKey: Uint8Array,
+    documentKey: DocumentKey
+  ): DbIndexEntry {
+    return {
+      indexId: this._indexId,
+      uid, // this.uid,
+      arrayValue: indexSafeUint8Array(this._arrayValue),
+      directionalValue: indexSafeUint8Array(this._directionalValue),
+      orderedDocumentKey: indexSafeUint8Array(orderedDocumentKey), // this.encodeDirectionalKey(fieldIndex, document.key),
+      documentKey: documentKey.path.toArray()
+    };
+  }
+
+  // Create a representation of the Index Entry as a DbIndexEntryKey
+  dbIndexEntryKey(
+    uid: string,
+    orderedDocumentKey: Uint8Array,
+    documentKey: DocumentKey
+  ): DbIndexEntryKey {
+    return [
+      this._indexId,
+      uid,
+      indexSafeUint8Array(this._arrayValue),
+      indexSafeUint8Array(this._directionalValue),
+      indexSafeUint8Array(orderedDocumentKey),
+      documentKey.path.toArray()
+    ];
+  }
 }
 
 export function indexEntryComparator(
   left: IndexEntry,
   right: IndexEntry
 ): number {
-  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);
 }
 
-export function compareByteArrays(left: Uint8Array, right: Uint8Array): number {
+export function compareByteArrays(
+  left: Uint8Array | number[],
+  right: Uint8Array | number[]
+): number {
   for (let i = 0; i < left.length && i < right.length; ++i) {
     const compare = left[i] - right[i];
     if (compare !== 0) {
@@ -85,3 +124,17 @@ export function compareByteArrays(left: Uint8Array, right: Uint8Array): number {
   }
   return left.length - right.length;
 }
+
+// Create an safe representation of Uint8Array values
+// If the browser is detected as Safari or WebKit, then
+// the input array will be converted to `number[]`.
+// Otherwise, the input array will be returned in its
+// original type.
+export function indexSafeUint8Array(
+  array: Uint8Array | number[]
+): Uint8Array | number[] {
+  if (isSafariOrWebkit() && !Array.isArray(array)) {
+    return Array.from(array);
+  }
+  return array;
+}