@firebase/firestore 3.4.8-canary.aa41fd662 → 3.4.8-canary.adb9aaa34

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.8-canary.aa41fd662";
+const version$1 = "3.4.8-canary.adb9aaa34";
 
 /**
  * @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.11-canary.aa41fd662";
+const version = "9.7.0-canary.adb9aaa34";
 
 /**
  * @license
@@ -3346,7 +3346,7 @@ function typeOrder(value) {
             return 4 /* ServerTimestampValue */;
         }
         else if (isMaxValue(value)) {
-            return 9 /* ArrayValue */;
+            return 9007199254740991 /* MaxValue */;
         }
         return 10 /* ObjectValue */;
     }
@@ -3558,6 +3558,15 @@ function compareArrays(left, right) {
     return primitiveComparator(leftArray.length, rightArray.length);
 }
 function compareMaps(left, right) {
+    if (left === MAX_VALUE.mapValue && right === MAX_VALUE.mapValue) {
+        return 0;
+    }
+    else if (left === MAX_VALUE.mapValue) {
+        return 1;
+    }
+    else if (right === MAX_VALUE.mapValue) {
+        return -1;
+    }
     const leftMap = left.fields || {};
     const leftKeys = Object.keys(leftMap);
     const rightMap = right.fields || {};
@@ -3805,27 +3814,31 @@ function valuesGetUpperBound(value) {
         return fail();
     }
 }
