@firebase/firestore 3.4.4-canary.222f264ff → 3.4.4-canary.2dd99ae2d

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
 import { fromJSON } from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4-canary.222f264ff";
+const version$1 = "3.4.4-canary.2dd99ae2d";
 
 /**
  * @license
@@ -61,7 +61,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.5-canary.222f264ff";
+const version = "9.6.5-canary.2dd99ae2d";
 
 /**
  * @license
@@ -3374,6 +3374,75 @@ function getLocalWriteTime(value) {
     return new Timestamp(localWriteTime.seconds, localWriteTime.nanos);
 }
 
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+class DatabaseInfo {
+    /**
+     * Constructs a DatabaseInfo using the provided host, databaseId and
+     * persistenceKey.
+     *
+     * @param databaseId - The database to use.
+     * @param appId - The Firebase App Id.
+     * @param persistenceKey - A unique identifier for this Firestore's local
+     * storage (used in conjunction with the databaseId).
+     * @param host - The Firestore backend host to connect to.
+     * @param ssl - Whether to use SSL when connecting.
+     * @param forceLongPolling - Whether to use the forceLongPolling option
+     * when using WebChannel as the network transport.
+     * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
+     * option when using WebChannel as the network transport.
+     * @param useFetchStreams Whether to use the Fetch API instead of
+     * XMLHTTPRequest
+     */
+    constructor(databaseId, appId, persistenceKey, host, ssl, forceLongPolling, autoDetectLongPolling, useFetchStreams) {
+        this.databaseId = databaseId;
+        this.appId = appId;
+        this.persistenceKey = persistenceKey;
+        this.host = host;
+        this.ssl = ssl;
+        this.forceLongPolling = forceLongPolling;
+        this.autoDetectLongPolling = autoDetectLongPolling;
+        this.useFetchStreams = useFetchStreams;
+    }
+}
+/** The default database name for a project. */
+const DEFAULT_DATABASE_NAME = '(default)';
+/**
+ * Represents the database ID a Firestore client is associated with.
+ * @internal
+ */
+class DatabaseId {
+    constructor(projectId, database) {
+        this.projectId = projectId;
+        this.database = database ? database : DEFAULT_DATABASE_NAME;
+    }
+    static empty() {
+        return new DatabaseId('', '');
+    }
+    get isDefaultDatabase() {
+        return this.database === DEFAULT_DATABASE_NAME;
+    }
+    isEqual(other) {
+        return (other instanceof DatabaseId &&
+            other.projectId === this.projectId &&
+            other.database === this.database);
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -3445,6 +3514,9 @@ class DocumentKey {
     static fromName(name) {
         return new DocumentKey(ResourcePath.fromString(name).popFirst(5));
     }
+    static empty() {
+        return new DocumentKey(ResourcePath.emptyPath());
+    }
     /** Returns true if the document is in the specified collectionId. */
     hasCollectionId(collectionId) {
         return (this.path.length >= 2 &&
@@ -4093,10 +4165,11 @@ function extractFieldMask(value) {
  * from all views.
  */
 class MutableDocument {
-    constructor(key, documentType, version, data, documentState) {
+    constructor(key, documentType, version, readTime, data, documentState) {
         this.key = key;
         this.documentType = documentType;
         this.version = version;
+        this.readTime = readTime;
         this.data = data;
         this.documentState = documentState;
     }
@@ -4105,18 +4178,18 @@ class MutableDocument {
      * base document for mutations.
      */
     static newInvalidDocument(documentKey) {
-        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
     /**
      * Creates a new document that is known to exist with the given data at the
      * given version.
      */
     static newFoundDocument(documentKey, version, value) {
-        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, value, 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, SnapshotVersion.min(), value, 0 /* SYNCED */);
     }
     /** Creates a new document that is known to not exist at the given version. */
     static newNoDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
     /**
      * Creates a new document that is known to exist at the given version but
@@ -4124,7 +4197,7 @@ class MutableDocument {
      * base document).
      */
     static newUnknownDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
+        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
     }
     /**
      * Changes the document type to indicate that it exists and that its version
@@ -4168,6 +4241,10 @@ class MutableDocument {
         this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
         return this;
     }
+    setReadTime(readTime) {
+        this.readTime = readTime;
+        return this;
+    }
     get hasLocalMutations() {
         return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
     }
@@ -4198,7 +4275,7 @@ class MutableDocument {
             this.data.isEqual(other.data));
     }
     mutableCopy() {
-        return new MutableDocument(this.key, this.documentType, this.version, this.data.clone(), this.documentState);
+        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
     }
     toString() {
         return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
@@ -4221,6 +4298,125 @@ function compareDocumentsByField(field, d1, d2) {
     }
 }
 
+/**
+ * @license
+ * Copyright 2021 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.
+ */
+/**
+ * The initial mutation batch id for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_LARGEST_BATCH_ID = -1;
+/**
+ * The initial sequence number for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_SEQUENCE_NUMBER = 0;
+/**
+ * An index definition for field indexes in Firestore.
+ *
+ * Every index is associated with a collection. The definition contains a list
+ * of fields and their index kind (which can be `ASCENDING`, `DESCENDING` or
+ * `CONTAINS` for ArrayContains/ArrayContainsAny queries).
+ *
+ * Unlike the backend, the SDK does not differentiate between collection or
+ * collection group-scoped indices. Every index can be used for both single
+ * collection and collection group queries.
+ */
+class FieldIndex {
+    constructor(
+    /**
+     * The index ID. Returns -1 if the index ID is not available (e.g. the index
+     * has not yet been persisted).
+     */
+    indexId, 
+    /** The collection ID this index applies to. */
+    collectionGroup, 
+    /** The field segments for this index. */
+    segments, 
+    /** Shows how up-to-date the index is for the current user. */
+    indexState) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.segments = segments;
+        this.indexState = indexState;
+    }
+}
+/** An ID for an index that has not yet been added to persistence.  */
+FieldIndex.UNKNOWN_ID = -1;
+/** An index component consisting of field path and index type.  */
+class IndexSegment {
+    constructor(
+    /** The field path of the component. */
+    fieldPath, 
+    /** The fields sorting order. */
+    kind) {
+        this.fieldPath = fieldPath;
+        this.kind = kind;
+    }
+}
+/**
+ * Stores the "high water mark" that indicates how updated the Index is for the
+ * current user.
+ */
+class IndexState {
+    constructor(
+    /**
+     * Indicates when the index was last updated (relative to other indexes).
+     */
+    sequenceNumber, 
+    /** The the latest indexed read time, document and batch id. */
+    offset) {
+        this.sequenceNumber = sequenceNumber;
+        this.offset = offset;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static empty() {
+        return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
+    }
+}
+/**
+ * Stores the latest read time, document and batch ID that were processed for an
+ * index.
+ */
+class IndexOffset {
+    constructor(
+    /**
+     * The latest read time version that has been indexed by Firestore for this
+     * field index.
+     */
+    readTime, 
+    /**
+     * The key of the last document that was indexed for this query. Use
+     * `DocumentKey.empty()` if no document has been indexed.
+     */
+    documentKey, 
+    /*
+     * The largest mutation batch id that's been processed by Firestore.
+     */
+    largestBatchId) {
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static min() {
+        return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+}
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -4345,7 +4541,7 @@ function targetEquals(left, right) {
     }
     return boundEquals(left.endAt, right.endAt);
 }
-function isDocumentTarget(target) {
+function targetIsDocumentTarget(target) {
     return (DocumentKey.isDocumentKey(target.path) &&
         target.collectionGroup === null &&
         target.filters.length === 0);
@@ -4533,6 +4729,7 @@ class ArrayContainsAnyFilter extends FieldFilter {
         return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
     }
 }
+// TODO(indexing): Change Bound.before to "inclusive"
 /**
  * Represents a bound of a query.
  *
@@ -6990,7 +7187,7 @@ class WatchChangeAggregator {
         const targetData = this.targetDataForActiveTarget(targetId);
         if (targetData) {
             const target = targetData.target;
-            if (isDocumentTarget(target)) {
+            if (targetIsDocumentTarget(target)) {
                 if (expectedCount === 0) {
                     // The existence filter told us the document does not exist. We deduce
                     // that this document does not exist and apply a deleted document to
@@ -7025,7 +7222,7 @@ class WatchChangeAggregator {
         this.targetStates.forEach((targetState, targetId) => {
             const targetData = this.targetDataForActiveTarget(targetId);
             if (targetData) {
-                if (targetState.current && isDocumentTarget(targetData.target)) {
+                if (targetState.current && targetIsDocumentTarget(targetData.target)) {
                     // Document queries for document that don't exist can produce an empty
                     // result set. To update our local cache, we synthesize a document
                     // delete if we have not previously received the document. This
@@ -7068,6 +7265,7 @@ class WatchChangeAggregator {
                 resolvedLimboDocuments = resolvedLimboDocuments.add(key);
             }
         });
+        this.pendingDocumentUpdates.forEach((_, doc) => doc.setReadTime(snapshotVersion));
         const remoteEvent = new RemoteEvent(snapshotVersion, targetChanges, this.pendingTargetResets, this.pendingDocumentUpdates, resolvedLimboDocuments);
         this.pendingDocumentUpdates = mutableDocumentMap();
         this.pendingDocumentTargetMapping = documentTargetMap();
@@ -7860,7 +8058,7 @@ function toLabel(serializer, purpose) {
 function toTarget(serializer, targetData) {
     let result;
     const target = targetData.target;
-    if (isDocumentTarget(target)) {
+    if (targetIsDocumentTarget(target)) {
         result = { documents: toDocumentsTarget(serializer, target) };
     }
     else {
@@ -8188,29 +8386,34 @@ class LocalSerializer {
 }
 /** Decodes a remote document from storage locally to a Document. */
 function fromDbRemoteDocument(localSerializer, remoteDoc) {
+    let doc;
     if (remoteDoc.document) {
-        return fromDocument(localSerializer.remoteSerializer, remoteDoc.document, !!remoteDoc.hasCommittedMutations);
+        doc = fromDocument(localSerializer.remoteSerializer, remoteDoc.document, !!remoteDoc.hasCommittedMutations);
     }
     else if (remoteDoc.noDocument) {
         const key = DocumentKey.fromSegments(remoteDoc.noDocument.path);
         const version = fromDbTimestamp(remoteDoc.noDocument.readTime);
-        const document = MutableDocument.newNoDocument(key, version);
-        return remoteDoc.hasCommittedMutations
-            ? document.setHasCommittedMutations()
-            : document;
+        doc = MutableDocument.newNoDocument(key, version);
+        if (remoteDoc.hasCommittedMutations) {
+            doc.setHasCommittedMutations();
+        }
     }
     else if (remoteDoc.unknownDocument) {
         const key = DocumentKey.fromSegments(remoteDoc.unknownDocument.path);
         const version = fromDbTimestamp(remoteDoc.unknownDocument.version);
-        return MutableDocument.newUnknownDocument(key, version);
+        doc = MutableDocument.newUnknownDocument(key, version);
     }
     else {
         return fail();
     }
+    if (remoteDoc.readTime) {
+        doc.setReadTime(fromDbTimestampKey(remoteDoc.readTime));
+    }
+    return doc;
 }
 /** Encodes a document for storage locally. */
-function toDbRemoteDocument(localSerializer, document, readTime) {
-    const dbReadTime = toDbTimestampKey(readTime);
+function toDbRemoteDocument(localSerializer, document) {
+    const dbReadTime = toDbTimestampKey(document.readTime);
     const parentPath = document.key.path.popLast().toArray();
     if (document.isFoundDocument()) {
         const doc = toDocument(localSerializer.remoteSerializer, document);
@@ -8221,10 +8424,10 @@ function toDbRemoteDocument(localSerializer, document, readTime) {
     }
     else if (document.isNoDocument()) {
         const path = document.key.path.toArray();
-        const readTime = toDbTimestamp(document.version);
+        const version = toDbTimestamp(document.version);
         const hasCommittedMutations = document.hasCommittedMutations;
         return new DbRemoteDocument(
-        /* unknownDocument= */ null, new DbNoDocument(path, readTime), 
+        /* unknownDocument= */ null, new DbNoDocument(path, version), 
         /* document= */ null, hasCommittedMutations, dbReadTime, parentPath);
     }
     else if (document.isUnknownDocument()) {
@@ -8305,7 +8508,7 @@ function toDbTarget(localSerializer, targetData) {
     const dbTimestamp = toDbTimestamp(targetData.snapshotVersion);
     const dbLastLimboFreeTimestamp = toDbTimestamp(targetData.lastLimboFreeSnapshotVersion);
     let queryProto;
-    if (isDocumentTarget(targetData.target)) {
+    if (targetIsDocumentTarget(targetData.target)) {
         queryProto = toDocumentsTarget(localSerializer.remoteSerializer, targetData.target);
     }
     else {
@@ -9753,7 +9956,7 @@ class IndexedDbLruDelegateImpl {
                         // Our size accounting requires us to read all documents before
                         // removing them.
                         return changeBuffer.getEntry(txn, docKey).next(() => {
-                            changeBuffer.removeEntry(docKey);
+                            changeBuffer.removeEntry(docKey, SnapshotVersion.min());
                             return documentTargetStore(txn).delete(sentinelKey$1(docKey));
                         });
                     }
@@ -9966,27 +10169,19 @@ class ObjectMap {
  */
 class RemoteDocumentChangeBuffer {
     constructor() {
-        // A mapping of document key to the new cache entry that should be written (or null if any
-        // existing cache entry should be removed).
+        // A mapping of document key to the new cache entry that should be written.
         this.changes = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
         this.changesApplied = false;
     }
-    getReadTime(key) {
-        const change = this.changes.get(key);
-        if (change) {
-            return change.readTime;
-        }
-        return SnapshotVersion.min();
-    }
     /**
      * Buffers a `RemoteDocumentCache.addEntry()` call.
      *
      * You can only modify documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    addEntry(document, readTime) {
+    addEntry(document) {
         this.assertNotApplied();
-        this.changes.set(document.key, { document, readTime });
+        this.changes.set(document.key, document);
     }
     /**
      * Buffers a `RemoteDocumentCache.removeEntry()` call.
@@ -9994,12 +10189,9 @@ class RemoteDocumentChangeBuffer {
      * You can only remove documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    removeEntry(key, readTime = null) {
+    removeEntry(key, readTime) {
         this.assertNotApplied();
-        this.changes.set(key, {
-            document: MutableDocument.newInvalidDocument(key),
-            readTime
-        });
+        this.changes.set(key, MutableDocument.newInvalidDocument(key).setReadTime(readTime));
     }
     /**
      * Looks up an entry in the cache. The buffered changes will first be checked,
@@ -10016,7 +10208,7 @@ class RemoteDocumentChangeBuffer {
         this.assertNotApplied();
         const bufferedEntry = this.changes.get(documentKey);
         if (bufferedEntry !== undefined) {
-            return PersistencePromise.resolve(bufferedEntry.document);
+            return PersistencePromise.resolve(bufferedEntry);
         }
         else {
             return this.getFromCache(transaction, documentKey);
@@ -10227,7 +10419,7 @@ class IndexedDbRemoteDocumentCacheImpl {
             if (key.length !== immediateChildrenPathLength) {
                 return;
             }
-            const document = fromDbRemoteDocument(this.serializer, dbRemoteDoc);
+            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
             if (!query.path.isPrefixOf(document.key.path)) {
                 control.done();
             }
@@ -10255,8 +10447,8 @@ class IndexedDbRemoteDocumentCacheImpl {
         return documentGlobalStore(txn).put(DbRemoteDocumentGlobal.key, metadata);
     }
     /**
-     * Decodes `remoteDoc` and returns the document (or null, if the document
-     * corresponds to the format used for sentinel deletes).
+     * Decodes `dbRemoteDoc` and returns the document (or an invalid document if
+     * the document corresponds to the format used for sentinel deletes).
      */
     maybeDecodeDocument(documentKey, dbRemoteDoc) {
         if (dbRemoteDoc) {
@@ -10350,8 +10542,8 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
         this.changes.forEach((key, documentChange) => {
             const previousSize = this.documentSizes.get(key);
-            if (documentChange.document.isValidDocument()) {
-                const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange.document, this.getReadTime(key));
+            if (documentChange.isValidDocument()) {
+                const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange);
                 collectionParents = collectionParents.add(key.path.popLast());
                 const size = dbDocumentSize(doc);
                 sizeDelta += size - previousSize;
@@ -10364,7 +10556,7 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
                     // RemoteDocumentCache. This entry is represented by a NoDocument
                     // with a version of 0 and ignored by `maybeDecodeDocument()` but
                     // preserved in `getNewDocumentChanges()`.
-                    const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, MutableDocument.newNoDocument(key, SnapshotVersion.min()), this.getReadTime(key));
+                    const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, documentChange.convertToNoDocument(SnapshotVersion.min()));
                     promises.push(this.documentCache.addEntry(transaction, key, deletedDoc));
                 }
                 else {
@@ -11951,14 +12143,14 @@ function localStoreApplyRemoteEventToLocalCache(localStore, remoteEvent) {
             }
         });
         let changedDocs = mutableDocumentMap();
-        remoteEvent.documentUpdates.forEach((key, doc) => {
+        remoteEvent.documentUpdates.forEach(key => {
             if (remoteEvent.resolvedLimboDocuments.has(key)) {
                 promises.push(localStoreImpl.persistence.referenceDelegate.updateLimboDocument(txn, key));
             }
         });
         // Each loop iteration only affects its "own" doc, so it's safe to get all the remote
         // documents in advance in a single call.
-        promises.push(populateDocumentChangeBuffer(txn, documentBuffer, remoteEvent.documentUpdates, remoteVersion, undefined).next(result => {
+        promises.push(populateDocumentChangeBuffer(txn, documentBuffer, remoteEvent.documentUpdates).next(result => {
             changedDocs = result;
         }));
         // HACK: The only reason we allow a null snapshot version is so that we
@@ -11999,17 +12191,13 @@ function localStoreApplyRemoteEventToLocalCache(localStore, remoteEvent) {
  * Note: this function will use `documentVersions` if it is defined;
  * when it is not defined, resorts to `globalVersion`.
  */
-function populateDocumentChangeBuffer(txn, documentBuffer, documents, globalVersion, 
-// TODO(wuandy): We could add `readTime` to MaybeDocument instead to remove
-// this parameter.
-documentVersions) {
+function populateDocumentChangeBuffer(txn, documentBuffer, documents) {
     let updatedKeys = documentKeySet();
     documents.forEach(k => (updatedKeys = updatedKeys.add(k)));
     return documentBuffer.getEntries(txn, updatedKeys).next(existingDocs => {
         let changedDocs = mutableDocumentMap();
         documents.forEach((key, doc) => {
             const existingDoc = existingDocs.get(key);
-            const docReadTime = (documentVersions === null || documentVersions === void 0 ? void 0 : documentVersions.get(key)) || globalVersion;
             // Note: The order of the steps below is important, since we want
             // to ensure that rejected limbo resolutions (which fabricate
             // NoDocuments with SnapshotVersion.min()) never add documents to
@@ -12018,14 +12206,14 @@ documentVersions) {
                 // NoDocuments with SnapshotVersion.min() are used in manufactured
                 // events. We remove these documents from cache since we lost
                 // access.
-                documentBuffer.removeEntry(key, docReadTime);
+                documentBuffer.removeEntry(key, doc.readTime);
                 changedDocs = changedDocs.insert(key, doc);
             }
             else if (!existingDoc.isValidDocument() ||
                 doc.version.compareTo(existingDoc.version) > 0 ||
                 (doc.version.compareTo(existingDoc.version) === 0 &&
                     existingDoc.hasPendingWrites)) {
-                documentBuffer.addEntry(doc, docReadTime);
+                documentBuffer.addEntry(doc);
                 changedDocs = changedDocs.insert(key, doc);
             }
             else {
@@ -12279,7 +12467,8 @@ function applyWriteToRemoteDocuments(localStoreImpl, txn, batchResult, documentB
                     // We use the commitVersion as the readTime rather than the
                     // document's updateTime since the updateTime is not advanced
                     // for updates that do not modify the underlying document.
-                    documentBuffer.addEntry(doc, batchResult.commitVersion);
+                    doc.setReadTime(batchResult.commitVersion);
+                    documentBuffer.addEntry(doc);
                 }
             }
         });
@@ -12380,14 +12569,14 @@ async function localStoreApplyBundledDocuments(localStore, bundleConverter, docu
     const localStoreImpl = debugCast(localStore);
     let documentKeys = documentKeySet();
     let documentMap = mutableDocumentMap();
-    let versionMap = documentVersionMap();
     for (const bundleDoc of documents) {
         const documentKey = bundleConverter.toDocumentKey(bundleDoc.metadata.name);
         if (bundleDoc.document) {
             documentKeys = documentKeys.add(documentKey);
         }
-        documentMap = documentMap.insert(documentKey, bundleConverter.toMutableDocument(bundleDoc));
-        versionMap = versionMap.insert(documentKey, bundleConverter.toSnapshotVersion(bundleDoc.metadata.readTime));
+        const doc = bundleConverter.toMutableDocument(bundleDoc);
+        doc.setReadTime(bundleConverter.toSnapshotVersion(bundleDoc.metadata.readTime));
+        documentMap = documentMap.insert(documentKey, doc);
     }
     const documentBuffer = localStoreImpl.remoteDocuments.newChangeBuffer({
         trackRemovals: true // Make sure document removals show up in `getNewDocumentChanges()`
@@ -12396,7 +12585,7 @@ async function localStoreApplyBundledDocuments(localStore, bundleConverter, docu
     // they will not get garbage collected right away.
     const umbrellaTargetData = await localStoreAllocateTarget(localStoreImpl, umbrellaTarget(bundleName));
     return localStoreImpl.persistence.runTransaction('Apply bundle documents', 'readwrite', txn => {
-        return populateDocumentChangeBuffer(txn, documentBuffer, documentMap, SnapshotVersion.min(), versionMap)
+        return populateDocumentChangeBuffer(txn, documentBuffer, documentMap)
             .next(changedDocs => {
             documentBuffer.apply(txn);
             return changedDocs;
@@ -12877,15 +13066,14 @@ class MemoryRemoteDocumentCacheImpl {
      * All calls of `addEntry`  are required to go through the RemoteDocumentChangeBuffer
      * returned by `newChangeBuffer()`.
      */
-    addEntry(transaction, doc, readTime) {
+    addEntry(transaction, doc) {
         const key = doc.key;
         const entry = this.docs.get(key);
         const previousSize = entry ? entry.size : 0;
         const currentSize = this.sizer(doc);
         this.docs = this.docs.insert(key, {
             document: doc.mutableCopy(),
-            size: currentSize,
-            readTime
+            size: currentSize
         });
         this.size += currentSize - previousSize;
         return this.indexManager.addToCollectionParentIndex(transaction, key.path.popLast());
@@ -12926,11 +13114,11 @@ class MemoryRemoteDocumentCacheImpl {
         const prefix = new DocumentKey(query.path.child(''));
         const iterator = this.docs.getIteratorFrom(prefix);
         while (iterator.hasNext()) {
-            const { key, value: { document, readTime } } = iterator.getNext();
+            const { key, value: { document } } = iterator.getNext();
             if (!query.path.isPrefixOf(key.path)) {
                 break;
             }
-            if (readTime.compareTo(sinceReadTime) <= 0) {
+            if (document.readTime.compareTo(sinceReadTime) <= 0) {
                 continue;
             }
             if (!queryMatches(query, document)) {
@@ -12974,8 +13162,8 @@ class MemoryRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
     applyChanges(transaction) {
         const promises = [];
         this.changes.forEach((key, doc) => {
-            if (doc.document.isValidDocument()) {
-                promises.push(this.documentCache.addEntry(transaction, doc.document, this.getReadTime(key)));
+            if (doc.isValidDocument()) {
+                promises.push(this.documentCache.addEntry(transaction, doc));
             }
             else {
                 this.documentCache.removeEntry(key);
@@ -13288,7 +13476,7 @@ class MemoryEagerDelegate {
             const key = DocumentKey.fromPath(path);
             return this.isReferenced(txn, key).next(isReferenced => {
                 if (!isReferenced) {
-                    changeBuffer.removeEntry(key);
+                    changeBuffer.removeEntry(key, SnapshotVersion.min());
                 }
             });
         }).next(() => {
@@ -20345,6 +20533,9 @@ async function syncEngineRejectListen(syncEngine, targetId, err) {
         // store to purge a document. However, it would be tricky to keep all of
         // the local store's invariants with another method.
         let documentUpdates = new SortedMap(DocumentKey.comparator);
+        // TODO(b/217189216): This limbo document should ideally have a read time,
+        // so that it is picked up by any read-time based scans. The backend,
+        // however, does not send a read time for target removals.
         documentUpdates = documentUpdates.insert(limboKey, MutableDocument.newNoDocument(limboKey, SnapshotVersion.min()));
         const resolvedLimboDocuments = documentKeySet().add(limboKey);
         const event = new RemoteEvent(SnapshotVersion.min(), 
@@ -22289,72 +22480,6 @@ function createBundleReader(data, serializer) {
     return newBundleReader(toByteStreamReader(content), serializer);
 }
 
-/**
- * @license
- * Copyright 2017 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.
- */
-class DatabaseInfo {
-    /**
-     * Constructs a DatabaseInfo using the provided host, databaseId and
-     * persistenceKey.
-     *
-     * @param databaseId - The database to use.
-     * @param appId - The Firebase App Id.
-     * @param persistenceKey - A unique identifier for this Firestore's local
-     * storage (used in conjunction with the databaseId).
-     * @param host - The Firestore backend host to connect to.
-     * @param ssl - Whether to use SSL when connecting.
-     * @param forceLongPolling - Whether to use the forceLongPolling option
-     * when using WebChannel as the network transport.
-     * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
-     * option when using WebChannel as the network transport.
-     * @param useFetchStreams Whether to use the Fetch API instead of
-     * XMLHTTPRequest
-     */
-    constructor(databaseId, appId, persistenceKey, host, ssl, forceLongPolling, autoDetectLongPolling, useFetchStreams) {
-        this.databaseId = databaseId;
-        this.appId = appId;
-        this.persistenceKey = persistenceKey;
-        this.host = host;
-        this.ssl = ssl;
-        this.forceLongPolling = forceLongPolling;
-        this.autoDetectLongPolling = autoDetectLongPolling;
-        this.useFetchStreams = useFetchStreams;
-    }
-}
-/** The default database name for a project. */
-const DEFAULT_DATABASE_NAME = '(default)';
-/**
- * Represents the database ID a Firestore client is associated with.
- * @internal
- */
-class DatabaseId {
-    constructor(projectId, database) {
-        this.projectId = projectId;
-        this.database = database ? database : DEFAULT_DATABASE_NAME;
-    }
-    get isDefaultDatabase() {
-        return this.database === DEFAULT_DATABASE_NAME;
-    }
-    isEqual(other) {
-        return (other instanceof DatabaseId &&
-            other.projectId === this.projectId &&
-            other.database === this.database);
-    }
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -26268,17 +26393,6 @@ function writeBatch(firestore) {
     ensureFirestoreConfigured(firestore);
     return new WriteBatch(firestore, mutations => executeWrite(firestore, mutations));
 }
-/** An index component consisting of field path and index type.  */
-class Segment {
-    constructor(
-    /** The field path of the component. */
-    fieldPath, 
-    /** The fields sorting order. */
-    kind) {
-        this.fieldPath = fieldPath;
-        this.kind = kind;
-    }
-}
 
 /**
  * @license
@@ -26302,27 +26416,29 @@ function setIndexConfiguration(firestore, jsonOrConfiguration) {
     const indexConfiguration = typeof jsonOrConfiguration === 'string'
         ? tryParseJson(jsonOrConfiguration)
         : jsonOrConfiguration;
+    const parsedIndexes = [];
     // PORTING NOTE: We don't return an error if the user has not enabled
     // persistence since `enableIndexeddbPersistence()` can fail on the Web.
     if (Array.isArray(indexConfiguration.indexes)) {
         for (const index of indexConfiguration.indexes) {
-            tryGetString(index, 'collectionGroup');
+            const collectionGroup = tryGetString(index, 'collectionGroup');
             const segments = [];
             if (Array.isArray(index.fields)) {
                 for (const field of index.fields) {
                     const fieldPathString = tryGetString(field, 'fieldPath');
                     const fieldPath = fieldPathFromDotSeparatedString('setIndexConfiguration', fieldPathString);
                     if (field.arrayConfig === 'CONTAINS') {
-                        segments.push(new Segment(fieldPath, 2 /* CONTAINS */));
+                        segments.push(new IndexSegment(fieldPath, 2 /* CONTAINS */));
                     }
                     else if (field.order === 'ASCENDING') {
-                        segments.push(new Segment(fieldPath, 0 /* ASCENDING */));
+                        segments.push(new IndexSegment(fieldPath, 0 /* ASCENDING */));
                     }
                     else if (field.order === 'DESCENDING') {
-                        segments.push(new Segment(fieldPath, 1 /* DESCENDING */));
+                        segments.push(new IndexSegment(fieldPath, 1 /* DESCENDING */));
                     }
                 }
             }
+            parsedIndexes.push(new FieldIndex(FieldIndex.UNKNOWN_ID, collectionGroup, segments, IndexState.empty()));
         }
     }
     // TODO(indexing): Configure indexes