@wix/himalaya-cli 0.1410.0 → 0.1412.0

package/templates/branded-lite/tier5-src/wix-spaces-chat-thread/index.ts

@@ -3,17 +3,33 @@
 // id (member picker / member detail "Message"). When the input is a member id we
 // resolve (get-or-create) the 1:1 chatroom first; getMessages/sendChatMessage always
 // operate on the resolved CHATROOM id.
-import { defineService } from "@himalaya/state";
-import { getMessages, sendChatMessage, getOrCreateDirectChatroom, type ChatMessage } from "@himalaya/wix-chat-web";
+//
+// LIVE: once the conversation is open, `load` also returns what keeps it live —
+// `_shared/chat-live.ts` picks a `wix-realtime://` stream when the screen passes a
+// `chatRealtime` channel, else a 4 s foreground `_poll` of `refresh`. A message from the
+// business then appears without the member leaving the screen. `load`, `setDraft` and
+// `send` keep their contract; the directives are stripped by the runtime, never state.
+import { defineService, type PollDirective, type StreamDirective } from "@himalaya/state";
+import { getMessages, sendChatMessage, getOrCreateDirectChatroom, getChatToken, type ChatMessage } from "@himalaya/wix-chat-web";
 import { getMyData } from "@himalaya/wix-users";
 import { formatMonthDayTime } from "../_shared/engine-intl.js";
 import { presence, presenceAfterError, detailInputId, type PresenceFlags } from "../_shared/detail-presence.js";
+import { writeMayHaveLanded } from "../_shared/owner-load-error.js";
+import { chatRealtimeConfig, createReloadGate, createSendIntents, createVisitToken, liveDirectives, postWithVisitToken, liveFallback, type ChatLiveMode, type ChatRealtimeConfig } from "../_shared/chat-live.js";
+
+const SERVICE = "spacesChatThread";
 
 // leadFill gates a per-row right-align: " " for MY messages (a flexible gated
 // spacer to the bubble's left → bubble hugs the right edge), "" for others
 // (spacer collapses → bubble stays left). mine drives the bubble tint.
 interface Row { id: string; text: string; when: string; leadFill: string; mine: string }
