@firebase/firestore 3.4.9-canary.f84cacd70 → 3.4.10

package/dist/private.d.ts

@@ -872,7 +872,7 @@ declare interface DocumentOverlayCache {
      * Gets the saved overlay mutation for the given document keys. Skips keys for
      * which there are no overlays.
      */
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    getOverlays(transaction: PersistenceTransaction, keys: _DocumentKey[]): PersistencePromise<OverlayMap>;
     /**
      * Saves the given document mutation map to persistence as overlays.
      * All overlays will have their largest batch id set to `largestBatchId`.
@@ -2085,16 +2085,6 @@ declare interface FirstPartyCredentialsSettings {
  */
 declare type FulfilledHandler<T, R> = ((result: T) => R | PersistencePromise<R>) | null;
 
-/**
- * Interface implemented by the LRU scheduler to start(), stop() and restart
- * garbage collection.
- */
-declare interface GarbageCollectionScheduler {
-    readonly started: boolean;
-    start(localStore: LocalStore): void;
-    stop(): void;
-}
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -2346,6 +2336,8 @@ declare interface IndexManager {
      * and returns the minimum offset of them all.
      */
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
+    /** Returns the minimum offset for the given collection group. */
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
 }
 
 /**
@@ -2616,8 +2608,119 @@ export declare interface LoadBundleTaskProgress {
     taskState: TaskState;
 }
 
+/**
+ * A readonly view of the local state of all documents we're tracking (i.e. we
+ * have a cached version in remoteDocumentCache or local mutations for the
+ * document). The view is computed by applying the mutations in the
+ * MutationQueue to the RemoteDocumentCache.
+ */
+declare class LocalDocumentsView {
+    readonly remoteDocumentCache: RemoteDocumentCache;
+    readonly mutationQueue: MutationQueue;
+    readonly documentOverlayCache: DocumentOverlayCache;
+    readonly indexManager: IndexManager;
+    constructor(remoteDocumentCache: RemoteDocumentCache, mutationQueue: MutationQueue, documentOverlayCache: DocumentOverlayCache, indexManager: IndexManager);
+    /**
+     * Get the local view of the document identified by `key`.
+     *
+     * @returns Local view of the document or null if we don't have any cached
+     * state for it.
+     */
+    getDocument(transaction: PersistenceTransaction, key: _DocumentKey): PersistencePromise<Document_2>;
+    /**
+     * Gets the local view of the documents identified by `keys`.
+     *
+     * If we don't have cached state for a document in `keys`, a NoDocument will
+     * be stored for that key in the resulting set.
+     */
+    getDocuments(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<DocumentMap>;
+    /**
+     * Similar to `getDocuments`, but creates the local view from the given
+     * `baseDocs` without retrieving documents from the local store.
+     *
+     * @param transaction - The transaction this operation is scoped to.
+     * @param docs - The documents to apply local mutations to get the local views.
+     * @param existenceStateChanged - The set of document keys whose existence state
+     *   is changed. This is useful to determine if some documents overlay needs
+     *   to be recalculated.
+     */
+    getLocalViewOfDocuments(transaction: PersistenceTransaction, docs: MutableDocumentMap, existenceStateChanged?: DocumentKeySet): PersistencePromise<DocumentMap>;
+    /**
+     * Gets the overlayed documents for the given document map, which will include
+     * the local view of those documents and a `FieldMask` indicating which fields
+     * are mutated locally, `null` if overlay is a Set or Delete mutation.
+     */
+    getOverlayedDocuments(transaction: PersistenceTransaction, docs: MutableDocumentMap): PersistencePromise<OverlayedDocumentMap>;
+    /**
+     * Fetches the overlays for {@code docs} and adds them to provided overlay map
+     * if the map does not already contain an entry for the given document key.
+     */
+    private populateOverlays;
+    /**
+     * Computes the local view for the given documents.
+     *
+     * @param docs - The documents to compute views for. It also has the base
+     *   version of the documents.
+     * @param overlays - The overlays that need to be applied to the given base
+     *   version of the documents.
+     * @param existenceStateChanged - A set of documents whose existence states
+     *   might have changed. This is used to determine if we need to re-calculate
+     *   overlays from mutation queues.
+     * @return A map represents the local documents view.
+     */
+    computeViews(transaction: PersistenceTransaction, docs: MutableDocumentMap, overlays: OverlayMap, existenceStateChanged: DocumentKeySet): PersistencePromise<OverlayedDocumentMap>;
+    private recalculateAndSaveOverlays;
+    /**
+     * Recalculates overlays by reading the documents from remote document cache
+     * first, and saves them after they are calculated.
+     */
+    recalculateAndSaveOverlaysForDocumentKeys(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<DocumentKeyMap<FieldMask | null>>;
+    /**
+     * Performs a query against the local view of all documents.
+     *
+     * @param transaction - The persistence transaction.
+     * @param query - The query to match documents against.
+     * @param offset - Read time and key to start scanning by (exclusive).
+     */
+    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query_2, offset: IndexOffset): PersistencePromise<DocumentMap>;
+    /**
+     * Given a collection group, returns the next documents that follow the provided offset, along
+     * with an updated batch ID.
+     *
+     * <p>The documents returned by this method are ordered by remote version from the provided
+     * offset. If there are no more remote documents after the provided offset, documents with
+     * mutations in order of batch id from the offset are returned. Since all documents in a batch are
+     * returned together, the total number of documents returned can exceed {@code count}.
+     *
+     * @param transaction
+     * @param collectionGroup The collection group for the documents.
+     * @param offset The offset to index into.
+     * @param count The number of documents to return
+     * @return A LocalWriteResult with the documents that follow the provided offset and the last processed batch id.
+     */
+    getNextDocuments(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset, count: number): PersistencePromise<LocalWriteResult>;
+    private getDocumentsMatchingDocumentQuery;
+    private getDocumentsMatchingCollectionGroupQuery;
+    private getDocumentsMatchingCollectionQuery;
+    /** Returns a base document that can be used to apply `overlay`. */
+    private getBaseDocument;
+}
+
 declare interface LocalStore {
     collectGarbage(garbageCollector: LruGarbageCollector): Promise<LruResults>;
+    /** Manages the list of active field and collection indices. */
+    indexManager: IndexManager;
+    /**
+     * The "local" view of all documents (layering mutationQueue on top of
+     * remoteDocumentCache).
+     */
+    localDocuments: LocalDocumentsView;
+}
+
+/** The result of a write to the local store. */
+declare interface LocalWriteResult {
+    batchId: BatchId;
+    changes: DocumentMap;
 }
 export { LogLevel }
 
@@ -2840,7 +2943,7 @@ declare class MutationBatch {
      * this batch. Returns a `DocumentKey` to `Mutation` map which can be used to
      * replace all the mutation applications.
      */
-    applyToLocalDocumentSet(documentMap: DocumentKeyMap<OverlayedDocument>, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
+    applyToLocalDocumentSet(documentMap: OverlayedDocumentMap, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }
@@ -2864,7 +2967,7 @@ declare class MutationBatchResult {
     static from(batch: MutationBatch, commitVersion: SnapshotVersion, results: MutationResult[]): MutationBatchResult;
 }
 
-declare type MutationMap = ObjectMap<_DocumentKey, Mutation>;
+declare type MutationMap = DocumentKeyMap<Mutation>;
 
 /** A queue of mutations to apply to the remote store. */
 declare interface MutationQueue {
@@ -3170,7 +3273,8 @@ declare interface OfflineComponentProvider {
     persistence: Persistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     initialize(cfg: ComponentConfiguration): Promise<void>;
     terminate(): Promise<void>;
@@ -3492,7 +3596,9 @@ declare class OverlayedDocument {
     mutatedFields: FieldMask | null);
 }
 
-declare type OverlayMap = ObjectMap<_DocumentKey, Overlay>;
+declare type OverlayedDocumentMap = DocumentKeyMap<OverlayedDocument>;
+
+declare type OverlayMap = DocumentKeyMap<Overlay>;
 
 declare interface ParseContext {
     readonly databaseId: _DatabaseId;
@@ -3711,6 +3817,17 @@ declare class PersistencePromise<T> {
     static forEach<R>(collection: {
         forEach: (cb: (r: R) => void) => void;
     }, f: (r: R) => PersistencePromise<void>): PersistencePromise<void>;
+    /**
+     * Concurrently map all array elements through asynchronous function.
+     */
+    static mapArray<T, U>(array: T[], f: (t: T) => PersistencePromise<U>): PersistencePromise<U[]>;
+    /**
+     * An alternative to recursive PersistencePromise calls, that avoids
+     * potential memory problems from unbounded chains of promises.
+     *
+     * The `action` will be called repeatedly while `condition` is true.
+     */
+    static doWhile(condition: () => boolean, action: () => PersistencePromise<void>): PersistencePromise<void>;
 }
 
 /**
@@ -4327,6 +4444,15 @@ declare type Resolver<T> = (value?: T) => void;
  */
 export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
 
+/**
+ * Interface to schedule periodic tasks within SDK.
+ */
+declare interface Scheduler {
+    readonly started: boolean;
+    start(): void;
+    stop(): void;
+}
+
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
  * include a server-generated timestamp in the written data.
@@ -5116,7 +5242,11 @@ declare const enum TimerId {
      * A timer used to retry operations scheduled via retryable AsyncQueue
      * operations.
      */
-    AsyncQueueRetry = "async_queue_retry"
+    AsyncQueueRetry = "async_queue_retry",
+    /**
+     *  A timer used to periodically attempt index backfill.
+     */
+    IndexBackfill = "index_backfill"
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firebase/firestore",
-  "version": "3.4.9-canary.f84cacd70",
+  "version": "3.4.10",
   "engines": {
     "node": ">=10.10.0"
   },
@@ -79,22 +79,22 @@
     "lite/package.json"
   ],
   "dependencies": {
-    "@firebase/component": "0.5.14-canary.f84cacd70",
-    "@firebase/logger": "0.3.2-canary.f84cacd70",
-    "@firebase/util": "1.6.0-canary.f84cacd70",
-    "@firebase/webchannel-wrapper": "0.6.1-canary.f84cacd70",
+    "@firebase/component": "0.5.15",
+    "@firebase/logger": "0.3.3",
+    "@firebase/util": "1.6.1",
+    "@firebase/webchannel-wrapper": "0.6.2",
     "@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.25-canary.f84cacd70"
+    "@firebase/app": "0.x"
   },
   "devDependencies": {
-    "@firebase/app": "0.7.25-canary.f84cacd70",
-    "@firebase/app-compat": "0.1.26-canary.f84cacd70",
-    "@firebase/auth": "0.20.2-canary.f84cacd70",
+    "@firebase/app": "0.7.26",
+    "@firebase/app-compat": "0.1.27",
+    "@firebase/auth": "0.20.3",
     "@rollup/plugin-alias": "3.1.9",
     "@rollup/plugin-json": "4.1.0",
     "@types/eslint": "7.29.0",