@firebase/firestore 3.4.7 → 3.4.8-canary.44948ac91

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @firebase/firestore
 
+## 3.4.8
+
+### Patch Changes
+
+- [`05dc9d6a0`](https://github.com/firebase/firebase-js-sdk/commit/05dc9d6a0db3058611dd7a2dc34daa726f9ba20d) [#6128](https://github.com/firebase/firebase-js-sdk/pull/6128) (fixes [#6110](https://github.com/firebase/firebase-js-sdk/issues/6110)) - Fixes an issue during multi-document lookup that resulted in the IndexedDB error "The parameter is less than or equal to this cursor's".
+
+- Updated dependencies [[`e9e5f6b3c`](https://github.com/firebase/firebase-js-sdk/commit/e9e5f6b3ca9d61323b22f87986d9959f5297ec59)]:
+  - @firebase/util@1.5.2
+  - @firebase/component@0.5.13
+
 ## 3.4.7
 
 ### Patch Changes

package/dist/firestore/src/core/query.d.ts

@@ -76,9 +76,7 @@ export declare function asCollectionQueryAtPath(query: Query, path: ResourcePath
  * Returns true if this query does not specify any query constraints that
  * could remove results.
  */
-export declare function matchesAllDocuments(query: Query): boolean;
-export declare function hasLimitToFirst(query: Query): boolean;
-export declare function hasLimitToLast(query: Query): boolean;
+export declare function queryMatchesAllDocuments(query: Query): boolean;
 export declare function getFirstOrderByField(query: Query): FieldPath | null;
 export declare function getInequalityFilterField(query: Query): FieldPath | null;
 /**
@@ -113,7 +111,7 @@ export declare function queryOrderBy(query: Query): OrderBy[];
 export declare function queryToTarget(query: Query): Target;
 export declare function queryWithAddedFilter(query: Query, filter: Filter): Query;
 export declare function queryWithAddedOrderBy(query: Query, orderBy: OrderBy): Query;
-export declare function queryWithLimit(query: Query, limit: number, limitType: LimitType): Query;
+export declare function queryWithLimit(query: Query, limit: number | null, limitType: LimitType): Query;
 export declare function queryWithStartAt(query: Query, bound: Bound): Query;
 export declare function queryWithEndAt(query: Query, bound: Bound): Query;
 export declare function queryEquals(left: Query, right: Query): boolean;

package/dist/firestore/src/core/target.d.ts

@@ -82,6 +82,8 @@ export declare function targetGetLowerBound(target: Target, fieldIndex: FieldInd
  * upper bound exists.
  */
 export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound | null;
+/** Returns the number of segments of a perfect index for this target. */
+export declare function targetGetSegmentCount(target: Target): number;
 export declare abstract class Filter {
     abstract matches(doc: Document): boolean;
 }

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

@@ -15,11 +15,28 @@
  * limitations under the License.
  */
 import { Target } from '../core/target';
-import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { DocumentMap } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
 import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
+/** Represents the index state as it relates to a particular target. */
+export declare const enum IndexType {
+    /** Indicates that no index could be found for serving the target. */
+    NONE = 0,
+    /**
+     * Indicates that only a "partial index" could be found for serving the
+     * target. A partial index is one which does not have a segment for every
+     * filter/orderBy in the target.
+     */
+    PARTIAL = 1,
+    /**
+     * Indicates that a "full index" could be found for serving the target. A full
+     * index is one which has a segment for every filter/orderBy in the target.
+     */
+    FULL = 2
+}
 /**
  * Represents a set of indexes that are used to execute queries efficiently.
  *
@@ -67,15 +84,15 @@ export interface IndexManager {
     /** 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.
+     * Returns the type of index (if any) that can be used to serve the given
+     * target.
      */
-    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    getIndexType(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexType>;
     /**
      * 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>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKey[] | null>;
     /**
      * Returns the next collection group to update. Returns `null` if no group
      * exists.
@@ -92,4 +109,9 @@ export interface IndexManager {
     updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
     /** Updates the index entries for the provided documents. */
     updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
+    /**
+     * Iterates over all field indexes that are used to serve the given target,
+     * and returns the minimum offset of them all.
+     */
+    getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

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

@@ -15,11 +15,13 @@
  * limitations under the License.
  */
 import { User } from '../auth/user';
+import { DatabaseId } from '../core/database_info';
 import { Target } from '../core/target';
-import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { DocumentMap } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
 import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
-import { IndexManager } from './index_manager';
+import { IndexManager, IndexType } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 /**
@@ -30,6 +32,7 @@ import { PersistenceTransaction } from './persistence_transaction';
  */
 export declare class IndexedDbIndexManager implements IndexManager {
     private user;
+    private readonly databaseId;
     /**
      * 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.
@@ -44,7 +47,7 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * contains only one term from the target's disjunctive normal form (DNF).
      */
     private targetToDnfSubTargets;
-    constructor(user: User);
+    constructor(user: User, databaseId: DatabaseId);
     /**
      * Adds a new entry to the collection parent index.
      *
@@ -56,7 +59,7 @@ export declare class IndexedDbIndexManager 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, target: Target): PersistencePromise<DocumentKeySet | null>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKey[] | null>;
     private getSubTargets;
     /**
      * Constructs a key range query on `DbIndexEntryStore` that unions all
@@ -72,7 +75,8 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * and user.
      */
     private generateEmptyBound;
-    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    private getFieldIndex;
+    getIndexType(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexType>;
     /**
      * 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
@@ -81,6 +85,11 @@ export declare class IndexedDbIndexManager implements IndexManager {
     private encodeDirectionalElements;
     /** Encodes a single value to the ascending index format. */
     private encodeSingleElement;
+    /**
+     * Returns an encoded form of the document key that sorts based on the key
+     * ordering of the field index.
+     */
+    private encodeDirectionalKey;
     /**
      * Encodes the given field values according to the specification in `target`.
      * For IN queries, a list of possible values is returned.
@@ -124,4 +133,5 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     private createRange;
+    getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

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

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 import { MutableDocument } from '../model/document';
+import { DocumentKey } from '../model/document_key';
 import { LocalSerializer } from './local_serializer';
 import { RemoteDocumentCache } from './remote_document_cache';
 export interface DocumentSizeEntry {
@@ -25,3 +26,11 @@ export interface IndexedDbRemoteDocumentCache extends RemoteDocumentCache {
 }
 /** Creates a new IndexedDbRemoteDocumentCache. */
 export declare function newIndexedDbRemoteDocumentCache(serializer: LocalSerializer): IndexedDbRemoteDocumentCache;
+/**
+ * Comparator that compares document keys according to the primary key sorting
+ * used by the `DbRemoteDocumentDocument` store (by prefix path, collection id
+ * and then document ID).
+ *
+ * Visible for testing.
+ */
+export declare function dbKeyComparator(l: DocumentKey, r: DocumentKey): number;

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

@@ -20,6 +20,7 @@ import { BundledQuery } from '../protos/firestore_bundle_proto';
 import { Document as ProtoDocument, DocumentsTarget as ProtoDocumentsTarget, QueryTarget as ProtoQueryTarget, Write as ProtoWrite } from '../protos/firestore_proto_api';
 import { EncodedResourcePath } from './encoded_resource_path';
 import { DbTimestampKey } from './indexeddb_sentinels';
+export declare const INDEXING_ENABLED = false;
 export declare const INDEXING_SCHEMA_VERSION = 14;
 /**
  * Schema Version for the Web client:
@@ -470,8 +471,13 @@ export interface DbIndexEntry {
     arrayValue: Uint8Array;
     /** The encoded directional value for equality and inequality filters. */
     directionalValue: Uint8Array;
-    /** The document key this entry points to. */
-    documentKey: EncodedResourcePath;
+    /**
+     * The document key this entry points to. This entry is encoded by an ordered
+     * encoder to match the key order of the index.
+     */
+    orderedDocumentKey: Uint8Array;
+    /** The segments of the document key this entry points to. */
+    documentKey: string[];
 }
 /**
  * An object representing a document overlay.

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

@@ -204,9 +204,16 @@ 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.
+ * an ordered and an encoded document path for the indexed document.
  */
-export declare type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
+export declare type DbIndexEntryKey = [
+    number,
+    string,
+    Uint8Array,
+    Uint8Array,
+    Uint8Array,
+    string[]
+];
 /** Name of the IndexedDb object store. */
 export declare const DbIndexEntryStore = "indexEntries";
 export declare const DbIndexEntryKeyPath: string[];

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

@@ -33,7 +33,7 @@ import { RemoteDocumentCache } from './remote_document_cache';
 export declare class LocalDocumentsView {
     readonly remoteDocumentCache: RemoteDocumentCache;
     readonly mutationQueue: MutationQueue;
-    readonly indexManager: IndexManager;
+    private readonly indexManager;
     constructor(remoteDocumentCache: RemoteDocumentCache, mutationQueue: MutationQueue, indexManager: IndexManager);
     /**
      * Get the local view of the document identified by `key`.

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

@@ -15,10 +15,11 @@
  * limitations under the License.
  */
 import { Target } from '../core/target';
-import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { DocumentMap } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
 import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
-import { IndexManager } from './index_manager';
+import { IndexManager, IndexType } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 /**
@@ -30,10 +31,11 @@ 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, target: Target): PersistencePromise<DocumentKeySet | null>;
-    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKey[] | null>;
+    getIndexType(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexType>;
     getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
     getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
+    getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
     updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
     updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }

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

@@ -17,14 +17,35 @@
 import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
 import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { IndexManager } from './index_manager';
 import { LocalDocumentsView } from './local_documents_view';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 /**
- * A query engine that takes advantage of the target document mapping in the
- * QueryCache. Query execution is optimized by only reading the documents that
- * previously matched a query plus any documents that were edited after the
- * query was last listened to.
+ * The Firestore query engine.
+ *
+ * Firestore queries can be executed in three modes. The Query Engine determines
+ * what mode to use based on what data is persisted. The mode only determines
+ * the runtime complexity of the query - the result set is equivalent across all
+ * implementations.
+ *
+ * The Query engine will use indexed-based execution if a user has configured
+ * any index that can be used to execute query (via `setIndexConfiguration()`).
+ * Otherwise, the engine will try to optimize the query by re-using a previously
+ * persisted query result. If that is not possible, the query will be executed
+ * via a full collection scan.
+ *
+ * Index-based execution is the default when available. The query engine
+ * supports partial indexed execution and merges the result from the index
+ * lookup with documents that have not yet been indexed. The index evaluation
+ * matches the backend's format and as such, the SDK can use indexing for all
+ * queries that the backend supports.
+ *
+ * If no index exists, the query engine tries to take advantage of the target
+ * document mapping in the TargetCache. These mappings exists for all queries
+ * that have been synced with the backend at least once and allow the query
+ * engine to only read documents that previously matched a query plus any
+ * documents that were edited after the query was last listened to.
  *
  * There are some cases when this optimization is not guaranteed to produce
  * the same results as full collection scans. In these cases, query
@@ -40,16 +61,29 @@ import { PersistenceTransaction } from './persistence_transaction';
  */
 export declare class QueryEngine {
     private localDocumentsView;
+    private indexManager;
+    private initialized;
     /** Sets the document view to query against. */
-    setLocalDocumentsView(localDocuments: LocalDocumentsView): void;
+    initialize(localDocuments: LocalDocumentsView, indexManager: IndexManager): void;
     /** Returns all local documents matching the specified query. */
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, lastLimboFreeSnapshotVersion: SnapshotVersion, remoteKeys: DocumentKeySet): PersistencePromise<DocumentMap>;
+    /**
+     * Performs an indexed query that evaluates the query based on a collection's
+     * persisted index values. Returns `null` if an index is not available.
+     */
+    private performQueryUsingIndex;
+    /**
+     * Performs a query based on the target's persisted query mapping. Returns
+     * `null` if the mapping is not available or cannot be used.
+     */
+    private performQueryUsingRemoteKeys;
     /** Applies the query filter and sorting to the provided documents.  */
     private applyQuery;
     /**
      * Determines if a limit query needs to be refilled from cache, making it
      * ineligible for index-free execution.
      *
+     * @param query The query.
      * @param sortedPreviousResults - The documents that matched the query when it
      * was last synchronized, sorted by the query's comparator.
      * @param remoteKeys - The document keys that matched the query at the last
@@ -59,4 +93,9 @@ export declare class QueryEngine {
      */
     private needsRefill;
     private executeFullCollectionScan;
+    /**
+     * Combines the results from an indexed execution with the remaining documents
+     * that have not yet been indexed.
+     */
+    private appendRemainingResults;
 }

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

@@ -186,6 +186,8 @@ export declare class SimpleDbStore<KeyType extends IDBValidKey, ValueType extend
     loadAll(): PersistencePromise<ValueType[]>;
     /** Loads all elements for the index range from the object store. */
     loadAll(range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /** Loads all elements ordered by the given index. */
+    loadAll(index: string): PersistencePromise<ValueType[]>;
     /**
      * Loads all elements from the object store that fall into the provided in the
      * index range for the given index.

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

@@ -31,7 +31,7 @@ export interface DocumentSizeEntries {
     sizeMap: SortedMap<DocumentKey, number>;
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
-export declare function documentMap(): DocumentMap;
+export declare function documentMap(...docs: Document[]): DocumentMap;
 export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
 export declare function newOverlayMap(): OverlayMap;
 export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;

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

@@ -70,6 +70,12 @@ export declare class FieldIndex {
 export declare function fieldIndexGetArraySegment(fieldIndex: FieldIndex): IndexSegment | undefined;
 /** Returns all directional (ascending/descending) segments for this index. */
 export declare function fieldIndexGetDirectionalSegments(fieldIndex: FieldIndex): IndexSegment[];
+/**
+ * Returns the order of the document key component for the given index.
+ *
+ * PORTING NOTE: This is only used in the Web IndexedDb implementation.
+ */
+export declare function fieldIndexGetKeyOrder(fieldIndex: FieldIndex): IndexKind;
 /**
  * Compares indexes by collection group and segments. Ignores update time and
  * index ID.

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

@@ -25,6 +25,9 @@ export declare function primitiveComparator<T>(left: T, right: T): number;
 export interface Equatable<T> {
     isEqual(other: T): boolean;
 }
+export interface Iterable<V> {
+    forEach: (cb: (v: V) => void) => void;
+}
 /** Helper to compare arrays using isEqual(). */
 export declare function arrayEquals<T>(left: T[], right: T[], comparator: (l: T, r: T) => boolean): boolean;
 /**

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

@@ -16,6 +16,7 @@
  */
 import { Query } from '../../../src/core/query';
 import { SnapshotVersion } from '../../../src/core/snapshot_version';
+import { IndexManager } from '../../../src/local/index_manager';
 import { LocalDocumentsView } from '../../../src/local/local_documents_view';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
 import { PersistenceTransaction } from '../../../src/local/persistence_transaction';
@@ -51,7 +52,7 @@ export declare class CountingQueryEngine extends QueryEngine {
     documentsReadByKey: number;
     resetCounts(): void;
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, lastLimboFreeSnapshotVersion: SnapshotVersion, remoteKeys: DocumentKeySet): PersistencePromise<DocumentMap>;
-    setLocalDocumentsView(localDocuments: LocalDocumentsView): void;
+    initialize(localDocuments: LocalDocumentsView, indexManager: IndexManager): void;
     private wrapRemoteDocumentCache;
     private wrapMutationQueue;
 }

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

@@ -15,9 +15,10 @@
  * limitations under the License.
  */
 import { Target } from '../../../src/core/target';
-import { IndexManager } from '../../../src/local/index_manager';
+import { IndexManager, IndexType } from '../../../src/local/index_manager';
 import { Persistence } from '../../../src/local/persistence';
-import { DocumentKeySet, DocumentMap } from '../../../src/model/collections';
+import { DocumentMap } from '../../../src/model/collections';
+import { DocumentKey } from '../../../src/model/document_key';
 import { FieldIndex, IndexOffset } from '../../../src/model/field_index';
 import { ResourcePath } from '../../../src/model/path';
 /**
@@ -33,8 +34,8 @@ export declare class TestIndexManager {
     addFieldIndex(index: FieldIndex): Promise<void>;
     deleteFieldIndex(index: FieldIndex): Promise<void>;
     getFieldIndexes(collectionGroup?: string): Promise<FieldIndex[]>;
-    getFieldIndex(target: Target): Promise<FieldIndex | null>;
-    getDocumentsMatchingTarget(target: Target): Promise<DocumentKeySet | null>;
+    getIndexType(target: Target): Promise<IndexType>;
+    getDocumentsMatchingTarget(target: Target): Promise<DocumentKey[] | null>;
     getNextCollectionGroupToUpdate(): Promise<string | null>;
     updateCollectionGroup(collectionGroup: string, offset: IndexOffset): Promise<void>;
     updateIndexEntries(documents: DocumentMap): Promise<void>;

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

@@ -47,10 +47,6 @@ export declare class TestRemoteDocumentCache {
     getEntries(documentKeys: DocumentKeySet): Promise<MutableDocumentMap>;
     getAllFromCollection(collection: ResourcePath, offset: IndexOffset): Promise<MutableDocumentMap>;
     getAllFromCollectionGroup(collectionGroup: string, offset: IndexOffset, limit: number): Promise<MutableDocumentMap>;
-    getNewDocumentChanges(sinceReadTime: SnapshotVersion): Promise<{
-        changedDocs: MutableDocumentMap;
-        readTime: SnapshotVersion;
-    }>;
     getSize(): Promise<number>;
     newChangeBuffer(options?: {
         trackRemovals: boolean;