@tribe-nest/forge 3.60.0 → 3.61.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tribe-nest/forge",
-  "version": "3.60.0",
+  "version": "3.61.0",
   "publishConfig": {
     "access": "public"
   },
@@ -35,6 +35,7 @@
     "@tribe-nest/media-protocol": "^1.0.0",
     "@tribe-nest/seating-core": "^1.0.0",
     "axios": "^1.7.9",
+    "cobe": "2.0.1",
     "libphonenumber-js": "^1.13.13",
     "lucide-react": "^0.510.0",
     "react-hook-form": "^7.60.0",

package/src/contexts/CartContext.tsx

@@ -1,6 +1,7 @@
 "use client";
 import type { IBookingFee, ProductDeliveryType } from "../types/models";
-import { useCallback, useContext, useMemo, useState } from "react";
+import { useCallback, useContext, useMemo, useRef, useState } from "react";
+import { trackMeta } from "../utils/metaEvents";
 import { createSharedContext } from "../runtime/registry";
 import type { ReactNode } from "react";
 import { useEffect } from "react";
@@ -333,6 +334,15 @@ export function CartProvider({ children }: { children: ReactNode }) {
         return false;
       }
       setCartItems((prev) => [...prev, next]);
+      // Meta AddToCart, only for a line that is new: a duplicate updates the
+      // line and adds nothing.
+      trackMeta("AddToCart", {
+        content_ids: [item.productId],
+        content_name: item.title,
+        content_type: "product",
+        value: Number(item.price) * (item.quantity || 1),
+        num_items: item.quantity || 1,
+      });
       return true;
     },
     [cartItems],
@@ -392,7 +402,30 @@ export function CartProvider({ children }: { children: ReactNode }) {
     }
   }, []);
 
+  // The latest selection, read by `setTickets` to tell an increase (an add,
+  // for Meta) from a decrease, outside the state updater (which must stay pure).
+  const ticketItemsRef = useRef(ticketItems);
+  ticketItemsRef.current = ticketItems;
+
   const setTickets = useCallback((item: TicketCartItem) => {
+    const before = ticketItemsRef.current.find((t) => t.eventId === item.eventId);
+    let added = 0;
+    let addedValue = 0;
+    for (const [ticketId, qty] of Object.entries(item.tickets)) {
+      const increase = qty - (before?.tickets[ticketId] ?? 0);
+      if (increase <= 0) continue;
+      added += increase;
+      addedValue += increase * Number(item.ticketMeta[ticketId]?.price ?? 0);
+    }
+    if (added > 0) {
+      trackMeta("AddToCart", {
+        content_ids: [item.eventId],
+        content_name: item.eventTitle,
+        content_type: "product",
+        value: Number.isFinite(addedValue) ? addedValue : undefined,
+        num_items: added,
+      });
+    }
     setTicketItems((prev) => [...prev.filter((t) => t.eventId !== item.eventId), item]);
     setCartOpen(true);
   }, []);

package/src/contexts/PublicAuthContext.tsx

@@ -31,7 +31,7 @@ import {
   storeTokenPair,
 } from "../client/tokenStorage";
 
-// Kept for compat — the canonical constants live in client/tokenStorage.ts.
+// Kept for compat. The canonical constants live in client/tokenStorage.ts.
 export const ACCESS_TOKEN_KEY = PUBLIC_ACCESS_TOKEN_KEY;
 export { PUBLIC_ACCESS_TOKEN_KEY };
 
@@ -129,7 +129,7 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
   }, []);
 
   const { data: currencies } = useQuery({
-    // profileId scopes the cache — supportedCurrencies is narrowed to the tenant's
+    // profileId scopes the cache: supportedCurrencies is narrowed to the tenant's
     // connected account (must match useCurrencies' key so they share one fetch).
     queryKey: ["public-currencies", profileId],
     queryFn: async () => {
@@ -241,6 +241,17 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
     }
   };
 
+  /**
+   * Sign in with a session another call already minted (the email-first flow's
+   * `signed_in` answers). The same three steps every sign-in here ends with:
+   * store the token pair, hand the access token to the client, record the user.
+   */
+  const adoptSession = (session: { token: string; refreshToken?: string; account: PublicAuthUser }) => {
+    storeTokenPair(PUBLIC_ACCESS_TOKEN_KEY, PUBLIC_REFRESH_TOKEN_KEY, session.token, session.refreshToken);
+    setToken(session.token);
+    dispatch({ type: Types.Login, payload: { user: session.account } });
+  };
+
   const resendLoginCode = async (email: string) => {
     // /public/sessions requires the profile context.
     await client.post("/public/sessions/resend-code", { email, profileId });
@@ -303,7 +314,7 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
         ...data,
       });
       // No token: signup issues no session until the emailed code is redeemed
