@firebase/database 0.13.4 → 0.13.5-20220816211541

package/dist/index.standalone.js

@@ -9390,7 +9390,7 @@ function viewProcessorApplyServerMerge(viewProcessor, viewCache, path, changedCh
     });
     viewMergeTree.children.inorderTraversal(function (childKey, childMergeTree) {
         var isUnknownDeepMerge = !viewCache.serverCache.isCompleteForChild(childKey) &&
-            childMergeTree.value === undefined;
+            childMergeTree.value === null;
         if (!serverNode.hasChild(childKey) && !isUnknownDeepMerge) {
             var serverChild = viewCache.serverCache
                 .getNode()
@@ -10092,9 +10092,12 @@ 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) {
+    if (skipListenerDedup === void 0) { skipListenerDedup = false; }
     // Find the syncPoint first. Then deal with whether or not it has matching listeners
     var path = query._path;
     var maybeSyncPoint = syncTree.syncPointTree_.get(path);
@@ -10111,50 +10114,54 @@ function syncTreeRemoveEventRegistration(syncTree, query, eventRegistration, can
         }
         var 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'
-        var removingDefault = -1 !==
-            removed.findIndex(function (query) {
-                return query._queryParams.loadsAllData();
+        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'
+            var removingDefault = -1 !==
+                removed.findIndex(function (query) {
+                    return query._queryParams.loadsAllData();
+                });
+            var covered = syncTree.syncPointTree_.findOnPath(path, function (relativePath, parentSyncPoint) {
+                return syncPointHasCompleteView(parentSyncPoint);
             });
-        var covered = syncTree.syncPointTree_.findOnPath(path, function (relativePath, parentSyncPoint) {
-            return syncPointHasCompleteView(parentSyncPoint);
-        });
-        if (removingDefault && !covered) {
-            var 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
-                var newViews = syncTreeCollectDistinctViewsForSubTree_(subtree);
-                // Ok, we've collected all the listens we need. Set them up.
-                for (var i = 0; i < newViews.length; ++i) {
-                    var view = newViews[i], newQuery = view.query;
-                    var listener = syncTreeCreateListenerForView_(syncTree, view);
-                    syncTree.listenProvider_.startListening(syncTreeQueryForListening_(newQuery), syncTreeTagForQuery_(syncTree, newQuery), listener.hashFn, listener.onComplete);
+            if (removingDefault && !covered) {
+                var 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
+                    var newViews = syncTreeCollectDistinctViewsForSubTree_(subtree);
+                    // Ok, we've collected all the listens we need. Set them up.
+                    for (var i = 0; i < newViews.length; ++i) {
+                        var view = newViews[i], newQuery = view.query;
+                        var 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
+                    var defaultTag = null;
+                    syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(query), defaultTag);
+                }
+                else {
+                    removed.forEach(function (queryToRemove) {
+                        var tagToRemove = syncTree.queryToTagMap.get(syncTreeMakeQueryKey_(queryToRemove));
+                        syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToRemove), tagToRemove);
+                    });
                 }
-            }
-        }
-        // 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
-                var defaultTag = null;
-                syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(query), defaultTag);
-            }
-            else {
-                removed.forEach(function (queryToRemove) {
-                    var 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
@@ -10162,30 +10169,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) {
-    var _a = syncTreeRegisterSyncPoint(query, syncTree), syncPoint = _a.syncPoint, serverCache = _a.serverCache, writesCache = _a.writesCache, serverCacheComplete = _a.serverCacheComplete;
-    var 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.
  *
@@ -10226,11 +10209,12 @@ 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) {
+    if (skipSetupListener === void 0) { skipSetupListener = false; }
     var path = query._path;
     var serverCache = null;
     var foundAncestorDefaultView = false;
@@ -10279,24 +10263,8 @@ function syncTreeRegisterSyncPoint(query, syncTree) {
         syncTree.tagToQueryMap.set(tag, queryKey);
     }
     var writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, path);
-    return {
-        syncPoint: syncPoint,
-        writesCache: writesCache,
-        serverCache: serverCache,
-        serverCacheComplete: serverCacheComplete,
-        foundAncestorDefaultView: foundAncestorDefaultView,
-        viewAlreadyExists: viewAlreadyExists
-    };
-}
-/**
- * Add an event callback for the specified query.
- *
- * @returns Events to raise.
- */
-function syncTreeAddEventRegistration(syncTree, query, eventRegistration) {
-    var _a = syncTreeRegisterSyncPoint(query, syncTree), syncPoint = _a.syncPoint, serverCache = _a.serverCache, writesCache = _a.writesCache, serverCacheComplete = _a.serverCacheComplete, viewAlreadyExists = _a.viewAlreadyExists, foundAncestorDefaultView = _a.foundAncestorDefaultView;
     var events = syncPointAddEventRegistration(syncPoint, query, eventRegistration, writesCache, serverCache, serverCacheComplete);
-    if (!viewAlreadyExists && !foundAncestorDefaultView) {
+    if (!viewAlreadyExists && !foundAncestorDefaultView && !skipSetupListener) {
         var view = syncPointViewForQuery(syncPoint, query);
         events = events.concat(syncTreeSetupListener_(syncTree, query, view));
     }
@@ -10426,7 +10394,7 @@ function syncTreeApplyOperationDescendantsHelper_(operation, syncPointTree, serv
 }
 function syncTreeCreateListenerForView_(syncTree, view) {
     var query = view.query;
-    var tag = syncTreeTagForQuery_(syncTree, query);
+    var tag = syncTreeTagForQuery(syncTree, query);
     return {
         hashFn: function () {
             var cache = viewGetServerCache(view) || ChildrenNode.EMPTY_NODE;
@@ -10454,7 +10422,7 @@ function syncTreeCreateListenerForView_(syncTree, view) {
 /**
  * Return the tag associated with the given query.
  */
-function syncTreeTagForQuery_(syncTree, query) {
+function syncTreeTagForQuery(syncTree, query) {
     var queryKey = syncTreeMakeQueryKey_(query);
     return syncTree.queryToTagMap.get(queryKey);
 }
@@ -10554,7 +10522,7 @@ function syncTreeGetNextQueryTag_() {
  */
 function syncTreeSetupListener_(syncTree, query, view) {
     var path = query._path;
-    var tag = syncTreeTagForQuery_(syncTree, query);
+    var tag = syncTreeTagForQuery(syncTree, query);
     var listener = syncTreeCreateListenerForView_(syncTree, view);
     var events = syncTree.listenProvider_.startListening(syncTreeQueryForListening_(query), tag, listener.hashFn, listener.onComplete);
     var subtree = syncTree.syncPointTree_.subtree(path);
@@ -10585,7 +10553,7 @@ function syncTreeSetupListener_(syncTree, query, view) {
         });
         for (var i = 0; i < queriesToStop.length; ++i) {
             var queryToStop = queriesToStop[i];
-            syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToStop), syncTreeTagForQuery_(syncTree, queryToStop));
+            syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToStop), syncTreeTagForQuery(syncTree, queryToStop));
         }
     }
     return events;
@@ -11522,14 +11490,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.
     var cached = syncTreeGetServerValue(repo.serverSyncTree_, query);
     if (cached != null) {
@@ -11537,24 +11505,34 @@ function repoGetValue(repo, query) {
     }
     return repo.server_.get(query).then(function (payload) {
         var 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);
+        var 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.
-            var 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.
-        }
-        var cancels = syncTreeRemoveEventRegistration(repo.serverSyncTree_, query, null);
-        if (cancels.length > 0) {
-            repoLog(repo, 'unexpected cancel events in repoGetValue');
+            var 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;
     }, function (err) {
         repoLog(repo, 'get for query ' + util.stringify(query) + ' failed: ' + err);
@@ -13314,7 +13292,9 @@ function update(ref, values) {
  */
 function get(query) {
     query = util.getModularInstance(query);
-    return repoGetValue(query._repo, query).then(function (node) {
+    var callbackContext = new CallbackContext(function () { });
+    var container = new ValueEventRegistration(callbackContext);
+    return repoGetValue(query._repo, query, container).then(function (node) {
         return new DataSnapshot(node, new ReferenceImpl(query._repo, query._path), query._queryParams.getIndex());
     });
 }