@firebase/firestore 3.4.4-canary.f5ac47fb1 → 3.4.5

package/dist/packages/firestore/src/local/remote_document_cache.d.ts

@@ -14,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
 import { DocumentKeySet, MutableDocumentMap } from '../model/collections';
 import { MutableDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
+import { ResourcePath } from '../model/path';
+import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentChangeBuffer } from './remote_document_change_buffer';
@@ -30,6 +31,8 @@ import { RemoteDocumentChangeBuffer } from './remote_document_change_buffer';
  * documents that are known to not exist.
  */
 export interface RemoteDocumentCache {
+    /** Sets the index manager to use for managing the collectionGroup index. */
+    setIndexManager(indexManager: IndexManager): void;
     /**
      * Looks up an entry in the cache.
      *
@@ -47,19 +50,14 @@ export interface RemoteDocumentCache {
      */
     getEntries(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<MutableDocumentMap>;
     /**
-     * Executes a query against the cached Document entries.
+     * Returns the documents from the provided collection.
      *
-     * Implementations may return extra documents if convenient. The results
-     * should be re-filtered by the consumer before presenting them to the user.
-     *
-     * Cached NoDocument entries have no bearing on query results.
-     *
-     * @param query - The query to match documents against.
+     * @param collection - The collection to read.
      * @param sinceReadTime - If not set to SnapshotVersion.min(), return only
      *     documents that have been read since this snapshot version (exclusive).
      * @returns The set of matching documents.
      */
-    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
+    getAll(transaction: PersistenceTransaction, collection: ResourcePath, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
     /**
      * Provides access to add or update the contents of the cache. The buffer
      * handles proper size accounting for the change.

package/dist/packages/firestore/src/model/document_key.d.ts

@@ -24,8 +24,13 @@ export declare class DocumentKey {
     static fromPath(path: string): DocumentKey;
     static fromName(name: string): DocumentKey;
     static empty(): DocumentKey;
+    get collectionGroup(): string;
     /** Returns true if the document is in the specified collectionId. */
     hasCollectionId(collectionId: string): boolean;
+    /** Returns the collection group (i.e. the name of the parent collection) for this key. */
+    getCollectionGroup(): string;
+    /** Returns the fully qualified path to the parent collection. */
+    getCollectionPath(): ResourcePath;
     isEqual(other: DocumentKey | null): boolean;
     toString(): string;
     static comparator(k1: DocumentKey, k2: DocumentKey): number;

package/dist/packages/firestore/src/model/field_index.d.ts

@@ -43,7 +43,7 @@ export declare class FieldIndex {
     /** The collection ID this index applies to. */
     readonly collectionGroup: string;
     /** The field segments for this index. */
-    readonly segments: IndexSegment[];
+    readonly fields: IndexSegment[];
     /** Shows how up-to-date the index is for the current user. */
     readonly indexState: IndexState;
     /** An ID for an index that has not yet been added to persistence.  */
@@ -57,7 +57,7 @@ export declare class FieldIndex {
     /** The collection ID this index applies to. */
     collectionGroup: string, 
     /** The field segments for this index. */
-    segments: IndexSegment[], 
+    fields: IndexSegment[], 
     /** Shows how up-to-date the index is for the current user. */
     indexState: IndexState);
 }

package/dist/packages/firestore/src/model/overlay.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 './document_key';
+import { Mutation } from './mutation';
+/**
+ * Representation of an overlay computed by Firestore.
+ *
+ * Holds information about a mutation and the largest batch id in Firestore when
+ * the mutation was created.
+ */
+export declare class Overlay {
+    readonly largestBatchId: number;
+    readonly mutation: Mutation;
+    constructor(largestBatchId: number, mutation: Mutation);
+    getKey(): DocumentKey;
+    isEqual(other: Overlay | null): boolean;
+    toString(): string;
+}

package/dist/packages/firestore/src/model/target_index_matcher.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @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 { Target } from '../core/target';
+import { FieldIndex } from './field_index';
+/**
+ * A light query planner for Firestore.
+ *
+ * This class matches a `FieldIndex` against a Firestore Query `Target`. It
+ * determines whether a given index can be used to serve the specified target.
+ *
+ * The following table showcases some possible index configurations:
+ *
+ * Query                                               | Index
+ * -----------------------------------------------------------------------------
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC, b DESC
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC
+ * where('a', '==', 'a').where('b', '==', 'b')         | b DESC
+ * where('a', '>=', 'a').orderBy('a')                  | a ASC
+ * where('a', '>=', 'a').orderBy('a', 'desc')          | a DESC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC, b ASC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS, b ASCENDING
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS
+ */
+export declare class TargetIndexMatcher {
+    private readonly collectionId;
+    private readonly inequalityFilter?;
+    private readonly equalityFilters;
+    private readonly orderBys;
+    constructor(target: Target);
+    /**
+     * Returns whether the index can be used to serve the TargetIndexMatcher's
+     * target.
+     *
+     * An index is considered capable of serving the target when:
+     * - The target uses all index segments for its filters and orderBy clauses.
+     *   The target can have additional filter and orderBy clauses, but not
+     *   fewer.
+     * - If an ArrayContains/ArrayContainsAnyfilter is used, the index must also
+     *   have a corresponding `CONTAINS` segment.
+     * - All directional index segments can be mapped to the target as a series of
+     *   equality filters, a single inequality filter and a series of orderBy
+     *   clauses.
+     * - The segments that represent the equality filters may appear out of order.
+     * - The optional segment for the inequality filter must appear after all
+     *   equality segments.
+     * - The segments that represent that orderBy clause of the target must appear
+     *   in order after all equality and inequality segments. Single orderBy
+     *   clauses cannot be skipped, but a continuous orderBy suffix may be
+     *   omitted.
+     */
+    servedByIndex(index: FieldIndex): boolean;
+    private hasMatchingEqualityFilter;
+    private matchesFilter;
+    private matchesOrderBy;
+}

package/dist/packages/firestore/src/platform/node/grpc_connection.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { GrpcObject } from '@grpc/grpc-js';
+import * as grpc from '@grpc/grpc-js';
 import { Token } from '../../api/credentials';
 import { DatabaseInfo } from '../../core/database_info';
 import { Connection, Stream } from '../../remote/connection';
@@ -26,7 +26,7 @@ export declare class GrpcConnection implements Connection {
     private readonly databasePath;
     private readonly firestore;
     private cachedStub;
-    constructor(protos: GrpcObject, databaseInfo: DatabaseInfo);
+    constructor(protos: grpc.GrpcObject, databaseInfo: DatabaseInfo);
     private ensureActiveStub;
     invokeRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp>;
     invokeStreamingRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp[]>;

package/dist/packages/firestore/src/platform/node/load_protos.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { GrpcObject } from '@grpc/grpc-js';
+import * as grpc from '@grpc/grpc-js';
 import { IConversionOptions, Root } from 'protobufjs';
 /** Used by tests so we can match @grpc/proto-loader behavior. */
 export declare const protoLoaderOptions: IConversionOptions;
@@ -23,6 +23,6 @@ export declare const protoLoaderOptions: IConversionOptions;
  *
  * @returns The GrpcObject representing our protos.
  */
-export declare function loadProtos(): GrpcObject;
+export declare function loadProtos(): grpc.GrpcObject;
 /** Used by tests so we can directly create ProtobufJS proto message objects from JSON protos. */
 export declare function loadRawProtos(): Root;

package/dist/packages/firestore/src/util/sorted_set.d.ts

@@ -60,3 +60,21 @@ export declare class SortedSetIterator<T> {
     getNext(): T;
     hasNext(): boolean;
 }
+/**
+ * Compares two sorted sets for equality using their natural ordering. The
+ * method computes the intersection and invokes `onAdd` for every element that
+ * is in `after` but not `before`. `onRemove` is invoked for every element in
+ * `before` but missing from `after`.
+ *
+ * The method creates a copy of both `before` and `after` and runs in O(n log
+ * n), where n is the size of the two lists.
+ *
+ * @param before - The elements that exist in the original set.
+ * @param after - The elements to diff against the original set.
+ * @param comparator - The comparator for the elements in before and after.
+ * @param onAdd - A function to invoke for every element that is part of `
+ * after` but not `before`.
+ * @param onRemove - A function to invoke for every element that is part of
+ * `before` but not `after`.
+ */
+export declare function diffSortedSets<T>(before: SortedSet<T>, after: SortedSet<T>, comparator: (l: T, r: T) => number, onAdd: (entry: T) => void, onRemove: (entry: T) => void): void;

package/dist/packages/firestore/test/unit/local/counting_query_engine.d.ts

@@ -31,7 +31,7 @@ export declare class CountingQueryEngine extends QueryEngine {
      * `getAllMutationBatchesAffectingQuery()` API (since the last call to
      * `resetCounts()`)
      */
-    mutationsReadByQuery: number;
+    mutationsReadByCollection: number;
     /**
      * The number of mutations returned by the MutationQueue's
      * `getAllMutationBatchesAffectingDocumentKey()` and
@@ -41,9 +41,9 @@ export declare class CountingQueryEngine extends QueryEngine {
     mutationsReadByKey: number;
     /**
      * The number of documents returned by the RemoteDocumentCache's
-     * `getDocumentsMatchingQuery()` API (since the last call to `resetCounts()`)
+     * `getAll()` API (since the last call to `resetCounts()`)
      */
-    documentsReadByQuery: number;
+    documentsReadByCollection: number;
     /**
      * The number of documents returned by the RemoteDocumentCache's `getEntry()`
      * and `getEntries()` APIs (since the last call to `resetCounts()`)

package/dist/packages/firestore/test/unit/local/document_overlay_cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/firestore/test/unit/local/persistence_test_helpers.d.ts

@@ -54,6 +54,7 @@ export declare function testIndexedDbPersistence(options?: {
     dontPurgeData?: boolean;
     synchronizeTabs?: boolean;
     queue?: AsyncQueue;
+    schemaVersion?: number;
 }, lruParams?: LruParams): Promise<IndexedDbPersistence>;
 /** Creates and starts a MemoryPersistence instance for testing. */
 export declare function testMemoryEagerPersistence(): Promise<MemoryPersistence>;

package/dist/packages/firestore/test/unit/local/test_document_overlay_cache.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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 { DocumentOverlayCache } from '../../../src/local/document_overlay_cache';
+import { Persistence } from '../../../src/local/persistence';
+import { DocumentKeySet } from '../../../src/model/collections';
+import { DocumentKey } from '../../../src/model/document_key';
+import { Mutation } from '../../../src/model/mutation';
+import { Overlay } from '../../../src/model/overlay';
+import { ResourcePath } from '../../../src/model/path';
+/**
+ * A wrapper around a DocumentOverlayCache that automatically creates a
+ * transaction around every operation to reduce test boilerplate.
+ */
+export declare class TestDocumentOverlayCache {
+    private persistence;
+    private cache;
+    constructor(persistence: Persistence, cache: DocumentOverlayCache);
+    saveOverlays(largestBatch: number, data: Map<DocumentKey, Mutation>): Promise<void>;
+    getOverlay(key: DocumentKey): Promise<Overlay | null>;
+    getOverlayMutation(docKey: string): Promise<Mutation | null>;
+    getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<Map<DocumentKey, Overlay>>;
+    removeOverlaysForBatchId(documentKeys: DocumentKeySet, batchId: number): Promise<void>;
+}

package/dist/packages/firestore/test/unit/local/test_index_manager.d.ts

@@ -14,8 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Target } from '../../../src/core/target';
 import { IndexManager } from '../../../src/local/index_manager';
 import { Persistence } from '../../../src/local/persistence';
+import { DocumentKeySet, DocumentMap } from '../../../src/model/collections';
+import { FieldIndex, IndexOffset } from '../../../src/model/field_index';
 import { ResourcePath } from '../../../src/model/path';
 /**
  * A wrapper around IndexManager that automatically creates a
@@ -27,4 +30,12 @@ export declare class TestIndexManager {
     constructor(persistence: Persistence, indexManager: IndexManager);
     addToCollectionParentIndex(collectionPath: ResourcePath): Promise<void>;
     getCollectionParents(collectionId: string): Promise<ResourcePath[]>;
+    addFieldIndex(index: FieldIndex): Promise<void>;
+    deleteFieldIndex(index: FieldIndex): Promise<void>;
+    getFieldIndexes(collectionGroup?: string): Promise<FieldIndex[]>;
+    getFieldIndex(target: Target): Promise<FieldIndex | null>;
+    getDocumentsMatchingTarget(fieldIndex: FieldIndex, target: Target): Promise<DocumentKeySet>;
+    getNextCollectionGroupToUpdate(): Promise<string | null>;
+    updateCollectionGroup(collectionGroup: string, offset: IndexOffset): Promise<void>;
+    updateIndexEntries(documents: DocumentMap): Promise<void>;
 }

package/dist/packages/firestore/test/unit/local/test_remote_document_cache.d.ts

@@ -14,13 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Query } from '../../../src/core/query';
 import { SnapshotVersion } from '../../../src/core/snapshot_version';
+import { IndexManager } from '../../../src/local/index_manager';
 import { Persistence } from '../../../src/local/persistence';
 import { RemoteDocumentChangeBuffer } from '../../../src/local/remote_document_change_buffer';
 import { DocumentKeySet, MutableDocumentMap } from '../../../src/model/collections';
 import { MutableDocument } from '../../../src/model/document';
 import { DocumentKey } from '../../../src/model/document_key';
+import { ResourcePath } from '../../../src/model/path';
 /**
  * A wrapper around a RemoteDocumentCache that automatically creates a
  * transaction around every operation to reduce test boilerplate.
@@ -29,6 +30,7 @@ export declare class TestRemoteDocumentCache {
     private readonly persistence;
     private readonly cache;
     constructor(persistence: Persistence);
+    setIndexManager(indexManager: IndexManager): void;
     /**
      * Reads all of the documents first so we can safely add them and keep the size calculation in
      * sync.
@@ -42,7 +44,7 @@ export declare class TestRemoteDocumentCache {
     removeEntry(documentKey: DocumentKey, version?: SnapshotVersion): Promise<void>;
     getEntry(documentKey: DocumentKey): Promise<MutableDocument>;
     getEntries(documentKeys: DocumentKeySet): Promise<MutableDocumentMap>;
-    getDocumentsMatchingQuery(query: Query, sinceReadTime: SnapshotVersion): Promise<MutableDocumentMap>;
+    getAll(collection: ResourcePath, sinceReadTime: SnapshotVersion): Promise<MutableDocumentMap>;
     getNewDocumentChanges(sinceReadTime: SnapshotVersion): Promise<{
         changedDocs: MutableDocumentMap;
         readTime: SnapshotVersion;

package/dist/packages/firestore/test/unit/local/test_remote_document_change_buffer.d.ts

@@ -28,7 +28,7 @@ export declare class TestRemoteDocumentChangeBuffer {
     buffer: RemoteDocumentChangeBuffer;
     constructor(persistence: Persistence, buffer: RemoteDocumentChangeBuffer);
     addEntry(document: MutableDocument, readTime: SnapshotVersion): void;
-    removeEntry(key: DocumentKey): void;
+    removeEntry(key: DocumentKey, readTime: SnapshotVersion): void;
     getEntry(documentKey: DocumentKey): Promise<MutableDocument>;
     apply(): Promise<void>;
 }

package/dist/packages/firestore/test/unit/model/target_index_matcher.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export {};

package/dist/private.d.ts

@@ -850,6 +850,56 @@ declare type DocumentKeySet = SortedSet<_DocumentKey>;
 
 declare type DocumentMap = SortedMap<_DocumentKey, Document_2>;
 
+/**
+ * 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.
+ */
+declare 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>>;
+}
+
 /**
  * A `DocumentReference` refers to a document location in a Firestore database
  * and can be used to write, read, or listen to the location. The document at
@@ -1211,7 +1261,7 @@ declare class FieldIndex {
     /** The collection ID this index applies to. */
     readonly collectionGroup: string;
     /** The field segments for this index. */
-    readonly segments: IndexSegment[];
+    readonly fields: IndexSegment[];
     /** Shows how up-to-date the index is for the current user. */
     readonly indexState: IndexState_2;
     /** An ID for an index that has not yet been added to persistence.  */
@@ -1225,7 +1275,7 @@ declare class FieldIndex {
     /** The collection ID this index applies to. */
     collectionGroup: string, 
     /** The field segments for this index. */
-    segments: IndexSegment[], 
+    fields: IndexSegment[], 
     /** Shows how up-to-date the index is for the current user. */
     indexState: IndexState_2);
 }
@@ -3357,6 +3407,21 @@ export declare type OrderByDirection = 'desc' | 'asc';
 
 declare type OrderDirection = 'DIRECTION_UNSPECIFIED' | 'ASCENDING' | 'DESCENDING';
 
+/**
+ * Representation of an overlay computed by Firestore.
+ *
+ * Holds information about a mutation and the largest batch id in Firestore when
+ * the mutation was created.
+ */
+declare class Overlay {
+    readonly largestBatchId: number;
+    readonly mutation: Mutation;
+    constructor(largestBatchId: number, mutation: Mutation);
+    getKey(): _DocumentKey;
+    isEqual(other: Overlay | null): boolean;
+    toString(): string;
+}
+
 declare interface ParseContext {
     readonly databaseId: _DatabaseId;
     readonly ignoreUndefinedProperties: boolean;
@@ -3460,7 +3525,7 @@ declare interface Persistence {
      * extent possible (e.g. in the case of uid switching from
      * sally=&gt;jack=&gt;sally, sally's mutation queue will be preserved).
      */
-    getMutationQueue(user: User): MutationQueue;
+    getMutationQueue(user: User, indexManager: IndexManager): MutationQueue;
     /**
      * Returns a TargetCache representing the persisted cache of targets.
      *
@@ -3493,7 +3558,12 @@ declare interface Persistence {
      * this is called. In particular, the memory-backed implementation does this
      * to emulate the persisted implementation to the extent possible.
      */
-    getIndexManager(): IndexManager;
+    getIndexManager(user: User): IndexManager;
+    /**
+     * Returns a DocumentOverlayCache representing the documents that are mutated
+     * locally.
+     */
+    getDocumentOverlayCache(user: User): DocumentOverlayCache;
     /**
      * Performs an operation inside a persistence transaction. Any reads or writes
      * against persistence must be performed within a transaction. Writes will be
@@ -3904,6 +3974,8 @@ declare type Rejector = (error: Error) => void;
  * documents that are known to not exist.
  */
 declare interface RemoteDocumentCache {
+    /** Sets the index manager to use for managing the collectionGroup index. */
+    setIndexManager(indexManager: IndexManager): void;
     /**
      * Looks up an entry in the cache.
      *
@@ -3921,19 +3993,14 @@ declare interface RemoteDocumentCache {
      */
     getEntries(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<MutableDocumentMap>;
     /**
-     * Executes a query against the cached Document entries.
-     *
-     * Implementations may return extra documents if convenient. The results
-     * should be re-filtered by the consumer before presenting them to the user.
-     *
-     * Cached NoDocument entries have no bearing on query results.
+     * Returns the documents from the provided collection.
      *
-     * @param query - The query to match documents against.
+     * @param collection - The collection to read.
      * @param sinceReadTime - If not set to SnapshotVersion.min(), return only
      *     documents that have been read since this snapshot version (exclusive).
      * @returns The set of matching documents.
      */
-    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query_2, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
+    getAll(transaction: PersistenceTransaction, collection: _ResourcePath, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
     /**
      * Provides access to add or update the contents of the cache. The buffer
      * handles proper size accounting for the change.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firebase/firestore",
-  "version": "3.4.4-canary.f5ac47fb1",
+  "version": "3.4.5",
   "engines": {
     "node": ">=10.10.0"
   },
@@ -77,22 +77,22 @@
     "lite/package.json"
   ],
   "dependencies": {
-    "@firebase/component": "0.5.10-canary.f5ac47fb1",
-    "@firebase/logger": "0.3.2-canary.f5ac47fb1",
-    "@firebase/util": "1.4.3-canary.f5ac47fb1",
-    "@firebase/webchannel-wrapper": "0.6.1-canary.f5ac47fb1",
+    "@firebase/component": "0.5.10",
+    "@firebase/logger": "0.3.2",
+    "@firebase/util": "1.4.3",
+    "@firebase/webchannel-wrapper": "0.6.1",
     "@grpc/grpc-js": "^1.3.2",
     "@grpc/proto-loader": "^0.6.0",
     "node-fetch": "2.6.7",
     "tslib": "^2.1.0"
   },
   "peerDependencies": {
-    "@firebase/app": "0.7.16-canary.f5ac47fb1"
+    "@firebase/app": "0.x"
   },
   "devDependencies": {
-    "@firebase/app": "0.7.16-canary.f5ac47fb1",
-    "@firebase/app-compat": "0.1.17-canary.f5ac47fb1",
-    "@firebase/auth": "0.19.8-canary.f5ac47fb1",
+    "@firebase/app": "0.7.17",
+    "@firebase/app-compat": "0.1.18",
+    "@firebase/auth": "0.19.9",
     "@rollup/plugin-alias": "3.1.5",
     "@rollup/plugin-json": "4.1.0",
     "@types/eslint": "7.28.0",