-      // (see PublicAuthChallenge). Keep the caller's data — `verifyRegistration`
+      // (see PublicAuthChallenge). Keep the caller's data: `verifyRegistration`
       // needs the coupon/consent flags again to finish the job.
       const { email } = response.data as { status: "verify_email"; email: string };
       dispatch({ type: Types.Loading, payload: { isLoading: false } });
@@ -372,6 +383,7 @@ function PublicAuthProvider({ children }: AuthProviderProps) {
         validateLoginCredentials,
         verifyLoginCode,
         resendLoginCode,
+        adoptSession,
         logout,
         register,
         verifyRegistration,

package/src/data/queries/_tests/metaSignals.spec.tsx

@@ -0,0 +1,130 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+
+/**
+ * Every request that creates a visitor record carries `metaSignals`, which is
+ * what lets a server event sent later (from a worker, with no request) still
+ * match the visitor. A create response that carries `metaEvent` means the
+ * server queued that event: the browser fires only its pixel twin.
+ */
+
+const post = vi.fn();
+
+vi.mock("../../../provider/ForgeProvider", () => ({
+  useForge: () => ({ client: { post }, profileId: "profile-1" }),
+}));
+
+import { useSubmitPublicForm } from "../useForms";
+import { useJoinEmailList } from "../useLeadMagnet";
+import { useCreateOrder } from "../useOrders";
+import { useUpdateCoachingBooking } from "../useCoachingAvailability";
+import { resetMetaPolicy, setMetaPolicy } from "../../../utils/metaEvents";
+import { saveCookieConsent, GRANT_ALL, DENY_ALL } from "../../../utils/cookieConsent";
+
+const wrapper = ({ children }: { children: ReactNode }) => {
+  const queryClient = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+};
+
+let fbq: ReturnType<typeof vi.fn>;
+let fetchSpy: ReturnType<typeof vi.fn>;
+const pixel = () => fbq.mock.calls.filter((c) => c[0] === "trackSingle");
+
+beforeEach(() => {
+  post.mockReset();
+  resetMetaPolicy();
+  window.localStorage.clear();
+  document.cookie = "_fbp=fb.1.1.2; path=/";
+  fbq = vi.fn();
+  (window as unknown as { fbq: unknown }).fbq = fbq;
+  fetchSpy = vi.fn().mockResolvedValue({ ok: true });
+  vi.stubGlobal("fetch", fetchSpy);
+  window.history.replaceState({}, "", "/contact");
+  setMetaPolicy({
+    pixelId: "555",
+    enabled: true,
+    requireConsent: true,
+    apiUrl: "https://api.test",
+    subdomain: "artist",
+    currency: "USD",
+    resolved: true,
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  resetMetaPolicy();
+  document.cookie = "_fbp=; path=/; max-age=0";
+});
+
+describe("useSubmitPublicForm", () => {
+  it("attaches metaSignals and fires the pixel copy of the server's Lead", async () => {
+    saveCookieConsent(GRANT_ALL);
+    post.mockResolvedValue({ data: { id: "sub-1", metaEvent: { name: "Lead", eventId: "sub-1", customData: { content_name: "Contact" } } } });
+    const { result } = renderHook(() => useSubmitPublicForm("form-1"), { wrapper });
+
+    await act(async () => {
+      await result.current.mutateAsync({ answers: [], respondentEmail: "a@b.test" });
+    });
+
+    expect(post).toHaveBeenCalledWith("/public/forms/form-1/submit", {
+      answers: [],
+      respondentEmail: "a@b.test",
+      idempotencyKey: expect.any(String),
+      metaSignals: { pageUrl: "http://localhost:3000/contact", marketingConsent: true, fbp: "fb.1.1.2" },
+    });
+    expect(pixel()).toEqual([["trackSingle", "555", "Lead", { content_name: "Contact" }, { eventID: "sub-1" }]]);
+    // The server already queued its copy.
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("sends consent false and no Meta ids when marketing was declined, and fires no pixel", async () => {
+    saveCookieConsent(DENY_ALL);
+    post.mockResolvedValue({ data: { id: "sub-2", metaEvent: { name: "Lead", eventId: "sub-2" } } });
+    const { result } = renderHook(() => useSubmitPublicForm("form-1"), { wrapper });
+
+    await act(async () => {
+      await result.current.mutateAsync([]);
+    });
+
+    expect(post.mock.calls[0][1].metaSignals).toEqual({ pageUrl: "http://localhost:3000/contact", marketingConsent: false });
+    expect(pixel()).toEqual([]);
+  });
+});
+
+describe("other create requests", () => {
+  beforeEach(() => saveCookieConsent(GRANT_ALL));
+
+  it("useJoinEmailList attaches metaSignals and fires CompleteRegistration from the response", async () => {
+    post.mockResolvedValue({ data: { metaEvent: { name: "CompleteRegistration", eventId: "subscriber-1" } } });
+    const { result } = renderHook(() => useJoinEmailList(), { wrapper });
+    await act(async () => {
+      await result.current.mutateAsync({ email: "a@b.test", emailListId: "list-1" });
+    });
+    expect(post.mock.calls[0][1]).toMatchObject({ email: "a@b.test", profileId: "profile-1", metaSignals: { marketingConsent: true } });
+    expect(pixel()).toEqual([["trackSingle", "555", "CompleteRegistration", {}, { eventID: "subscriber-1" }]]);
+  });
+
+  it("useUpdateCoachingBooking fires Schedule from the response", async () => {
+    post.mockResolvedValue({ data: { bookingId: "b-1", isConfirmed: true, metaEvent: { name: "Schedule", eventId: "b-1" } } });
+    const { result } = renderHook(() => useUpdateCoachingBooking("coach-1"), { wrapper });
+    await act(async () => {
+      await result.current.mutateAsync({ bookingId: "b-1", email: "a@b.test", firstName: "A", lastName: "B", confirmIfFree: true });
+    });
+    expect(post.mock.calls[0][1].metaSignals).toMatchObject({ marketingConsent: true, fbp: "fb.1.1.2" });
+    expect(pixel()).toEqual([["trackSingle", "555", "Schedule", {}, { eventID: "b-1" }]]);
+  });
+
+  it("useCreateOrder attaches metaSignals and fires nothing itself", async () => {
+    post.mockResolvedValue({ data: { orderId: "o-1", totalAmount: 10, subTotal: 10 } });
+    const { result } = renderHook(() => useCreateOrder(), { wrapper });
+    await act(async () => {
+      await result.current.mutateAsync({ amount: 10, email: "a@b.test", cartItems: [] });
+    });
+    expect(post.mock.calls[0][1]).toMatchObject({ amount: 10, profileId: "profile-1", metaSignals: { marketingConsent: true } });
+    expect(pixel()).toEqual([]);
+  });
+});

package/src/data/queries/useAccount.ts

@@ -1,6 +1,6 @@
 import type { IPublicOrder, IPublicPost, PaginatedData } from "../../types/models";
 import { useForge } from "../../provider/ForgeProvider";
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { useInfiniteQuery, useMutation, useQuery } from "@tanstack/react-query";
 
 /** Orders placed by the signed-in member on this profile. */
 export function useUserOrders(accountId?: string) {
@@ -40,6 +40,11 @@ export type NotificationPreferences = {
 };
 
 /** The member's notification-type preferences for this profile. */
+/**
+ * @deprecated Reads `newPosts` / `chatMessages`, which the server never sends:
+ * the preferences endpoint speaks the `"<type>.<channel>"` matrix. Use
+ * `useNotificationMatrix` and `useUpdateNotificationMatrix`.
+ */
 export function useNotificationPreferences(enabled = true) {
   const { client, profileId } = useForge();
 
@@ -55,7 +60,11 @@ export function useNotificationPreferences(enabled = true) {
   });
 }
 
-/** Update one notification-type preference. */
+/**
+ * @deprecated Sends `{ newPosts: false }`, which the server drops without an
+ * error (it accepts only `"<type>.<channel>"` keys), so nothing is ever saved.
+ * Use `useUpdateNotificationMatrix`.
+ */
 export function useUpdateNotificationPreference() {
   const { client, profileId } = useForge();
 
@@ -69,3 +78,25 @@ export function useUpdateNotificationPreference() {
     },
   });
 }
+
+/**
+ * Every order, a page at a time, for a list with a "Show more" button.
+ *
+ * `useUserOrders` sends no page, so the server's default of 10 applies and a
+ * buyer with more orders than that never saw the older ones. `/public/orders`
+ * returns a bare array with no total, so a FULL page is the only sign that
+ * another may follow; an exact multiple costs one extra, empty request.
+ */
+export function useUserOrdersPaged(accountId?: string, limit = 20) {
+  const { client, profileId } = useForge();
+  return useInfiniteQuery({
+    queryKey: ["user-orders", accountId, profileId, "paged", limit],
+    initialPageParam: 1,
+    queryFn: async ({ pageParam }) => {
+      const res = await client.get("/public/orders", { params: { profileId, page: pageParam, limit } });
+      return res.data as IPublicOrder[];
+    },
+    getNextPageParam: (last, pages) => (last.length === limit ? pages.length + 1 : undefined),
+    enabled: !!accountId && !!profileId && !!client,
+  });
+}

package/src/data/queries/useAnalytics.ts

@@ -5,7 +5,7 @@ import { useForge } from "../../provider/ForgeProvider";
  * server-side CAPI twin, and for correlating first-party events. */
 export function newEventId(): string {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
-  // Fallback for older runtimes — not cryptographically strong, only needs to be
+  // Fallback for older runtimes: not cryptographically strong, only needs to be
   // unique enough to pair a pixel + CAPI event.
   return `evt_${Date.now().toString(36)}_${Math.abs(hashString(String(performance?.now?.() ?? Date.now()))).toString(36)}`;
 }
@@ -33,7 +33,7 @@ export function getAnalyticsSessionId(subdomain: string): string | null {
     }
     return sessionId;
   } catch {
-    // Private mode / storage disabled — fall back to an ephemeral per-load id.
+    // Private mode / storage disabled: fall back to an ephemeral per-load id.
     return `${subdomain}_${Date.now()}`;
   }
 }
@@ -44,7 +44,7 @@ export interface TrackEventOptions {
   /**
    * Store a session id in `sessionStorage` and send it with events. Default
    * `true`. Set `false` for cookieless, Plausible-style analytics: nothing is
-   * written to the device and no id is sent — the backend derives a rotating
+   * written to the device and no id is sent; the backend derives a rotating
    * per-day visitor hash instead, so the "visits" metric still works without
    * needing storage consent.
    */
@@ -53,7 +53,7 @@ export interface TrackEventOptions {
 
 /**
  * The first-party website-analytics primitive. Returns a `track(eventType,
- * eventData)` function that posts to `POST /public/websites/track-event` — the
+ * eventData)` function that posts to `POST /public/websites/track-event`, the
  * same feed the platform's admin analytics dashboard reads (visits, page views,
  * clicks, geo). The backend enriches each event with geo-IP + user agent.
  *
@@ -68,7 +68,7 @@ export function useTrackEvent(opts?: TrackEventOptions) {
 
   const buildPayload = useCallback(
     (eventData: Record<string, unknown>) => {
-      // Cookieless mode omits the sessionId entirely — the backend derives a
+      // Cookieless mode omits the sessionId entirely; the backend derives a
       // rotating per-day visitor hash so nothing touches the device.
       const sessionId = storeSession && subdomain ? getAnalyticsSessionId(subdomain) : undefined;
       const payload: Record<string, unknown> = { ...eventData };
@@ -133,5 +133,5 @@ export function useTrackEvent(opts?: TrackEventOptions) {
     [apiUrl, subdomain, buildPayload],
   );
 
-  return { track, trackBeacon };
+  return { track, trackBeacon, apiUrl, subdomain };
 }

package/src/data/queries/useCallChat.ts

@@ -22,7 +22,7 @@ type ReactionRow = { emoji: string; count: number; reactedByMe: boolean };
 type MessageWithReactions = ChatMessage & { reactions?: ReactionRow[] };
 
 const senderName = (message: MessageWithReactions): string =>
-  [message.senderFirstName, message.senderLastName].filter(Boolean).join(" ").trim() || message.senderAccountId;
+  [message.senderFirstName, message.senderLastName].filter(Boolean).join(" ").trim() || (message.senderAccountId ?? "");
 
 export function useCallChat(callId: string | undefined): CallStageChat | undefined {
   const { client, profileId } = useForge();
@@ -145,7 +145,7 @@ export function useCallChat(callId: string | undefined): CallStageChat | undefin
       id: message.id,
       content: message.content,
       senderName: senderName(message),
-      senderKey: message.senderAccountId,
+      senderKey: message.senderAccountId ?? message.senderAgentId ?? "",
       at: message.createdAt,
       reactions: message.reactions ?? [],
     }));

package/src/data/queries/useChat.ts

@@ -14,6 +14,11 @@ export interface ChatChannel {
   description: string | null;
   /** For DM channels, the counterpart participant (backend-enriched). */
   otherParticipant?: ChatDmPeer | null;
+  /**
+   * A DM's pair key. Null for the member and creator DM; `agent:...` for the
+   * member's DM with the community AI (see `isCommunityAgentDm`).
+   */
+  dmKey?: string | null;
 }
 
 export interface ChatAttachment {
@@ -27,7 +32,11 @@ export interface ChatMessage {
   id: string;
   channelId: string;
   content: string | null;
-  senderAccountId: string;
+  /** Null when the community AI sent it (`senderAgentId` is then set). */
+  senderAccountId: string | null;
+  /** The community AI, when it sent this message. `senderFirstName` is then its name. */
+  senderAgentId?: string | null;
+  senderAgentAvatarUrl?: string | null;
   senderFirstName: string;
   senderLastName: string;
   isPinned: boolean;

package/src/data/queries/useCheckouts.ts

@@ -1,4 +1,5 @@
 import { useMutation } from "@tanstack/react-query";
+import { readMetaSignals } from "../../utils/metaEvents";
 import { useForge } from "../../provider/ForgeProvider";
 import { bundleCouponRequestBody } from "../../ui/headless/checkout/bundleCoupon";
 import type { CartItem, TicketCartItem } from "../../contexts/CartContext";
@@ -133,7 +134,7 @@ export function useCreateCheckout() {
 
   return useMutation<CreateCheckoutResult, unknown, Record<string, unknown>>({
     mutationFn: async (body) => {
-      const res = await client.post("/public/checkouts", { profileId, ...body });
+      const res = await client.post("/public/checkouts", { profileId, ...body, metaSignals: readMetaSignals() });
       return res.data;
     },
   });

package/src/data/queries/useCoachingAvailability.ts

@@ -1,4 +1,5 @@
 import type { BookingSlot, CancellationTermsView, PillarDiscountQuote } from "../../types/models";
+import { fireServerMetaEvent, readMetaSignals, type ServerMetaEvent } from "../../utils/metaEvents";
 import { useForge } from "../../provider/ForgeProvider";
 import { useMutation, useQuery } from "@tanstack/react-query";
 
@@ -44,6 +45,7 @@ export function useReserveCoachingBooking(productId?: string) {
     mutationFn: async ({ slotId }) => {
       const res = await client.post(`/public/coaching/products/${productId}/booking/reserve`, {
         slotId,
+        metaSignals: readMetaSignals(),
       });
       return res.data;
     },
@@ -71,6 +73,8 @@ export type UpdateCoachingBookingInput = {
 export type UpdateCoachingBookingResult = PillarDiscountQuote & {
   bookingId: string;
   isConfirmed: boolean;
+  /** Set when this call newly confirmed a free booking and the server queued Schedule. */
+  metaEvent?: ServerMetaEvent;
 };
 
 /**
@@ -87,9 +91,14 @@ export function useUpdateCoachingBooking(productId?: string) {
 
   return useMutation<UpdateCoachingBookingResult, unknown, UpdateCoachingBookingInput>({
     mutationFn: async (body) => {
-      const res = await client.post(`/public/coaching/products/${productId}/booking/update`, body);
+      const res = await client.post(`/public/coaching/products/${productId}/booking/update`, {
+        ...body,
+        metaSignals: readMetaSignals(),
+      });
       return res.data;
     },
+    // A free booking newly confirmed: the server queued Schedule; fire its pixel twin.
+    onSuccess: (data) => fireServerMetaEvent(data),
   });
 }
 

package/src/data/queries/useCommunities.ts

@@ -29,6 +29,8 @@ export interface PublicCommunity {
   category: string | null;
   tags: string[];
   memberCount: number;
+  /** How a visitor gets in. Absent on older servers: treat as open. */
+  joinMode?: "open" | "application" | "invite";
 }
 
 /** A tier the viewer may join: the public tier shape plus the community it belongs to. */