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

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

@@ -0,0 +1,71 @@
+/**
+ * @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 { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * Provides methods to read and write document overlays.
+ *
+ * An overlay is a saved mutation, that gives a local view of a document when
+ * applied to the remote version of the document.
+ *
+ * Each overlay stores the largest batch ID that is included in the overlay,
+ * which allows us to remove the overlay once all batches leading up to it have
+ * been acknowledged.
+ */
+export interface DocumentOverlayCache {
+    /**
+     * Gets the saved overlay mutation for the given document key.
+     * Returns null if there is no overlay for that key.
+     */
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    /**
+     * Saves the given document mutation map to persistence as overlays.
+     * All overlays will have their largest batch id set to `largestBatchId`.
+     */
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: MutationMap): 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<OverlayMap>;
+    /**
+     * 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<OverlayMap>;
+}

package/dist/lite/firestore/src/local/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 { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
@@ -40,4 +43,53 @@ export interface IndexManager {
      * path for a root-level collection).
      */
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
+    /**
+     * Adds a field path index.
+     *
+     * Values for this index are persisted via the index backfill, which runs
+     * asynchronously in the background. Once the first values are written,
+     * an index can be used to serve partial results for any matching queries.
+     * Any unindexed portion of the database will continue to be served via
+     * collection scons.
+     */
+    addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    /** Removes the given field index and deletes all index values. */
+    deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    /**
+     * Returns a list of field indexes that correspond to the specified collection
+     * group.
+     *
+     * @param collectionGroup The collection group to get matching field indexes
+     * for.
+     * @return A collection of field indexes for the specified collection group.
+     */
+    getFieldIndexes(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<FieldIndex[]>;
+    /** Returns all configured field indexes. */
+    getFieldIndexes(transaction: PersistenceTransaction): PersistencePromise<FieldIndex[]>;
+    /**
+     * Returns an index that can be used to serve the provided target. Returns
+     * `null` if no index is configured.
+     */
+    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    /**
+     * Returns the documents that match the given target based on the provided
+     * index or `null` if the target does not have a matching index.
+     */
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKeySet | null>;
+    /**
+     * Returns the next collection group to update. Returns `null` if no group
+     * exists.
+     */
+    getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
+    /**
+     * Sets the collection group's latest read time.
+     *
+     * This method updates the index offset for all field indices for the
+     * collection group and increments their sequence number. Subsequent calls to
+     * `getNextCollectionGroupToUpdate()` will return a different collection group
+     * (unless only one collection group is configured).
+     */
+    updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
+    /** Updates the index entries for the provided documents. */
+    updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }

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

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { User } from '../auth/user';
+import { DocumentKeySet, 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 { LocalSerializer } from './local_serializer';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * Implementation of DocumentOverlayCache using IndexedDb.
+ */
+export declare class IndexedDbDocumentOverlayCache implements DocumentOverlayCache {
+    private readonly serializer;
+    private readonly userId;
+    /**
+     * @param serializer - The document serializer.
+     * @param userId - The userId for which we are accessing overlays.
+     */
+    constructor(serializer: LocalSerializer, userId: string);
+    static forUser(serializer: LocalSerializer, user: User): IndexedDbDocumentOverlayCache;
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: 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/lite/firestore/src/local/indexeddb_index_manager.d.ts

@@ -14,22 +14,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { User } from '../auth/user';
+import { Target } from '../core/target';
+import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 /**
  * A persisted implementation of IndexManager.
+ *
+ * PORTING NOTE: Unlike iOS and Android, the Web SDK does not memoize index
+ * data as it supports multi-tab access.
  */
 export declare class IndexedDbIndexManager implements IndexManager {
+    private user;
     /**
      * An in-memory copy of the index entries we've already written since the SDK
      * launched. Used to avoid re-writing the same entry repeatedly.
      *
-     * This is *NOT* a complete cache of what's in persistence and so can never be used to
-     * satisfy reads.
+     * This is *NOT* a complete cache of what's in persistence and so can never be
+     * used to satisfy reads.
      */
     private collectionParentsCache;
+    private uid;
+    /**
+     * Maps from a target to its equivalent list of sub-targets. Each sub-target
+     * contains only one term from the target's disjunctive normal form (DNF).
+     */
+    private targetToDnfSubTargets;
+    constructor(user: User);
     /**
      * Adds a new entry to the collection parent index.
      *
@@ -39,4 +54,74 @@ export declare class IndexedDbIndexManager implements IndexManager {
      */
     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>;
+    private getSubTargets;
+    /**
+     * Constructs a key range query on `DbIndexEntryStore` that unions all
+     * bounds.
+     */
+    private generateIndexRanges;
+    /** Generates the lower bound for `arrayValue` and `directionalValue`. */
+    private generateLowerBound;
+    /** Generates the upper bound for `arrayValue` and `directionalValue`. */
+    private generateUpperBound;
+    /**
+     * Generates an empty bound that scopes the index scan to the current index
+     * and user.
+     */
+    private generateEmptyBound;
+    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    /**
+     * Returns the byte encoded form of the directional values in the field index.
+     * Returns `null` if the document does not have all fields specified in the
+     * index.
+     */
+    private encodeDirectionalElements;
+    /** Encodes a single value to the ascending index format. */
+    private encodeSingleElement;
+    /**
+     * Encodes the given field values according to the specification in `target`.
+     * For IN queries, a list of possible values is returned.
+     */
+    private encodeValues;
+    /**
+     * Encodes the given bounds according to the specification in `target`. For IN
+     * queries, a list of possible values is returned.
+     */
+    private encodeBound;
+    /** Returns the byte representation for the provided encoders. */
+    private getEncodedBytes;
+    /**
+     * Creates a separate encoder for each element of an array.
+     *
+     * The method appends each value to all existing encoders (e.g. filter("a",
+     * "==", "a1").filter("b", "in", ["b1", "b2"]) becomes ["a1,b1", "a1,b2"]). A
+     * list of new encoders is returned.
+     */
+    private expandIndexValues;
+    private isInFilter;
+    getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
+    getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
+    updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
+    updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
+    private addIndexEntry;
+    private deleteIndexEntry;
+    private getExistingIndexEntries;
+    /** Creates the index entries for the given document. */
+    private computeIndexEntries;
+    /**
+     * Updates the index entries for the provided document by deleting entries
+     * that are no longer referenced in `newEntries` and adding all newly added
+     * entries.
+     */
+    private updateEntries;
+    private getNextSequenceNumber;
+    /**
+     * Returns a new set of IDB ranges that splits the existing range and excludes
+     * any values that match the `notInValue` from these ranges. As an example,
+     * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
+     */
+    private createRange;
 }

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

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

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

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