@wix/himalaya-cli 0.817.0 → 0.819.0

package/templates/nonprofit-cause-owner/tier5-src/himi-owner-lite-overview/index.ts

@@ -0,0 +1,220 @@
+// Tier-5 bundle: __HIMI_APP_NAME__ — Across your businesses (cross-site rollup).
+//
+// The question this screen answers is the one the Sites list cannot: an owner with three
+// restaurants does not want to know which businesses exist, they want to know WHICH ONE
+// NEEDS THEM RIGHT NOW. Answering that means reading every business at once.
+//
+// Which is exactly what `setActiveSite` cannot do. It re-scopes the whole process — every
+// later call, every worker, the conducted cache and the entity cache move with it — so
+// rolling up N businesses through it would mean N switches, N mints, and the owner's actual
+// scope left wherever the loop happened to stop. `site.forSite(msid)` addresses ONE call at
+// one business without moving anything, so the fan-out below is a plain `Promise.all` and
+// the active business is untouched when it finishes.
+//
+// Reads are two rungs, deliberately:
+//   1. `querySites` — ACCOUNT level (the owner's wixSession2 cookie alone, no per-site
+//      instance), so the list loads before any business is picked. Same call the Sites
+//      screen makes.
+//   2. per-business `searchOrders` — SITE level, scoped by `site.forSite(msid)`, which sends
+//      `wix-site-id` for that call so the transport mints that business's User instance.
+//
+// ONE BUSINESS FAILING MUST NOT BLANK THE ROLLUP. A site the owner has no Stores app on,
+// or one whose mint fails, resolves to `null` and renders as "—" beside the others rather
+// than throwing the whole screen into its error state. A rollup that disappears because one
+// of five businesses is unreachable is worse than one that says so in a row.
+
+import { defineService } from "@himalaya/state";
+import { querySites, type WixSite } from "@himalaya/wix-site-list";
+import { site } from "@himalaya/wix-platform";
+import { searchOrders } from "@himalaya/wix-ecom";
+import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
+import { DEMO_SITES, DEMO_NOTE } from "../_shared/owner-preview-demo.js";
+import { stashCopy, copyParam } from "../_shared/himi-copy.js";
+
+/** Mirrors the Home dashboard's "needs attention" definition, so a number here means the
+ *  same thing it means after the owner drills into that business. */
+const ATTENTION_PAYMENT_STATUSES = ["NOT_PAID", "PARTIALLY_PAID"];
+const ATTENTION_FULFILLMENT_STATUSES = ["NOT_FULFILLED", "PARTIALLY_FULFILLED"];
+
+/** Cap per business. This is a glance, not the orders list — and it bounds the fan-out on
+ *  an account with many businesses. A count at the cap reads as "50+". */
+const PER_SITE_LIMIT = 50;
+
+interface OverviewRow {
+  id: string;
+  name: string;
+  initial: string;
+  /** "3", "50+", or "—" when that business could not be read. */
+  attention: string;
+  attentionLabel: string;
+  /** Drives the row's emphasis without the descriptor needing a comparison. */
+  needsAttention: boolean;
+  calm: boolean;
+}
+
+interface OverviewState {
+  status: "loading" | "ready" | "error";
+  rows: OverviewRow[];
+  summary: string;
+  emptyText: string;
+  error: string;
+  isLoading: boolean;
+  notLoading: boolean;
+  notErrored: boolean;
+  noEmpty: boolean;
+  hideContent: boolean;
+  demoNote: string;
+  notDemo: boolean;
+}
+
+function initialOf(name: string): string {
+  return (name.trim()[0] || "S").toUpperCase();
+}
+
+function countLabel(n: number | null): string {
+  if (n === null) return "—";
+  return n >= PER_SITE_LIMIT ? `${PER_SITE_LIMIT}+` : String(n);
+}
+
+function rowFor(id: string, name: string, count: number | null): OverviewRow {
+  const needs = count !== null && count > 0;
+  return {
+    id,
+    name,
+    initial: initialOf(name),
+    attention: countLabel(count),
+    // Reads as ONE phrase with the count rendered beside it — "3" + "orders need
+    // attention". So the label never repeats the number, or the row would say "1 · 1 order
+    // needs attention".
+    attentionLabel: count === null
+      ? copyParam("ownerOverview.unavailable", "Couldn’t read this business")
+      : count === 0
+        ? copyParam("ownerOverview.allClear", "All clear")
+        : count === 1
+          ? copyParam("ownerOverview.oneNeedsAttention", "order needs attention")
+          : copyParam("ownerOverview.manyNeedAttention", "orders need attention"),
+    needsAttention: needs,
+    calm: !needs,
+  };
+}
+
+/**
+ * Build the whole state from its FOUR real inputs. Everything else is derived here and
+ * never inherited.
+ *
+ * Deliberately not `shape({ ...previous, rows })`: the derived fields are strings and
+ * booleans, so a spread carries the previous load's `summary` forward and `??` keeps it —
+ * `""` is not nullish. That reads as "the rollup silently kept the last render's headline",
+ * which is exactly the bug a spread-and-default shape invites.
+ */
+function shape(input: { status: OverviewState["status"]; rows?: OverviewRow[]; error?: string; demoNote?: string }): OverviewState {
+  const { status } = input;
+  const rows = input.rows ?? [];
+  const isLoading = status === "loading";
+  const flagged = rows.filter((r) => r.needsAttention).length;
+  const demoNote = input.demoNote ?? "";
+  return {
+    status,
+    rows,
+    // Leads with the businesses that want the owner, because that is the whole point of
+    // the screen. "All caught up" is a real answer, not an empty state.
+    summary: rows.length === 0 ? "" : flagged === 0
+      ? copyParam("ownerOverview.allCaughtUp", "All caught up across your businesses")
+      : flagged === 1
+        ? copyParam("ownerOverview.oneBusinessNeedsYou", "1 business needs you")
+        : `${flagged} ${copyParam("ownerOverview.manyBusinessesNeedYou", "businesses need you")}`,
+    emptyText: rows.length ? "" : copyParam("ownerOverview.empty", "No businesses on this account yet."),
+    error: input.error ?? "",
+    isLoading,
+    notLoading: !isLoading,
+    notErrored: status !== "error",
+    noEmpty: rows.length > 0 || status !== "ready",
+    hideContent: status !== "ready" || rows.length === 0,
+    demoNote,
+    notDemo: !demoNote,
+  };
+}
+
+/** Bridge-unavailable fallback: the sample businesses, honestly labelled. */
+function demoRollup(): OverviewState {
+  const rows = DEMO_SITES.map((d, i) => rowFor(d.id, d.name, i === 0 ? 2 : 0));
+  return shape({ status: "ready", rows, demoNote: copyParam("ownerCommon.demoNote", DEMO_NOTE) });
+}
+
+/**
+ * One business's "needs attention" count, or null when that business could not be read.
+ *
+ * `site.forSite(msid)` is handed straight to the generated client as its options bag — it
+ * is shaped as one — so this call carries `wix-site-id` for THIS business while the app's
+ * active business stays wherever the owner left it.
+ */
+async function attentionCount(msid: string): Promise<number | null> {
+  try {
+    const res = await searchOrders({
+      search: {
+        filter: {
+          archived: false,
+          status: { $nin: ["CANCELED", "CANCELLED"] },
+          $or: [
+            { paymentStatus: { $in: ATTENTION_PAYMENT_STATUSES } },
+            { paymentStatus: "PAID", fulfillmentStatus: { $in: ATTENTION_FULFILLMENT_STATUSES } },
+          ],
+        },
+        cursorPaging: { limit: PER_SITE_LIMIT },
+      },
+    }, site.forSite(msid));
+    return (res.orders ?? []).length;
+  } catch {
+    // Deliberately swallowed per business — see the header. The row says "—".
+    return null;
+  }
+}
+
+async function loadRollup(): Promise<OverviewState> {
+  if (isOwnerPreviewDemo()) return demoRollup();
+  try {
+    const res = await querySites({ query: { cursorPaging: { limit: 50 } } });
+    const businesses = (res.sites ?? [])
+      .filter((r: WixSite) => r?.id)
+      .map((r: WixSite) => ({
+        id: r.id || "",
+        name: r.displayName || (r as { name?: string }).name || r.id || "Site",
+      }));
+    if (businesses.length === 0) return shape({ status: "ready", rows: [] });
+
+    // THE FAN-OUT. Concurrent, one business each, active scope untouched.
+    const counts = await Promise.all(businesses.map((b) => attentionCount(b.id)));
+    const rows = businesses.map((b, i) => rowFor(b.id, b.name, counts[i]));
+    // Businesses that want the owner first; stable by name inside each group so the list
+    // does not reshuffle between loads.
+    // Plain codepoint compare, NOT localeCompare: the watch and wearable engines ship no
+    // ECMA-402, so an Intl-dependent worker either dies or silently mis-sorts there.
+    // Ordering business names is not a collation problem worth a wrist failure for.
+    rows.sort((a, b) =>
+      a.needsAttention === b.needsAttention
+        ? (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+        : (a.needsAttention ? -1 : 1));
+    return shape({ status: "ready", rows });
+  } catch (e) {
+    // Only the ACCOUNT-level list failing gets here; a per-business failure is a row.
+    if (isBridgeUnavailable(e)) return demoRollup();
+    return shape({ status: "error", rows: [], error: ownerLoadError(e) });
+  }
+}
+
+const svc = defineService<OverviewState, {
+  load: (s: OverviewState, arg?: unknown) => Promise<OverviewState>;
+  retry: (s: OverviewState) => Promise<OverviewState>;
+}>("himiOwnerLiteOverview", {
+  state: shape({ status: "loading" }),
+  actions: {
+    load: async (_s, arg) => {
+      stashCopy(arg); // absorb the descriptor's onAppear copy-pack param
+      return loadRollup();
+    },
+    retry: async () => loadRollup(),
+  },
+});
+
+svc.load();
+export { svc };