@firebase/firestore 3.4.7-canary.7343a55c4 → 3.4.7-canary.7a4e65cef

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.7-canary.7343a55c4";
+const version$1 = "3.4.7-canary.7a4e65cef";
 
 /**
  * @license
@@ -86,7 +86,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 = "9.6.10-canary.7343a55c4";
+const version = "9.6.10-canary.7a4e65cef";
 
 /**
  * @license
@@ -1418,13 +1418,14 @@ const DbIndexEntryKeyPath = [
     'uid',
     'arrayValue',
     'directionalValue',
+    'orderedDocumentKey',
     'documentKey'
 ];
 const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
 const DbIndexEntryDocumentKeyIndexPath = [
     'indexId',
     'uid',
-    'documentKey'
+    'orderedDocumentKey'
 ];
 /** Name of the IndexedDb object store. */
 const DbDocumentOverlayStore = 'documentOverlays';
@@ -4221,6 +4222,17 @@ function fieldIndexGetArraySegment(fieldIndex) {
 function fieldIndexGetDirectionalSegments(fieldIndex) {
     return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
 }
+/**
+ * Returns the order of the document key component for the given index.
+ *
+ * PORTING NOTE: This is only used in the Web IndexedDb implementation.
+ */
+function fieldIndexGetKeyOrder(fieldIndex) {
+    const directionalSegments = fieldIndexGetDirectionalSegments(fieldIndex);
+    return directionalSegments.length === 0
+        ? 0 /* ASCENDING */
+        : directionalSegments[directionalSegments.length - 1].kind;
+}
 /** Returns a debug representation of the field index */
 function fieldIndexToString(fieldIndex) {
     return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
@@ -4521,58 +4533,15 @@ function targetGetLowerBound(target, fieldIndex) {
     // For each segment, retrieve a lower bound if there is a suitable filter or
     // startAt.
     for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        let segmentValue = undefined;
-        let segmentInclusive = true;
-        // Process all filters to find a value for the current field segment
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            let filterValue = undefined;
-            let filterInclusive = true;
-            switch (fieldFilter.op) {
-                case "<" /* LESS_THAN */:
-                case "<=" /* LESS_THAN_OR_EQUAL */:
-                    filterValue = valuesGetLowerBound(fieldFilter.value);
-                    break;
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                case ">=" /* GREATER_THAN_OR_EQUAL */:
-                    filterValue = fieldFilter.value;
-                    break;
-                case ">" /* GREATER_THAN */:
-                    filterValue = fieldFilter.value;
-                    filterInclusive = false;
-                    break;
-                case "!=" /* NOT_EQUAL */:
-                case "not-in" /* NOT_IN */:
-                    filterValue = MIN_VALUE;
-                    break;
-                // Remaining filters cannot be used as lower bounds.
-            }
-            if (valuesMax(segmentValue, filterValue) === filterValue) {
-                segmentValue = filterValue;
-                segmentInclusive = filterInclusive;
-            }
-        }
-        // If there is a startAt bound, compare the values against the existing
-        // boundary to see if we can narrow the scope.
-        if (target.startAt !== null) {
-            for (let i = 0; i < target.orderBy.length; ++i) {
-                const orderBy = target.orderBy[i];
-                if (orderBy.field.isEqual(segment.fieldPath)) {
-                    const cursorValue = target.startAt.position[i];
-                    if (valuesMax(segmentValue, cursorValue) === cursorValue) {
-                        segmentValue = cursorValue;
-                        segmentInclusive = target.startAt.inclusive;
-                    }
-                    break;
-                }
-            }
-        }
-        if (segmentValue === undefined) {
+        const segmentBound = segment.kind === 0 /* ASCENDING */
+            ? targetGetLowerBoundForField(target, segment.fieldPath, target.startAt)
+            : targetGetUpperBoundForField(target, segment.fieldPath, target.startAt);
+        if (!segmentBound.value) {
             // No lower bound exists
             return null;
         }
-        values.push(segmentValue);
-        inclusive && (inclusive = segmentInclusive);
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
     }
     return new Bound(values, inclusive);
 }
@@ -4587,62 +4556,125 @@ function targetGetUpperBound(target, fieldIndex) {
     // For each segment, retrieve an upper bound if there is a suitable filter or
     // endAt.
     for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        let segmentValue = undefined;
-        let segmentInclusive = true;
-        // Process all filters to find a value for the current field segment
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            let filterValue = undefined;
-            let filterInclusive = true;
-            switch (fieldFilter.op) {
-                case ">=" /* GREATER_THAN_OR_EQUAL */:
-                case ">" /* GREATER_THAN */:
-                    filterValue = valuesGetUpperBound(fieldFilter.value);
-                    filterInclusive = false;
-                    break;
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                case "<=" /* LESS_THAN_OR_EQUAL */:
-                    filterValue = fieldFilter.value;
-                    break;
-                case "<" /* LESS_THAN */:
-                    filterValue = fieldFilter.value;
-                    filterInclusive = false;
-                    break;
-                case "!=" /* NOT_EQUAL */:
-                case "not-in" /* NOT_IN */:
-                    filterValue = MAX_VALUE;
-                    break;
-                // Remaining filters cannot be used as upper bounds.
-            }
-            if (valuesMin(segmentValue, filterValue) === filterValue) {
-                segmentValue = filterValue;
-                segmentInclusive = filterInclusive;
-            }
-        }
-        // If there is a endAt bound, compare the values against the existing
-        // boundary to see if we can narrow the scope.
-        if (target.endAt !== null) {
-            for (let i = 0; i < target.orderBy.length; ++i) {
-                const orderBy = target.orderBy[i];
-                if (orderBy.field.isEqual(segment.fieldPath)) {
-                    const cursorValue = target.endAt.position[i];
-                    if (valuesMin(segmentValue, cursorValue) === cursorValue) {
-                        segmentValue = cursorValue;
-                        segmentInclusive = target.endAt.inclusive;
-                    }
-                    break;
-                }
-            }
-        }
-        if (segmentValue === undefined) {
+        const segmentBound = segment.kind === 0 /* ASCENDING */
+            ? targetGetUpperBoundForField(target, segment.fieldPath, target.endAt)
+            : targetGetLowerBoundForField(target, segment.fieldPath, target.endAt);
+        if (!segmentBound.value) {
             // No upper bound exists
             return null;
         }
-        values.push(segmentValue);
-        inclusive && (inclusive = segmentInclusive);
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
     }
     return new Bound(values, inclusive);
 }
