@wix/himalaya-cli 0.904.0 → 0.905.0

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

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/restaurant/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/retail-store/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/yoga-studio/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];