@firebase/firestore 3.1.1 → 3.2.0

package/dist/{index.node.cjs.esm2017.js → index.node.mjs}

@@ -4,13 +4,13 @@ import { Logger, LogLevel } from '@firebase/logger';
 import { inspect, TextEncoder, TextDecoder } from 'util';
 import { createMockUserToken, getModularInstance, deepEqual, getUA, isIndexedDBAvailable, isSafari } from '@firebase/util';
 import { randomBytes as randomBytes$1 } from 'crypto';
+import module from 'module';
 import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
-import { version as version$2 } from '@grpc/grpc-js/package.json';
 import { resolve, join } from 'path';
 import { loadSync } from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.1.1";
+const version$1 = "3.2.0";
 
 /**
  * @license
@@ -63,7 +63,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.1.3";
+const version = "9.2.0";
 
 /**
  * @license
@@ -14236,8 +14236,13 @@ function nodePromise(action) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+// This is a hack fix for Node ES modules to use `require`.
+// @ts-ignore To avoid using `--module es2020` flag.
+const require = module.createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { version: grpcVersion } = require('@grpc/grpc-js/package.json');
 const LOG_TAG$9 = 'Connection';
-const X_GOOG_API_CLIENT_VALUE = `gl-node/${process.versions.node} fire/${SDK_VERSION} grpc/${version$2}`;
+const X_GOOG_API_CLIENT_VALUE = `gl-node/${process.versions.node} fire/${SDK_VERSION} grpc/${grpcVersion}`;
 function createMetadata(databasePath, token, appId) {
     hardAssert(token === null || token.type === 'OAuth');
     const metadata = new Metadata();
@@ -14668,6 +14673,8 @@ class ExponentialBackoff {
 const LOG_TAG$7 = 'PersistentStream';
 /** The time a stream stays open after it is marked idle. */
 const IDLE_TIMEOUT_MS = 60 * 1000;
