@wix/himalaya-cli 0.1243.0 → 0.1244.0

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

@@ -13,6 +13,9 @@
 // PAYMENT_PENDING and settles on the shared in-app pay rail, and a private one comes
 // back APPROVAL_PENDING (the owner approves; there is nothing to charge). Any failure
 // degrades to the site-directing message rather than a dead button.
+//
+// App Store prices and the payment route come from the shared IAP catalog layer (@himalaya/iap).
+// Until a mapping backend is connected it is disabled, and this worker runs its pre-pricing path.
 import { defineService } from "@himalaya/state";
 import {
   getProgram,
@@ -28,6 +31,8 @@ import { cleanTitle, initials } from "../_shared/himi-text.js";
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
 import { payCashierOrder } from "@himalaya/checkout";
 import { formatCurrency } from "../_shared/engine-intl.js";
+import { createIapCatalogPricing, iapPriceFields, onlineProgramItem, type IapCatalogItem, type IapPollDirective, type IapPriceFields } from "@himalaya/iap";
+import { hostIapScope, hostScopeComplete, iapPriceCopy, resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
 
 /** Wix Online Programs appDefId — the vertical a participant's cashier order is
  *  paid under (mirrors AppDefId.CHALLENGES in Wix's RN apps). */
@@ -55,6 +60,13 @@ interface State {
   hasImage: boolean;
   noImage: boolean;
   hideContent: boolean;
+  /** "One-time purchase" beside an App Store price. */
+  priceNote: string;
+  hidePriceRetry: boolean;
+  /** Bound to the Enrol CTA's `disabledPath`; `enroll` re-checks the route itself regardless. */
+  enrollDisabled: boolean;
+  enrollNote: string;
+  _poll?: IapPollDirective;
 }
 
 function inputId(): string {
@@ -149,45 +161,65 @@ function ready(state: State, p: WixProgram | undefined): State {
   });
 }
 
+/** §8.10 drift discipline: getProgram is the primary read; when the GET path 404s/errors the
+ *  programs QUERY is the fallback (client-side find keeps it correct even when the gateway ignores
+ *  the filter shape). Throws only when both fail. */
+async function fetchProgram(id: string): Promise<WixProgram | undefined> {
+  if (!id) return undefined;
+  try {
+    return (await getProgram(id)).program;
+  } catch {
+    const response = await queryPrograms({ cursorPaging: { limit: 50 } });
+    return (response.programs ?? []).find((candidate) => candidate.id === id);
+  }
+}
+
 async function load(state: State, arg?: unknown): Promise<State> {
   stashCopy(arg);
-  const id = inputId();
-  if (!id) return ready(state, undefined);
   try {
-    const response = await getProgram(id);
-    return ready(state, response.program);
+    return ready(state, await fetchProgram(inputId()));
   } catch {
-    // Drifted GET path / transient failure → the query fallback. Client-side
-    // find keeps this correct even when the gateway ignores the filter shape.
-    try {
-      const response = await queryPrograms({ cursorPaging: { limit: 50 } });
-      return ready(state, (response.programs ?? []).find((candidate) => candidate.id === id));
-    } catch {
-      return derive({ ...state, status: "error" });
-    }
+    return derive({ ...state, status: "error" });
   }
 }
 
-async function enroll(state: State): Promise<State> {
-  const id = inputId();
-  if (!id) return state;
+/** Whether the existing commerce flow may start (before the join) and continue (before the Wix
+ *  payment): a price refresh can move the program onto a route this flow must not charge. */
+interface CommerceGuards {
+  mayStart(): boolean;
+  mayContinue(): boolean;
+}
+
+const ALWAYS_ALLOWED: CommerceGuards = { mayStart: () => true, mayContinue: () => true };
+
+async function enrollmentMessage(name: string, guards: CommerceGuards): Promise<string> {
+  const blocked = () => iapPriceCopy("program").purchaseUnavailable;
+  if (!guards.mayStart()) return blocked();
   try {
-    const joined = await joinProgram(id);
+    const joined = await joinProgram(inputId());
     const participant = joined.participant;
     const programState = (participant?.state ?? "").toUpperCase();
     if (programState === "APPROVAL_PENDING") {
-      return derive({ ...state, actionMessage: copyParam("program.approvalPendingMessage", "Request sent — the host will approve your place.") });
+      return copyParam("program.approvalPendingMessage", "Request sent — the host will approve your place.");
     }
     const payable = payableIdOf(participant);
     if (!payable) {
       // Free / open program (or one already settled) ⇒ nothing to charge.
-      return derive({ ...state, actionMessage: copyTemplate("program.joinedMessage", "You're enrolled in {name}.", { name: state.name }) });
+      return copyTemplate("program.joinedMessage", "You're enrolled in {name}.", { name });
     }
     const msid = await wixPlatformSession.signedInstanceStatus().then((s) => s.msid ?? "").catch(() => "");
+    // Re-read before each step that commits money: a route that settles meanwhile wins.
+    let withdrawn = false;
+    const stillAllowed = () => {
+      if (!guards.mayContinue()) withdrawn = true;
+      return !withdrawn;
+    };
+    if (!stillAllowed()) return blocked();
     const pay = await payCashierOrder({
       appId: WIX_PROGRAMS_APP_ID,
       snapshotId: payable,
       msid,
+      mayCharge: stillAllowed,
       // Wallet-less apps need a rail too. Without this thunk a paid program was
       // unpayable on any app with no provisioned wallet — `payCashierOrder`
       // returned `failed` and the CTA fell through to the site-directing message,
@@ -201,6 +233,7 @@ async function enroll(state: State): Promise<State> {
       // message as before, and nothing regresses — but when it is right, a
       // wallet-less site can actually sell the program IN-APP.
       cashierUrl: async () => {
+        if (!stillAllowed()) return undefined;
         const redirect = await createRedirectSession({
           ecomOrderPaymentRequest: { paymentRequestId: payable },
           callbacks: { postFlowUrl: "himalaya-himi-branded-lite://screen/himi_programs" },
@@ -208,43 +241,137 @@ async function enroll(state: State): Promise<State> {
         return redirect.redirectSession?.fullUrl;
       },
     });
-    if (pay.kind === "paid") {
-      return derive({ ...state, actionMessage: copyTemplate("program.joinedMessage", "You're enrolled in {name}.", { name: state.name }) });
-    }
-    if (pay.kind === "handoff") return derive({ ...state, actionMessage: "" });
-    if (pay.kind === "cancelled") {
-      return derive({ ...state, actionMessage: copyParam("program.joinCancelledMessage", "Payment cancelled — you haven't enrolled.") });
-    }
+    if (withdrawn) return blocked();
+    if (pay.kind === "paid") return copyTemplate("program.joinedMessage", "You're enrolled in {name}.", { name });
+    if (pay.kind === "handoff") return "";
+    if (pay.kind === "cancelled") return copyParam("program.joinCancelledMessage", "Payment cancelled — you haven't enrolled.");
   } catch {
     // fall through to the site-directing message
   }
-  return derive({ ...state, actionMessage: copyTemplate("program.joinOnSiteMessage", "Enrolment happens on the website — visit the site to join {name}.", { name: state.name }) });
-}
-
-const svc = defineService<State, {
-  load: (state: State, arg?: unknown) => Promise<State>;
-  enroll: (state: State) => Promise<State>;
-}>("himiBrandedProgram", {
-  state: derive({
-    status: "loading",
-    actionMessage: "",
-    name: "",
-    description: "",
-    meta: "",
-    priceLine: "",
-    image: "",
-    initial: "",
-    emptyText: copyParam("program.emptyText", "This program is no longer available."),
-    isLoading: true,
-    notLoading: false,
-    isErrored: false,
-    notErrored: true,
-    noEmpty: true,
-    hasImage: false,
-    noImage: true,
-    hideContent: true,
-  }),
-  actions: { load, enroll },
+  return copyTemplate("program.joinOnSiteMessage", "Enrolment happens on the website — visit the site to join {name}.", { name });
+}
+
+async function enroll(state: State): Promise<State> {
+  if (!inputId()) return state;
+  return derive({ ...state, actionMessage: await enrollmentMessage(state.name, ALWAYS_ALLOWED) });
+}
+
+// ── App Store pricing (enabled only when a mapping backend is connected) ─────
+//
+// One writer: `loadPriced` and `enrollPriced` keep their results here and every state change goes
+// through the synchronous `pricingPublish`, which re-reads the latest content and route. An async
+// action returning its own state could land after a refresh and revive a stale price or route.
+
+const pricing = createIapCatalogPricing({ onChange: () => { void svc.pricingPublish(); } });
+const PRICING_NOT_HYDRATED = ["priceLine", "priceNote", "hidePriceRetry", "enrollDisabled", "enrollNote"] as const;
+const CONTENT_KEYS = ["status", "name", "description", "meta", "image", "initial", "emptyText"] as const;
+type Content = Pick<State, (typeof CONTENT_KEYS)[number]>;
+const NO_PRICE: IapPriceFields = { priceText: "", priceNote: "", priceLoading: false, hidePriceRetry: true, actionDisabled: true, actionNote: "" };
+let content: Content;
+let pricedItem: IapCatalogItem | undefined;
+let scopeIncomplete = false;
+let actionMessage = "";
+let loadSeq = 0;
+
+function contentOf(state: State): Content {
+  return Object.fromEntries(CONTENT_KEYS.map((key) => [key, state[key]])) as Content;
+}
+
+const programReference = () => onlineProgramItem({ id: inputId() })?.reference;
+
+async function loadPriced(state: State, arg?: unknown): Promise<undefined> {
+  stashCopy(arg);
+  const seq = ++loadSeq;
+  const found = await fetchProgram(inputId()).then((program) => ({ program }), () => undefined);
+  if (seq !== loadSeq) return undefined;
+  content = found ? contentOf(ready(state, found.program)) : { ...content, status: "error" };
+  pricedItem = found?.program ? onlineProgramItem({ id: inputId() }, priceOf(found.program)) : pricedItem;
+  void svc.pricingPublish();
+  if (found?.program) void priceProgram();
+  return undefined;
+}
+
+/** Content never waits on this, and the host scope is re-read each time, so a failed app-info
+ *  read recovers on the next refresh. */
+async function priceProgram(): Promise<void> {
+  // The Retry action is declared in both modes; with no backend it must not reach the host.
+  if (!pricing.enabled) return;
+  const host = await hostIapScope();
+  scopeIncomplete = !hostScopeComplete(host);
+  if (pricedItem) await pricing.load({ ...host, items: [pricedItem] });
+}
+
+async function enrollPriced(): Promise<undefined> {
+  const reference = programReference();
+  if (!reference) return undefined;
+  // A tap that lands as a refresh starts is refused without a verdict: the route is unknown, not
+  // App Store, and the screen already reads "Loading price…" with Enrol disabled.
+  actionMessage = pricing.checkoutGuard(reference).route === "resolving" ? "" : await enrollmentMessage(content.name, {
+    mayStart: () => pricing.checkoutGuard(reference).allowed,
+    mayContinue: () => pricing.continueCheckoutGuard(reference).allowed,
+  });
+  void svc.pricingPublish();
+  return undefined;
+}
+
+function pricedState(state: State): State {
+  const reference = programReference();
+  const price = reference ? iapPriceFields(pricing.view(reference), iapPriceCopy("program")) : NO_PRICE;
+  return derive({
+    ...state, ...content, actionMessage,
+    priceLine: price.priceText, priceNote: price.priceNote, hidePriceRetry: price.hidePriceRetry && !scopeIncomplete,
+    enrollDisabled: price.actionDisabled, enrollNote: price.actionNote,
+  });
+}
+
+const INITIAL_STATE: State = derive({
+  status: "loading",
+  actionMessage: "",
+  name: "",
+  description: "",
+  meta: "",
+  priceLine: "",
+  image: "",
+  initial: "",
+  emptyText: copyParam("program.emptyText", "This program is no longer available."),
+  isLoading: true,
+  notLoading: false,
+  isErrored: false,
+  notErrored: true,
+  noEmpty: true,
+  hasImage: false,
+  noImage: true,
+  hideContent: true,
+  priceNote: "",
+  hidePriceRetry: true,
+  enrollDisabled: pricing.enabled,
+  enrollNote: "",
 });
 
+type Actions = {
+  load: (state: State, arg?: unknown) => Promise<State | undefined>;
+  enroll: (state: State) => Promise<State | undefined>;
+  pricingPublish: (state: State) => State;
+  pricingStart: (state: State) => State;
+  pricingRefresh: (state: State) => Promise<undefined>;
+};
+
+const svc = defineService<State, Actions>("himiBrandedProgram", {
+  state: INITIAL_STATE,
+  ...(pricing.enabled ? { notHydrated: [...PRICING_NOT_HYDRATED] } : {}),
+  actions: {
+    load: pricing.enabled ? loadPriced : load,
+    enroll: pricing.enabled ? enrollPriced : enroll,
+    pricingPublish: pricedState,
+    pricingStart: (state) => ({ ...pricedState(state), _poll: pricing.pollDirective("himiBrandedProgram.pricingRefresh") }),
+    pricingRefresh: async () => { await priceProgram(); return undefined; },
+  },
+});
+
+content = contentOf(svc.getState());
+if (pricing.enabled) {
+  resetUnhydratedKeysOnOlderRuntime(svc, INITIAL_STATE, PRICING_NOT_HYDRATED);
+  void svc.pricingStart();
+}
+
 export { svc };

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

@@ -6,11 +6,19 @@
 // self-contained (name, cover, description snippet, cheap meta) — no detail
 // screen; enrolling stays a hosted-site flow.
 // Four-state (loading / error / rows / empty) like the sibling branded workers.
-import { defineService } from "../_shared/collection-service.js";
+//
+// App Store prices come from the shared IAP catalog layer (@himalaya/iap). Until a mapping backend
+// is connected it is disabled, and this worker runs exactly its pre-pricing path.
+import { defineService as register } from "@himalaya/state";
+import { decorateCollection } from "../_shared/collection-service.js";
 import { queryPrograms, type WixProgram } from "@himalaya/wix-online-programs";
+import { createIapCatalogPricing, iapPriceFields, onlineProgramItem, type IapPollDirective } from "@himalaya/iap";
 import { wixMediaUrl } from "@himalaya/wix-media";
 import { cleanTitle, initials } from "../_shared/himi-text.js";
 import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+import { hostIapScope, hostScopeComplete, iapPriceCopy, resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
+
+const SERVICE = "himiBrandedPrograms";
 
 interface ProgramRow {
   id: string;
@@ -27,6 +35,15 @@ interface ProgramRow {
   noImage: boolean;
   /** Templated in-app program detail — rows tap through (no more dead wall). */
   detailScreenId: string;
+  /** This run's App Store price or its loading/unavailable label; "" when pricing is off. The
+   *  collection card shows it in the caption ahead of `meta`. */
+  priceLine: string;
+}
+
+/** A row as loaded, before pricing — the half that may be restored from a cold-boot snapshot. */
+interface ProgramContent extends Omit<ProgramRow, "priceLine"> {
+  /** The Wix ID, or "" when the row fell back to its title and so cannot be priced. */
+  wixId: string;
 }
 
 interface State {
@@ -40,6 +57,13 @@ interface State {
   hasRows: boolean;
   noRows: boolean;
   noEmpty: boolean;
+  hidePriceRetry: boolean;
+  /** Beside the list-level Retry, so it says what failed. */
+  priceRetryText: string;
+  programs?: ProgramContent[];
+  /** Derived from `rows` by the collection decorator. */
+  collection?: unknown;
+  _poll?: IapPollDirective;
 }
 
 /** v3 nests display fields under `description`/`settings`; older shapes are
@@ -86,7 +110,7 @@ function isDraft(p: WixProgram): boolean {
   return state === "DRAFT";
 }
 
-function programRow(p: WixProgram): ProgramRow {
+function programFields(p: WixProgram): Omit<ProgramRow, "priceLine"> {
   const name = programTitle(p);
   const image = programImage(p);
   const id = p.id || name;
@@ -109,6 +133,14 @@ function programRow(p: WixProgram): ProgramRow {
   };
 }
 
+function programRow(p: WixProgram): ProgramRow {
+  return { ...programFields(p), priceLine: "" };
+}
+
+function programContent(p: WixProgram): ProgramContent {
+  return { ...programFields(p), wixId: p.id ?? "" };
+}
+
 function ready(rows: ProgramRow[]): State {
   return {
     status: "ready",
@@ -121,46 +153,134 @@ function ready(rows: ProgramRow[]): State {
     hasRows: rows.length > 0,
     noRows: rows.length === 0,
     noEmpty: rows.length > 0,
+    hidePriceRetry: true,
+    priceRetryText: "",
   };
 }
 
-const svc = defineService<State, {
-  load: (state: State, arg?: unknown) => Promise<State>;
-}>("himiBrandedPrograms", {
-  state: {
-    status: "loading",
-    rows: [],
-    emptyText: "",
-    isLoading: true,
-    notLoading: false,
-    isErrored: false,
-    notErrored: true,
-    hasRows: false,
-    noRows: true,
+// Bridge errors land here — a graceful error card with retry, never a dead
+// screen (the branded four-state contract).
+function errored(state: State): State {
+  return {
+    ...state,
+    status: "error",
+    isLoading: false,
+    notLoading: true,
+    isErrored: true,
+    notErrored: false,
     noEmpty: true,
-  },
-  actions: {
-    load: async (state, arg) => {
-      stashCopy(arg);
-      try {
-        const response = await queryPrograms({ cursorPaging: { limit: 50 } });
-        return ready((response.programs ?? []).filter((p) => !isDraft(p)).map(programRow));
-      } catch {
-        // Bridge errors land here — a graceful error card with retry, never a
-        // dead screen (the branded four-state contract).
-        return {
-          ...state,
-          status: "error",
-          isLoading: false,
-          notLoading: true,
-          isErrored: true,
-          notErrored: false,
-          noEmpty: true,
-        };
-      }
-    },
-  },
-});
+  };
+}
+
+async function fetchPrograms(): Promise<WixProgram[]> {
+  const response = await queryPrograms({ cursorPaging: { limit: 50 } });
+  return (response.programs ?? []).filter((p) => !isDraft(p));
+}
+
+async function load(state: State, arg?: unknown): Promise<State> {
+  stashCopy(arg);
+  try {
+    return ready((await fetchPrograms()).map(programRow));
+  } catch {
+    return errored(state);
+  }
+}
+
+// ── App Store pricing (enabled only when a mapping backend is connected) ─────
+//
+// One writer: `loadPriced` keeps its content here and every state change goes through the
+// synchronous `pricingPublish`, which re-reads the latest content and prices. An async action
+// that returned its own state could land after a newer publication and repaint stale prices.
+
+const pricing = createIapCatalogPricing({ onChange: () => { void svc.pricingPublish(); } });
+const PRICING_NOT_HYDRATED = ["rows", "collection", "hidePriceRetry"] as const;
+let content: { status: State["status"]; programs: ProgramContent[] } = { status: "loading", programs: [] };
+let scopeIncomplete = false;
+let loadSeq = 0;
+
+async function loadPriced(_state: State, arg?: unknown): Promise<undefined> {
+  stashCopy(arg);
+  const seq = ++loadSeq;
+  const programs = await fetchPrograms().catch(() => undefined);
+  if (seq !== loadSeq) return undefined;
+  content = programs ? { status: "ready", programs: programs.map(programContent) } : { ...content, status: "error" };
+  void svc.pricingPublish();
+  if (programs) void priceContent();
+  return undefined;
+}
+
+/** Prices the programs on screen now. Content never waits on this, and the host scope is re-read
+ *  each time, so a failed app-info read recovers on the next refresh. */
+async function priceContent(): Promise<void> {
+  // The Retry action is declared in both modes; with no backend it must not reach the host.
+  if (!pricing.enabled) return;
+  const host = await hostIapScope();
+  scopeIncomplete = !hostScopeComplete(host);
+  if (content.status !== "ready") return;
+  await pricing.load({ ...host, items: content.programs.flatMap((program) => onlineProgramItem({ id: program.wixId }) ?? []) });
+}
+
+function pricedState(state: State): State {
+  const copy = iapPriceCopy("programs");
+  const views = content.programs.map((program) => {
+    const item = onlineProgramItem({ id: program.wixId });
+    return item ? pricing.view(item.reference) : undefined;
+  });
+  const rows = content.programs.map(({ wixId: _wixId, ...row }, i) =>
+    ({ ...row, priceLine: views[i] ? iapPriceFields(views[i]!, copy).priceText : "" }));
+  const shown = content.status === "ready" ? ready(rows) : content.status === "error" ? errored({ ...state, rows }) : INITIAL_STATE;
+  return {
+    ...state, ...shown, programs: content.programs,
+    // Retry re-prices the programs on screen, which only a ready list has.
+    hidePriceRetry: content.status !== "ready" || !views.some((view) => view && (scopeIncomplete || view.retryable)),
+    priceRetryText: copyParam("programs.priceRetryText", "Some prices could not be loaded."),
+  };
+}
+
+const INITIAL_STATE: State = {
+  status: "loading",
+  rows: [],
+  emptyText: "",
+  isLoading: true,
+  notLoading: false,
+  isErrored: false,
+  notErrored: true,
+  hasRows: false,
+  noRows: true,
+  noEmpty: true,
+  hidePriceRetry: true,
+  priceRetryText: "",
+};
+
+type Actions = {
+  load: (state: State, arg?: unknown) => Promise<State | undefined>;
+  pricingPublish: (state: State) => State;
+  pricingStart: (state: State) => State;
+  pricingRefresh: (state: State) => Promise<undefined>;
+};
+
+const actions: Actions = {
+  load: pricing.enabled ? loadPriced : load,
+  pricingPublish: pricedState,
+  pricingStart: (state) => ({ ...pricedState(state), _poll: pricing.pollDirective(`${SERVICE}.pricingRefresh`) }),
+  pricingRefresh: async () => { await priceContent(); return undefined; },
+};
+
+// The collection decorator's own `defineService` drops `notHydrated`, so the decorated definition
+// is registered directly: this run's prices must never be restored from a cold-boot snapshot.
+const decorated = decorateCollection(SERVICE, { state: INITIAL_STATE, actions } as unknown as Parameters<typeof decorateCollection>[1]);
+const svc = register<State, Actions>(SERVICE, (pricing.enabled
+  ? { ...decorated, notHydrated: [...PRICING_NOT_HYDRATED] }
+  : decorated) as unknown as Parameters<typeof register<State, Actions>>[1]);
+
+if (pricing.enabled) {
+  const booted = svc.getState();
+  if ((booted.status === "ready" || booted.status === "error") && Array.isArray(booted.programs)) {
+    content = { status: booted.status, programs: booted.programs };
+  }
+  resetUnhydratedKeysOnOlderRuntime(svc, decorated.state as unknown as State, PRICING_NOT_HYDRATED);
+  void svc.pricingStart();
+}
 
 // Kick the first load at module scope, like every other list bundle
 // (himi-store-shop, himi-booking-services, himi-events-list, himi-blog-feed …).