@firebase/firestore 3.4.4 → 3.4.5-canary.09e62431f

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

@@ -0,0 +1,238 @@
+/**
+ * @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 { BatchId, TargetId } from '../core/types';
+import { ResourcePath } from '../model/path';
+import { EncodedResourcePath } from './encoded_resource_path';
+import { DbDocumentMutation } from './indexeddb_schema';
+/** A timestamp type that can be used in IndexedDb keys. */
+export declare type DbTimestampKey = [/* seconds */ number, /* nanos */ number];
+export declare type DbPrimaryClientKey = typeof DbPrimaryClientKey;
+/**
+ * Name of the IndexedDb object store.
+ *
+ * Note that the name 'owner' is chosen to ensure backwards compatibility with
+ * older clients that only supported single locked access to the persistence
+ * layer.
+ */
+export declare const DbPrimaryClientStore = "owner";
+/**
+ * The key string used for the single object that exists in the
+ * DbPrimaryClient store.
+ */
+export declare const DbPrimaryClientKey = "owner";
+/** Object keys in the 'mutationQueues' store are userId strings. */
+export declare type DbMutationQueueKey = string;
+/** Name of the IndexedDb object store.  */
+export declare const DbMutationQueueStore = "mutationQueues";
+/** Keys are automatically assigned via the userId property. */
+export declare const DbMutationQueueKeyPath = "userId";
+/** The 'mutations' store  is keyed by batch ID. */
+export declare type DbMutationBatchKey = BatchId;
+/** Name of the IndexedDb object store.  */
+export declare const DbMutationBatchStore = "mutations";
+/** Keys are automatically assigned via the userId, batchId properties. */
+export declare const DbMutationBatchKeyPath = "batchId";
+/** The index name for lookup of mutations by user. */
+export declare const DbMutationBatchUserMutationsIndex = "userMutationsIndex";
+/** The user mutations index is keyed by [userId, batchId] pairs. */
+export declare const DbMutationBatchUserMutationsKeyPath: string[];
+/**
+ * The key for a db document mutation, which is made up of a userID, path, and
+ * batchId. Note that the path must be serialized into a form that indexedDB can
+ * sort.
+ */
+export declare type DbDocumentMutationKey = [string, EncodedResourcePath, BatchId];
+/**
+ * Creates a [userId] key for use in the DbDocumentMutations index to iterate
+ * over all of a user's document mutations.
+ */
+export declare function newDbDocumentMutationPrefixForUser(userId: string): [string];
+/**
+ * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
+ * index to iterate over all at document mutations for a given path or lower.
+ */
+export declare function newDbDocumentMutationPrefixForPath(userId: string, path: ResourcePath): [string, EncodedResourcePath];
+/**
+ * Creates a full index key of [userId, encodedPath, batchId] for inserting
+ * and deleting into the DbDocumentMutations index.
+ */
+export declare function newDbDocumentMutationKey(userId: string, path: ResourcePath, batchId: BatchId): DbDocumentMutationKey;
+/**
+ * Because we store all the useful information for this store in the key,
+ * there is no useful information to store as the value. The raw (unencoded)
+ * path cannot be stored because IndexedDb doesn't store prototype
+ * information.
+ */
+export declare const DbDocumentMutationPlaceholder: DbDocumentMutation;
+export declare const DbDocumentMutationStore = "documentMutations";
+export declare const DbRemoteDocumentStore = "remoteDocuments";
+/**
+ * An index that provides access to all entries sorted by read time (which
+ * corresponds to the last modification time of each row).
+ *
+ * This index is used to provide a changelog for Multi-Tab.
+ */
+export declare const DbRemoteDocumentReadTimeIndex = "readTimeIndex";
+export declare const DbRemoteDocumentReadTimeIndexPath = "readTime";
+/**
+ * An index that provides access to documents in a collection sorted by read
+ * time.
+ *
+ * This index is used to allow the RemoteDocumentCache to fetch newly changed
+ * documents in a collection.
+ */
+export declare const DbRemoteDocumentCollectionReadTimeIndex = "collectionReadTimeIndex";
+export declare const DbRemoteDocumentCollectionReadTimeIndexPath: string[];
+export declare const DbRemoteDocumentGlobalStore = "remoteDocumentGlobal";
+export declare const DbRemoteDocumentGlobalKey = "remoteDocumentGlobalKey";
+export declare type DbRemoteDocumentGlobalKey = typeof DbRemoteDocumentGlobalKey;
+/**
+ * A key in the 'targets' object store is a targetId of the query.
+ */
+export declare type DbTargetKey = TargetId;
+export declare const DbTargetStore = "targets";
+/** Keys are automatically assigned via the targetId property. */
+export declare const DbTargetKeyPath = "targetId";
+/** The name of the queryTargets index. */
+export declare const DbTargetQueryTargetsIndexName = "queryTargetsIndex";
+/**
+ * The index of all canonicalIds to the targets that they match. This is not
+ * a unique mapping because canonicalId does not promise a unique name for all
+ * possible queries, so we append the targetId to make the mapping unique.
+ */
+export declare const DbTargetQueryTargetsKeyPath: string[];
+/**
+ * The key for a DbTargetDocument, containing a targetId and an encoded resource
+ * path.
+ */
+export declare type DbTargetDocumentKey = [TargetId, EncodedResourcePath];
+/** Name of the IndexedDb object store.  */
+export declare const DbTargetDocumentStore = "targetDocuments";
+/** Keys are automatically assigned via the targetId, path properties. */
+export declare const DbTargetDocumentKeyPath: string[];
+/** The index name for the reverse index. */
+export declare const DbTargetDocumentDocumentTargetsIndex = "documentTargetsIndex";
+/** We also need to create the reverse index for these properties. */
+export declare const DbTargetDocumentDocumentTargetsKeyPath: string[];
+/**
+ * The type to represent the single allowed key for the DbTargetGlobal store.
+ */
+export declare type DbTargetGlobalKey = typeof DbTargetGlobalKey;
+/**
+ * The key string used for the single object that exists in the
+ * DbTargetGlobal store.
+ */
+export declare const DbTargetGlobalKey = "targetGlobalKey";
+export declare const DbTargetGlobalStore = "targetGlobal";
+/**
+ * The key for a DbCollectionParent entry, containing the collection ID
+ * and the parent path that contains it. Note that the parent path will be an
+ * empty path in the case of root-level collections.
+ */
+export declare type DbCollectionParentKey = [string, EncodedResourcePath];
+/** Name of the IndexedDb object store. */
+export declare const DbCollectionParentStore = "collectionParents";
+/** Keys are automatically assigned via the collectionId, parent properties. */
+export declare const DbCollectionParentKeyPath: string[];
+/** Name of the IndexedDb object store. */
+export declare const DbClientMetadataStore = "clientMetadata";
+/** Keys are automatically assigned via the clientId properties. */
+export declare const DbClientMetadataKeyPath = "clientId";
+/** Object keys in the 'clientMetadata' store are clientId strings. */
+export declare type DbClientMetadataKey = string;
+export declare type DbBundlesKey = string;
+/** Name of the IndexedDb object store. */
+export declare const DbBundleStore = "bundles";
+export declare const DbBundleKeyPath = "bundleId";
+export declare type DbNamedQueriesKey = string;
+/** Name of the IndexedDb object store. */
+export declare const DbNamedQueryStore = "namedQueries";
+export declare const DbNamedQueryKeyPath = "name";
+/** The key for each index consisting of just the index id. */
+export declare type DbIndexConfigurationKey = number;
+/** Name of the IndexedDb object store. */
+export declare const DbIndexConfigurationStore = "indexConfiguration";
+export declare const DbIndexConfigurationKeyPath = "indexId";
+/**
+ * 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.
+ */
+export declare const DbIndexConfigurationCollectionGroupIndex = "collectionGroupIndex";
+export declare const DbIndexConfigurationCollectionGroupIndexPath = "collectionGroup";
+/** The key for each index state consisting of the index id and its user id. */
+export declare type DbIndexStateKey = [number, string];
+/** Name of the IndexedDb object store. */
+export declare const DbIndexStateStore = "indexState";
+export declare const DbIndexStateKeyPath: 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.
+ */
+export declare const DbIndexStateSequenceNumberIndex = "sequenceNumberIndex";
+export declare const DbIndexStateSequenceNumberIndexPath: string[];
+/**
+ * The key for each index entry consists of the index id and its user id,
+ * the encoded array and directional value for the indexed fields as well as
+ * the encoded document path for the indexed document.
+ */
+export declare type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
+/** Name of the IndexedDb object store. */
+export declare const DbIndexEntryStore = "indexEntries";
+export declare const DbIndexEntryKeyPath: string[];
+export declare const DbIndexEntryDocumentKeyIndex = "documentKeyIndex";
+export declare const DbIndexEntryDocumentKeyIndexPath: string[];
+export declare type DbDocumentOverlayKey = [
+    string,
+    string,
+    string
+];
+/** Name of the IndexedDb object store. */
+export declare const DbDocumentOverlayStore = "documentOverlays";
+export declare const DbDocumentOverlayKeyPath: string[];
+export declare const DbDocumentOverlayCollectionPathOverlayIndex = "collectionPathOverlayIndex";
+export declare const DbDocumentOverlayCollectionPathOverlayIndexPath: string[];
+export declare const DbDocumentOverlayCollectionGroupOverlayIndex = "collectionGroupOverlayIndex";
+export declare const DbDocumentOverlayCollectionGroupOverlayIndexPath: string[];
+export declare const V1_STORES: string[];
+export declare const V3_STORES: string[];
+export declare const V4_STORES: string[];
+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[];
+/**
+ * A key in the 'remoteDocuments' object store is a string array containing the
+ * segments that make up the path.
+ */
+export declare type DbRemoteDocumentKey = string[];

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