+/** The time a stream stays open until we consider it healthy. */
+const HEALTHY_TIMEOUT_MS = 10 * 1000;
 /**
  * A PersistentStream is an abstract base class that represents a streaming RPC
  * to the Firestore backend. It's built on top of the connections own support
@@ -14701,9 +14708,10 @@ const IDLE_TIMEOUT_MS = 60 * 1000;
  *  ListenerType: The type of the listener that will be used for callbacks
  */
 class PersistentStream {
-    constructor(queue, connectionTimerId, idleTimerId, connection, credentialsProvider, listener) {
+    constructor(queue, connectionTimerId, idleTimerId, healthTimerId, connection, credentialsProvider, listener) {
         this.queue = queue;
         this.idleTimerId = idleTimerId;
+        this.healthTimerId = healthTimerId;
         this.connection = connection;
         this.credentialsProvider = credentialsProvider;
         this.listener = listener;
@@ -14715,6 +14723,7 @@ class PersistentStream {
          */
         this.closeCount = 0;
         this.idleTimer = null;
+        this.healthCheck = null;
         this.stream = null;
         this.backoff = new ExponentialBackoff(queue, connectionTimerId);
     }
@@ -14727,15 +14736,16 @@ class PersistentStream {
      */
     isStarted() {
         return (this.state === 1 /* Starting */ ||
-            this.state === 2 /* Open */ ||
-            this.state === 4 /* Backoff */);
+            this.state === 5 /* Backoff */ ||
+            this.isOpen());
     }
     /**
      * Returns true if the underlying RPC is open (the onOpen() listener has been
      * called) and the stream is ready for outbound requests.
      */
     isOpen() {
-        return this.state === 2 /* Open */;
+        return (this.state === 2 /* Open */ ||
+            this.state === 3 /* Healthy */);
     }
     /**
      * Starts the RPC. Only allowed if isStarted() returns false. The stream is
@@ -14745,7 +14755,7 @@ class PersistentStream {
      * When start returns, isStarted() will return true.
      */
     start() {
-        if (this.state === 3 /* Error */) {
+        if (this.state === 4 /* Error */) {
             this.performBackoff();
             return;
         }
@@ -14811,6 +14821,13 @@ class PersistentStream {
             this.idleTimer = null;
         }
     }
+    /** Cancels the health check delayed operation. */
+    cancelHealthCheck() {
+        if (this.healthCheck) {
+            this.healthCheck.cancel();
+            this.healthCheck = null;
+        }
+    }
     /**
      * Closes the stream and cleans up as necessary:
      *
@@ -14827,11 +14844,12 @@ class PersistentStream {
     async close(finalState, error) {
         // Cancel any outstanding timers (they're guaranteed not to execute).
         this.cancelIdleCheck();
+        this.cancelHealthCheck();
         this.backoff.cancel();
         // Invalidates any stream-related callbacks (e.g. from auth or the
         // underlying stream), guaranteeing they won't execute.
         this.closeCount++;
-        if (finalState !== 3 /* Error */) {
+        if (finalState !== 4 /* Error */) {
             // If this is an intentional close ensure we don't delay our next connection attempt.
             this.backoff.reset();
         }
@@ -14841,9 +14859,15 @@ class PersistentStream {
             logError('Using maximum backoff delay to prevent overloading the backend.');
             this.backoff.resetToMax();
         }
-        else if (error && error.code === Code.UNAUTHENTICATED) {
-            // "unauthenticated" error means the token was rejected. Try force refreshing it in case it
-            // just expired.
+        else if (error &&
+            error.code === Code.UNAUTHENTICATED &&
+            this.state !== 3 /* Healthy */) {
+            // "unauthenticated" error means the token was rejected. This should rarely
+            // happen since both Auth and AppCheck ensure a sufficient TTL when we
+            // request a token. If a user manually resets their system clock this can
+            // fail, however. In this case, we should get a Code.UNAUTHENTICATED error
+            // before we received the first message and we need to invalidate the token
+            // to ensure that we fetch a new token.
             this.credentialsProvider.invalidateToken();
         }
         // Clean up the underlying stream because we are no longer interested in events.
@@ -14892,6 +14916,12 @@ class PersistentStream {
         this.stream.onOpen(() => {
             dispatchIfNotClosed(() => {
                 this.state = 2 /* Open */;
+                this.healthCheck = this.queue.enqueueAfterDelay(this.healthTimerId, HEALTHY_TIMEOUT_MS, () => {
+                    if (this.isOpen()) {
+                        this.state = 3 /* Healthy */;
+                    }
+                    return Promise.resolve();
+                });
                 return this.listener.onOpen();
             });
         });
@@ -14907,7 +14937,7 @@ class PersistentStream {
         });
     }
     performBackoff() {
-        this.state = 4 /* Backoff */;
+        this.state = 5 /* Backoff */;
         this.backoff.backoffAndRun(async () => {
             this.state = 0 /* Initial */;
             this.start();
@@ -14921,7 +14951,7 @@ class PersistentStream {
         // we never expect this to happen because if we stop a stream ourselves,
         // this callback will never be called. To prevent cases where we retry
         // without a backoff accidentally, we set the stream to error in all cases.
-        return this.close(3 /* Error */, error);
+        return this.close(4 /* Error */, error);
     }
     /**
      * Returns a "dispatcher" function that dispatches operations onto the
@@ -14952,7 +14982,7 @@ class PersistentStream {
  */
 class PersistentListenStream extends PersistentStream {
     constructor(queue, connection, credentials, serializer, listener) {
-        super(queue, "listen_stream_connection_backoff" /* ListenStreamConnectionBackoff */, "listen_stream_idle" /* ListenStreamIdle */, connection, credentials, listener);
+        super(queue, "listen_stream_connection_backoff" /* ListenStreamConnectionBackoff */, "listen_stream_idle" /* ListenStreamIdle */, "health_check_timeout" /* HealthCheckTimeout */, connection, credentials, listener);
         this.serializer = serializer;
     }
     startRpc(token) {
@@ -15011,7 +15041,7 @@ class PersistentListenStream extends PersistentStream {
  */
 class PersistentWriteStream extends PersistentStream {
     constructor(queue, connection, credentials, serializer, listener) {
-        super(queue, "write_stream_connection_backoff" /* WriteStreamConnectionBackoff */, "write_stream_idle" /* WriteStreamIdle */, connection, credentials, listener);
+        super(queue, "write_stream_connection_backoff" /* WriteStreamConnectionBackoff */, "write_stream_idle" /* WriteStreamIdle */, "health_check_timeout" /* HealthCheckTimeout */, connection, credentials, listener);
         this.serializer = serializer;
         this.handshakeComplete_ = false;
     }
@@ -20776,12 +20806,12 @@ function verifyNotInitialized(firestore) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function registerFirestore(variant) {
+function registerFirestore(variant, useFetchStreams = true) {
     setSDKVersion(SDK_VERSION$1);
     _registerComponent(new Component('firestore', (container, { options: settings }) => {
         const app = container.getProvider('app').getImmediate();
         const firestoreInstance = new Firestore(app, new FirebaseCredentialsProvider(container.getProvider('auth-internal')));
-        settings = Object.assign({ useFetchStreams: true }, settings);
+        settings = Object.assign({ useFetchStreams }, settings);
         firestoreInstance._setSettings(settings);
         return firestoreInstance;
     }, "PUBLIC" /* PUBLIC */));
@@ -23307,6 +23337,7 @@ class Transaction extends Transaction$1 {
  * rejected promise with the corresponding failure error is returned.
  */
 function runTransaction(firestore, updateFunction) {
+    firestore = cast(firestore, Firestore);
     const client = ensureFirestoreConfigured(firestore);
     return firestoreClientTransaction(client, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)));
 }
@@ -23449,4 +23480,4 @@ function writeBatch(firestore) {
 registerFirestore('node');
 
 export { AbstractUserDataWriter, Bytes, CACHE_SIZE_UNLIMITED, CollectionReference, DocumentReference, DocumentSnapshot, FieldPath, FieldValue, Firestore, FirestoreError, GeoPoint, LoadBundleTask, Query, QueryConstraint, QueryDocumentSnapshot, QuerySnapshot, SnapshotMetadata, Timestamp, Transaction, WriteBatch, DatabaseId as _DatabaseId, DocumentKey as _DocumentKey, EmptyCredentialsProvider as _EmptyCredentialsProvider, FieldPath$1 as _FieldPath, cast as _cast, debugAssert as _debugAssert, isBase64Available as _isBase64Available, logWarn as _logWarn, validateIsNotUsedTogether as _validateIsNotUsedTogether, addDoc, arrayRemove, arrayUnion, clearIndexedDbPersistence, collection, collectionGroup, connectFirestoreEmulator, deleteDoc, deleteField, disableNetwork, doc, documentId, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, enableNetwork, endAt, endBefore, ensureFirestoreConfigured, executeWrite, getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, getFirestore, increment, initializeFirestore, limit, limitToLast, loadBundle, namedQuery, onSnapshot, onSnapshotsInSync, orderBy, query, queryEqual, refEqual, runTransaction, serverTimestamp, setDoc, setLogLevel, snapshotEqual, startAfter, startAt, terminate, updateDoc, waitForPendingWrites, where, writeBatch };
-//# sourceMappingURL=index.node.cjs.esm2017.js.map
+//# sourceMappingURL=index.node.mjs.map