-function valuesMax(left, right) {
-    if (left === undefined) {
-        return right;
+function lowerBoundCompare(left, right) {
+    const cmp = valueCompare(left.value, right.value);
+    if (cmp !== 0) {
+        return cmp;
     }
-    else if (right === undefined) {
-        return left;
+    if (left.inclusive && !right.inclusive) {
+        return -1;
     }
-    else {
-        return valueCompare(left, right) > 0 ? left : right;
+    else if (!left.inclusive && right.inclusive) {
+        return 1;
     }
+    return 0;
 }
-function valuesMin(left, right) {
-    if (left === undefined) {
-        return right;
+function upperBoundCompare(left, right) {
+    const cmp = valueCompare(left.value, right.value);
+    if (cmp !== 0) {
+        return cmp;
     }
-    else if (right === undefined) {
-        return left;
+    if (left.inclusive && !right.inclusive) {
+        return 1;
     }
-    else {
-        return valueCompare(left, right) < 0 ? left : right;
+    else if (!left.inclusive && right.inclusive) {
+        return -1;
     }
+    return 0;
 }
 
 /**
@@ -5209,7 +5222,7 @@ function targetGetNotInValues(target, fieldIndex) {
 }
 /**
  * Returns a lower bound of field values that can be used as a starting point to
- * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * scan the index defined by `fieldIndex`. Returns `MIN_VALUE` if no lower bound
  * exists.
  */
 function targetGetLowerBound(target, fieldIndex) {
@@ -5221,10 +5234,6 @@ function targetGetLowerBound(target, fieldIndex) {
         const segmentBound = segment.kind === 0 /* ASCENDING */
             ? targetGetAscendingBound(target, segment.fieldPath, target.startAt)
             : targetGetDescendingBound(target, segment.fieldPath, target.startAt);
-        if (!segmentBound.value) {
-            // No lower bound exists
-            return null;
-        }
         values.push(segmentBound.value);
         inclusive && (inclusive = segmentBound.inclusive);
     }
@@ -5232,7 +5241,7 @@ function targetGetLowerBound(target, fieldIndex) {
 }
 /**
  * Returns an upper bound of field values that can be used as an ending point
- * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * when scanning the index defined by `fieldIndex`. Returns `MAX_VALUE` if no
  * upper bound exists.
  */
 function targetGetUpperBound(target, fieldIndex) {
@@ -5244,10 +5253,6 @@ function targetGetUpperBound(target, fieldIndex) {
         const segmentBound = segment.kind === 0 /* ASCENDING */
             ? targetGetDescendingBound(target, segment.fieldPath, target.endAt)
             : targetGetAscendingBound(target, segment.fieldPath, target.endAt);
-        if (!segmentBound.value) {
-            // No upper bound exists
-            return null;
-        }
         values.push(segmentBound.value);
         inclusive && (inclusive = segmentBound.inclusive);
     }
@@ -5258,11 +5263,11 @@ function targetGetUpperBound(target, fieldIndex) {
  * the provided `fieldPath` (or the upper bound for an descending segment).
  */
 function targetGetAscendingBound(target, fieldPath, bound) {
-    let value = undefined;
+    let value = MIN_VALUE;
     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 filterValue = MIN_VALUE;
         let filterInclusive = true;
         switch (fieldFilter.op) {
             case "<" /* LESS_THAN */:
@@ -5284,7 +5289,7 @@ function targetGetAscendingBound(target, fieldPath, bound) {
                 break;
             // Remaining filters cannot be used as lower bounds.
         }
-        if (valuesMax(value, filterValue) === filterValue) {
+        if (lowerBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) < 0) {
             value = filterValue;
             inclusive = filterInclusive;
         }
@@ -5296,7 +5301,7 @@ function targetGetAscendingBound(target, fieldPath, bound) {
             const orderBy = target.orderBy[i];
             if (orderBy.field.isEqual(fieldPath)) {
                 const cursorValue = bound.position[i];
-                if (valuesMax(value, cursorValue) === cursorValue) {
+                if (lowerBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) < 0) {
                     value = cursorValue;
                     inclusive = bound.inclusive;
                 }
@@ -5311,11 +5316,11 @@ function targetGetAscendingBound(target, fieldPath, bound) {
  * the provided `fieldPath` (or the lower bound for a descending segment).
  */
 function targetGetDescendingBound(target, fieldPath, bound) {
-    let value = undefined;
+    let value = MAX_VALUE;
     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 filterValue = MAX_VALUE;
         let filterInclusive = true;
         switch (fieldFilter.op) {
             case ">=" /* GREATER_THAN_OR_EQUAL */:
@@ -5338,7 +5343,7 @@ function targetGetDescendingBound(target, fieldPath, bound) {
                 break;
             // Remaining filters cannot be used as upper bounds.
         }
-        if (valuesMin(value, filterValue) === filterValue) {
+        if (upperBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) > 0) {
             value = filterValue;
             inclusive = filterInclusive;
         }
@@ -5350,7 +5355,7 @@ function targetGetDescendingBound(target, fieldPath, bound) {
             const orderBy = target.orderBy[i];
             if (orderBy.field.isEqual(fieldPath)) {
                 const cursorValue = bound.position[i];
-                if (valuesMin(value, cursorValue) === cursorValue) {
+                if (upperBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) > 0) {
                     value = cursorValue;
                     inclusive = bound.inclusive;
                 }
@@ -5857,10 +5862,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
+                ? new Bound(queryImpl.endAt.position, queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
+                ? new Bound(queryImpl.startAt.position, queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -10219,7 +10224,7 @@ class IndexedDbIndexManager {
                     const lowerBoundEncoded = this.encodeBound(index, subTarget, lowerBound);
                     const upperBoundEncoded = this.encodeBound(index, subTarget, upperBound);
                     const notInEncoded = this.encodeValues(index, subTarget, notInValues);
-                    const indexRanges = this.generateIndexRanges(index.indexId, arrayValues, lowerBoundEncoded, !!lowerBound && lowerBound.inclusive, upperBoundEncoded, !!upperBound && upperBound.inclusive, notInEncoded);
+                    const indexRanges = this.generateIndexRanges(index.indexId, arrayValues, lowerBoundEncoded, lowerBound.inclusive, upperBoundEncoded, upperBound.inclusive, notInEncoded);
                     return PersistencePromise.forEach(indexRanges, (indexRange) => {
                         return indexEntries
                             .loadFirst(indexRange, target.limit)
@@ -10257,19 +10262,15 @@ class IndexedDbIndexManager {
         // index range per value in an ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filter
         // combined with the values from the query bounds.
         const totalScans = (arrayValues != null ? arrayValues.length : 1) *
-            Math.max(lowerBounds != null ? lowerBounds.length : 1, upperBounds != null ? upperBounds.length : 1);
+            Math.max(lowerBounds.length, upperBounds.length);
         const scansPerArrayElement = totalScans / (arrayValues != null ? arrayValues.length : 1);
         const indexRanges = [];
         for (let i = 0; i < totalScans; ++i) {
             const arrayValue = arrayValues
                 ? this.encodeSingleElement(arrayValues[i / scansPerArrayElement])
                 : EMPTY_VALUE;
-            const lowerBound = lowerBounds
-                ? this.generateLowerBound(indexId, arrayValue, lowerBounds[i % scansPerArrayElement], lowerBoundInclusive)
-                : this.generateEmptyBound(indexId);
-            const upperBound = upperBounds
-                ? this.generateUpperBound(indexId, arrayValue, upperBounds[i % scansPerArrayElement], upperBoundInclusive)
-                : this.generateEmptyBound(indexId + 1);
+            const lowerBound = this.generateLowerBound(indexId, arrayValue, lowerBounds[i % scansPerArrayElement], lowerBoundInclusive);
+            const upperBound = this.generateUpperBound(indexId, arrayValue, upperBounds[i % scansPerArrayElement], upperBoundInclusive);
             const notInBound = notInValues.map(notIn => this.generateLowerBound(indexId, arrayValue, notIn, 
             /* inclusive= */ true));
             indexRanges.push(...this.createRange(lowerBound, upperBound, notInBound));
@@ -10286,13 +10287,6 @@ class IndexedDbIndexManager {
         const entry = new IndexEntry(indexId, DocumentKey.empty(), arrayValue, directionalValue);
         return inclusive ? entry.successor() : entry;
     }
-    /**
-     * Generates an empty bound that scopes the index scan to the current index
-     * and user.
-     */
-    generateEmptyBound(indexId) {
-        return new IndexEntry(indexId, DocumentKey.empty(), EMPTY_VALUE, EMPTY_VALUE);
-    }
     getFieldIndex(transaction, target) {
         const targetIndexMatcher = new TargetIndexMatcher(target);
         const collectionGroup = target.collectionGroup != null
@@ -10387,9 +10381,6 @@ class IndexedDbIndexManager {
      * queries, a list of possible values is returned.
      */
     encodeBound(fieldIndex, target, bound) {
-        if (bound == null) {
-            return null;
-        }
         return this.encodeValues(fieldIndex, target, bound.position);
     }
     /** Returns the byte representation for the provided encoders. */
@@ -24063,18 +24054,18 @@ class Transaction$2 {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
 /**
  * TransactionRunner encapsulates the logic needed to run and retry transactions
  * with backoff.
  */
 class TransactionRunner {
-    constructor(asyncQueue, datastore, updateFunction, deferred) {
+    constructor(asyncQueue, datastore, options, updateFunction, deferred) {
         this.asyncQueue = asyncQueue;
         this.datastore = datastore;
+        this.options = options;
         this.updateFunction = updateFunction;
         this.deferred = deferred;
-        this.attemptsRemaining = DEFAULT_MAX_ATTEMPTS_COUNT;
+        this.attemptsRemaining = options.maxAttempts;
         this.backoff = new ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */
@@ -24432,11 +24423,11 @@ function firestoreClientAddSnapshotsInSyncListener(client, observer) {
  * been committed. For this reason, it is required that all reads are
  * performed before any writes. Transactions must be performed while online.
  */
-function firestoreClientTransaction(client, updateFunction) {
+function firestoreClientTransaction(client, updateFunction, options) {
     const deferred = new Deferred();
     client.asyncQueue.enqueueAndForget(async () => {
         const datastore = await getDatastore(client);
-        new TransactionRunner(client.asyncQueue, datastore, updateFunction, deferred).run();
+        new TransactionRunner(client.asyncQueue, datastore, options, updateFunction, deferred).run();
     });
     return deferred.promise;
 }
@@ -27636,6 +27627,31 @@ function validateOrderByAndInequalityMatch(baseQuery, inequality, orderBy) {
     }
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_TRANSACTION_OPTIONS = {
+    maxAttempts: 5
+};
+function validateTransactionOptions(options) {
+    if (options.maxAttempts < 1) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Max attempts must be at least 1');
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -28357,10 +28373,12 @@ class Transaction extends Transaction$1 {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-function runTransaction(firestore, updateFunction) {
+function runTransaction(firestore, updateFunction, options) {
     firestore = cast(firestore, Firestore);
+    const optionsWithDefaults = Object.assign(Object.assign({}, DEFAULT_TRANSACTION_OPTIONS), options);
+    validateTransactionOptions(optionsWithDefaults);
     const client = ensureFirestoreConfigured(firestore);
-    return firestoreClientTransaction(client, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)));
+    return firestoreClientTransaction(client, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)), optionsWithDefaults);
 }
 
 /**