@firebase/firestore 3.4.8 → 3.4.9

package/dist/lite/index.node.mjs

@@ -6,7 +6,7 @@ import { FirebaseError, createMockUserToken, getModularInstance } from '@firebas
 import nodeFetch from 'node-fetch';
 import { randomBytes as randomBytes$1 } from 'crypto';
 
-const version$1 = "3.4.8";
+const version$1 = "3.4.9";
 
 /**
  * @license
@@ -59,7 +59,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";
+const version = "9.8.0";
 
 /**
  * @license
@@ -2186,6 +2186,13 @@ function isSafeInteger(value) {
  * limitations under the License.
  */
 const MAX_VALUE_TYPE = '__max__';
+const MAX_VALUE = {
+    mapValue: {
+        fields: {
+            '__type__': { stringValue: MAX_VALUE_TYPE }
+        }
+    }
+};
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
@@ -2220,7 +2227,7 @@ function typeOrder(value) {
             return 4 /* ServerTimestampValue */;
         }
         else if (isMaxValue(value)) {
-            return 9 /* ArrayValue */;
+            return 9007199254740991 /* MaxValue */;
         }
         return 10 /* ObjectValue */;
     }
@@ -2432,6 +2439,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 || {};
@@ -3132,9 +3148,6 @@ class QueryImpl {
 function newQueryForPath(path) {
     return new QueryImpl(path);
 }
-function hasLimitToLast(query) {
-    return !isNullOrUndefined(query.limit) && query.limitType === "L" /* Last */;
-}
 function getFirstOrderByField(query) {
     return query.explicitOrderBy.length > 0
         ? query.explicitOrderBy[0].field
@@ -3235,10 +3248,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);
@@ -6056,7 +6069,8 @@ function fieldPathFromArgument(methodName, arg) {
  * limitations under the License.
  */
 function validateHasExplicitOrderByForLimitToLast(query) {
-    if (hasLimitToLast(query) && query.explicitOrderBy.length === 0) {
+    if (query.limitType === "L" /* Last */ &&
+        query.explicitOrderBy.length === 0) {
         throw new FirestoreError(Code.UNIMPLEMENTED, 'limitToLast() queries require specifying at least one orderBy() clause');
     }
 }
@@ -6696,7 +6710,7 @@ function getDocs(query) {
     const userDataWriter = new LiteUserDataWriter(query.firestore);
     return invokeRunQueryRpc(datastore, query._query).then(result => {
         const docs = result.map(doc => new QueryDocumentSnapshot(query.firestore, userDataWriter, doc.key, doc, query.converter));
-        if (hasLimitToLast(query._query)) {
+        if (query._query.limitType === "L" /* Last */) {
             // Limit to last queries reverse the orderBy constraint that was
             // specified by the user. As such, we need to reverse the order of the
             // results to return the documents in the expected order.
@@ -6991,6 +7005,31 @@ function writeBatch(firestore) {
     return new WriteBatch(firestore, writes => invokeCommitRpc(datastore, writes));
 }
 
+/**
+ * @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 2017 Google LLC
@@ -7165,18 +7204,18 @@ class Transaction$1 {
  * 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. */
@@ -7720,11 +7759,13 @@ class Transaction {
  * `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 datastore = getDatastore(firestore);
+    const optionsWithDefaults = Object.assign(Object.assign({}, DEFAULT_TRANSACTION_OPTIONS), options);
+    validateTransactionOptions(optionsWithDefaults);
     const deferred = new Deferred();
-    new TransactionRunner(newAsyncQueue(), datastore, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)), deferred).run();
+    new TransactionRunner(newAsyncQueue(), datastore, optionsWithDefaults, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)), deferred).run();
     return deferred.promise;
 }