@@ -20,7 +20,8 @@ import { ListenSequenceNumber, TargetId } from '../core/types';
 import { DocumentKeySet } from '../model/collections';
 import { DocumentKey } from '../model/document_key';
 import { IndexedDbLruDelegate } from './indexeddb_lru_delegate';
-import { DbTargetDocument, DbTargetDocumentKey } from './indexeddb_schema';
+import { DbTargetDocument } from './indexeddb_schema';
+import { DbTargetDocumentKey } from './indexeddb_sentinels';
 import { LocalSerializer } from './local_serializer';
 import { ActiveTargets } from './lru_garbage_collector';
 import { PersistencePromise } from './persistence_promise';

package/dist/packages/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/packages/firestore/src/local/local_serializer.d.ts

@@ -14,14 +14,19 @@
  * 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, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget } from './indexeddb_schema';
+import { DbDocumentOverlayKey, DbTimestampKey } from './indexeddb_sentinels';
 import { TargetData } from './target_data';
 /** Serializer for values stored in the LocalStore. */
 export declare class LocalSerializer {
@@ -31,7 +36,7 @@ export declare class LocalSerializer {
 /** Decodes a remote document from storage locally to a Document. */
 export declare function fromDbRemoteDocument(localSerializer: LocalSerializer, remoteDoc: DbRemoteDocument): MutableDocument;
 /** Encodes a document for storage locally. */
-export declare function toDbRemoteDocument(localSerializer: LocalSerializer, document: MutableDocument, readTime: SnapshotVersion): DbRemoteDocument;
+export declare function toDbRemoteDocument(localSerializer: LocalSerializer, document: MutableDocument): DbRemoteDocument;
 export declare function toDbTimestampKey(snapshotVersion: SnapshotVersion): DbTimestampKey;
 export declare function fromDbTimestampKey(dbTimestampKey: DbTimestampKey): SnapshotVersion;
 /** Encodes a batch of mutations into a DbMutationBatch for local storage. */
@@ -61,3 +66,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/packages/firestore/src/local/memory_document_overlay_cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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, MutationMap, OverlayMap } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
+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: MutationMap): PersistencePromise<void>;
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<OverlayMap>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<OverlayMap>;
+    private saveOverlay;
+}

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

