@firebase/firestore 3.4.13 → 3.4.14-canary.47895fe5b

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.13";
+const version$1 = "3.4.14-canary.47895fe5b";
 
 /**
  * @license
@@ -86,7 +86,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.9.1";
+const version = "9.9.3-canary.47895fe5b";
 
 /**
  * @license
@@ -641,18 +641,40 @@ class FirebaseAuthCredentialsProvider {
  * safer to keep the implementation as-is.
  */
 class FirstPartyToken {
-    constructor(gapi, sessionIndex, iamToken) {
+    constructor(gapi, sessionIndex, iamToken, authTokenFactory) {
+        this.gapi = gapi;
+        this.sessionIndex = sessionIndex;
+        this.iamToken = iamToken;
+        this.authTokenFactory = authTokenFactory;
         this.type = 'FirstParty';
         this.user = User.FIRST_PARTY;
-        this.headers = new Map();
-        this.headers.set('X-Goog-AuthUser', sessionIndex);
-        const authHeader = gapi['auth']['getAuthHeaderValueForFirstParty']([]);
-        if (authHeader) {
-            this.headers.set('Authorization', authHeader);
+        this._headers = new Map();
+    }
+    /** Gets an authorization token, using a provided factory function, or falling back to First Party GAPI. */
+    getAuthToken() {
+        if (this.authTokenFactory) {
+            return this.authTokenFactory();
+        }
+        else {
+            // Make sure this really is a Gapi client.
+            hardAssert(!!(typeof this.gapi === 'object' &&
+                this.gapi !== null &&
+                this.gapi['auth'] &&
+                this.gapi['auth']['getAuthHeaderValueForFirstParty']));
+            return this.gapi['auth']['getAuthHeaderValueForFirstParty']([]);
+        }
+    }
+    get headers() {
+        this._headers.set('X-Goog-AuthUser', this.sessionIndex);
+        // Use array notation to prevent minification
+        const authHeaderTokenValue = this.getAuthToken();
+        if (authHeaderTokenValue) {
+            this._headers.set('Authorization', authHeaderTokenValue);
         }
-        if (iamToken) {
-            this.headers.set('X-Goog-Iam-Authorization-Token', iamToken);
+        if (this.iamToken) {
+            this._headers.set('X-Goog-Iam-Authorization-Token', this.iamToken);
         }
+        return this._headers;
     }
 }
 /*
@@ -661,13 +683,14 @@ class FirstPartyToken {
  * to applications hosted by Google.
  */
 class FirstPartyAuthCredentialsProvider {
-    constructor(gapi, sessionIndex, iamToken) {
+    constructor(gapi, sessionIndex, iamToken, authTokenFactory) {
         this.gapi = gapi;
         this.sessionIndex = sessionIndex;
         this.iamToken = iamToken;
+        this.authTokenFactory = authTokenFactory;
     }
     getToken() {
-        return Promise.resolve(new FirstPartyToken(this.gapi, this.sessionIndex, this.iamToken));
+        return Promise.resolve(new FirstPartyToken(this.gapi, this.sessionIndex, this.iamToken, this.authTokenFactory));
     }
     start(asyncQueue, changeListener) {
         // Fire with initial uid.
@@ -778,12 +801,7 @@ function makeAuthCredentialsProvider(credentials) {
     switch (credentials['type']) {
         case 'gapi':
             const client = credentials['client'];
-            // Make sure this really is a Gapi client.
-            hardAssert(!!(typeof client === 'object' &&
-                client !== null &&
-                client['auth'] &&
-                client['auth']['getAuthHeaderValueForFirstParty']));
-            return new FirstPartyAuthCredentialsProvider(client, credentials['sessionIndex'] || '0', credentials['iamToken'] || null);
+            return new FirstPartyAuthCredentialsProvider(client, credentials['sessionIndex'] || '0', credentials['iamToken'] || null, credentials['authTokenFactory'] || null);
         case 'provider':
             return credentials['client'];
         default:
@@ -1523,6 +1541,23 @@ function fieldIndexGetKeyOrder(fieldIndex) {
         ? 0 /* ASCENDING */
         : directionalSegments[directionalSegments.length - 1].kind;
 }
+/**
+ * Compares indexes by collection group and segments. Ignores update time and
+ * index ID.
+ */
+function fieldIndexSemanticComparator(left, right) {
+    let cmp = primitiveComparator(left.collectionGroup, right.collectionGroup);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    for (let i = 0; i < Math.min(left.fields.length, right.fields.length); ++i) {
+        cmp = indexSegmentComparator(left.fields[i], right.fields[i]);
+        if (cmp !== 0) {
+            return cmp;
+        }
+    }
+    return primitiveComparator(left.fields.length, right.fields.length);
+}
 /** Returns a debug representation of the field index */
 function fieldIndexToString(fieldIndex) {
     return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
@@ -1538,6 +1573,13 @@ class IndexSegment {
         this.kind = kind;
     }
 }
+function indexSegmentComparator(left, right) {
+    const cmp = FieldPath$1.comparator(left.fieldPath, right.fieldPath);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    return primitiveComparator(left.kind, right.kind);
+}
 /**
  * Stores the "high water mark" that indicates how updated the Index is for the
  * current user.
@@ -1624,31 +1666,6 @@ function indexOffsetComparator(left, right) {
     }
     return primitiveComparator(left.largestBatchId, right.largestBatchId);
 }
-/**
- * Schema Version for the Web client:
- * 1.  Initial version including Mutation Queue, Query Cache, and Remote
- *     Document Cache
- * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
- *     longer required because migration 3 unconditionally clears it.
- * 3.  Dropped and re-created Query Cache to deal with cache corruption related
- *     to limbo resolution. Addresses
- *     https://github.com/firebase/firebase-ios-sdk/issues/1548
- * 4.  Multi-Tab Support.
- * 5.  Removal of held write acks.
- * 6.  Create document global for tracking document cache size.
- * 7.  Ensure every cached document has a sentinel row with a sequence number.
- * 8.  Add collection-parent index for Collection Group queries.
- * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
- *     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 document overlays.
- * 13. Rewrite the keys of the remote document cache to allow for efficient
- *     document lookup via `getAll()`.
- * 14. Add overlays.
- * 15. Add indexing support.
- */
-const SCHEMA_VERSION = 14;
 
 /**
  * @license
@@ -2608,6 +2625,8 @@ function checkForAndReportiOSError(error) {
 }
 
 const LOG_TAG$h = 'IndexBackiller';
+/** How long we wait to try running index backfill after SDK initialization. */
+const INITIAL_BACKFILL_DELAY_MS = 15;
 /** Minimum amount of time between backfill checks, after the first one. */
 const REGULAR_BACKFILL_DELAY_MS = 1;
 /** The maximum number of documents to process each time backfill() is called. */
@@ -2620,6 +2639,7 @@ class IndexBackfillerScheduler {
         this.task = null;
     }
     start() {
+        this.schedule(INITIAL_BACKFILL_DELAY_MS);
     }
     stop() {
         if (this.task) {
@@ -12735,6 +12755,48 @@ function dbKeyComparator(l, r) {
     return primitiveComparator(left[left.length - 1], right[right.length - 1]);
 }
 
+/**
+ * @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
+ *     Document Cache
+ * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
+ *     longer required because migration 3 unconditionally clears it.
+ * 3.  Dropped and re-created Query Cache to deal with cache corruption related
+ *     to limbo resolution. Addresses
+ *     https://github.com/firebase/firebase-ios-sdk/issues/1548
+ * 4.  Multi-Tab Support.
+ * 5.  Removal of held write acks.
+ * 6.  Create document global for tracking document cache size.
+ * 7.  Ensure every cached document has a sentinel row with a sequence number.
+ * 8.  Add collection-parent index for Collection Group queries.
+ * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
+ *     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 document overlays.
+ * 13. Rewrite the keys of the remote document cache to allow for efficient
+ *     document lookup via `getAll()`.
+ * 14. Add overlays.
+ * 15. Add indexing support.
+ */
+const SCHEMA_VERSION = 15;
+
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -15273,6 +15335,73 @@ async function indexedDbClearPersistence(persistenceKey) {
     await SimpleDb.delete(dbName);
 }
 
+/**
+ * @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.
+ */
+/**
+ * Compares two array for equality using comparator. The method computes the
+ * intersection and invokes `onAdd` for every element that is in `after` but not
+ * `before`. `onRemove` is invoked for every element in `before` but missing
+ * from `after`.
+ *
+ * The method creates a copy of both `before` and `after` and runs in O(n log
+ * n), where n is the size of the two lists.
+ *
+ * @param before - The elements that exist in the original array.
+ * @param after - The elements to diff against the original array.
+ * @param comparator - The comparator for the elements in before and after.
+ * @param onAdd - A function to invoke for every element that is part of `
+ * after` but not `before`.
+ * @param onRemove - A function to invoke for every element that is part of
+ * `before` but not `after`.
+ */
+function diffArrays(before, after, comparator, onAdd, onRemove) {
+    before = [...before];
+    after = [...after];
+    before.sort(comparator);
+    after.sort(comparator);
+    const bLen = before.length;
+    const aLen = after.length;
+    let a = 0;
+    let b = 0;
+    while (a < aLen && b < bLen) {
+        const cmp = comparator(before[b], after[a]);
+        if (cmp < 0) {
+            // The element was removed if the next element in our ordered
+            // walkthrough is only in `before`.
+            onRemove(before[b++]);
+        }
+        else if (cmp > 0) {
+            // The element was added if the next element in our ordered walkthrough
+            // is only in `after`.
+            onAdd(after[a++]);
+        }
+        else {
+            a++;
+            b++;
+        }
+    }
+    while (a < aLen) {
+        onAdd(after[a++]);
+    }
+    while (b < bLen) {
+        onRemove(before[b++]);
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -16122,6 +16251,19 @@ async function localStoreSaveNamedQuery(localStore, query, documents = documentK
             .next(() => localStoreImpl.targetCache.addMatchingKeys(transaction, documents, allocated.targetId))
             .next(() => localStoreImpl.bundleCache.saveNamedQuery(transaction, query));
     });
+}
+async function localStoreConfigureFieldIndexes(localStore, newFieldIndexes) {
+    const localStoreImpl = debugCast(localStore);
+    const indexManager = localStoreImpl.indexManager;
+    const promises = [];
+    return localStoreImpl.persistence.runTransaction('Configure indexes', 'readwrite', transaction => indexManager
+        .getFieldIndexes(transaction)
+        .next(oldFieldIndexes => diffArrays(oldFieldIndexes, newFieldIndexes, fieldIndexSemanticComparator, fieldIndex => {
+        promises.push(indexManager.addFieldIndex(transaction, fieldIndex));
+    }, fieldIndex => {
+        promises.push(indexManager.deleteFieldIndex(transaction, fieldIndex));
+    }))
+        .next(() => PersistencePromise.waitFor(promises)));
 }
 
 /**
@@ -16201,9 +16343,56 @@ class QueryEngine {
      * persisted index values. Returns `null` if an index is not available.
      */
     performQueryUsingIndex(transaction, query) {
-        {
+        if (queryMatchesAllDocuments(query)) {
+            // Queries that match all documents don't benefit from using
+            // key-based lookups. It is more efficient to scan all documents in a
+            // collection, rather than to perform individual lookups.
             return PersistencePromise.resolve(null);
         }
+        let target = queryToTarget(query);
+        return this.indexManager
+            .getIndexType(transaction, target)
+            .next(indexType => {
+            if (indexType === 0 /* NONE */) {
+                // The target cannot be served from any index.
+                return null;
+            }
+            if (query.limit !== null && indexType === 1 /* PARTIAL */) {
+                // We cannot apply a limit for targets that are served using a partial
+                // index. If a partial index will be used to serve the target, the
+                // query may return a superset of documents that match the target
+                // (e.g. if the index doesn't include all the target's filters), or
+                // may return the correct set of documents in the wrong order (e.g. if
+                // the index doesn't include a segment for one of the orderBys).
+                // Therefore, a limit should not be applied in such cases.
+                query = queryWithLimit(query, null, "F" /* First */);
+                target = queryToTarget(query);
+            }
+            return this.indexManager
+                .getDocumentsMatchingTarget(transaction, target)
+                .next(keys => {
+                const sortedKeys = documentKeySet(...keys);
+                return this.localDocumentsView
+                    .getDocuments(transaction, sortedKeys)
+                    .next(indexedDocuments => {
+                    return this.indexManager
+                        .getMinOffset(transaction, target)
+                        .next(offset => {
+                        const previousResults = this.applyQuery(query, indexedDocuments);
+                        if (this.needsRefill(query, previousResults, sortedKeys, offset.readTime)) {
+                            // A limit query whose boundaries change due to local
+                            // edits can be re-run against the cache by excluding the
+                            // limit. This ensures that all documents that match the
+                            // query's filters are included in the result set. The SDK
+                            // can then apply the limit once all local edits are
+                            // incorporated.
+                            return this.performQueryUsingIndex(transaction, queryWithLimit(query, null, "F" /* First */));
+                        }
+                        return this.appendRemainingResults(transaction, previousResults, query, offset);
+                    });
+                });
+            });
+        });
     }
     /**
      * Performs a query based on the target's persisted query mapping. Returns
@@ -24298,7 +24487,7 @@ class AsyncObserver {
             this.scheduleEvent(this.observer.error, error);
         }
         else {
-            console.error('Uncaught Error in snapshot listener:', error);
+            logError('Uncaught Error in snapshot listener:', error);
         }
     }
     mute() {
@@ -26229,7 +26418,7 @@ function setPersistenceProviders(client, onlineComponentProvider, offlineCompone
             if (!canFallbackFromIndexedDbError(error)) {
                 throw error;
             }
-            console.warn('Error enabling offline persistence. Falling back to ' +
+            logWarn('Error enabling offline persistence. Falling back to ' +
                 'persistence disabled: ' +
                 error);
             persistenceResult.reject(error);
@@ -29143,14 +29332,23 @@ function writeBatch(firestore) {
  * limitations under the License.
  */
 function setIndexConfiguration(firestore, jsonOrConfiguration) {
+    var _a;
     firestore = cast(firestore, Firestore);
-    ensureFirestoreConfigured(firestore);
+    const client = ensureFirestoreConfigured(firestore);
+    // PORTING NOTE: We don't return an error if the user has not enabled
+    // persistence since `enableIndexeddbPersistence()` can fail on the Web.
+    if (!((_a = client.offlineComponents) === null || _a === void 0 ? void 0 : _a.indexBackfillerScheduler)) {
+        logWarn('Cannot enable indexes when persistence is disabled');
+        return Promise.resolve();
+    }
+    const parsedIndexes = parseIndexes(jsonOrConfiguration);
+    return getLocalStore(client).then(localStore => localStoreConfigureFieldIndexes(localStore, parsedIndexes));
+}
+function parseIndexes(jsonOrConfiguration) {
     const indexConfiguration = typeof jsonOrConfiguration === 'string'
         ? tryParseJson(jsonOrConfiguration)
         : jsonOrConfiguration;
     const parsedIndexes = [];
-    // PORTING NOTE: We don't return an error if the user has not enabled
-    // persistence since `enableIndexeddbPersistence()` can fail on the Web.
     if (Array.isArray(indexConfiguration.indexes)) {
         for (const index of indexConfiguration.indexes) {
             const collectionGroup = tryGetString(index, 'collectionGroup');
@@ -29173,8 +29371,7 @@ function setIndexConfiguration(firestore, jsonOrConfiguration) {
             parsedIndexes.push(new FieldIndex(FieldIndex.UNKNOWN_ID, collectionGroup, segments, IndexState.empty()));
         }
     }
-    // TODO(indexing): Configure indexes
-    return Promise.resolve();
+    return parsedIndexes;
 }
 function tryParseJson(json) {
     var _a;
@@ -29182,7 +29379,7 @@ function tryParseJson(json) {
         return JSON.parse(json);
     }
     catch (e) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON:' + ((_a = e) === null || _a === void 0 ? void 0 : _a.message));
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON: ' + ((_a = e) === null || _a === void 0 ? void 0 : _a.message));
     }
 }
 function tryGetString(data, property) {
@@ -29239,7 +29436,6 @@ exports._cast = cast;
 exports._debugAssert = debugAssert;
 exports._isBase64Available = isBase64Available;
 exports._logWarn = logWarn;
-exports._setIndexConfiguration = setIndexConfiguration;
 exports._validateIsNotUsedTogether = validateIsNotUsedTogether;
 exports.addDoc = addDoc;
 exports.arrayRemove = arrayRemove;
@@ -29282,6 +29478,7 @@ exports.refEqual = refEqual;
 exports.runTransaction = runTransaction;
 exports.serverTimestamp = serverTimestamp;
 exports.setDoc = setDoc;
+exports.setIndexConfiguration = setIndexConfiguration;
 exports.setLogLevel = setLogLevel;
 exports.snapshotEqual = snapshotEqual;
 exports.startAfter = startAfter;