@wix/himalaya-cli 0.1391.0 → 0.1393.0

package/templates/portfolio-creative/tier5-src/himi-branded-lite-cart/index.ts

@@ -24,25 +24,33 @@ async function resolveMsid(): Promise<string> {
   }
 }
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
-import { getAll, upsert, remove as dbRemove, enqueue, type DbEntity } from "@himalaya/local-db";
-import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
+import { getAll, upsert, remove as dbRemove, type DbEntity } from "@himalaya/local-db";
+import { isOfflineFailure, writeMayHaveLanded } from "../_shared/owner-load-error.js";
 
 // Offline-first (data-offline): the cart is READ-THROUGH — paint the last-synced line
 // items from the on-device `cart` entity first (instant, works offline), then
-// revalidate from Wix and refresh the cache. `remove` is WRITE-BEHIND — the line is
-// dropped from the cache OPTIMISTICALLY, then the Wix write is attempted; if it can't
-// reach the bridge/network the removal is ENQUEUED for replay on reconnect. The
-// checkout redirect path is unchanged. Every local-db call is wrapped so a build
+// revalidate from Wix and refresh the cache.
+// `remove` drops the line from the cache only AFTER Wix confirms it; a failed removal
+// keeps the line on screen and says nothing was removed (no host replays a
+// queued write, so the old "removed offline" promise was a removal that never happened).
+// The checkout redirect path is unchanged. Every local-db call is wrapped so a build
 // without the `local_database` grant behaves exactly as before (online-only).
 const ENTITY = "cart";
 async function readCachedItems(): Promise<Row[]> {
   try { return (await getAll(ENTITY)) as unknown as Row[]; } catch { return []; }
 }
+/** Mirror the cart Wix returned: upsert its lines and drop any cached line it no longer has
+ *  (one removed elsewhere, or a removal whose answer was lost), so the offline paint never
+ *  shows a line that is gone. */
 async function writeCachedItems(rows: Row[]): Promise<void> {
-  try { for (const r of rows) await upsert(ENTITY, r as unknown as DbEntity); } catch { /* capability not granted → online-only */ }
+  try {
+    const keep = new Set(rows.map((r) => r.id));
+    for (const old of (await getAll(ENTITY)) as unknown as Row[]) if (!keep.has(old.id)) await dbRemove(ENTITY, old.id);
+    for (const r of rows) await upsert(ENTITY, r as unknown as DbEntity);
+  } catch { /* capability not granted → online-only */ }
 }
+
 async function cacheDrop(id: string): Promise<void> { try { await dbRemove(ENTITY, id); } catch { /* capability not granted */ } }
-async function queueWrite(actionId: string, params: Record<string, string>): Promise<void> { try { await enqueue(actionId, params); } catch { /* capability not granted */ } }
 
 interface Row {
   catalogReference?: { appId: string; catalogItemId: string; options?: Record<string, unknown> };
@@ -164,6 +172,39 @@ function derive(state: State): State {
   };
 }
 
+/** Remove one line (the trash button, and "−" at quantity 1). The cache drops it only once
+ *  Wix confirms; a failure keeps it on screen and says why. */
+/** Remove one line (the trash button, and "−" at quantity 1). The cache drops it only once
+ *  Wix confirms; a failure keeps it on screen and says why. */
+async function removeLine(state: State, id: string): Promise<State> {
+  try {
+    await removeLineItemsFromCurrentCart([id]);
+  } catch (e) {
+    // The line stays visible (and cached) until a read says otherwise.
+    if (isOfflineFailure(e)) {
+      return derive({ ...state, checkoutHint: copyParam("cart.removeOfflineFailedMessage", "You’re offline — nothing was removed. Try again when you reconnect.") });
+    }
+    // It may have landed (mid-request drop, after-send envelope, gateway 5xx): say so,
+    // rather than "could not remove".
+    if (writeMayHaveLanded(e)) {
+      return derive({ ...state, checkoutHint: copyParam("cart.removeUnconfirmedMessage", "The connection dropped, so this item may already be removed. Refresh to check.") });
+    }
+    return derive({ ...state, checkoutHint: copyParam("cart.removeFailedMessage", "Could not remove this item.") });
+  }
+  // Wix confirmed it: only now does the line leave the cache, and it stays gone even
+  // if the re-fetch below fails.
+  await cacheDrop(id);
+  const removed = copyParam("cart.itemRemovedMessage", "Item removed.");
+  try {
+    return await refresh(state, removed);
+  } catch {
+    // The totals Wix last sent still count the removed line, and the new ones did not
+    // arrive: show none rather than a wrong one.
+    const items = state.items.filter((it) => it.id !== id);
+    return derive({ ...state, status: "ready", items, subtotal: "", commerceSubtotal: "", emptyText: items.length ? "" : copyParam("cart.emptyText", "Your cart is empty."), checkoutHint: removed });
+  }
+}
+
 async function refresh(state: State, checkoutHint = ""): Promise<State> {
   const cart = await getCurrentCart();
   const items = (cart.lineItems ?? []).map(row);
@@ -240,21 +281,7 @@ const svc = defineService<State, {
     remove: async (state, arg) => {
       const id = itemId(arg);
       if (!id) return state;
-      // Optimistic local delete — the cart drops the row immediately (offline or not).
-      await cacheDrop(id);
-      try {
-        await removeLineItemsFromCurrentCart([id]);
-        return await refresh(state, copyParam("cart.itemRemovedMessage", "Item removed."));
-      } catch (e) {
-        if (isBridgeUnavailable(e)) {
-          // Offline / no bridge: the optimistic cache drop already shows; queue the
-          // removal to replay (WriteQueue, idempotent) when connectivity returns.
-          await queueWrite("tier5.himiStoreCart.remove", { id });
-          const items = state.items.filter((it) => it.id !== id);
-          return derive({ ...state, status: "ready", items, emptyText: items.length ? "" : copyParam("cart.emptyText", "Your cart is empty."), checkoutHint: copyParam("cart.removedOfflineMessage", "Removed offline — will sync when you reconnect.") });
-        }
-        return derive({ ...state, checkoutHint: copyParam("cart.removeFailedMessage", "Could not remove this item.") });
-      }
+      return removeLine(state, id);
     },
     increment: async (state, arg) => {
       const id = itemId(arg);
@@ -272,12 +299,9 @@ const svc = defineService<State, {
       const id = itemId(arg);
       const line = state.items.find((candidate) => candidate.id === id);
       if (!line) return state;
+      // Qty 1 − ⇒ remove the line (the control never dead-ends), with remove's handling.
+      if (line.quantity <= 1) return removeLine(state, id);
       try {
-        if (line.quantity <= 1) {
-          // Qty 1 − ⇒ remove the line (the control never dead-ends).
-          await removeLineItemsFromCurrentCart([id]);
-          return await refresh(state, copyParam("cart.itemRemovedMessage", "Item removed."));
-        }
         const cartId = (await getCurrentCart()).id || "";
         await updateLineItemQuantity(cartId, id, line.quantity - 1);
         return await refresh(state);