@@ -14,6 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Target } from '../core/target';
+import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
@@ -25,6 +28,14 @@ export declare class MemoryIndexManager implements IndexManager {
     private collectionParentIndex;
     addToCollectionParentIndex(transaction: PersistenceTransaction, collectionPath: ResourcePath): PersistencePromise<void>;
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
+    addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKeySet | null>;
+    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    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>;
 }
 /**
  * Internal implementation of the collection-parent index exposed by MemoryIndexManager.

package/dist/packages/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/packages/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;

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

@@ -18,6 +18,7 @@ import { User } from '../auth/user';
 import { TargetId } from '../core/types';
 import { DocumentKey } from '../model/document_key';
 import { BundleCache } from './bundle_cache';
+import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
 import { LocalStore } from './local_store';
 import { MutationQueue } from './mutation_queue';
@@ -140,7 +141,7 @@ export interface Persistence {
      * extent possible (e.g. in the case of uid switching from
      * sally=>jack=>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.
      *
@@ -173,7 +174,12 @@ export 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

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/local/remote_document_change_buffer.d.ts

@@ -21,13 +21,6 @@ import { DocumentKey } from '../model/document_key';
 import { ObjectMap } from '../util/obj_map';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
-/**
- * Represents a document change to be applied to remote document cache.
- */
-interface RemoteDocumentChange {
-    readonly document: MutableDocument;
-    readonly readTime: SnapshotVersion | null;
-}
 /**
  * An in-memory buffer of entries to be written to a RemoteDocumentCache.
  * It can be used to batch up a set of changes to be written to the cache, but
@@ -43,26 +36,25 @@ interface RemoteDocumentChange {
  * porting this class as part of that implementation work.
  */
 export declare abstract class RemoteDocumentChangeBuffer {
-    protected changes: ObjectMap<DocumentKey, RemoteDocumentChange>;
+    protected changes: ObjectMap<DocumentKey, MutableDocument>;
     private changesApplied;
     protected abstract getFromCache(transaction: PersistenceTransaction, documentKey: DocumentKey): PersistencePromise<MutableDocument>;
     protected abstract getAllFromCache(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<MutableDocumentMap>;
     protected abstract applyChanges(transaction: PersistenceTransaction): PersistencePromise<void>;
-    protected getReadTime(key: DocumentKey): SnapshotVersion;
     /**
      * Buffers a `RemoteDocumentCache.addEntry()` call.
      *
      * You can only modify documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    addEntry(document: MutableDocument, readTime: SnapshotVersion): void;
+    addEntry(document: MutableDocument): void;
     /**
      * Buffers a `RemoteDocumentCache.removeEntry()` call.
      *
      * You can only remove documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    removeEntry(key: DocumentKey, readTime?: SnapshotVersion | null): void;
+    removeEntry(key: DocumentKey, readTime: SnapshotVersion): void;
     /**
      * Looks up an entry in the cache. The buffered changes will first be checked,
      * and if no buffered change applies, this will forward to
@@ -94,4 +86,3 @@ export declare abstract class RemoteDocumentChangeBuffer {
     /** Helper to assert this.changes is not null  */
     protected assertNotApplied(): void;
 }
-export {};

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

@@ -36,6 +36,7 @@ export declare class SimpleDbTransaction {
     constructor(action: string, transaction: IDBTransaction);
     get completionPromise(): Promise<void>;
     abort(error?: Error): void;
+    maybeCommit(): void;
     /**
      * Returns a SimpleDbStore<KeyType, ValueType> for the specified store. All
      * operations performed on the SimpleDbStore happen within the context of this
@@ -181,9 +182,20 @@ export declare class SimpleDbStore<KeyType extends IDBValidKey, ValueType extend
      * Returns the number of rows in the store.
      */
     count(): PersistencePromise<number>;
+    /** Loads all elements from the object store. */
     loadAll(): PersistencePromise<ValueType[]>;
+    /** Loads all elements for the index range from the object store. */
     loadAll(range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /**
+     * Loads all elements from the object store that fall into the provided in the
+     * index range for the given index.
+     */
     loadAll(index: string, range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /**
+     * Loads the first `count` elements from the provided index range. Loads all
+     * elements if no limit is provided.
+     */
+    loadFirst(range: IDBKeyRange, count: number | null): PersistencePromise<ValueType[]>;
     deleteAll(): PersistencePromise<void>;
     deleteAll(range: IDBKeyRange): PersistencePromise<void>;
     deleteAll(index: string, range: IDBKeyRange): PersistencePromise<void>;

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

@@ -16,10 +16,13 @@
  */
 import { SnapshotVersion } from '../core/snapshot_version';
 import { TargetId } from '../core/types';
+import { ObjectMap } from '../util/obj_map';
 import { SortedMap } from '../util/sorted_map';
 import { SortedSet } from '../util/sorted_set';
 import { Document, MutableDocument } from './document';
 import { DocumentKey } from './document_key';
+import { Mutation } from './mutation';
+import { Overlay } from './overlay';
 /** Miscellaneous collection types / constants. */
 export declare type MutableDocumentMap = SortedMap<DocumentKey, MutableDocument>;
 export declare function mutableDocumentMap(): MutableDocumentMap;
@@ -29,6 +32,10 @@ export interface DocumentSizeEntries {
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
 export declare function documentMap(): DocumentMap;
+export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
+export declare function newOverlayMap(): OverlayMap;
+export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;
+export declare function newMutationMap(): MutationMap;
 export declare type DocumentVersionMap = SortedMap<DocumentKey, SnapshotVersion>;
 export declare function documentVersionMap(): DocumentVersionMap;
 export declare type DocumentKeySet = SortedSet<DocumentKey>;

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

@@ -30,6 +30,11 @@ export interface Document {
      * document was guaranteed to not exist.
      */
     readonly version: SnapshotVersion;
+    /**
+     * The timestamp at which this document was read from the remote server. Uses
+     * `SnapshotVersion.min()` for documents created by the user.
+     */
+    readonly readTime: SnapshotVersion;
     /** The underlying data of this document or an empty value if no data exists. */
     readonly data: ObjectValue;
     /** Returns whether local mutations were applied via the mutation queue. */
@@ -79,6 +84,7 @@ export declare class MutableDocument implements Document {
     readonly key: DocumentKey;
     private documentType;
     version: SnapshotVersion;
+    readTime: SnapshotVersion;
     data: ObjectValue;
     private documentState;
     private constructor();
@@ -118,6 +124,7 @@ export declare class MutableDocument implements Document {
     convertToUnknownDocument(version: SnapshotVersion): MutableDocument;
     setHasCommittedMutations(): MutableDocument;
     setHasLocalMutations(): MutableDocument;
+    setReadTime(readTime: SnapshotVersion): MutableDocument;
     get hasLocalMutations(): boolean;
     get hasCommittedMutations(): boolean;
     get hasPendingWrites(): boolean;

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

@@ -23,8 +23,14 @@ export declare class DocumentKey {
     constructor(path: ResourcePath);
     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;