@firebase/database 0.13.4 → 0.13.5-20220818183912

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Unreleased
 
+## 0.13.5-20220818183912
+
+### Patch Changes
+
+- [`9f1e3c667`](https://github.com/firebase/firebase-js-sdk/commit/9f1e3c66747126c8e24894d73f7fa27480bec08d) [#6536](https://github.com/firebase/firebase-js-sdk/pull/6536) - Revert "Updated type of action parameter for DataSnapshot#forEach"
+
+* [`a5d9e1083`](https://github.com/firebase/firebase-js-sdk/commit/a5d9e10831c2877e9d15c8a33b15557e4251c4de) [#6497](https://github.com/firebase/firebase-js-sdk/pull/6497) - Fix issue with how get results for filtered queries are added to cache.
+  Fix issue with events not getting propagated to listeners by get.
+
+- [`fcd4b8ac3`](https://github.com/firebase/firebase-js-sdk/commit/fcd4b8ac36636a60d83cd3370969ff9192f9e6ad) [#6508](https://github.com/firebase/firebase-js-sdk/pull/6508) - Fixed faulty transaction bug causing filtered index queries to override default queries.
+
 ## 0.13.4
 
 ### Patch Changes

package/dist/index.esm2017.js

@@ -4,7 +4,7 @@ import { stringify, jsonEval, contains, assert, isNodeSdk, base64, stringToByteA
 import { Logger, LogLevel } from '@firebase/logger';
 
 const name = "@firebase/database";
-const version = "0.13.4";
+const version = "0.13.5-20220818183912";
 
 /**
  * @license
@@ -9135,7 +9135,7 @@ function viewProcessorApplyServerMerge(viewProcessor, viewCache, path, changedCh
     });
     viewMergeTree.children.inorderTraversal((childKey, childMergeTree) => {
         const isUnknownDeepMerge = !viewCache.serverCache.isCompleteForChild(childKey) &&
-            childMergeTree.value === undefined;
+            childMergeTree.value === null;
         if (!serverNode.hasChild(childKey) && !isUnknownDeepMerge) {
             const serverChild = viewCache.serverCache
                 .getNode()
@@ -9774,9 +9774,11 @@ function syncTreeApplyTaggedListenComplete(syncTree, path, tag) {
  *
  * @param eventRegistration - If null, all callbacks are removed.
  * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
+ * @param skipListenerDedup - When performing a `get()`, we don't add any new listeners, so no
+ *  deduping needs to take place. This flag allows toggling of that behavior
  * @returns Cancel events, if cancelError was provided.
  */
-function syncTreeRemoveEventRegistration(syncTree, query, eventRegistration, cancelError) {
+function syncTreeRemoveEventRegistration(syncTree, query, eventRegistration, cancelError, skipListenerDedup = false) {
     // Find the syncPoint first. Then deal with whether or not it has matching listeners
     const path = query._path;
     const maybeSyncPoint = syncTree.syncPointTree_.get(path);
@@ -9793,48 +9795,52 @@ function syncTreeRemoveEventRegistration(syncTree, query, eventRegistration, can
         }
         const removed = removedAndEvents.removed;
         cancelEvents = removedAndEvents.events;
-        // We may have just removed one of many listeners and can short-circuit this whole process
-        // We may also not have removed a default listener, in which case all of the descendant listeners should already be
-        // properly set up.
-        //
-        // Since indexed queries can shadow if they don't have other query constraints, check for loadsAllData(), instead of
-        // queryId === 'default'
-        const removingDefault = -1 !==
-            removed.findIndex(query => {
-                return query._queryParams.loadsAllData();
-            });
-        const covered = syncTree.syncPointTree_.findOnPath(path, (relativePath, parentSyncPoint) => syncPointHasCompleteView(parentSyncPoint));
-        if (removingDefault && !covered) {
-            const subtree = syncTree.syncPointTree_.subtree(path);
-            // There are potentially child listeners. Determine what if any listens we need to send before executing the
-            // removal
-            if (!subtree.isEmpty()) {
-                // We need to fold over our subtree and collect the listeners to send
-                const newViews = syncTreeCollectDistinctViewsForSubTree_(subtree);
-                // Ok, we've collected all the listens we need. Set them up.
-                for (let i = 0; i < newViews.length; ++i) {
-                    const view = newViews[i], newQuery = view.query;
-                    const listener = syncTreeCreateListenerForView_(syncTree, view);
-                    syncTree.listenProvider_.startListening(syncTreeQueryForListening_(newQuery), syncTreeTagForQuery_(syncTree, newQuery), listener.hashFn, listener.onComplete);
-                }
-            }
-        }
-        // If we removed anything and we're not covered by a higher up listen, we need to stop listening on this query
-        // The above block has us covered in terms of making sure we're set up on listens lower in the tree.
-        // Also, note that if we have a cancelError, it's already been removed at the provider level.
-        if (!covered && removed.length > 0 && !cancelError) {
-            // If we removed a default, then we weren't listening on any of the other queries here. Just cancel the one
-            // default. Otherwise, we need to iterate through and cancel each individual query
-            if (removingDefault) {
-                // We don't tag default listeners
-                const defaultTag = null;
-                syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(query), defaultTag);
-            }
-            else {
-                removed.forEach((queryToRemove) => {
-                    const tagToRemove = syncTree.queryToTagMap.get(syncTreeMakeQueryKey_(queryToRemove));
-                    syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToRemove), tagToRemove);
+        if (!skipListenerDedup) {
+            /**
+             * We may have just removed one of many listeners and can short-circuit this whole process
+             * We may also not have removed a default listener, in which case all of the descendant listeners should already be
+             * properly set up.
+             */
+            // Since indexed queries can shadow if they don't have other query constraints, check for loadsAllData(), instead of
+            // queryId === 'default'
+            const removingDefault = -1 !==
+                removed.findIndex(query => {
+                    return query._queryParams.loadsAllData();
                 });
+            const covered = syncTree.syncPointTree_.findOnPath(path, (relativePath, parentSyncPoint) => syncPointHasCompleteView(parentSyncPoint));
+            if (removingDefault && !covered) {
+                const subtree = syncTree.syncPointTree_.subtree(path);
+                // There are potentially child listeners. Determine what if any listens we need to send before executing the
+                // removal
+                if (!subtree.isEmpty()) {
+                    // We need to fold over our subtree and collect the listeners to send
+                    const newViews = syncTreeCollectDistinctViewsForSubTree_(subtree);
+                    // Ok, we've collected all the listens we need. Set them up.
+                    for (let i = 0; i < newViews.length; ++i) {
+                        const view = newViews[i], newQuery = view.query;
+                        const listener = syncTreeCreateListenerForView_(syncTree, view);
+                        syncTree.listenProvider_.startListening(syncTreeQueryForListening_(newQuery), syncTreeTagForQuery(syncTree, newQuery), listener.hashFn, listener.onComplete);
+                    }
+                }
+                // Otherwise there's nothing below us, so nothing we need to start listening on
+            }
+            // If we removed anything and we're not covered by a higher up listen, we need to stop listening on this query
+            // The above block has us covered in terms of making sure we're set up on listens lower in the tree.
+            // Also, note that if we have a cancelError, it's already been removed at the provider level.
+            if (!covered && removed.length > 0 && !cancelError) {
+                // If we removed a default, then we weren't listening on any of the other queries here. Just cancel the one
+                // default. Otherwise, we need to iterate through and cancel each individual query
+                if (removingDefault) {
+                    // We don't tag default listeners
+                    const defaultTag = null;
+                    syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(query), defaultTag);
+                }
+                else {
+                    removed.forEach((queryToRemove) => {
+                        const tagToRemove = syncTree.queryToTagMap.get(syncTreeMakeQueryKey_(queryToRemove));
+                        syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToRemove), tagToRemove);
+                    });
+                }
             }
         }
         // Now, clear all of the tags we're tracking for the removed listens
@@ -9842,30 +9848,6 @@ function syncTreeRemoveEventRegistration(syncTree, query, eventRegistration, can
     }
     return cancelEvents;
 }
-/**
- * This function was added to support non-listener queries,
- * specifically for use in repoGetValue. It sets up all the same
- * local cache data-structures (SyncPoint + View) that are
- * needed for listeners without installing an event registration.
- * If `query` is not `loadsAllData`, it will also provision a tag for
- * the query so that query results can be merged into the sync
- * tree using existing logic for tagged listener queries.
- *
- * @param syncTree - Synctree to add the query to.
- * @param query - Query to register
- * @returns tag as a string if query is not a default query, null if query is not.
- */
-function syncTreeRegisterQuery(syncTree, query) {
-    const { syncPoint, serverCache, writesCache, serverCacheComplete } = syncTreeRegisterSyncPoint(query, syncTree);
-    const view = syncPointGetView(syncPoint, query, writesCache, serverCache, serverCacheComplete);
-    if (!syncPoint.views.has(query._queryIdentifier)) {
-        syncPoint.views.set(query._queryIdentifier, view);
-    }
-    if (!query._queryParams.loadsAllData()) {
-        return syncTreeTagForQuery_(syncTree, query);
-    }
-    return null;
-}
 /**
  * Apply new server data for the specified tagged query.
  *
@@ -9906,11 +9888,11 @@ function syncTreeApplyTaggedQueryMerge(syncTree, path, changedChildren, tag) {
     }
 }
 /**
- * Creates a new syncpoint for a query and creates a tag if the view doesn't exist.
- * Extracted from addEventRegistration to allow `repoGetValue` to properly set up the SyncTree
- * without actually listening on a query.
+ * Add an event callback for the specified query.
+ *
+ * @returns Events to raise.
  */
-function syncTreeRegisterSyncPoint(query, syncTree) {
+function syncTreeAddEventRegistration(syncTree, query, eventRegistration, skipSetupListener = false) {
     const path = query._path;
     let serverCache = null;
     let foundAncestorDefaultView = false;
@@ -9959,24 +9941,8 @@ function syncTreeRegisterSyncPoint(query, syncTree) {
         syncTree.tagToQueryMap.set(tag, queryKey);
     }
     const writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, path);
-    return {
-        syncPoint,
-        writesCache,
-        serverCache,
-        serverCacheComplete,
-        foundAncestorDefaultView,
-        viewAlreadyExists
-    };
-}
-/**
- * Add an event callback for the specified query.
- *
- * @returns Events to raise.
- */
-function syncTreeAddEventRegistration(syncTree, query, eventRegistration) {
-    const { syncPoint, serverCache, writesCache, serverCacheComplete, viewAlreadyExists, foundAncestorDefaultView } = syncTreeRegisterSyncPoint(query, syncTree);
     let events = syncPointAddEventRegistration(syncPoint, query, eventRegistration, writesCache, serverCache, serverCacheComplete);
-    if (!viewAlreadyExists && !foundAncestorDefaultView) {
+    if (!viewAlreadyExists && !foundAncestorDefaultView && !skipSetupListener) {
         const view = syncPointViewForQuery(syncPoint, query);
         events = events.concat(syncTreeSetupListener_(syncTree, query, view));
     }
@@ -10106,7 +10072,7 @@ function syncTreeApplyOperationDescendantsHelper_(operation, syncPointTree, serv
 }
 function syncTreeCreateListenerForView_(syncTree, view) {
     const query = view.query;
-    const tag = syncTreeTagForQuery_(syncTree, query);
+    const tag = syncTreeTagForQuery(syncTree, query);
     return {
         hashFn: () => {
             const cache = viewGetServerCache(view) || ChildrenNode.EMPTY_NODE;
@@ -10134,7 +10100,7 @@ function syncTreeCreateListenerForView_(syncTree, view) {
 /**
  * Return the tag associated with the given query.
  */
-function syncTreeTagForQuery_(syncTree, query) {
+function syncTreeTagForQuery(syncTree, query) {
     const queryKey = syncTreeMakeQueryKey_(query);
     return syncTree.queryToTagMap.get(queryKey);
 }
@@ -10234,7 +10200,7 @@ function syncTreeGetNextQueryTag_() {
  */
 function syncTreeSetupListener_(syncTree, query, view) {
     const path = query._path;
-    const tag = syncTreeTagForQuery_(syncTree, query);
+    const tag = syncTreeTagForQuery(syncTree, query);
     const listener = syncTreeCreateListenerForView_(syncTree, view);
     const events = syncTree.listenProvider_.startListening(syncTreeQueryForListening_(query), tag, listener.hashFn, listener.onComplete);
     const subtree = syncTree.syncPointTree_.subtree(path);
@@ -10265,7 +10231,7 @@ function syncTreeSetupListener_(syncTree, query, view) {
         });
         for (let i = 0; i < queriesToStop.length; ++i) {
             const queryToStop = queriesToStop[i];
-            syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToStop), syncTreeTagForQuery_(syncTree, queryToStop));
+            syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToStop), syncTreeTagForQuery(syncTree, queryToStop));
         }
     }
     return events;
@@ -11190,14 +11156,14 @@ function repoGetNextWriteId(repo) {
  * belonging to active listeners. If they are found, such values
  * are considered to be the most up-to-date.
  *
- * If the client is not connected, this method will try to
- * establish a connection and request the value for `query`. If
- * the client is not able to retrieve the query result, it reports
- * an error.
+ * If the client is not connected, this method will wait until the
+ *  repo has established a connection and then request the value for `query`.
+ * If the client is not able to retrieve the query result for another reason,
+ * it reports an error.
  *
  * @param query - The query to surface a value for.
  */
-function repoGetValue(repo, query) {
+function repoGetValue(repo, query, eventRegistration) {
     // Only active queries are cached. There is no persisted cache.
     const cached = syncTreeGetServerValue(repo.serverSyncTree_, query);
     if (cached != null) {
@@ -11205,24 +11171,34 @@ function repoGetValue(repo, query) {
     }
     return repo.server_.get(query).then(payload => {
         const node = nodeFromJSON(payload).withIndex(query._queryParams.getIndex());
-        // if this is a filtered query, then overwrite at path
+        /**
+         * Below we simulate the actions of an `onlyOnce` `onValue()` event where:
+         * Add an event registration,
+         * Update data at the path,
+         * Raise any events,
+         * Cleanup the SyncTree
+         */
+        syncTreeAddEventRegistration(repo.serverSyncTree_, query, eventRegistration, true);
+        let events;
         if (query._queryParams.loadsAllData()) {
-            syncTreeApplyServerOverwrite(repo.serverSyncTree_, query._path, node);
+            events = syncTreeApplyServerOverwrite(repo.serverSyncTree_, query._path, node);
         }
         else {
-            // Simulate `syncTreeAddEventRegistration` without events/listener setup.
-            // We do this (along with the syncTreeRemoveEventRegistration` below) so that
-            // `repoGetValue` results have the same cache effects as initial listener(s)
-            // updates.
-            const tag = syncTreeRegisterQuery(repo.serverSyncTree_, query);
-            syncTreeApplyTaggedQueryOverwrite(repo.serverSyncTree_, query._path, node, tag);
-            // Call `syncTreeRemoveEventRegistration` with a null event registration, since there is none.
-            // Note: The below code essentially unregisters the query and cleans up any views/syncpoints temporarily created above.
-        }
-        const cancels = syncTreeRemoveEventRegistration(repo.serverSyncTree_, query, null);
-        if (cancels.length > 0) {
-            repoLog(repo, 'unexpected cancel events in repoGetValue');
+            const tag = syncTreeTagForQuery(repo.serverSyncTree_, query);
+            events = syncTreeApplyTaggedQueryOverwrite(repo.serverSyncTree_, query._path, node, tag);
         }
+        /*
+         * We need to raise events in the scenario where `get()` is called at a parent path, and
+         * while the `get()` is pending, `onValue` is called at a child location. While get() is waiting
+         * for the data, `onValue` will register a new event. Then, get() will come back, and update the syncTree
+         * and its corresponding serverCache, including the child location where `onValue` is called. Then,
+         * `onValue` will receive the event from the server, but look at the syncTree and see that the data received
+         * from the server is already at the SyncPoint, and so the `onValue` callback will never get fired.
+         * Calling `eventQueueRaiseEventsForChangedPath()` is the correct way to propagate the events and
+         * ensure the corresponding child events will get fired.
+         */
+        eventQueueRaiseEventsForChangedPath(repo.eventQueue_, query._path, events);
+        syncTreeRemoveEventRegistration(repo.serverSyncTree_, query, eventRegistration, null, true);
         return node;
     }, err => {
         repoLog(repo, 'get for query ' + stringify(query) + ' failed: ' + err);
@@ -12905,7 +12881,9 @@ function update(ref, values) {
  */
 function get(query) {
     query = getModularInstance(query);
-    return repoGetValue(query._repo, query).then(node => {
+    const callbackContext = new CallbackContext(() => { });
+    const container = new ValueEventRegistration(callbackContext);
+    return repoGetValue(query._repo, query, container).then(node => {
         return new DataSnapshot(node, new ReferenceImpl(query._repo, query._path), query._queryParams.getIndex());
     });
 }