@firebase/firestore 3.4.4-canary.f5ac47fb1 → 3.4.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @firebase/firestore
 
+## 3.4.5
+
+### Patch Changes
+
+- [`bb8f37c3e`](https://github.com/firebase/firebase-js-sdk/commit/bb8f37c3e83e73876d14fa751cb04ae5e1367394) [#5993](https://github.com/firebase/firebase-js-sdk/pull/5993) - Fixed a bug that caused Firestore streams to get restarted with the same App Check token.
+
+* [`f5ac47fb1`](https://github.com/firebase/firebase-js-sdk/commit/f5ac47fb1a44f7b985fcae1d934e1ffb6ba41d67) [#5982](https://github.com/firebase/firebase-js-sdk/pull/5982) - On browsers that support IndexedDB V3, we now invoke `transaction.commit()` to speed up data processing.
+
+- [`c1b9cf120`](https://github.com/firebase/firebase-js-sdk/commit/c1b9cf1201807fc177a89c9613c06130524563e4) [#5985](https://github.com/firebase/firebase-js-sdk/pull/5985) - Some database operations now use `IndexedDB.getAll()` on browsers where support is availbe.
+
+* [`e9619685b`](https://github.com/firebase/firebase-js-sdk/commit/e9619685b9153f7d6f8767e09e2e1eacc337df76) [#5980](https://github.com/firebase/firebase-js-sdk/pull/5980) - Queries are now send to the backend before the SDK starts local processing, which reduces overall Query latency.
+
 ## 3.4.4
 
 ### Patch Changes

package/dist/firestore/src/api/credentials.d.ts

@@ -176,6 +176,7 @@ export declare class FirebaseAppCheckTokenProvider implements CredentialsProvide
     private tokenListener;
     private forceRefresh;
     private appCheck;
+    private latestAppCheckToken;
     constructor(appCheckProvider: Provider<AppCheckInternalComponentName>);
     start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<string>): void;
     getToken(): Promise<Token | null>;

package/dist/firestore/src/index/index_byte_encoder.d.ts

@@ -1,3 +1,20 @@
+/**
+ * @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.
+ */
+import { IndexKind } from '../model/field_index';
 import { DirectionalIndexByteEncoder } from './directional_index_byte_encoder';
 /**
  * Implements `DirectionalIndexByteEncoder` using `OrderedCodeWriter` for the
@@ -8,7 +25,7 @@ export declare class IndexByteEncoder {
     private ascending;
     private descending;
     seed(encodedBytes: Uint8Array): void;
-    forKind(kind: 'asc' | 'desc'): DirectionalIndexByteEncoder;
+    forKind(kind: IndexKind): DirectionalIndexByteEncoder;
     encodedBytes(): Uint8Array;
     reset(): void;
 }

package/dist/firestore/src/index/index_entry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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.
+ */
+import { DocumentKey } from '../model/document_key';
+/** Represents an index entry saved by the SDK in persisted storage. */
+export declare class IndexEntry {
+    readonly indexId: number;
+    readonly documentKey: DocumentKey;
+    readonly arrayValue: Uint8Array;
+    readonly directionalValue: Uint8Array;
+    constructor(indexId: number, documentKey: DocumentKey, arrayValue: Uint8Array, directionalValue: Uint8Array);
+}
+export declare function indexEntryComparator(left: IndexEntry, right: IndexEntry): number;

package/dist/firestore/src/local/document_overlay_cache.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @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.
+ */
+import { DocumentKeySet } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
+import { Mutation } from '../model/mutation';
+import { Overlay } from '../model/overlay';
+import { ResourcePath } from '../model/path';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * Provides methods to read and write document overlays.
+ *
+ * An overlay is a saved mutation, that gives a local view of a document when
+ * applied to the remote version of the document.
+ *
+ * Each overlay stores the largest batch ID that is included in the overlay,
+ * which allows us to remove the overlay once all batches leading up to it have
+ * been acknowledged.
+ */
+export interface DocumentOverlayCache {
+    /**
+     * Gets the saved overlay mutation for the given document key.
+     * Returns null if there is no overlay for that key.
+     */
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    /**
+     * Saves the given document mutation map to persistence as overlays.
+     * All overlays will have their largest batch id set to `largestBatchId`.
+     */
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    /** Removes overlays for the given document keys and batch ID. */
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    /**
+     * Returns all saved overlays for the given collection.
+     *
+     * @param transaction - The persistence transaction to use for this operation.
+     * @param collection - The collection path to get the overlays for.
+     * @param sinceBatchId - The minimum batch ID to filter by (exclusive).
+     * Only overlays that contain a change past `sinceBatchId` are returned.
+     * @returns Mapping of each document key in the collection to its overlay.
+     */
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    /**
+     * Returns `count` overlays with a batch ID higher than `sinceBatchId` for the
+     * provided collection group, processed by ascending batch ID. The method
+     * always returns all overlays for a batch even if the last batch contains
+     * more documents than the remaining limit.
+     *
+     * @param transaction - The persistence transaction used for this operation.
+     * @param collectionGroup - The collection group to get the overlays for.
+     * @param sinceBatchId - The minimum batch ID to filter by (exclusive).
+     * Only overlays that contain a change past `sinceBatchId` are returned.
+     * @param count - The number of overlays to return. Can be exceeded if the last
+     * batch contains more entries.
+     * @return Mapping of each document key in the collection group to its overlay.
+     */
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+}

package/dist/firestore/src/local/indexeddb_document_overlay_cache.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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.
+ */
+import { User } from '../auth/user';
+import { DocumentKeySet } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
+import { Mutation } from '../model/mutation';
+import { Overlay } from '../model/overlay';
+import { ResourcePath } from '../model/path';
+import { DocumentOverlayCache } from './document_overlay_cache';
+import { LocalSerializer } from './local_serializer';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * Implementation of DocumentOverlayCache using IndexedDb.
+ */
+export declare class IndexedDbDocumentOverlayCache implements DocumentOverlayCache {
+    private readonly serializer;
+    private readonly userId;
+    /**
+     * @param serializer - The document serializer.
+     * @param userId - The userId for which we are accessing overlays.
+     */
+    constructor(serializer: LocalSerializer, userId: string);
+    static forUser(serializer: LocalSerializer, user: User): IndexedDbDocumentOverlayCache;
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    private saveOverlay;
+}

package/dist/firestore/src/local/indexeddb_index_manager.d.ts

@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { User } from '../auth/user';
 import { Target } from '../core/target';
 import { DocumentKeySet, DocumentMap } from '../model/collections';
 import { FieldIndex, IndexOffset } from '../model/field_index';
@@ -23,16 +24,22 @@ import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 /**
  * A persisted implementation of IndexManager.
+ *
+ * PORTING NOTE: Unlike iOS and Android, the Web SDK does not memoize index
+ * data as it supports multi-tab access.
  */
 export declare class IndexedDbIndexManager implements IndexManager {
+    private user;
     /**
      * 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.
      *
-     * This is *NOT* a complete cache of what's in persistence and so can never be used to
-     * satisfy reads.
+     * This is *NOT* a complete cache of what's in persistence and so can never be
+     * used to satisfy reads.
      */
     private collectionParentsCache;
+    private uid;
+    constructor(user: User);
     /**
      * Adds a new entry to the collection parent index.
      *
@@ -46,8 +53,28 @@ export declare class IndexedDbIndexManager implements IndexManager {
     deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
     getDocumentsMatchingTarget(transaction: PersistenceTransaction, fieldIndex: FieldIndex, target: Target): PersistencePromise<DocumentKeySet>;
     getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    /**
+     * Returns the byte encoded form of the directional values in the field index.
+     * Returns `null` if the document does not have all fields specified in the
+     * index.
+     */
+    private encodeDirectionalElements;
+    /** Encodes a single value to the ascending index format. */
+    private encodeSingleElement;
     getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
     getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
     updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
     updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
+    private addIndexEntry;
+    private deleteIndexEntry;
+    private getExistingIndexEntries;
+    /** Creates the index entries for the given document. */
+    private computeIndexEntries;
+    /**
+     * Updates the index entries for the provided document by deleting entries
+     * that are no longer referenced in `newEntries` and adding all newly added
+     * entries.
+     */
+    private updateEntries;
+    private getNextSequenceNumber;
 }

package/dist/firestore/src/local/indexeddb_persistence.d.ts

@@ -21,6 +21,7 @@ import { JsonProtoSerializer } from '../remote/serializer';
 import { AsyncQueue } from '../util/async_queue';
 import { DocumentLike, WindowLike } from '../util/types';
 import { BundleCache } from './bundle_cache';
+import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
 import { IndexedDbLruDelegateImpl } from './indexeddb_lru_delegate_impl';
 import { IndexedDbMutationQueue } from './indexeddb_mutation_queue';
@@ -99,6 +100,7 @@ export declare class IndexedDbPersistence implements Persistence {
      * no longer be able to access IndexedDB.
      */
     private readonly forceOwningTab;
+    private readonly schemaVersion;
     private simpleDb;
     private listenSequence;
     private _started;
@@ -118,7 +120,6 @@ export declare class IndexedDbPersistence implements Persistence {
     /** A listener to notify on primary state changes. */
     private primaryStateListener;
     private readonly targetCache;
-    private readonly indexManager;
     private readonly remoteDocumentCache;
     private readonly bundleCache;
     private readonly webStorage;
@@ -133,7 +134,7 @@ export declare class IndexedDbPersistence implements Persistence {
      * If set to true, forcefully obtains database access. Existing tabs will
      * no longer be able to access IndexedDB.
      */
-    forceOwningTab: boolean);
+    forceOwningTab: boolean, schemaVersion?: number);
     /**
      * Attempt to start IndexedDb persistence.
      *
@@ -207,10 +208,11 @@ export declare class IndexedDbPersistence implements Persistence {
      */
     getActiveClients(): Promise<ClientId[]>;
     get started(): boolean;
-    getMutationQueue(user: User): IndexedDbMutationQueue;
+    getMutationQueue(user: User, indexManager: IndexManager): IndexedDbMutationQueue;
     getTargetCache(): IndexedDbTargetCache;
     getRemoteDocumentCache(): IndexedDbRemoteDocumentCache;
-    getIndexManager(): IndexManager;
+    getIndexManager(user: User): IndexManager;
+    getDocumentOverlayCache(user: User): DocumentOverlayCache;
     getBundleCache(): BundleCache;
     runTransaction<T>(action: string, mode: PersistenceTransactionMode, transactionOperation: (transaction: PersistenceTransaction) => PersistencePromise<T>): Promise<T>;
     /**

package/dist/firestore/src/local/indexeddb_remote_document_cache.d.ts

@@ -17,7 +17,6 @@
 import { SnapshotVersion } from '../core/snapshot_version';
 import { MutableDocumentMap } from '../model/collections';
 import { MutableDocument } from '../model/document';
-import { IndexManager } from './index_manager';
 import { LocalSerializer } from './local_serializer';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
@@ -28,13 +27,8 @@ export interface DocumentSizeEntry {
 }
 export interface IndexedDbRemoteDocumentCache extends RemoteDocumentCache {
 }
-/**
- * Creates a new IndexedDbRemoteDocumentCache.
- *
- * @param serializer - The document serializer.
- * @param indexManager - The query indexes that need to be maintained.
- */
-export declare function newIndexedDbRemoteDocumentCache(serializer: LocalSerializer, indexManager: IndexManager): IndexedDbRemoteDocumentCache;
+/** Creates a new IndexedDbRemoteDocumentCache. */
+export declare function newIndexedDbRemoteDocumentCache(serializer: LocalSerializer): IndexedDbRemoteDocumentCache;
 /**
  * Returns the set of documents that have changed since the specified read
  * time.

package/dist/firestore/src/local/indexeddb_schema.d.ts

@@ -20,7 +20,7 @@ import { ResourcePath } from '../model/path';
 import { BundledQuery } from '../protos/firestore_bundle_proto';
 import { Document as ProtoDocument, DocumentsTarget as ProtoDocumentsTarget, QueryTarget as ProtoQueryTarget, Write as ProtoWrite } from '../protos/firestore_proto_api';
 import { EncodedResourcePath } from './encoded_resource_path';
-export declare const INDEXING_SCHEMA_VERSION = 12;
+export declare const INDEXING_SCHEMA_VERSION = 13;
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -39,7 +39,8 @@ export declare const INDEXING_SCHEMA_VERSION = 12;
  *     an auto-incrementing ID. This is required for Index-Free queries.
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
- * 12. Add indexing support.
+ * 12. Add document overlays.
+ * 13. Add indexing support.
  */
 export declare const SCHEMA_VERSION: number;
 /**
@@ -809,22 +810,38 @@ export declare class DbNamedQuery {
 export declare type DbIndexConfigurationKey = number;
 /** An object representing the global configuration for a field index. */
 export declare class DbIndexConfiguration {
-    /** The index id for this entry. */
-    indexId: number;
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    indexId: number | undefined;
     /** The collection group this index belongs to. */
     collectionGroup: string;
     /** The fields to index for this index. */
-    fields: [[name: string, kind: IndexKind]];
+    fields: Array<[name: string, kind: IndexKind]>;
     /** Name of the IndexedDb object store. */
     static store: string;
     static keyPath: string;
+    /**
+     * An index that provides access to the index configurations by collection
+     * group.
+     *
+     * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+     * not possible here as the Web client supports concurrent access to
+     * persistence via multi-tab.
+     */
+    static collectionGroupIndex: string;
+    static collectionGroupIndexPath: string;
     constructor(
-    /** The index id for this entry. */
-    indexId: number, 
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    indexId: number | undefined, 
     /** The collection group this index belongs to. */
     collectionGroup: string, 
     /** The fields to index for this index. */
-    fields: [[name: string, kind: IndexKind]]);
+    fields: Array<[name: string, kind: IndexKind]>);
 }
 /** The key for each index state consisting of the index id and its user id. */
 export declare type DbIndexStateKey = [number, string];
@@ -860,6 +877,16 @@ export declare class DbIndexState {
     /** Name of the IndexedDb object store. */
     static store: string;
     static keyPath: string[];
+    /**
+     * An index that provides access to documents in a collection sorted by last
+     * update time. Used by the backfiller.
+     *
+     * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+     * not possible here as the Web client supports concurrent access to
+     * persistence via multi-tab.
+     */
+    static sequenceNumberIndex: string;
+    static sequenceNumberIndexPath: string[];
     constructor(
     /** The index id for this entry. */
     indexId: number, 
@@ -893,7 +920,7 @@ export declare class DbIndexState {
  */
 export declare type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
 /** An object that stores the encoded entries for all documents and fields. */
-export declare class DbIndexEntries {
+export declare class DbIndexEntry {
     /** The index id for this entry. */
     indexId: number;
     /** The user id for this entry. */
@@ -907,6 +934,8 @@ export declare class DbIndexEntries {
     /** Name of the IndexedDb object store. */
     static store: string;
     static keyPath: string[];
+    static documentKeyIndex: string;
+    static documentKeyIndexPath: string[];
     constructor(
     /** The index id for this entry. */
     indexId: number, 
@@ -919,6 +948,48 @@ export declare class DbIndexEntries {
     /** The document key this entry points to. */
     documentKey: EncodedResourcePath);
 }
+export declare type DbDocumentOverlayKey = [
+    string,
+    string,
+    string
+];
+/**
+ * An object representing a document overlay.
+ */
+export declare class DbDocumentOverlay {
+    /** The user ID to whom this overlay belongs. */
+    userId: string;
+    /** The path to the collection that contains the document. */
+    collectionPath: string;
+    /** The ID (key) of the document within the collection. */
+    documentId: string;
+    /** The collection group to which the document belongs. */
+    collectionGroup: string;
+    /** The largest batch ID that's been applied for this overlay. */
+    largestBatchId: number;
+    /** The overlay mutation. */
+    overlayMutation: ProtoWrite;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string[];
+    static collectionPathOverlayIndex: string;
+    static collectionPathOverlayIndexPath: string[];
+    static collectionGroupOverlayIndex: string;
+    static collectionGroupOverlayIndexPath: string[];
+    constructor(
+    /** The user ID to whom this overlay belongs. */
+    userId: string, 
+    /** The path to the collection that contains the document. */
+    collectionPath: string, 
+    /** The ID (key) of the document within the collection. */
+    documentId: string, 
+    /** The collection group to which the document belongs. */
+    collectionGroup: string, 
+    /** The largest batch ID that's been applied for this overlay. */
+    largestBatchId: number, 
+    /** The overlay mutation. */
+    overlayMutation: ProtoWrite);
+}
 export declare const V1_STORES: string[];
 export declare const V3_STORES: string[];
 export declare const V4_STORES: string[];
@@ -926,9 +997,12 @@ export declare const V6_STORES: string[];
 export declare const V8_STORES: string[];
 export declare const V11_STORES: string[];
 export declare const V12_STORES: string[];
+export declare const V13_STORES: string[];
 /**
  * The list of all default IndexedDB stores used throughout the SDK. This is
  * used when creating transactions so that access across all stores is done
  * atomically.
  */
 export declare const ALL_STORES: string[];
+/** Returns the object stores for the provided schema. */
+export declare function getObjectStores(schemaVersion: number): string[];

package/dist/firestore/src/local/local_documents_view.d.ts

@@ -69,5 +69,4 @@ export declare class LocalDocumentsView {
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;
-    private addMissingBaseDocuments;
 }

package/dist/firestore/src/local/local_serializer.d.ts

@@ -14,14 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { User } from '../auth/user';
 import { BundleMetadata, NamedQuery } from '../core/bundle';
 import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
 import { MutableDocument } from '../model/document';
+import { DocumentKey } from '../model/document_key';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { MutationBatch } from '../model/mutation_batch';
-import { BundleMetadata as ProtoBundleMetadata, NamedQuery as ProtoNamedQuery, BundledQuery as ProtoBundledQuery } from '../protos/firestore_bundle_proto';
+import { Overlay } from '../model/overlay';
+import { BundledQuery as ProtoBundledQuery, BundleMetadata as ProtoBundleMetadata, NamedQuery as ProtoNamedQuery } from '../protos/firestore_bundle_proto';
 import { JsonProtoSerializer } from '../remote/serializer';
-import { DbBundle, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestampKey } from './indexeddb_schema';
+import { DbBundle, DbDocumentOverlay, DbDocumentOverlayKey, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestampKey } from './indexeddb_schema';
 import { TargetData } from './target_data';
 /** Serializer for values stored in the LocalStore. */
 export declare class LocalSerializer {
@@ -61,3 +65,15 @@ export declare function fromBundledQuery(bundledQuery: ProtoBundledQuery): Query
 export declare function fromProtoNamedQuery(namedQuery: ProtoNamedQuery): NamedQuery;
 /** Decodes a BundleMetadata proto into a BundleMetadata object. */
 export declare function fromBundleMetadata(metadata: ProtoBundleMetadata): BundleMetadata;
+/** Encodes a DbDocumentOverlay object to an Overlay model object. */
+export declare function fromDbDocumentOverlay(localSerializer: LocalSerializer, dbDocumentOverlay: DbDocumentOverlay): Overlay;
+/** Decodes an Overlay model object into a DbDocumentOverlay object. */
+export declare function toDbDocumentOverlay(localSerializer: LocalSerializer, userId: string, overlay: Overlay): DbDocumentOverlay;
+/**
+ * Returns the DbDocumentOverlayKey corresponding to the given user and
+ * document key.
+ */
+export declare function toDbDocumentOverlayKey(userId: string, docKey: DocumentKey): DbDocumentOverlayKey;
+export declare function toDbIndexConfiguration(index: FieldIndex): DbIndexConfiguration;
+export declare function fromDbIndexConfiguration(index: DbIndexConfiguration, state: DbIndexState | null): FieldIndex;
+export declare function toDbIndexState(indexId: number, user: User, sequenceNumber: number, offset: IndexOffset): DbIndexState;

package/dist/firestore/src/local/memory_document_overlay_cache.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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.
+ */
+import { DocumentKeySet } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
+import { Mutation } from '../model/mutation';
+import { Overlay } from '../model/overlay';
+import { ResourcePath } from '../model/path';
+import { DocumentOverlayCache } from './document_overlay_cache';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * An in-memory implementation of DocumentOverlayCache.
+ */
+export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache {
+    private overlays;
+    private overlayByBatchId;
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    private saveOverlay;
+}

package/dist/firestore/src/local/memory_persistence.d.ts

@@ -19,6 +19,8 @@ import { ListenSequenceNumber, TargetId } from '../core/types';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { JsonProtoSerializer } from '../remote/serializer';
+import { DocumentOverlayCache } from './document_overlay_cache';
+import { IndexManager } from './index_manager';
 import { ActiveTargets, LruDelegate, LruGarbageCollector, LruParams } from './lru_garbage_collector';
 import { MemoryBundleCache } from './memory_bundle_cache';
 import { MemoryIndexManager } from './memory_index_manager';
@@ -43,6 +45,7 @@ export declare class MemoryPersistence implements Persistence {
      */
     private readonly indexManager;
     private mutationQueues;
+    private overlays;
     private readonly remoteDocumentCache;
     private readonly targetCache;
     private readonly bundleCache;
@@ -62,8 +65,9 @@ export declare class MemoryPersistence implements Persistence {
     get started(): boolean;
     setDatabaseDeletedListener(): void;
     setNetworkEnabled(): void;
-    getIndexManager(): MemoryIndexManager;
-    getMutationQueue(user: User): MutationQueue;
+    getIndexManager(user: User): MemoryIndexManager;
+    getDocumentOverlayCache(user: User): DocumentOverlayCache;
+    getMutationQueue(user: User, indexManager: IndexManager): MutationQueue;
     getTargetCache(): MemoryTargetCache;
     getRemoteDocumentCache(): MemoryRemoteDocumentCache;
     getBundleCache(): MemoryBundleCache;

package/dist/firestore/src/local/memory_remote_document_cache.d.ts

@@ -16,7 +16,6 @@
  */
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
-import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -27,9 +26,8 @@ export interface MemoryRemoteDocumentCache extends RemoteDocumentCache {
 /**
  * Creates a new memory-only RemoteDocumentCache.
  *
- * @param indexManager - A class that manages collection group indices.
  * @param sizer - Used to assess the size of a document. For eager GC, this is
  * expected to just return 0 to avoid unnecessarily doing the work of
  * calculating the size.
  */
-export declare function newMemoryRemoteDocumentCache(indexManager: IndexManager, sizer: DocumentSizer): MemoryRemoteDocumentCache;
+export declare function newMemoryRemoteDocumentCache(sizer: DocumentSizer): MemoryRemoteDocumentCache;