@firebase/firestore 3.4.4-canary.2dd99ae2d → 3.4.4-canary.7f959622d

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
 import { fromJSON } from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4-canary.2dd99ae2d";
+const version$1 = "3.4.4-canary.7f959622d";
 
 /**
  * @license
@@ -61,7 +61,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.6.5-canary.2dd99ae2d";
+const version = "9.6.5-canary.7f959622d";
 
 /**
  * @license
@@ -1192,23 +1192,6 @@ function decodeResourcePath(path) {
     }
     return new ResourcePath(segments);
 }
-
-/**
- * @license
- * Copyright 2017 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.
- */
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -1227,6 +1210,7 @@ function decodeResourcePath(path) {
  *     an auto-incrementing ID. This is required for Index-Free queries.
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
+ * 12. Add indexing support.
  */
 const SCHEMA_VERSION = 11;
 /**
@@ -1753,9 +1737,7 @@ class DbClientMetadata {
 DbClientMetadata.store = 'clientMetadata';
 /** Keys are automatically assigned via the clientId properties. */
 DbClientMetadata.keyPath = 'clientId';
-/**
- * A object representing a bundle loaded by the SDK.
- */
+/** An object representing a bundle loaded by the SDK. */
 class DbBundle {
     constructor(
     /** The ID of the loaded bundle. */
@@ -1772,9 +1754,7 @@ class DbBundle {
 /** Name of the IndexedDb object store. */
 DbBundle.store = 'bundles';
 DbBundle.keyPath = 'bundleId';
-/**
- * A object representing a named query loaded by the SDK via a bundle.
- */
+/** An object representing a named query loaded by the SDK via a bundle. */
 class DbNamedQuery {
     constructor(
     /** The name of the query. */
@@ -1791,6 +1771,93 @@ class DbNamedQuery {
 /** Name of the IndexedDb object store. */
 DbNamedQuery.store = 'namedQueries';
 DbNamedQuery.keyPath = 'name';
+/** An object representing the global configuration for a field index. */
+class DbIndexConfiguration {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The collection group this index belongs to. */
+    collectionGroup, 
+    /** The fields to index for this index. */
+    fields) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.fields = fields;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexConfiguration.store = 'indexConfiguration';
+DbIndexConfiguration.keyPath = 'indexId';
+/**
+ * An object describing how up-to-date the index backfill is for each user and
+ * index.
+ */
+class DbIndexState {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber, 
+    /**
+     * The latest read time that has been indexed by Firestore for this field
+     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
+     */
+    readTime, 
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey, 
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.sequenceNumber = sequenceNumber;
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexState.store = 'indexState';
+DbIndexState.keyPath = ['indexId', 'uid'];
+/** An object that stores the encoded entries for all documents and fields. */
+class DbIndexEntries {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /** The encoded array index value for this entry. */
+    arrayValue, 
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue, 
+    /** The document key this entry points to. */
+    documentKey) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.arrayValue = arrayValue;
+        this.directionalValue = directionalValue;
+        this.documentKey = documentKey;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexEntries.store = 'indexEntries';
+DbIndexEntries.keyPath = [
+    'indexId',
+    'uid',
+    'arrayValue',
+    'directionalValue',
+    'documentKey'
+];
 // Visible for testing
 const V1_STORES = [
     DbMutationQueue.store,
@@ -1805,7 +1872,6 @@ const V1_STORES = [
 // V2 is no longer usable (see comment at top of file)
 // Visible for testing
 const V3_STORES = V1_STORES;
-// Visible for testing
 // Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
 const V4_STORES = [...V3_STORES, DbClientMetadata.store];
 // V5 does not change the set of stores.
@@ -1815,6 +1881,12 @@ const V8_STORES = [...V6_STORES, DbCollectionParent.store];
 // V9 does not change the set of stores.
 // V10 does not change the set of stores.
 const V11_STORES = [...V8_STORES, DbBundle.store, DbNamedQuery.store];
+[
+    ...V11_STORES,
+    DbIndexConfiguration.store,
+    DbIndexState.store,
+    DbIndexEntries.store
+];
 /**
  * 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
@@ -4460,27 +4532,29 @@ function newTarget(path, collectionGroup = null, orderBy = [], filters = [], lim
 function canonifyTarget(target) {
     const targetImpl = debugCast(target);
     if (targetImpl.memoizedCanonicalId === null) {
-        let canonicalId = targetImpl.path.canonicalString();
+        let str = targetImpl.path.canonicalString();
         if (targetImpl.collectionGroup !== null) {
-            canonicalId += '|cg:' + targetImpl.collectionGroup;
+            str += '|cg:' + targetImpl.collectionGroup;
         }
-        canonicalId += '|f:';
-        canonicalId += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
-        canonicalId += '|ob:';
-        canonicalId += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
+        str += '|f:';
+        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
+        str += '|ob:';
+        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
         if (!isNullOrUndefined(targetImpl.limit)) {
-            canonicalId += '|l:';
-            canonicalId += targetImpl.limit;
+            str += '|l:';
+            str += targetImpl.limit;
         }
         if (targetImpl.startAt) {
-            canonicalId += '|lb:';
-            canonicalId += canonifyBound(targetImpl.startAt);
+            str += '|lb:';
+            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
+            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
         }
         if (targetImpl.endAt) {
-            canonicalId += '|ub:';
-            canonicalId += canonifyBound(targetImpl.endAt);
+            str += '|ub:';
+            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
+            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
         }
-        targetImpl.memoizedCanonicalId = canonicalId;
+        targetImpl.memoizedCanonicalId = str;
     }
     return targetImpl.memoizedCanonicalId;
 }
@@ -4503,10 +4577,14 @@ function stringifyTarget(target) {
             .join(', ')}]`;
     }
     if (target.startAt) {
-        str += ', startAt: ' + canonifyBound(target.startAt);
+        str += ', startAt: ';
+        str += target.startAt.inclusive ? 'b:' : 'a:';
+        str += target.startAt.position.map(p => canonicalId(p)).join(',');
     }
     if (target.endAt) {
-        str += ', endAt: ' + canonifyBound(target.endAt);
+        str += ', endAt: ';
+        str += target.endAt.inclusive ? 'a:' : 'b:';
+        str += target.endAt.position.map(p => canonicalId(p)).join(',');
     }
     return `Target(${str})`;
 }
@@ -4729,7 +4807,6 @@ class ArrayContainsAnyFilter extends FieldFilter {
         return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
     }
 }
-// TODO(indexing): Change Bound.before to "inclusive"
 /**
  * Represents a bound of a query.
  *
@@ -4745,17 +4822,11 @@ class ArrayContainsAnyFilter extends FieldFilter {
  * just after the provided values.
  */
 class Bound {
-    constructor(position, before) {
+    constructor(position, inclusive) {
         this.position = position;
-        this.before = before;
+        this.inclusive = inclusive;
     }
 }
-function canonifyBound(bound) {
-    // TODO(b/29183165): Make this collision robust.
-    return `${bound.before ? 'b' : 'a'}:${bound.position
-        .map(p => canonicalId(p))
-        .join(',')}`;
-}
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -4775,11 +4846,7 @@ function stringifyOrderBy(orderBy) {
 function orderByEquals(left, right) {
     return left.dir === right.dir && left.field.isEqual(right.field);
 }
-/**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
- */
-function sortsBeforeDocument(bound, orderBy, doc) {
+function boundCompareToDocument(bound, orderBy, doc) {
     let comparison = 0;
     for (let i = 0; i < bound.position.length; i++) {
         const orderByComponent = orderBy[i];
@@ -4798,7 +4865,23 @@ function sortsBeforeDocument(bound, orderBy, doc) {
             break;
         }
     }
-    return bound.before ? comparison <= 0 : comparison < 0;
+    return comparison;
+}
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+function boundSortsAfterDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+function boundSortsBeforeDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison <= 0 : comparison < 0;
 }
 function boundEquals(left, right) {
     if (left === null) {
@@ -4807,7 +4890,7 @@ function boundEquals(left, right) {
     else if (right === null) {
         return false;
     }
-    if (left.before !== right.before ||
+    if (left.inclusive !== right.inclusive ||
         left.position.length !== right.position.length) {
         return false;
     }
@@ -5011,10 +5094,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.before)
+                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.before)
+                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -5102,11 +5185,11 @@ function queryMatchesFilters(query, doc) {
 /** Makes sure a document is within the bounds, if provided. */
 function queryMatchesBounds(query, doc) {
     if (query.startAt &&
-        !sortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
+        !boundSortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
         return false;
     }
     if (query.endAt &&
-        sortsBeforeDocument(query.endAt, queryOrderBy(query), doc)) {
+        !boundSortsAfterDocument(query.endAt, queryOrderBy(query), doc)) {
         return false;
     }
     return true;
@@ -7985,10 +8068,10 @@ function toQueryTarget(serializer, target) {
         result.structuredQuery.limit = limit;
     }
     if (target.startAt) {
-        result.structuredQuery.startAt = toCursor(target.startAt);
+        result.structuredQuery.startAt = toStartAtCursor(target.startAt);
     }
     if (target.endAt) {
-        result.structuredQuery.endAt = toCursor(target.endAt);
+        result.structuredQuery.endAt = toEndAtCursor(target.endAt);
     }
     return result;
 }
@@ -8021,11 +8104,11 @@ function convertQueryTargetToQuery(target) {
     }
     let startAt = null;
     if (query.startAt) {
-        startAt = fromCursor(query.startAt);
+        startAt = fromStartAtCursor(query.startAt);
     }
     let endAt = null;
     if (query.endAt) {
-        endAt = fromCursor(query.endAt);
+        endAt = fromEndAtCursor(query.endAt);
     }
     return newQuery(path, collectionGroup, orderBy, filterBy, limit, "F" /* First */, startAt, endAt);
 }
@@ -8116,16 +8199,27 @@ function toOrder(orderBys) {
 function fromOrder(orderBys) {
     return orderBys.map(order => fromPropertyOrder(order));
 }
-function toCursor(cursor) {
+function toStartAtCursor(cursor) {
     return {
-        before: cursor.before,
+        before: cursor.inclusive,
         values: cursor.position
     };
 }
-function fromCursor(cursor) {
-    const before = !!cursor.before;
+function toEndAtCursor(cursor) {
+    return {
+        before: !cursor.inclusive,
+        values: cursor.position
+    };
+}
+function fromStartAtCursor(cursor) {
+    const inclusive = !!cursor.before;
+    const position = cursor.values || [];
+    return new Bound(position, inclusive);
+}
+function fromEndAtCursor(cursor) {
+    const inclusive = !cursor.before;
     const position = cursor.values || [];
-    return new Bound(position, before);
+    return new Bound(position, inclusive);
 }
 // visible for testing
 function toDirection(dir) {
@@ -10637,9 +10731,6 @@ class SchemaConverter {
      * and local feature development.
      */
     createOrUpgrade(db, txn, fromVersion, toVersion) {
-        hardAssert(fromVersion < toVersion &&
-            fromVersion >= 0 &&
-            toVersion <= SCHEMA_VERSION);
         const simpleDbTransaction = new SimpleDbTransaction('createOrUpgrade', txn);
         if (fromVersion < 1 && toVersion >= 1) {
             createPrimaryClientStore(db);
@@ -10706,6 +10797,11 @@ class SchemaConverter {
                 createNamedQueriesStore(db);
             });
         }
+        if (fromVersion < 12 && toVersion >= 12) {
+            p = p.next(() => {
+                createFieldIndex(db);
+            });
+        }
         return p;
     }
     addDocumentGlobal(txn) {
@@ -10912,6 +11008,17 @@ function createNamedQueriesStore(db) {
     db.createObjectStore(DbNamedQuery.store, {
         keyPath: DbNamedQuery.keyPath
     });
+}
+function createFieldIndex(db) {
+    db.createObjectStore(DbIndexConfiguration.store, {
+        keyPath: DbIndexConfiguration.keyPath
+    });
+    db.createObjectStore(DbIndexState.store, {
+        keyPath: DbIndexState.keyPath
+    });
+    db.createObjectStore(DbIndexEntries.store, {
+        keyPath: DbIndexEntries.keyPath
+    });
 }
 
 /**
@@ -25228,51 +25335,53 @@ function limitToLast(limit) {
     return new QueryLimitConstraint('limitToLast', limit, "L" /* Last */);
 }
 class QueryStartAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithStartAt(query._query, bound));
     }
 }
 function startAt(...docOrFields) {
-    return new QueryStartAtConstraint('startAt', docOrFields, /*before=*/ true);
+    return new QueryStartAtConstraint('startAt', docOrFields, 
+    /*inclusive=*/ true);
 }
 function startAfter(...docOrFields) {
     return new QueryStartAtConstraint('startAfter', docOrFields, 
-    /*before=*/ false);
+    /*inclusive=*/ false);
 }
 class QueryEndAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithEndAt(query._query, bound));
     }
 }
 function endBefore(...docOrFields) {
-    return new QueryEndAtConstraint('endBefore', docOrFields, /*before=*/ true);
+    return new QueryEndAtConstraint('endBefore', docOrFields, 
+    /*inclusive=*/ false);
 }
 function endAt(...docOrFields) {
-    return new QueryEndAtConstraint('endAt', docOrFields, /*before=*/ false);
+    return new QueryEndAtConstraint('endAt', docOrFields, /*inclusive=*/ true);
 }
 /** Helper function to create a bound from a document or fields */
-function newQueryBoundFromDocOrFields(query, methodName, docOrFields, before) {
+function newQueryBoundFromDocOrFields(query, methodName, docOrFields, inclusive) {
     docOrFields[0] = getModularInstance(docOrFields[0]);
     if (docOrFields[0] instanceof DocumentSnapshot$1) {
-        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, before);
+        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, inclusive);
     }
     else {
         const reader = newUserDataReader(query.firestore);
-        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, before);
+        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, inclusive);
     }
 }
 function newQueryFilter(query, methodName, dataReader, databaseId, fieldPath, op, value) {
@@ -25330,7 +25439,7 @@ function newQueryOrderBy(query, fieldPath, direction) {
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
  */
-function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
+function newQueryBoundFromDocument(query, databaseId, methodName, doc, inclusive) {
     if (!doc) {
         throw new FirestoreError(Code.NOT_FOUND, `Can't use a DocumentSnapshot that doesn't exist for ` +
             `${methodName}().`);
@@ -25367,12 +25476,12 @@ function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
             }
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Converts a list of field values to a `Bound` for the given query.
  */
-function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, before) {
+function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, inclusive) {
     // Use explicit order by's because it has to match the query the user made
     const orderBy = query.explicitOrderBy;
     if (values.length > orderBy.length) {
@@ -25409,7 +25518,7 @@ function newQueryBoundFromFields(query, databaseId, dataReader, methodName, valu
             components.push(wrapped);
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Parses the given `documentIdValue` into a `ReferenceValue`, throwing