Allow priority requests to go to the front of the sequential queue

src/ONYXKEYS.js

@@ -243,17 +243,12 @@ export default {
     // Experimental memory only Onyx mode flag
     IS_USING_MEMORY_ONLY_KEYS: 'isUsingMemoryOnlyKeys',
 
+    // The ID of the last Onyx update that was applied to this client
+    ONYX_UPDATES_LAST_UPDATE_ID: 'onyxUpdatesLastUpdateID',
+
     // The access token to be used with the Mapbox library
     MAPBOX_ACCESS_TOKEN: 'mapboxAccessToken',
 
-    ONYX_UPDATES: {
-        // The ID of the last Onyx update that was applied to this client
-        LAST_UPDATE_ID: 'onyxUpdatesLastUpdateID',
-
-        // The ID of the previous Onyx update that was applied to this client
-        PREVIOUS_UPDATE_ID: 'onyxUpdatesPreviousUpdateID',
-    },
-
     // Manual request tab selector
     SELECTED_TAB: 'selectedTab',
 

src/libs/API.js

@@ -36,8 +36,9 @@ Request.use(Middleware.SaveResponseInOnyx);
  * @param {Object} [onyxData.optimisticData] - Onyx instructions that will be passed to Onyx.update() before the request is made.
  * @param {Object} [onyxData.successData] - Onyx instructions that will be passed to Onyx.update() when the response has jsonCode === 200.
  * @param {Object} [onyxData.failureData] - Onyx instructions that will be passed to Onyx.update() when the response has jsonCode !== 200.
+ * @param {Boolean} [prioritizeRequest] Whether or not the request should be prioritized at the front of the queue or placed onto the back of the queue
  */
-function write(command, apiCommandParameters = {}, onyxData = {}) {
+function write(command, apiCommandParameters = {}, onyxData = {}, prioritizeRequest = false) {
     Log.info('Called API write', false, {command, ...apiCommandParameters});
 
     // Optimistically update Onyx
@@ -66,7 +67,7 @@ function write(command, apiCommandParameters = {}, onyxData = {}) {
     };
 
     // Write commands can be saved and retried, so push it to the SequentialQueue
-    SequentialQueue.push(request);
+    SequentialQueue.push(request, prioritizeRequest);
 }
 
 /**

src/libs/Navigation/AppNavigator/AuthScreens.js

@@ -330,7 +330,7 @@ export default compose(
             key: ONYXKEYS.IS_USING_MEMORY_ONLY_KEYS,
         },
         onyxUpdatesLastUpdateID: {
-            key: ONYXKEYS.ONYX_UPDATES.LAST_UPDATE_ID,
+            key: ONYXKEYS.ONYX_UPDATES_LAST_UPDATE_ID,
         },
     }),
 )(AuthScreens);

src/libs/Network/SequentialQueue.js

@@ -101,10 +101,11 @@ NetworkStore.onReconnection(flush);
 
 /**
  * @param {Object} request
+ * @param {Boolean} [front] whether or not the request should be placed in the front of the queue
  */
-function push(request) {
+function push(request, front = false) {
     // Add request to Persisted Requests so that it can be retried if it fails
-    PersistedRequests.save([request]);
+    PersistedRequests.save([request], front);
 
     // If we are offline we don't need to trigger the queue to empty as it will happen when we come back online
     if (NetworkStore.isOffline()) {

src/libs/actions/App.js

@@ -183,8 +183,9 @@ function openApp() {
  * Fetches data when the app reconnects to the network
  * @param {Number} [updateIDFrom] the ID of the Onyx update that we want to start fetching from
  * @param {Number} [updateIDTo] the ID of the Onyx update that we want to fetch up to
+ * @param {Boolean} [prioritizeRequest] whether or not the request should be put at the front of the sequential queue before other requests
  */
-function reconnectApp(updateIDFrom = 0, updateIDTo = 0) {
+function reconnectApp(updateIDFrom = 0, updateIDTo = 0, prioritizeRequest = false) {
     console.debug(`[OnyxUpdates] App reconnecting with updateIDFrom: ${updateIDFrom} and updateIDTo: ${updateIDTo}`);
     getPolicyParamsForOpenOrReconnect().then((policyParams) => {
         const params = {...policyParams};
@@ -208,7 +209,7 @@ function reconnectApp(updateIDFrom = 0, updateIDTo = 0) {
             params.updateIDTo = updateIDTo;
         }
 
-        API.write('ReconnectApp', params, getOnyxDataForOpenOrReconnect());
+        API.write('ReconnectApp', params, getOnyxDataForOpenOrReconnect(), prioritizeRequest);
     });
 }
 

src/libs/actions/PersistedRequests.js

@@ -15,9 +15,14 @@ function clear() {
 
 /**
  * @param {Array} requestsToPersist
+ * @param {Boolean} [front] whether or not the request should go in the front of the queue
  */
-function save(requestsToPersist) {
-    persistedRequests = persistedRequests.concat(requestsToPersist);
+function save(requestsToPersist, front = false) {
+    if (persistedRequests.length) {
+        persistedRequests = front ? persistedRequests.unshift(...requestsToPersist) : persistedRequests.concat(requestsToPersist);
+    } else {
+        persistedRequests = requestsToPersist;
+    }
     Onyx.set(ONYXKEYS.PERSISTED_REQUESTS, persistedRequests);
 }
 

src/libs/actions/User.js

@@ -18,6 +18,8 @@ import * as ReportActionsUtils from '../ReportActionsUtils';
 import * as ErrorUtils from '../ErrorUtils';
 import * as Session from './Session';
 import * as PersonalDetails from './PersonalDetails';
+import * as App from './App';
+import Log from '../Log';
 
 let currentUserAccountID = '';
 let currentEmail = '';
@@ -41,6 +43,12 @@ Onyx.connect({
     },
 });
 
+let onyxUpdatesLastUpdateID;
+Onyx.connect({
+    key: ONYXKEYS.ONYX_UPDATES_LAST_UPDATE_ID,
+    callback: (val) => (onyxUpdatesLastUpdateID = val),
+});
+
 /**
  * Attempt to close the user's account
  *
@@ -558,15 +566,29 @@ function subscribeToUserEvents() {
             // until we finish the migration to reliable updates. So let's check it before actually updating
             // the properties in Onyx
             if (pushJSON.lastUpdateID && pushJSON.previousUpdateID) {
-                console.debug('[OnyxUpdates] Received lastUpdateID from pusher', pushJSON.lastUpdateID);
-                console.debug('[OnyxUpdates] Received previousUpdateID from pusher', pushJSON.previousUpdateID);
-                // Store these values in Onyx to allow App.reconnectApp() to fetch incremental updates from the server when a previous session is being reconnected to.
-                Onyx.multiSet({
-                    [ONYXKEYS.ONYX_UPDATES.LAST_UPDATE_ID]: Number(pushJSON.lastUpdateID || 0),
-                    [ONYXKEYS.ONYX_UPDATES.PREVIOUS_UPDATE_ID]: Number(pushJSON.previousUpdateID || 0),
-                });
+                const pushJSONLastUpdateID = Number(pushJSON.lastUpdateID || 0);
+                const pushJSONPreviousUpdateID = Number(pushJSON.previousUpdateID || 0);
+
+                console.debug('[OnyxUpdates] Received lastUpdateID from pusher', pushJSONLastUpdateID);
+                console.debug('[OnyxUpdates] Received previousUpdateID from pusher', pushJSONPreviousUpdateID);
+                console.debug('[OnyxUpdates] The lastUpdateID the client received was', onyxUpdatesLastUpdateID);
+
+                // Store this value in Onyx to allow AuthScreens to fetch incremental updates from the server when a previous session is being reconnected to.
+                Onyx.set(ONYXKEYS.ONYX_UPDATES_LAST_UPDATE_ID, pushJSONLastUpdateID);
+
+                // The previous update from the server does not match the last update the client got which means the client is missing some updates.
+                // ReconnectApp will fetch updates starting from the last update this client got and going to the last update the server sent.
+                if (onyxUpdatesLastUpdateID < pushJSONPreviousUpdateID) {
+                    console.debug('[OnyxUpdates] Gap detected in update IDs so fetching incremental updates');
+                    Log.info('Gap detected in update IDs from Pusher so fetching incremental updates', true, {
+                        lastUpdateIDFromPusher: pushJSONLastUpdateID,
+                        previousUpdateIDFromPusher: pushJSONPreviousUpdateID,
+                        lastUpdateIDOnClient: onyxUpdatesLastUpdateID,
+                    });
+                    App.reconnectApp(onyxUpdatesLastUpdateID, pushJSONLastUpdateID, true);
+                }
             } else {
-                console.debug('[OnyxUpdates] No lastUpdateID and previousUpdateID provided');
+                console.debug('[OnyxUpdates] No lastUpdateID and previousUpdateID provided from Pusher');
             }
         }
         _.each(updates, (multipleEvent) => {