@firebase/firestore 3.4.9-canary.d38eced3b → 3.4.9-canary.dbf623ffe

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

@@ -36,6 +36,11 @@ export interface DocumentOverlayCache {
      * Returns null if there is no overlay for that key.
      */
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    /**
+     * 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>;
     /**
      * Saves the given document mutation map to persistence as overlays.
      * All overlays will have their largest batch id set to `largestBatchId`.

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

@@ -36,6 +36,7 @@ export declare class IndexedDbDocumentOverlayCache implements DocumentOverlayCac
     constructor(serializer: LocalSerializer, userId: string);
     static forUser(serializer: LocalSerializer, user: User): IndexedDbDocumentOverlayCache;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
     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>;

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

@@ -21,7 +21,7 @@ import { Document as ProtoDocument, DocumentsTarget as ProtoDocumentsTarget, Que
 import { EncodedResourcePath } from './encoded_resource_path';
 import { DbTimestampKey } from './indexeddb_sentinels';
 export declare const INDEXING_ENABLED = false;
-export declare const INDEXING_SCHEMA_VERSION = 14;
+export declare const INDEXING_SCHEMA_VERSION = 15;
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -43,7 +43,8 @@ export declare const INDEXING_SCHEMA_VERSION = 14;
  * 12. Add document overlays.
  * 13. Rewrite the keys of the remote document cache to allow for efficient
  *     document lookup via `getAll()`.
- * 14. Add indexing support.
+ * 14. Add overlays.
+ * 15. Add indexing support.
  */
 export declare const SCHEMA_VERSION: number;
 /**

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

@@ -39,4 +39,5 @@ export declare class SchemaConverter implements SimpleDbSchemaConverter {
     private createCollectionParentIndex;
     private rewriteCanonicalIds;
     private rewriteRemoteDocumentCache;
+    private runOverlayMigration;
 }

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

@@ -240,6 +240,7 @@ export declare const V11_STORES: string[];
 export declare const V12_STORES: string[];
 export declare const V13_STORES: string[];
 export declare const V14_STORES: string[];
+export declare const V15_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

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

@@ -15,12 +15,15 @@
  * limitations under the License.
  */
 import { Query } from '../core/query';
-import { DocumentKeySet, DocumentMap, MutableDocumentMap } from '../model/collections';
+import { DocumentKeySet, OverlayMap, DocumentMap, MutableDocumentMap, DocumentKeyMap } from '../model/collections';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { IndexOffset } from '../model/field_index';
+import { FieldMask } from '../model/field_mask';
+import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
 import { MutationQueue } from './mutation_queue';
+import { OverlayedDocument } from './overlayed_document';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -33,8 +36,9 @@ import { RemoteDocumentCache } from './remote_document_cache';
 export declare class LocalDocumentsView {
     readonly remoteDocumentCache: RemoteDocumentCache;
     readonly mutationQueue: MutationQueue;
-    private readonly indexManager;
-    constructor(remoteDocumentCache: RemoteDocumentCache, mutationQueue: MutationQueue, indexManager: IndexManager);
+    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`.
      *
@@ -42,9 +46,6 @@ export declare class LocalDocumentsView {
      * state for it.
      */
     getDocument(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Document>;
-    /** Internal version of `getDocument` that allows reusing batches. */
-    private getDocumentInternal;
-    private applyLocalMutationsToDocuments;
     /**
      * Gets the local view of the documents identified by `keys`.
      *
@@ -53,10 +54,46 @@ export declare class LocalDocumentsView {
      */
     getDocuments(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<DocumentMap>;
     /**
-     * Applies the local view the given `baseDocs` without retrieving documents
-     * from the local store.
+     * 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<DocumentKeyMap<OverlayedDocument>>;
+    /**
+     * 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<DocumentKeyMap<OverlayedDocument>>;
+    private recalculateAndSaveOverlays;
+    /**
+     * Recalculates overlays by reading the documents from remote document cache
+     * first, and saves them after they are calculated.
      */
-    applyLocalViewToDocuments(transaction: PersistenceTransaction, baseDocs: MutableDocumentMap): PersistencePromise<void>;
+    recalculateAndSaveOverlaysForDocumentKeys(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<DocumentKeyMap<FieldMask | null>>;
     /**
      * Performs a query against the local view of all documents.
      *
@@ -68,4 +105,6 @@ export declare class LocalDocumentsView {
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;
+    /** Returns a base document that can be used to apply `overlay`. */
+    private getBaseDocument;
 }

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

@@ -28,6 +28,7 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
     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>;

package/dist/firestore/src/local/overlayed_document.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 { Document } from '../model/document';
+import { FieldMask } from '../model/field_mask';
+/**
+ * Represents a local view (overlay) of a document, and the fields that are
+ * locally mutated.
+ */
+export declare class OverlayedDocument {
+    readonly overlayedDocument: Document;
+    /**
+     * The fields that are locally mutated by patch mutations. If the overlayed
+     * document is from set or delete mutations, this returns null.
+     */
+    readonly mutatedFields: FieldMask | null;
+    constructor(overlayedDocument: Document, 
+    /**
+     * The fields that are locally mutated by patch mutations. If the overlayed
+     * document is from set or delete mutations, this returns null.
+     */
+    mutatedFields: FieldMask | null);
+}

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

@@ -36,6 +36,8 @@ 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 DocumentKeyMap<T> = ObjectMap<DocumentKey, T>;
+export declare function newDocumentKeyMap<T>(): DocumentKeyMap<T>;
 export declare type DocumentVersionMap = SortedMap<DocumentKey, SnapshotVersion>;
 export declare function documentVersionMap(): DocumentVersionMap;
 export declare type DocumentKeySet = SortedSet<DocumentKey>;

package/dist/firestore/src/model/field_mask.d.ts

@@ -28,6 +28,12 @@ import { FieldPath } from './path';
 export declare class FieldMask {
     readonly fields: FieldPath[];
     constructor(fields: FieldPath[]);
+    static empty(): FieldMask;
+    /**
+     * Returns a new FieldMask object that is the result of adding all the given
+     * fields paths to this field mask.
+     */
+    unionWith(extraFields: FieldPath[]): FieldMask;
     /**
      * Verifies that `fieldPath` is included by at least one field in this field
      * mask.

package/dist/firestore/src/model/mutation.d.ts

@@ -149,7 +149,19 @@ export declare abstract class Mutation {
     abstract readonly key: DocumentKey;
     abstract readonly precondition: Precondition;
     abstract readonly fieldTransforms: FieldTransform[];
+    /**
+     * Returns a `FieldMask` representing the fields that will be changed by
+     * applying this mutation. Returns `null` if the mutation will overwrite the
+     * entire document.
+     */
+    abstract getFieldMask(): FieldMask | null;
 }
+/**
+ * A utility method to calculate a `Mutation` representing the overlay from the
+ * final state of the document, and a `FieldMask` representing the fields that
+ * are mutated by the local mutations.
+ */
+export declare function calculateOverlayMutation(doc: MutableDocument, mask: FieldMask | null): Mutation | null;
 /**
  * Applies this mutation to the given document for the purposes of computing a
  * new remote document. If the input document doesn't match the expected state
@@ -172,10 +184,12 @@ export declare function mutationApplyToRemoteDocument(mutation: Mutation, docume
  * @param document - The document to mutate. The input document can be an
  *     invalid document if the client has no knowledge of the pre-mutation state
  *     of the document.
+ * @param previousMask - The fields that have been updated before applying this mutation.
  * @param localWriteTime - A timestamp indicating the local write time of the
  *     batch this mutation is a part of.
+ * @returns A `FieldMask` representing the fields that are changed by applying this mutation.
  */
-export declare function mutationApplyToLocalView(mutation: Mutation, document: MutableDocument, localWriteTime: Timestamp): void;
+export declare function mutationApplyToLocalView(mutation: Mutation, document: MutableDocument, previousMask: FieldMask | null, localWriteTime: Timestamp): FieldMask | null;
 /**
  * If this mutation is not idempotent, returns the base value to persist with
  * this mutation. If a base value is returned, the mutation is always applied
@@ -205,6 +219,7 @@ export declare class SetMutation extends Mutation {
     readonly fieldTransforms: FieldTransform[];
     constructor(key: DocumentKey, value: ObjectValue, precondition: Precondition, fieldTransforms?: FieldTransform[]);
     readonly type: MutationType;
+    getFieldMask(): FieldMask | null;
 }
 /**
  * A mutation that modifies fields of the document at the given key with the
@@ -227,6 +242,7 @@ export declare class PatchMutation extends Mutation {
     readonly fieldTransforms: FieldTransform[];
     constructor(key: DocumentKey, data: ObjectValue, fieldMask: FieldMask, precondition: Precondition, fieldTransforms?: FieldTransform[]);
     readonly type: MutationType;
+    getFieldMask(): FieldMask | null;
 }
 /** A mutation that deletes the document at the given key. */
 export declare class DeleteMutation extends Mutation {
@@ -235,6 +251,7 @@ export declare class DeleteMutation extends Mutation {
     constructor(key: DocumentKey, precondition: Precondition);
     readonly type: MutationType;
     readonly fieldTransforms: FieldTransform[];
+    getFieldMask(): FieldMask | null;
 }
 /**
  * A mutation that verifies the existence of the document at the given key with
@@ -249,4 +266,5 @@ export declare class VerifyMutation extends Mutation {
     constructor(key: DocumentKey, precondition: Precondition);
     readonly type: MutationType;
     readonly fieldTransforms: FieldTransform[];
+    getFieldMask(): FieldMask | null;
 }

package/dist/firestore/src/model/mutation_batch.d.ts

@@ -17,8 +17,10 @@
 import { SnapshotVersion } from '../core/snapshot_version';
 import { BatchId } from '../core/types';
 import { Timestamp } from '../lite-api/timestamp';
-import { DocumentKeySet, DocumentMap, DocumentVersionMap } from './collections';
+import { OverlayedDocument } from '../local/overlayed_document';
+import { DocumentKeySet, MutationMap, DocumentVersionMap, DocumentKeyMap } from './collections';
 import { MutableDocument } from './document';
+import { FieldMask } from './field_mask';
 import { Mutation, MutationResult } from './mutation';
 /**
  * A batch of mutations that will be sent as one unit to the backend.
@@ -54,13 +56,16 @@ export declare class MutationBatch {
      * batch.
      *
      * @param document - The document to apply mutations to.
+     * @param mutatedFields - Fields that have been updated before applying this mutation batch.
+     * @returns A `FieldMask` representing all the fields that are mutated.
      */
-    applyToLocalView(document: MutableDocument): void;
+    applyToLocalView(document: MutableDocument, mutatedFields: FieldMask | null): FieldMask | null;
     /**
      * Computes the local view for all provided documents given the mutations in
-     * this batch.
+     * this batch. Returns a `DocumentKey` to `Mutation` map which can be used to
+     * replace all the mutation applications.
      */
-    applyToLocalDocumentSet(documentMap: DocumentMap): void;
+    applyToLocalDocumentSet(documentMap: DocumentKeyMap<OverlayedDocument>, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }

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

@@ -31,6 +31,7 @@ export declare class TestDocumentOverlayCache {
     constructor(persistence: Persistence, cache: DocumentOverlayCache);
     saveOverlays(largestBatch: number, data: MutationMap): Promise<void>;
     getOverlay(key: DocumentKey): Promise<Overlay | null>;
+    getOverlays(keys: DocumentKeySet): Promise<OverlayMap>;
     getOverlayMutation(docKey: string): Promise<Mutation | null>;
     getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
     getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;

package/dist/firestore/test/util/helpers.d.ts

@@ -69,6 +69,7 @@ export declare function blob(...bytes: number[]): Bytes;
 export declare function filter(path: string, op: string, value: unknown): FieldFilter;
 export declare function setMutation(keyStr: string, json: JsonObject<unknown>): SetMutation;
 export declare function patchMutation(keyStr: string, json: JsonObject<unknown>, precondition?: Precondition): PatchMutation;
+export declare function mergeMutation(keyStr: string, json: JsonObject<unknown>, updateMask: FieldPath[]): PatchMutation;
 export declare function deleteMutation(keyStr: string): DeleteMutation;
 export declare function mutationResult(testVersion: TestSnapshotVersion): MutationResult;
 export declare function bound(values: unknown[], inclusive: boolean): Bound;
@@ -177,3 +178,14 @@ export declare function expectSetToEqual<T>(set: SortedSet<T>, arr: T[]): void;
 export declare function expectEqualitySets<T>(elems: T[][], equalityFn: (v1: T, v2: T) => boolean, stringifyFn?: (v: T) => string): void;
 export declare function validateFirestoreError(expectedCode: Code, actualError: Error): void;
 export declare function forEachNumber<V>(obj: Dict<V>, fn: (key: number, val: V) => void): void;
+/**
+ * Returns all possible permutations of the given array.
+ * For `[a, b]`, this method returns `[[a, b], [b, a]]`.
+ */
+export declare function computePermutations<T>(input: T[]): T[][];
+/**
+ * Returns all possible combinations of the given array, including an empty
+ * array. For `[a, b, c]` this method returns
+ * `[[], [a], [a, b], [a, c], [b, c], [a, b, c]`.
+ */
+export declare function computeCombinations<T>(input: T[]): T[][];