@firebase/firestore 3.4.5 → 3.4.6-2022216223411

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

@@ -25,7 +25,8 @@ import { MutationBatch } from '../model/mutation_batch';
 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, DbDocumentOverlay, DbDocumentOverlayKey, DbIndexConfiguration, DbIndexState, 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 {

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

@@ -14,9 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { DocumentKeySet } from '../model/collections';
+import { DocumentKeySet, MutationMap, OverlayMap } from '../model/collections';
 import { DocumentKey } from '../model/document_key';
-import { Mutation } from '../model/mutation';
 import { Overlay } from '../model/overlay';
 import { ResourcePath } from '../model/path';
 import { DocumentOverlayCache } from './document_overlay_cache';
@@ -29,9 +28,9 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
-    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    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<Map<DocumentKey, Overlay>>;
-    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<OverlayMap>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<OverlayMap>;
     private saveOverlay;
 }

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

@@ -30,7 +30,7 @@ export declare class MemoryIndexManager implements IndexManager {
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
     addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
     deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
-    getDocumentsMatchingTarget(transaction: PersistenceTransaction, fieldIndex: FieldIndex, target: Target): PersistencePromise<DocumentKeySet>;
+    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>;

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

@@ -182,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/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/firestore/src/model/field_index.d.ts

@@ -70,6 +70,8 @@ export declare function fieldIndexGetDirectionalSegments(fieldIndex: FieldIndex)
  * index ID.
  */
 export declare function fieldIndexSemanticComparator(left: FieldIndex, right: FieldIndex): number;
+/** Returns a debug representation of the field index */
+export declare function fieldIndexToString(fieldIndex: FieldIndex): string;
 /** The type of the index, e.g. for which type of query it can be used. */
 export declare const enum IndexKind {
     /**

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

@@ -32,5 +32,6 @@ export declare const enum TypeOrder {
     RefValue = 7,
     GeoPointValue = 8,
     ArrayValue = 9,
-    ObjectValue = 10
+    ObjectValue = 10,
+    MaxValue = 9007199254740991
 }

package/dist/firestore/src/platform/node/base64.d.ts

@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Converts a Base64 encoded string to a binary string. */
 export declare function decodeBase64(encoded: string): string;
 /** Converts a binary string to a Base64 encoded string. */
 export declare function encodeBase64(raw: string): string;

package/dist/firestore/src/util/obj_map.d.ts

@@ -30,6 +30,8 @@ export declare class ObjectMap<KeyType, ValueType> {
      * constant time lookups in practice.
      */
     private inner;
+    /** The number of entries stored in the map */
+    private innerSize;
     constructor(mapKeyFn: (key: KeyType) => string, equalsFn: (l: KeyType, r: KeyType) => boolean);
     /** Get a value for this key, or undefined if it does not exist. */
     get(key: KeyType): ValueType | undefined;
@@ -42,4 +44,5 @@ export declare class ObjectMap<KeyType, ValueType> {
     delete(key: KeyType): boolean;
     forEach(fn: (key: KeyType, val: ValueType) => void): void;
     isEmpty(): boolean;
+    size(): number;
 }

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

@@ -16,7 +16,7 @@
  */
 import { DocumentOverlayCache } from '../../../src/local/document_overlay_cache';
 import { Persistence } from '../../../src/local/persistence';
-import { DocumentKeySet } from '../../../src/model/collections';
+import { DocumentKeySet, MutationMap, OverlayMap } from '../../../src/model/collections';
 import { DocumentKey } from '../../../src/model/document_key';
 import { Mutation } from '../../../src/model/mutation';
 import { Overlay } from '../../../src/model/overlay';
@@ -29,10 +29,10 @@ export declare class TestDocumentOverlayCache {
     private persistence;
     private cache;
     constructor(persistence: Persistence, cache: DocumentOverlayCache);
-    saveOverlays(largestBatch: number, data: Map<DocumentKey, Mutation>): Promise<void>;
+    saveOverlays(largestBatch: number, data: MutationMap): 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>>;
+    getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
+    getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;
     removeOverlaysForBatchId(documentKeys: DocumentKeySet, batchId: number): Promise<void>;
 }

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

@@ -34,7 +34,7 @@ export declare class TestIndexManager {
     deleteFieldIndex(index: FieldIndex): Promise<void>;
     getFieldIndexes(collectionGroup?: string): Promise<FieldIndex[]>;
     getFieldIndex(target: Target): Promise<FieldIndex | null>;
-    getDocumentsMatchingTarget(fieldIndex: FieldIndex, target: Target): Promise<DocumentKeySet>;
+    getDocumentsMatchingTarget(target: Target): Promise<DocumentKeySet | null>;
     getNextCollectionGroupToUpdate(): Promise<string | null>;
     updateCollectionGroup(collectionGroup: string, offset: IndexOffset): Promise<void>;
     updateIndexEntries(documents: DocumentMap): Promise<void>;