@tapcart/mobile-components 0.18.0 → 0.18.1

package/dist/components/hooks/swr-retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swr-retry.d.ts","sourceRoot":"","sources":["../../../components/hooks/swr-retry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAE3C,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAOtC,eAAO,MAAM,YAAY,QAAS,OAAO,KAAG,OAG3C,CAAA;AAED,eAAO,MAAM,kBAAkB,QAAS,OAAO,KAAG,OAA6B,CAAA;AAiC/E,KAAK,YAAY,GAAG,WAAW,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC,CAAA;AACjE,KAAK,SAAS,GAAG,WAAW,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAA;AAE3D,MAAM,MAAM,cAAc,GAAG;IAC3B,eAAe,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,gBAAgB,CAAC,oBAAoB,CAAC,CAAA;IAC1D,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,SAAS,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,QAAO,cAkCpC,CAAA"}
+{"version":3,"file":"swr-retry.d.ts","sourceRoot":"","sources":["../../../components/hooks/swr-retry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAE3C,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAOtC,eAAO,MAAM,YAAY,QAAS,OAAO,KAAG,OAG3C,CAAA;AAmDD,eAAO,MAAM,kBAAkB,QAAS,OAAO,KAAG,OACE,CAAA;AAiCpD,KAAK,YAAY,GAAG,WAAW,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC,CAAA;AACjE,KAAK,SAAS,GAAG,WAAW,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAA;AAE3D,MAAM,MAAM,cAAc,GAAG;IAC3B,eAAe,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,gBAAgB,CAAC,oBAAoB,CAAC,CAAA;IAC1D,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,SAAS,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,QAAO,cAkCpC,CAAA"}

package/dist/components/hooks/swr-retry.js

@@ -8,7 +8,53 @@ export const isAbortError = (err) => {
         return false;
     return err.name === "AbortError";
 };
-export const shouldRetryOnError = (err) => !isAbortError(err);
+/**
+ * The 4xx statuses that mean "later", not "never" — the request may well succeed
+ * unchanged, so retrying is not wasted.
+ *
+ * 425 Too Early is deliberately absent: it only arises from TLS 1.3 early data,
+ * which we never send, so treating it as retryable would describe a state this
+ * client cannot reach.
+ */
+const RETRYABLE_CLIENT_STATUSES = new Set([
+    // The server gave up waiting for the request, rather than refusing what it
+    // received. Nothing about the request is wrong, so a retry is the correct
+    // response — note `getRetryAfterMs` still only honors `Retry-After` on 429,
+    // so a 408 takes the normal backoff.
+    408,
+    429,
+]);
+/**
+ * A 4xx outside RETRYABLE_CLIENT_STATUSES is deterministic: the request itself
+ * is what the upstream refused, so every retry earns the identical rejection.
+ *
+ * WHY THIS MATTERS: retrying spends the upstream's quota for no chance of
+ * success. Google Retail calls are billed and quota'd against the *merchant's*
+ * GCP project, and on 2026-08-14 one store's filter — referencing a catalog
+ * attribute that was never marked indexable — was retried 4x per page view
+ * until it exhausted that quota. Google then 429'd every search for that store,
+ * including the ones that would have succeeded. A permanent rejection has to
+ * cost one call, not four.
+ *
+ * This predicate is shared across consumers (the cluster feed included), which
+ * is why the retryable set is defined by HTTP semantics rather than by what any
+ * one upstream happens to emit. The google-retail proxy collapses every upstream
+ * 4xx to 400 or 429 (see tapcart-microservices integrations/app/googleRetail/
+ * errors.js), so 408 reaches this predicate only from the other consumers.
+ *
+ * Errors carrying no `status` keep the previous behaviour (retry unless
+ * aborted), so integrations that do not populate it are unaffected.
+ */
+const isPermanentClientError = (err) => {
+    if (!err || typeof err !== "object")
+        return false;
+    const { status } = err;
+    return (typeof status === "number" &&
+        status >= 400 &&
+        status < 500 &&
+        !RETRYABLE_CLIENT_STATUSES.has(status));
+};
+export const shouldRetryOnError = (err) => !isAbortError(err) && !isPermanentClientError(err);
 const parseRetryAfter = (value) => {
     if (value === null || value === undefined)
         return null;

package/dist/components/hooks/swr-retry.test.js

@@ -31,6 +31,85 @@ describe("swr-retry helpers", () => {
             expect(shouldRetryOnError(new Error("boom"))).toBe(true);
             expect(shouldRetryOnError({ status: 500 })).toBe(true);
         });
+        // A 4xx is deterministic — retrying it burns the upstream's quota for no
+        // chance of success. This is the guard that stopped one bad Google Retail
+        // filter costing 4 API calls per page view.
+        it("returns false for a 4xx, which cannot succeed on retry", () => {
+            expect(shouldRetryOnError({ status: 400 })).toBe(false);
+            expect(shouldRetryOnError({ status: 403 })).toBe(false);
+            expect(shouldRetryOnError({ status: 404 })).toBe(false);
+            expect(shouldRetryOnError({ status: 499 })).toBe(false);
+        });
+        // 429 is the 4xx that means "later", not "never".
+        it("returns true for 429 so Retry-After is honored", () => {
+            expect(shouldRetryOnError({ status: 429 })).toBe(true);
+        });
+        /**
+         * 408 is the other one: the server gave up waiting for the request rather
+         * than refusing what it received, so the same request may well succeed. The
+         * google-retail proxy collapses upstream 408s to 400 before they get here,
+         * so this matters for the cluster feed and any future consumer — which is
+         * the reason the retryable set is defined by HTTP semantics and not by what
+         * one upstream emits.
+         */
+        it("returns true for 408, which is transient rather than deterministic", () => {
+            expect(shouldRetryOnError({ status: 408 })).toBe(true);
+            const clusterFeed408 = Object.assign(new Error("Cluster feed HTTP 408"), {
+                reason: "cluster-feed-http",
+                status: 408,
+                retryAfter: null,
+            });
+            expect(shouldRetryOnError(clusterFeed408)).toBe(true);
+        });
+        // 425 Too Early is retryable in the abstract but unreachable here — we send
+        // no TLS early data — so it stays in the permanent set deliberately.
+        it("returns false for 425, which this client cannot receive", () => {
+            expect(shouldRetryOnError({ status: 425 })).toBe(false);
+        });
+        it("returns true for 5xx and for statuses below 400", () => {
+            expect(shouldRetryOnError({ status: 500 })).toBe(true);
+            expect(shouldRetryOnError({ status: 503 })).toBe(true);
+            expect(shouldRetryOnError({ status: 399 })).toBe(true);
+        });
+        // Integrations that never set `status` must behave exactly as before.
+        it("retries when status is absent or not a number", () => {
+            expect(shouldRetryOnError(new Error("network down"))).toBe(true);
+            expect(shouldRetryOnError({ status: undefined })).toBe(true);
+            expect(shouldRetryOnError({ status: "400" })).toBe(true);
+            expect(shouldRetryOnError({})).toBe(true);
+        });
+        // An abort still wins even if a status rode along.
+        it("returns false for an AbortError carrying a retryable status", () => {
+            const err = Object.assign(new Error("aborted"), {
+                name: "AbortError",
+                status: 500,
+            });
+            expect(shouldRetryOnError(err)).toBe(false);
+        });
+        it("does not throw on null / undefined / primitives", () => {
+            expect(shouldRetryOnError(null)).toBe(true);
+            expect(shouldRetryOnError(undefined)).toBe(true);
+            expect(shouldRetryOnError(404)).toBe(true);
+        });
+        /**
+         * This hook is shared. Both known callers — use-infinite-scroll (the
+         * search-client path) and usePersonalizedClusterFeed — throw errors that
+         * carry `status`, so both stop retrying 4xx. That is deliberate: a 4xx is
+         * deterministic whichever API produced it, and the cluster feed already
+         * attached `status`/`retryAfter` (see use-personalized-cluster-feed-core.ts
+         * :258) purely so this layer could act on them.
+         */
+        it("applies to the cluster-feed error shape too, not just search", () => {
+            const clusterFeed4xx = Object.assign(new Error("Cluster feed HTTP 404"), {
+                reason: "cluster-feed-http",
+                status: 404,
+                retryAfter: null,
+            });
+            expect(shouldRetryOnError(clusterFeed4xx)).toBe(false);
+            // A network failure there has no status, so it still retries.
+            const clusterFeedNetwork = Object.assign(new Error("Cluster feed request failed"), { reason: "cluster-feed-network" });
+            expect(shouldRetryOnError(clusterFeedNetwork)).toBe(true);
+        });
     });
 });
 describe("useSwrRetryConfig", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapcart/mobile-components",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "style": "dist/styles.css",