Revert "Unpausing the queue when we receive Pusher updates while we're still loading the App"

src/libs/actions/OnyxUpdateManager.ts

@@ -41,18 +41,11 @@ export default () => {
     Onyx.connect({
         key: ONYXKEYS.ONYX_UPDATES_FROM_SERVER,
         callback: (value) => {
-            // When there's no value, there's nothing to process, so let's return early.
-            if (!value) {
-                return;
-            }
-            // If isLoadingApp is positive it means that OpenApp command hasn't finished yet, and in that case
-            // we don't have base state of the app (reports, policies, etc) setup. If we apply this update,
-            // we'll only have them overriten by the openApp response. So let's skip it and return.
-            if (isLoadingApp) {
-                // When ONYX_UPDATES_FROM_SERVER is set, we pause the queue. Let's unpause
-                // it so the app is not stuck forever without processing requests.
-                SequentialQueue.unpause();
-                console.debug(`[OnyxUpdateManager] Ignoring Onyx updates while OpenApp hans't finished yet.`);
+            // When the OpenApp command hasn't finished yet, we should not process any updates.
+            if (!value || isLoadingApp) {
+                if (isLoadingApp) {
+                    console.debug(`[OnyxUpdateManager] Ignoring Onyx updates while OpenApp hans't finished yet.`);
+                }
                 return;
             }
             // This key is shared across clients, thus every client/tab will have a copy and try to execute this method.
@@ -87,6 +80,11 @@ export default () => {
             // fully migrating to the reliable updates mode.
             // 2. This client already has the reliable updates mode enabled, but it's missing some updates and it
             // needs to fetch those.
+            //
+            // For both of those, we need to pause the sequential queue. This is important so that the updates are
+            // applied in their correct and specific order. If this queue was not paused, then there would be a lot of
+            // onyx data being applied while we are fetching the missing updates and that would put them all out of order.
+            SequentialQueue.pause();
             let canUnpauseQueuePromise;
 
             // The flow below is setting the promise to a reconnect app to address flow (1) explained above.

src/libs/actions/OnyxUpdates.ts

@@ -119,9 +119,6 @@ function apply({lastUpdateID, type, request, response, updates}: OnyxUpdatesFrom
  * @param [updateParams.updates] Exists if updateParams.type === 'pusher'
  */
 function saveUpdateInformation(updateParams: OnyxUpdatesFromServer) {
-    // Unpause the Sequential queue so we go back to processing requests to guarantee we don't make the app unusable
-    SequentialQueue.unpause();
-
     // Always use set() here so that the updateParams are never merged and always unique to the request that came in
     Onyx.set(ONYXKEYS.ONYX_UPDATES_FROM_SERVER, updateParams);
 }
@@ -151,6 +148,9 @@ function applyOnyxUpdatesReliably(updates: OnyxUpdatesFromServer) {
         apply(updates);
         return;
     }
+
+    // If we reached this point, we need to pause the queue while we prepare to fetch older OnyxUpdates.
+    SequentialQueue.pause();
     saveUpdateInformation(updates);
 }