-interface S extends PresenceFlags { status: "loading" | "ready"; messages: Row[]; emptyText: string; draft: string; sendHint: string; resolvedChatroomId: string; myUserId: string }
+interface S extends PresenceFlags {
+  status: "loading" | "ready"; messages: Row[]; emptyText: string; draft: string; sendHint: string; resolvedChatroomId: string; myUserId: string;
+  /** Which path keeps the open thread live (diagnostic). */
+  live?: ChatLiveMode;
+  _stream?: StreamDirective;
+  _poll?: PollDirective;
+}
 
 function inputId(): string {
   return (globalThis as { himalaya?: { input?: { id?: string } } }).himalaya?.input?.id ?? "";
@@ -49,9 +65,65 @@ function norm(m: ChatMessage, i: number, myUserId: string): Row {
   return { id: mm.id || `m${i}`, text: text || "Message", when, leadFill: mine ? " " : "", mine: mine ? "1" : "" };
 }
 
+// ONE member chatToken per visit (`_shared/chat-live.ts`): a 4 s re-read would otherwise
+// mint a token every 4 s on top of its GET. Reset on every `load`.
+const memberToken = createVisitToken(() => getChatToken({ role: "member" }).then((t) => t.chatToken));
+
 async function reload(id: string, myUserId: string): Promise<Row[]> {
-  const msgs = id ? await getMessages(id, 30, { role: "member" }) : [];
-  return (msgs ?? []).map((m, i) => norm(m, i, myUserId));
+  if (!id) return [];
+  const token = memberToken.get();
+  try {
+    const msgs = await getMessages(id, 30, { role: "member", chatToken: await token });
+    return (msgs ?? []).map((m, i) => norm(m, i, myUserId));
+  } catch (e) {
+    memberToken.drop(token);
+    throw e;
+  }
+}
+
+/** Send ids that belong to the intent (conversation + text), not the tap. */
+const intents = createSendIntents();
+
+/** Post once per intent: a retried tap of the same text reuses its message id, so a send
+ *  that failed ambiguously and is tapped again stays one message. */
+async function postOnce(chatroomId: string, text: string): Promise<void> {
+  const messageId = intents.idFor(chatroomId, text);
+  await postWithVisitToken(memberToken, (chatToken) => sendChatMessage(chatroomId, text, { role: "member", chatToken, messageId }));
+  intents.settle(chatroomId, text);
+}
+
+/** A send in flight. Set synchronously before the first `await`: an async action publishes
+ *  no state until it returns, so a state flag could not stop a second tap. */
+let sendingNow = false;
+
+// The conversation a live re-read reads, and the channel the screen passed (if any).
+let current = { chatroomId: "", myUserId: "" };
+let realtime: ChatRealtimeConfig | null = null;
+const gate = createReloadGate(() => reload(current.chatroomId, current.myUserId));
+
+/** A tick or a stream event: re-read the open conversation. A failed tick keeps the
+ *  thread as it is — the next one tries again.
+ *
+ *  The read lands on the LIVE state (`svc.getState()`), not the state the tick started
+ *  with: the runtime replaces the whole service state with what an action returns, so a
+ *  tick that resolves after the member typed or sent would otherwise put back the old
+ *  draft and the old messages. */
+async function reread(s: S): Promise<S> {
+  if (!s.found || !s.resolvedChatroomId || s.resolvedChatroomId !== current.chatroomId) return s;
+  try {
+    const messages = await gate.request();
+    const now = svc.getState();
+    if (now.resolvedChatroomId !== s.resolvedChatroomId) return now;
+    return { ...now, messages, emptyText: messages.length ? "" : now.emptyText };
+  } catch {
+    return svc.getState();
+  }
+}
+
+/** The live service state, for an action that awaited. A typed function rather than
+ *  `svc.getState()` inline, so `svc`'s own initializer does not reference it. */
+function liveState(): S {
+  return svc.getState();
 }
 
 // Resolve my user id once (best-effort) so messages can be tagged mine/other.
@@ -60,17 +132,23 @@ async function resolveMyUserId(): Promise<string> {
 }
 
 const svc = defineService<S, {
-  load: (s: S) => Promise<S>;
+  load: (s: S, a?: unknown) => Promise<S>;
   setDraft: (s: S, a?: unknown) => S;
   send: (s: S) => Promise<S>;
-}>("spacesChatThread", {
+  refresh: (s: S) => Promise<S>;
+  onStreamEvent: (s: S) => Promise<S>;
+  onStreamError: (s: S) => S;
+}>(SERVICE, {
   state: { status: "loading", messages: [], emptyText: "", draft: "", sendHint: "", resolvedChatroomId: "", myUserId: "", ...presence("loading") },
   actions: {
-    load: async (s) => {
+    load: async (s, a) => {
+      const param = (a as { chatRealtime?: unknown } | null | undefined)?.chatRealtime;
+      if (param !== undefined) realtime = chatRealtimeConfig(param);
       const raw = inputId();
       // No thread / recipient id (a stale link, a route opened directly) -> the shared
       // not-found state, and no composer: there is nobody to send to.
       if (!detailInputId()) return { ...s, status: "ready", messages: [], emptyText: "", ...presence("missing") };
+      memberToken.reset();
       // Resolve chatroom + my user id concurrently (myUserId tags own messages).
       const [chatroomId, myUserId] = await Promise.all([resolveChatroomId(raw, inputKind()), resolveMyUserId()]);
       // A recipient whose 1:1 chatroom could not be resolved is not a conversation yet:
@@ -79,7 +157,8 @@ const svc = defineService<S, {
       if (!chatroomId) return { ...s, status: "ready", resolvedChatroomId: "", myUserId, messages: [], emptyText: "", ...presence("failed") };
       try {
         const messages = await reload(chatroomId, myUserId);
-        return { ...s, status: "ready", resolvedChatroomId: chatroomId, myUserId, messages, emptyText: messages.length ? "" : "No messages yet. Say hello!", ...presence("found") };
+        current = { chatroomId, myUserId };
+        return { ...s, status: "ready", resolvedChatroomId: chatroomId, myUserId, messages, emptyText: messages.length ? "" : "No messages yet. Say hello!", ...presence("found"), ...liveDirectives(realtime, chatroomId, SERVICE) };
       } catch (e) {
         // A thread whose messages cannot be read is not a live, empty conversation: a 404
         // is the shared not-found state, anything else the load-error line — never a
@@ -88,24 +167,55 @@ const svc = defineService<S, {
       }
     },
     setDraft: (s, a) => ({ ...s, draft: val(a) }),
+    // The fallback poll's tick.
+    refresh: async (s) => reread(s),
+    // "The conversation changed" — the event's payload is deliberately not read.
+    onStreamEvent: async (s) => reread(s),
+    // The channel is gone, or this host refuses it (the web host does): poll instead.
+    onStreamError: (s) => (s.found && s.resolvedChatroomId ? { ...s, ...liveFallback(SERVICE) } : s),
     // REAL WRITE: send the typed message to the RESOLVED chatroom id, then re-read.
+    // Every return builds on the LIVE state: the runtime replaces state wholesale, and ticks
+    // or typing may have changed it while this awaited.
     send: async (s) => {
       const text = s.draft.trim();
       if (!text) return { ...s, sendHint: "Type a message first." };
-      // Resolve lazily in case send() runs before load() settled.
-      let chatroomId = s.resolvedChatroomId;
-      if (!chatroomId) chatroomId = await resolveChatroomId(inputId(), inputKind());
-      if (!chatroomId) return { ...s, sendHint: "Couldn't start conversation." };
+      if (sendingNow) return s;
+      sendingNow = true;
       try {
-        await sendChatMessage(chatroomId, text, { role: "member" });
+        // Resolve lazily in case send() runs before load() settled.
+        let chatroomId = s.resolvedChatroomId;
+        if (!chatroomId) chatroomId = await resolveChatroomId(inputId(), inputKind());
+        if (!chatroomId) return { ...liveState(), sendHint: "Couldn't start conversation." };
+        try {
+          await postOnce(chatroomId, text);
+        } catch (e) {
+          // Surface a short reason (the SDK rejects with "HTTP <code>: <body>") so a
+          // real failure is diagnosable on-device instead of an opaque "Couldn't send".
+          // A failure that may have posted anyway (a gateway timeout after the backend stored
+          // it) must not read as "Couldn't send": say it may have gone. A retry of the same text
+          // reuses its message id, so it cannot become a second message.
+          const msg = (e as { message?: string })?.message || "";
+          if (writeMayHaveLanded(e)) return { ...liveState(), resolvedChatroomId: chatroomId, sendHint: "Couldn't confirm it was sent — check before sending again." };
+          return { ...liveState(), resolvedChatroomId: chatroomId, sendHint: msg ? `Couldn't send — ${msg.slice(0, 80)}` : "Couldn't send — try again." };
+        }
+        // SENT. From here on nothing may say otherwise: a failed re-read must not offer a
+        // second Send of a message that already posted.
         const myUserId = s.myUserId || (await resolveMyUserId());
-        const messages = await reload(chatroomId, myUserId);
-        return { ...s, resolvedChatroomId: chatroomId, myUserId, messages, draft: "", emptyText: "", sendHint: "Sent ✓" };
-      } catch (e) {
-        // Surface a short reason (the SDK rejects with "HTTP <code>: <body>") so a
-        // real failure is diagnosable on-device instead of an opaque "Couldn't send".
-        const msg = (e as { message?: string })?.message || "";
-        return { ...s, resolvedChatroomId: chatroomId, sendHint: msg ? `Couldn't send — ${msg.slice(0, 80)}` : "Couldn't send — try again." };
+        // Re-read THROUGH the live-read gate, so this read queues behind a tick already in
+        // flight instead of racing it: whatever lands last then holds the sent reply.
+        current = { chatroomId, myUserId };
+        const cleared = (now: S): string => (now.draft.trim() === text ? "" : now.draft);
+        try {
+          const messages = await gate.request();
+          const now = liveState();
+          return { ...now, resolvedChatroomId: chatroomId, myUserId, messages, draft: cleared(now), emptyText: "", sendHint: "Sent ✓" };
+        } catch {
+          const now = liveState();
+          const mine: Row = { id: `local-${now.messages.length}`, text, when: "", leadFill: " ", mine: "1" };
+          return { ...now, resolvedChatroomId: chatroomId, myUserId, messages: [...now.messages, mine], draft: cleared(now), emptyText: "", sendHint: "Sent ✓" };
+        }
+      } finally {
+        sendingNow = false;
       }
     },
   },

package/templates/community-club-owner/config.ts

@@ -78,6 +78,23 @@ export default defineApp({
         "parentScreenId": "",
         "tabId": "manage"
       },
+      {
+        "screenId": "himi_owner_lite_inbox",
+        "isPublic": false,
+        "paramKeys": [],
+        "parentScreenId": "",
+        "tabId": "inbox"
+      },
+      {
+        "screenId": "himi_owner_lite_inbox_thread",
+        "isPublic": false,
+        "paramKeys": [
+          "id",
+          "kind"
+        ],
+        "parentScreenId": "himi_owner_lite_inbox",
+        "tabId": "inbox"
+      },
       {
         "screenId": "himi_owner_lite_search",
         "isPublic": false,
@@ -528,6 +545,12 @@ export default defineApp({
           "icon": "home",
           "selectedIcon": "home_fill"
         },
+        {
+          "id": "inbox",
+          "screenId": "himi_owner_lite_inbox",
+          "label": "Inbox",
+          "icon": "chat"
+        },
         {
           "id": "aria",
           "screenId": "himi_owner_lite_aria",
@@ -552,6 +575,12 @@ export default defineApp({
           "icon": "home",
           "selectedIcon": "home_fill"
         },
+        {
+          "id": "inbox",
+          "screenId": "himi_owner_lite_inbox",
+          "label": "Inbox",
+          "icon": "chat"
+        },
         {
           "id": "aria",
           "screenId": "himi_owner_lite_aria",