@tribe-nest/forge 3.59.0 → 3.61.0

package/src/data/queries/usePosts.ts

@@ -1,5 +1,5 @@
 import type { IPublicPost, PaginatedData } from "../../types/models";
-import { useForge } from "../../provider/ForgeProvider";
+import { useCommunityScope } from "../../contexts/CommunityContext";
 import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
 
 export interface GetPostsParams {
@@ -10,14 +10,15 @@ export interface GetPostsParams {
 }
 
 export function useGetPosts(params?: GetPostsParams) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetPosts()");
 
   return useQuery<PaginatedData<IPublicPost>>({
-    queryKey: ["posts", profileId, params],
+    queryKey: ["posts", communityId, params],
     queryFn: async () => {
       const res = await client.get("/public/posts", {
         params: {
-          profileId: profileId,
+          profileId,
+          communityId,
           page: params?.page || 1,
           limit: 10,
           filter: {
@@ -29,7 +30,7 @@ export function useGetPosts(params?: GetPostsParams) {
       });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
@@ -46,19 +47,20 @@ export interface GetPostsInfiniteParams {
  * ships media for locked posts, so paging is safe for any auth state.
  */
 export function useGetPostsInfinite(params?: GetPostsInfiniteParams) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetPostsInfinite()");
   const limit = params?.pageSize ?? 10;
 
   return useInfiniteQuery<PaginatedData<IPublicPost>>({
     queryKey: [
       "posts-infinite",
-      profileId,
+      communityId,
       { query: params?.query, type: params?.type, membershipTierId: params?.membershipTierId, limit },
     ],
     queryFn: async ({ pageParam = 1 }) => {
       const res = await client.get("/public/posts", {
         params: {
-          profileId: profileId,
+          profileId,
+          communityId,
           page: pageParam,
           limit,
           filter: {
@@ -72,23 +74,23 @@ export function useGetPostsInfinite(params?: GetPostsInfiniteParams) {
     },
     initialPageParam: 1,
     getNextPageParam: (lastPage) => (lastPage.hasNextPage ? (lastPage.nextPage ?? lastPage.page + 1) : undefined),
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
 /**
- * The member's saved posts (GET /public/posts/saved — requires auth). The
+ * The member's saved posts (GET /public/posts/saved: requires auth). The
  * endpoint returns a single `{ data, total }` page.
  */
 export function useGetSavedPosts(enabled = true) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetSavedPosts()");
 
   return useQuery<{ data: IPublicPost[]; total: number }>({
-    queryKey: ["posts-saved", profileId],
+    queryKey: ["posts-saved", communityId],
     queryFn: async () => {
-      const res = await client.get("/public/posts/saved", { params: { profileId } });
+      const res = await client.get("/public/posts/saved", { params: { profileId, communityId } });
       return res.data;
     },
-    enabled: !!profileId && !!client && enabled,
+    enabled: !!profileId && !!communityId && !!client && enabled,
   });
 }

package/src/data/queries/useSiteApp.ts

@@ -0,0 +1,130 @@
+import { useEffect, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useForge } from "../../provider/ForgeProvider";
+import { internalPath } from "../../runtime/pages";
+
+/**
+ * The site app: the installable app every website is (one per origin).
+ *
+ * Speaks `GET /public/websites/app?host=<host>`, which answers for the website
+ * that owns the host the visitor is on. Contract:
+ * docs/proposals/site-app-and-website-menu.md, sections 2 and 3.
+ */
+
+/** The built-in sections of the app home, in their default order. */
+export const SITE_APP_SECTION_KEYS = [
+  "needs_you",
+  "portal",
+  "communities",
+  "coming_up",
+  "learning",
+  "explore_communities",
+  "events",
+  "courses",
+  "shop",
+] as const;
+
+export type SiteAppSectionKey = (typeof SITE_APP_SECTION_KEYS)[number];
+
+/** What may sit in the app bar between Home and More. */
+export const SITE_APP_BAR_KEYS = ["communities", "portal", "inbox", "events", "courses", "shop"] as const;
+
+export type SiteAppBarKey = (typeof SITE_APP_BAR_KEYS)[number];
+
+/** How many configured items fit between Home and More. */
+export const SITE_APP_BAR_MAX_ITEMS = 3;
+
+export type SiteAppHomeSection =
+  | { type: "builtin"; key: SiteAppSectionKey; visible: boolean }
+  | { type: "link"; id: string; label: string; href: string; visible: boolean };
+
+/** The public answer, exactly as section 3 of the contract shapes it. */
+export interface SiteApp {
+  websiteId: string;
+  profileId: string;
+  appName: string;
+  shortName: string;
+  iconUrl: string | null;
+  themeColor: string | null;
+  backgroundColor: string | null;
+  /** `/i/app`, or the creator's own start page. Home everywhere. */
+  startUrl: string;
+  /** Only the VISIBLE sections, in the configured order. */
+  homeSections: SiteAppHomeSection[];
+  barItems: SiteAppBarKey[];
+  installPrompt: boolean;
+  pushPrompt: boolean;
+  activeVersionId: string | null;
+}
+
+/** Where the app starts when the creator has not chosen a page of their own. */
+export const SITE_APP_DEFAULT_START = internalPath("app");
+
+/** Visible by default; `events` and `courses` are off until the creator turns them on. */
+const DEFAULT_HIDDEN: ReadonlySet<SiteAppSectionKey> = new Set(["events", "courses"]);
+
+/** The visible home sections when no settings answer: the contract's defaults. */
+export const SITE_APP_DEFAULT_SECTIONS: readonly SiteAppHomeSection[] = SITE_APP_SECTION_KEYS.filter(
+  (key) => !DEFAULT_HIDDEN.has(key),
+).map((key) => ({ type: "builtin", key, visible: true }) as const);
+
+export const SITE_APP_DEFAULT_BAR: readonly SiteAppBarKey[] = ["communities", "portal", "inbox"];
+
+export const siteAppKeys = {
+  byHost: (host: string | null) => ["site-app", host] as const,
+};
+
+/**
+ * The host the visitor is on, read after mount.
+ *
+ * Not during render: the server has no `window`, and reading it there would
+ * render one thing on the server and another on the first client pass.
+ */
+export function useCurrentHost(): string | null {
+  const [host, setHost] = useState<string | null>(null);
+  useEffect(() => {
+    if (typeof window !== "undefined") setHost(window.location.host || null);
+  }, []);
+  return host;
+}
+
+/**
+ * This website's app settings, for the host the visitor is on.
+ *
+ * An unknown host (a preview, the edit sandbox) is a 404, which is an answer
+ * rather than a fault: it is not retried, and every reader falls back to the
+ * defaults (`useAppHomeHref` to `/i/app`).
+ */
+export function useSiteApp(opts: { host?: string | null; enabled?: boolean } = {}) {
+  const { client } = useForge();
+  const currentHost = useCurrentHost();
+  const host = opts.host ?? currentHost;
+  return useQuery<SiteApp>({
+    queryKey: siteAppKeys.byHost(host),
+    queryFn: async () => (await client.get("/public/websites/app", { params: { host } })).data as SiteApp,
+    enabled: !!client && !!host && opts.enabled !== false,
+    retry: false,
+    // Settings change rarely, and every page with an app bar reads them.
+    staleTime: 5 * 60_000,
+  });
+}
+
+/**
+ * Where "Home" is: the creator's start page when they chose one, else `/i/app`.
+ *
+ * The Home rule (contract section 4): the app bar's Home, the community
+ * header's logo, and where sign-in lands by default all read this, so a creator
+ * who moves Home moves it everywhere at once.
+ */
+export function useAppHomeHref(): string {
+  const { data } = useSiteApp();
+  return resolveAppHomeHref(data);
+}
+
+/** The pure half of `useAppHomeHref`, for a caller that already holds the settings. */
+export function resolveAppHomeHref(app: Pick<SiteApp, "startUrl"> | null | undefined): string {
+  const start = app?.startUrl?.trim();
+  // Only a root-relative path is a Home: anything else would send the member off-site.
+  if (!start || !start.startsWith("/") || start.startsWith("//")) return SITE_APP_DEFAULT_START;
+  return start;
+}

package/src/data/queries/useSubscriptions.ts

@@ -1,4 +1,6 @@
 import { useForge } from "../../provider/ForgeProvider";
+import { readMetaSignals } from "../../utils/metaEvents";
+import { useOptionalCommunityContext } from "../../contexts/CommunityContext";
 import { useMutation } from "@tanstack/react-query";
 import { usePublicAuth } from "../../contexts/PublicAuthContext";
 import type { QuestionnaireAnswer } from "../../types/models";
@@ -20,6 +22,8 @@ export type CreateSubscriptionInput = {
    * invite must be for the signed-in email); ignored on an open tier.
    */
   inviteToken?: string;
+  /** A shareable invite link token (`?join=`); opens an invite-only tier, still charges a paid one. */
+  joinToken?: string;
   /** Answers to the tier's questions. Required by the server when the tier has any. */
   questionnaire?: QuestionnaireAnswer[];
 };
@@ -55,6 +59,8 @@ export type CreateSubscriptionResult = {
    * charged today, and the first charge is on `endsAt`.
    */
   trial?: { days: number; endsAt: string } | null;
+  /** The slug of the community the tier belongs to, so the caller can land the fan inside it. */
+  communitySlug?: string;
 };
 
 /** Subscribe to a paid tier, or move an existing subscription onto another one. */
@@ -63,7 +69,11 @@ export function useCreateSubscription() {
 
   return useMutation<CreateSubscriptionResult, unknown, CreateSubscriptionInput>({
     mutationFn: async (body) => {
-      const res = await client.post("/public/payments/subscriptions", { ...body, profileId });
+      const res = await client.post("/public/payments/subscriptions", {
+        ...body,
+        profileId,
+        metaSignals: readMetaSignals(),
+      });
       return res.data;
     },
   });
@@ -73,10 +83,12 @@ export function useCreateSubscription() {
 export function useCreateFreeSubscription() {
   const { client, profileId } = useForge();
 
-  return useMutation<unknown, unknown, {
+  return useMutation<{ communitySlug?: string } | undefined, unknown, {
       membershipTierId: string;
       attributionRefId?: string;
       inviteToken?: string;
+      /** A shareable invite link token (`?join=`). */
+      joinToken?: string;
       /** Answers to the tier's questions. Required by the server when the tier has any. */
       questionnaire?: QuestionnaireAnswer[];
     }>({
@@ -89,7 +101,7 @@ export function useCreateFreeSubscription() {
 
 export type CancelMembershipResult = {
   membershipId: string;
-  /** The status AFTER cancelling — still `active` while a paid period runs out. */
+  /** The status AFTER cancelling: still `active` while a paid period runs out. */
   status: string;
   /** True when the cancellation was scheduled rather than applied immediately. */
   cancelAtPeriodEnd: boolean;
@@ -104,7 +116,7 @@ export type CancelMembershipResult = {
  * schedules it for the end of the period they have already paid for and the
  * member keeps their benefits until `accessUntil`. Free tiers (and any
  * membership with nothing paid up) end immediately. Works for every membership
- * the member can still use — including one whose card is failing, which used to
+ * the member can still use: including one whose card is failing, which used to
  * be rejected with an error the UI never showed.
  */
 export function useCancelMembership() {
@@ -126,7 +138,7 @@ export function useCancelMembership() {
  *
  * Every membership-aware surface should use this instead of reading
  * `user.membership.status`. `access` answers "can they see it", `message`
- * answers "what do we tell them" — two different questions, and conflating
+ * answers "what do we tell them": two different questions, and conflating
  * them is what locked past_due members out while calling them "Cancelled".
  */
 export function useMembershipAccess(): {
@@ -143,12 +155,12 @@ export function useMembershipAccess(): {
  *
  * This is the other half of keeping access through `past_due`: the grace window
  * is only a recovery window if the member can actually fix their card inside
- * it. Nothing about the caller is sent — the server derives the provider
+ * it. Nothing about the caller is sent: the server derives the provider
  * customer from the session, because a customer id in a request body is a
  * cross-tenant leak waiting to happen.
  *
  * `returnUrl` defaults to the current page so the member lands back where they
- * were. The returned `url` is a one-time link — redirect, never render it.
+ * were. The returned `url` is a one-time link: redirect, never render it.
  */
 export function useOpenBillingPortal() {
   const { client, profileId } = useForge();
@@ -170,14 +182,21 @@ export function useOpenBillingPortal() {
 /**
  * Reconcile the most recent subscription after a checkout return.
  * Returns the latest subscription status (e.g. "active").
+ *
+ * A fan can subscribe in several communities of one creator, so "the latest"
+ * is the latest IN A COMMUNITY: pass `communityId`, or it is read from the
+ * surrounding `<CommunityProvider>`.
  */
 export function useConfirmLatestSubscription() {
   const { client, profileId } = useForge();
+  const contextCommunityId = useOptionalCommunityContext()?.communityId;
 
-  return useMutation<{ status: string }, unknown, void>({
-    mutationFn: async () => {
+  return useMutation<{ status: string }, unknown, { communityId?: string } | void>({
+    mutationFn: async (input) => {
+      const communityId = (input && input.communityId) || contextCommunityId;
       const res = await client.post("/public/payments/subscriptions/confirm-latest", {
         profileId,
+        ...(communityId ? { communityId } : {}),
       });
       return res.data;
     },