@tribe-nest/forge 1.13.0

package/src/data/queries/useCoachingProducts.ts

@@ -0,0 +1,67 @@
+import type { CoachingProduct, PaginatedData } from "../../types/models";
+import { useForge } from "../../provider/ForgeProvider";
+import { useQuery } from "@tanstack/react-query";
+
+export interface GetCoachingProductsParams {
+  page?: number;
+  query?: string;
+}
+
+export function useGetCoachingProducts(params?: GetCoachingProductsParams, enabled = true) {
+  const { client, profileId } = useForge();
+
+  return useQuery<PaginatedData<CoachingProduct>>({
+    queryKey: ["coaching-products", profileId, params],
+    queryFn: async () => {
+      const res = await client.get("/public/coaching/products", {
+        params: {
+          profileId: profileId,
+          page: params?.page || 1,
+          limit: 10,
+        },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && enabled,
+  });
+}
+
+export function useGetCoachingProduct(coachingProductId?: string, options?: { initialData?: CoachingProduct }) {
+  const { client, profileId } = useForge();
+
+  return useQuery<CoachingProduct>({
+    queryKey: ["coaching-product", profileId, { coachingProductId }],
+    queryFn: async () => {
+      const res = await client.get(`/public/coaching/products/${coachingProductId}`, {
+        params: {
+          profileId: profileId,
+        },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!coachingProductId,
+    initialData: options?.initialData,
+  });
+}
+
+export function useGetCoachingProductsByIds(coachingProductIds: string[]) {
+  const { client, profileId } = useForge();
+  const idsKey = coachingProductIds.join(",");
+
+  return useQuery<CoachingProduct[]>({
+    queryKey: ["coaching-products", "batch", profileId, idsKey],
+    queryFn: async () => {
+      const res = await client.get("/public/coaching/products/batch", {
+        params: {
+          profileId: profileId,
+          ids: idsKey,
+        },
+      });
+      const data = res.data as CoachingProduct[];
+      return coachingProductIds
+        .map((id) => data.find((p) => p.id === id))
+        .filter((p): p is CoachingProduct => p != null);
+    },
+    enabled: !!profileId && !!client && coachingProductIds.length > 0,
+  });
+}

package/src/data/queries/useCohortPage.ts

@@ -0,0 +1,17 @@
+import type { CohortPagePayload } from "../../types/models";
+import { useForge } from "../../provider/ForgeProvider";
+import { useQuery } from "@tanstack/react-query";
+
+/** The public cohort landing page payload (data + serialized craft layout). */
+export function useCohortPage(cohortId?: string) {
+  const { client } = useForge();
+
+  return useQuery<CohortPagePayload>({
+    queryKey: ["public-cohort-page", cohortId],
+    queryFn: async () => {
+      const res = await client.get(`/public/cohorts/${cohortId}/page`);
+      return res.data;
+    },
+    enabled: !!client && !!cohortId,
+  });
+}

package/src/data/queries/useCollections.ts

@@ -0,0 +1,211 @@
+import type {
+  Collection,
+  CollectionEntry,
+  CollectionQueryParams,
+  CollectionQuery,
+  CollectionAggregate,
+  CollectionAggregateBucket,
+  CollectionSearchResult,
+} from "../../types/models";
+import { useForge } from "../../provider/ForgeProvider";
+import { useQuery, useMutation } from "@tanstack/react-query";
+import { collectionParamsToQuery, collectionParamsKey, splitCollectionQuery, collectionQueryKey } from "../collectionParams";
+
+// Generic data hooks for CMS collections. Collection-agnostic — a lawyers
+// directory and a recipe index use the same three hooks. The bespoke rendering
+// lives in the (agent-authored) site routes; these just fetch schema + entries.
+
+/**
+ * A collection's definition + ordered field schema, by slug. Use it to drive
+ * bespoke rendering (read `.fields` for keys/types/sections).
+ */
+export function useCollection(slug?: string, options?: { initialData?: Collection | null }) {
+  const { client, profileId } = useForge();
+
+  return useQuery<Collection | null>({
+    queryKey: ["collection-schema", profileId, slug],
+    queryFn: async () => {
+      const res = await client.get(`/public/collections/${slug}/schema`, {
+        params: { profileId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!slug,
+    initialData: options?.initialData,
+  });
+}
+
+/**
+ * Search/filter/sort/geo over a collection's published entries (GET /entries,
+ * lenient). Which fields accept filter/sort is creator-controlled — read
+ * `useCollection(slug).fields` for the queryable set.
+ *
+ * @deprecated Prefer {@link useCollectionQuery}, which runs the full query
+ * engine (reference `expand`, `select`, multi-key sort, cursor, `mine` scope)
+ * and validates strictly. `useCollectionEntries` stays for backwards
+ * compatibility with existing sites and won't be removed.
+ */
+export function useCollectionEntries(
+  slug?: string,
+  params?: CollectionQueryParams,
+  options?: { initialData?: CollectionSearchResult },
+) {
+  const { client, profileId } = useForge();
+
+  return useQuery<CollectionSearchResult>({
+    queryKey: ["collection-entries", profileId, slug, collectionParamsKey(params)],
+    queryFn: async () => {
+      const res = await client.get(`/public/collections/${slug}/entries`, {
+        params: collectionParamsToQuery(profileId, params),
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!slug,
+    initialData: options?.initialData,
+  });
+}
+
+/**
+ * Rich, structured query over a collection via the query engine (POST /query):
+ * the full operator set + reference `expand`, `select`, multi-key `sort`, cursor
+ * pagination, facets, and `scope: "mine"` (the logged-in member's own rows,
+ * drafts included). STRICT — an undeclared field / wrong-kind operator errors,
+ * so it catches mistakes. Additive to `useCollectionEntries`, which is unchanged.
+ */
+export function useCollectionQuery(
+  slug?: string,
+  query?: CollectionQuery,
+  options?: { initialData?: CollectionSearchResult; enabled?: boolean },
+) {
+  const { client, profileId } = useForge();
+  const { scope, query: body } = splitCollectionQuery(query);
+
+  return useQuery<CollectionSearchResult>({
+    queryKey: ["collection-query", profileId, slug, collectionQueryKey(query)],
+    queryFn: async () => {
+      const res = await client.post(`/public/collections/${slug}/query`, { profileId, scope, query: body });
+      return res.data;
+    },
+    enabled: (options?.enabled ?? true) && !!profileId && !!client && !!slug,
+    initialData: options?.initialData,
+  });
+}
+
+/**
+ * Aggregate a collection (group-by + count/sum/avg/min/max) via POST /aggregate —
+ * totals, leaderboards, "washes remaining". `scope: "mine"` restricts to the
+ * member's own rows.
+ */
+export function useCollectionAggregate(
+  slug?: string,
+  aggregate?: CollectionAggregate,
+  opts?: { scope?: "public" | "mine"; where?: CollectionQuery["where"]; search?: string; enabled?: boolean },
+) {
+  const { client, profileId } = useForge();
+
+  return useQuery<CollectionAggregateBucket[]>({
+    queryKey: ["collection-aggregate", profileId, slug, JSON.stringify({ aggregate, ...opts })],
+    queryFn: async () => {
+      const res = await client.post(`/public/collections/${slug}/aggregate`, {
+        profileId,
+        scope: opts?.scope,
+        where: opts?.where,
+        search: opts?.search,
+        aggregate,
+      });
+      return res.data.data;
+    },
+    enabled: (opts?.enabled ?? true) && !!profileId && !!client && !!slug && !!aggregate,
+  });
+}
+
+export type SubmitCollectionEntryInput = {
+  data: Record<string, unknown>;
+  /** For anonymous submissions, when the collection requires them. */
+  name?: string;
+  email?: string;
+};
+
+export type SubmitCollectionEntryResult = { id: string; slug: string; status: "draft" | "published" };
+
+/**
+ * Submit a new entry to a collection that has public submissions enabled
+ * (e.g. leave a review). Members are authenticated via the Forge token; the
+ * result's `status` is "published" (auto) or "draft" (held for review).
+ */
+export function useSubmitCollectionEntry(slug?: string) {
+  const { client, profileId } = useForge();
+
+  return useMutation<SubmitCollectionEntryResult, unknown, SubmitCollectionEntryInput>({
+    mutationFn: async (input) => {
+      const res = await client.post(`/public/collections/${slug}/entries`, {
+        profileId,
+        data: input.data,
+        name: input.name,
+        email: input.email,
+      });
+      return res.data;
+    },
+  });
+}
+
+// --- owner-scoped writes (member-owned collections) ---------------------------
+// For a `user`-owned collection, a signed-in member manages THEIR OWN rows. The
+// owner + profile come from the member's token, so these send neither.
+
+export type MyEntryInput = { data: Record<string, unknown>; status?: "draft" | "published" };
+export type MyEntryResult = { id: string; slug?: string; status: "draft" | "published" };
+
+/** Create one of the member's own entries in a user-owned collection. */
+export function useCreateMyEntry(slug?: string) {
+  const { client } = useForge();
+  return useMutation<MyEntryResult, unknown, MyEntryInput>({
+    mutationFn: async (input) => {
+      const res = await client.post(`/public/collections/${slug}/my-entries`, input);
+      return res.data;
+    },
+  });
+}
+
+/** Update one of the member's own entries. */
+export function useUpdateMyEntry(slug?: string) {
+  const { client } = useForge();
+  return useMutation<MyEntryResult, unknown, { entryId: string } & MyEntryInput>({
+    mutationFn: async ({ entryId, ...input }) => {
+      const res = await client.put(`/public/collections/${slug}/my-entries/${entryId}`, input);
+      return res.data;
+    },
+  });
+}
+
+/** Delete one of the member's own entries. */
+export function useDeleteMyEntry(slug?: string) {
+  const { client } = useForge();
+  return useMutation<{ success: boolean }, unknown, { entryId: string }>({
+    mutationFn: async ({ entryId }) => {
+      const res = await client.delete(`/public/collections/${slug}/my-entries/${entryId}`);
+      return res.data;
+    },
+  });
+}
+
+/** A single published entry by slug. */
+export function useCollectionEntry(
+  slug?: string,
+  entrySlug?: string,
+  options?: { initialData?: CollectionEntry | null },
+) {
+  const { client, profileId } = useForge();
+
+  return useQuery<CollectionEntry | null>({
+    queryKey: ["collection-entry", profileId, slug, entrySlug],
+    queryFn: async () => {
+      const res = await client.get(`/public/collections/${slug}/entries/${entrySlug}`, {
+        params: { profileId },
+      });
+      return res.data;
+    },
+    enabled: !!profileId && !!client && !!slug && !!entrySlug,
+    initialData: options?.initialData,
+  });
+}