+/**
+ * Returns the value to use as the lower bound for ascending index segment at
+ * the provided `fieldPath` (or the upper bound for an descending segment).
+ */
+function targetGetLowerBoundForField(target, fieldPath, bound) {
+    let value = undefined;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = undefined;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case "<" /* LESS_THAN */:
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                filterValue = valuesGetLowerBound(fieldFilter.value);
+                break;
+            case "==" /* EQUAL */:
+            case "in" /* IN */:
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case ">" /* GREATER_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* NOT_EQUAL */:
+            case "not-in" /* NOT_IN */:
+                filterValue = MIN_VALUE;
+                break;
+            // Remaining filters cannot be used as lower bounds.
+        }
+        if (valuesMax(value, filterValue) === filterValue) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (valuesMax(value, cursorValue) === cursorValue) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
+    }
+    return { value, inclusive };
+}
+/**
+ * Returns the value to use as the upper bound for ascending index segment at
+ * the provided `fieldPath` (or the lower bound for an descending segment).
+ */
+function targetGetUpperBoundForField(target, fieldPath, bound) {
+    let value = undefined;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = undefined;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+            case ">" /* GREATER_THAN */:
+                filterValue = valuesGetUpperBound(fieldFilter.value);
+                filterInclusive = false;
+                break;
+            case "==" /* EQUAL */:
+            case "in" /* IN */:
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case "<" /* LESS_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* NOT_EQUAL */:
+            case "not-in" /* NOT_IN */:
+                filterValue = MAX_VALUE;
+                break;
+            // Remaining filters cannot be used as upper bounds.
+        }
+        if (valuesMin(value, filterValue) === filterValue) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (valuesMin(value, cursorValue) === cursorValue) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
+    }
+    return { value, inclusive };
+}
 class Filter {
 }
 class FieldFilter extends Filter {
@@ -10046,8 +10078,9 @@ const EMPTY_VALUE = new Uint8Array(0);
  * data as it supports multi-tab access.
  */
 class IndexedDbIndexManager {
-    constructor(user) {
+    constructor(user, databaseId) {
         this.user = user;
+        this.databaseId = databaseId;
         /**
          * An in-memory copy of the index entries we've already written since the SDK
          * launched. Used to avoid re-writing the same entry repeatedly.
@@ -10143,7 +10176,8 @@ class IndexedDbIndexManager {
                 return PersistencePromise.resolve(null);
             }
             else {
-                let result = documentKeySet();
+                let existingKeys = documentKeySet();
+                const result = [];
                 return PersistencePromise.forEach(indexes, (index, subTarget) => {
                     logDebug(LOG_TAG$f, `Using index ${fieldIndexToString(index)} to execute ${canonifyTarget(target)}`);
                     const arrayValues = targetGetArrayValues(subTarget, index);
@@ -10159,7 +10193,11 @@ class IndexedDbIndexManager {
                             .loadFirst(indexRange, target.limit)
                             .next(entries => {
                             entries.forEach(entry => {
-                                result = result.add(new DocumentKey(decodeResourcePath(entry.documentKey)));
+                                const documentKey = DocumentKey.fromSegments(entry.documentKey);
+                                if (!existingKeys.has(documentKey)) {
+                                    existingKeys = existingKeys.add(documentKey);
+                                    result.push(documentKey);
+                                }
                             });
                         });
                     });
@@ -10258,6 +10296,15 @@ class IndexedDbIndexManager {
         FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* ASCENDING */));
         return encoder.encodedBytes();
     }
+    /**
+     * Returns an encoded form of the document key that sorts based on the key
+     * ordering of the field index.
+     */
+    encodeDirectionalKey(fieldIndex, documentKey) {
+        const encoder = new IndexByteEncoder();
+        FirestoreIndexValueWriter.INSTANCE.writeIndexValue(refValue(this.databaseId, documentKey), encoder.forKind(fieldIndexGetKeyOrder(fieldIndex)));
+        return encoder.encodedBytes();
+    }
     /**
      * Encodes the given field values according to the specification in `target`.
      * For IN queries, a list of possible values is returned.
@@ -10381,7 +10428,7 @@ class IndexedDbIndexManager {
                     return this.getExistingIndexEntries(transaction, key, fieldIndex).next(existingEntries => {
                         const newEntries = this.computeIndexEntries(doc, fieldIndex);
                         if (!existingEntries.isEqual(newEntries)) {
-                            return this.updateEntries(transaction, doc, existingEntries, newEntries);
+                            return this.updateEntries(transaction, doc, fieldIndex, existingEntries, newEntries);
                         }
                         return PersistencePromise.resolve();
                     });
@@ -10389,24 +10436,26 @@ class IndexedDbIndexManager {
             });
         });
     }
-    addIndexEntry(transaction, document, indexEntry) {
+    addIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
         return indexEntries.put({
             indexId: indexEntry.indexId,
             uid: this.uid,
             arrayValue: indexEntry.arrayValue,
             directionalValue: indexEntry.directionalValue,
-            documentKey: encodeResourcePath(document.key.path)
+            orderedDocumentKey: this.encodeDirectionalKey(fieldIndex, document.key),
+            documentKey: document.key.path.toArray()
         });
     }
-    deleteIndexEntry(transaction, document, indexEntry) {
+    deleteIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
         return indexEntries.delete([
             indexEntry.indexId,
             this.uid,
             indexEntry.arrayValue,
             indexEntry.directionalValue,
-            encodeResourcePath(document.key.path)
+            this.encodeDirectionalKey(fieldIndex, document.key),
+            document.key.path.toArray()
         ]);
     }
     getExistingIndexEntries(transaction, documentKey, fieldIndex) {
@@ -10418,7 +10467,7 @@ class IndexedDbIndexManager {
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
-                encodeResourcePath(documentKey.path)
+                this.encodeDirectionalKey(fieldIndex, documentKey)
             ])
         }, (_, entry) => {
             results = results.add(new IndexEntry(fieldIndex.indexId, documentKey, entry.arrayValue, entry.directionalValue));
@@ -10451,15 +10500,15 @@ class IndexedDbIndexManager {
      * that are no longer referenced in `newEntries` and adding all newly added
      * entries.
      */
-    updateEntries(transaction, document, existingEntries, newEntries) {
+    updateEntries(transaction, document, fieldIndex, existingEntries, newEntries) {
         logDebug(LOG_TAG$f, "Updating index entries for document '%s'", document.key);
         const promises = [];
         diffSortedSets(existingEntries, newEntries, indexEntryComparator, 
         /* onAdd= */ entry => {
-            promises.push(this.addIndexEntry(transaction, document, entry));
+            promises.push(this.addIndexEntry(transaction, document, fieldIndex, entry));
         }, 
         /* onRemove= */ entry => {
-            promises.push(this.deleteIndexEntry(transaction, document, entry));
+            promises.push(this.deleteIndexEntry(transaction, document, fieldIndex, entry));
         });
         return PersistencePromise.waitFor(promises);
     }
@@ -10516,13 +10565,15 @@ class IndexedDbIndexManager {
                 this.uid,
                 bounds[i].arrayValue,
                 bounds[i].directionalValue,
-                ''
+                EMPTY_VALUE,
+                []
             ], [
                 bounds[i + 1].indexId,
                 this.uid,
                 bounds[i + 1].arrayValue,
                 bounds[i + 1].directionalValue,
-                ''
+                EMPTY_VALUE,
+                []
             ]));
         }
         return ranges;
@@ -13182,7 +13233,7 @@ class IndexedDbPersistence {
         return this.remoteDocumentCache;
     }
     getIndexManager(user) {
-        return new IndexedDbIndexManager(user);
+        return new IndexedDbIndexManager(user, this.serializer.remoteSerializer.databaseId);
     }
     getDocumentOverlayCache(user) {
         return IndexedDbDocumentOverlayCache.forUser(this.serializer, user);