fix: make mobile recent work sync generation-safe (Closes #1485)

frontend/mobile-recent-work.js

@@ -15,9 +15,42 @@
   const setTimer = options.setTimeout || setTimeout;
   const clearTimer = options.clearTimeout || clearTimeout;
   const debounceMs = Number.isFinite(options.debounceMs) ? Math.max(0, options.debounceMs) : 150;
+  const retryMs = Number.isFinite(options.retryMs) ? Math.max(1, options.retryMs) : 1000;
+  const retryMaxMs = Number.isFinite(options.retryMaxMs) ? Math.max(retryMs, options.retryMaxMs) : 30000;
   let syncFlight = null;
   let syncAccount = '';
   let debounceTimer = null;
+  let retryTimer = null;
+  let retryAccount = '';
+  let retryAttempt = 0;
+  let operationSequence = 0;
+
+  function operationId() {
+    operationSequence += 1;
+    return Date.now().toString(36) + '-' + operationSequence.toString(36);
+  }
+
+  function clearRetry(resetAttempt = false) {
+    if (retryTimer) clearTimer(retryTimer);
+    retryTimer = null;
+    retryAccount = '';
+    if (resetAttempt) retryAttempt = 0;
+  }
+
+  function scheduleRetry(accountKey) {
+    if (retryTimer || key() !== accountKey || !hasPending(read())) return false;
+    retryAccount = accountKey;
+    const delay = Math.min(retryMaxMs, retryMs * (2 ** retryAttempt));
+    retryAttempt += 1;
+    retryTimer = setTimer(() => {
+      const timer = retryTimer;
+      retryTimer = null;
+      retryAccount = '';
+      if (timer) clearTimer(timer);
+      if (key() === accountKey && hasPending(read())) void sync();
+    }, delay);
+    return true;
+  }
 
   function login() {
     return String(getLogin?.() || '').trim().toLowerCase();
@@ -66,13 +99,28 @@
       const route = action === 'pin' ? item?.route : String(candidate?.route || '');
       if ((action !== 'pin' && action !== 'unpin') || !route || (action === 'pin' && !item)) continue;
       if (!unique.some(existing => (existing.item?.route || existing.route) === route)) {
-        unique.push(action === 'pin' ? {action, item} : {action, route});
+        const normalized = action === 'pin' ? {action, item} : {action, route};
+        if (typeof candidate.operationId === 'string' && candidate.operationId) normalized.operationId = candidate.operationId;
+        unique.push(normalized);
       }
       if (unique.length === pinnedLimit) break;
     }
     return unique;
   }
 
+  function normalizePending(value) {
+    if (!Array.isArray(value)) return [];
+    const unique = [];
+    for (const candidate of value) {
+      const item = normalize(candidate);
+      if (!item || unique.some(existing => existing.route === item.route)) continue;
+      if (typeof candidate.operationId === 'string' && candidate.operationId) item.operationId = candidate.operationId;
+      unique.push(item);
+      if (unique.length === limit) break;
+    }
+    return unique;
+  }
+
   function empty() {
     return {items:[], pinned:[], pending:[], pinOps:[]};
   }
@@ -86,7 +134,7 @@
       return {
         items:normalizeList(parsed?.items),
         pinned:normalizeList(parsed?.pinned, pinnedLimit),
-        pending:normalizeList(parsed?.pending),
+        pending:normalizePending(parsed?.pending),
         pinOps:normalizePinOps(parsed?.pinOps),
       };
     } catch (_) {
@@ -100,7 +148,7 @@
       storage.setItem(accountKey, JSON.stringify({
         items:normalizeList(value.items),
         pinned:normalizeList(value.pinned, pinnedLimit),
-        pending:normalizeList(value.pending),
+        pending:normalizePending(value.pending),
         pinOps:normalizePinOps(value.pinOps),
       }));
       return true;
@@ -149,7 +197,7 @@
     const current = read();
     current.items = [normalized, ...current.items.filter(existing => existing.route !== normalized.route)].slice(0, limit);
     current.pinned = current.pinned.map(existing => existing.route === normalized.route ? normalized : existing);
-    current.pending = [normalized, ...current.pending.filter(existing => existing.route !== normalized.route)].slice(0, limit);
+    current.pending = [{...normalized, operationId:operationId()}, ...current.pending.filter(existing => existing.route !== normalized.route)].slice(0, limit);
     if (!persist(current, accountKey)) return false;
     announce(current);
     render();
@@ -159,7 +207,7 @@
 
   function queuePinOp(current, operation) {
     const route = operation.item?.route || operation.route;
-    current.pinOps = [operation, ...current.pinOps.filter(existing => (existing.item?.route || existing.route) !== route)];
+    current.pinOps = [{...operation, operationId:operationId()}, ...current.pinOps.filter(existing => (existing.item?.route || existing.route) !== route)];
   }
 
   function pin(item) {
@@ -206,7 +254,7 @@
     if (key() !== accountKey || !snapshot || !Array.isArray(snapshot.items)) return false;
     const remote = normalizeList(snapshot.items);
     const remotePinned = normalizeList(snapshot.pinned, pinnedLimit);
-    const unsent = normalizeList(pending);
+    const unsent = normalizePending(pending);
     const unsentPinOps = normalizePinOps(pinOps);
     const value = {
       items:normalizeList([...unsent, ...remote]),
@@ -231,7 +279,7 @@
         let snapshot;
         if (sending) {
           snapshot = await fetchJson('api/v1/recent-work', {
-            method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(sending),
+            method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(normalize(sending)),
           });
         } else {
           const isPin = pinOperation.action === 'pin';
@@ -244,17 +292,21 @@
         if (key() !== accountKey) return read();
         const latest = read();
         const pending = sending
-          ? latest.pending.filter(item => item.route !== sending.route)
+          ? latest.pending.filter(item => item.operationId !== sending.operationId)
           : latest.pending;
         const pinOps = pinOperation
           ? latest.pinOps.filter(operation => {
             const sameRoute = (operation.item?.route || operation.route) === (pinOperation.item?.route || pinOperation.route);
-            return !sameRoute || operation.action !== pinOperation.action;
+            return !sameRoute || operation.action !== pinOperation.action || operation.operationId !== pinOperation.operationId;
           })
           : latest.pinOps;
         if (!adopt(snapshot, accountKey, pending, pinOps)) throw new Error('Recent work response is invalid.');
+        retryAttempt = 0;
       } catch (_error) {
-        if (key() === accountKey) announce(read());
+        if (key() === accountKey) {
+          announce(read());
+          scheduleRetry(accountKey);
+        }
         return read();
       }
     }
@@ -264,6 +316,8 @@
   function sync() {
     if (debounceTimer) { clearTimer(debounceTimer); debounceTimer = null; }
     const accountKey = key();
+    if (retryTimer && retryAccount !== accountKey) clearRetry(true);
+    else if (retryTimer) clearRetry(false);
     if (!fetchJson || !accountKey || !hasPending(read())) return Promise.resolve(read());
     if (syncFlight && syncAccount === accountKey) return syncFlight;
     syncAccount = accountKey;