@btst/stack 2.0.1 → 2.2.0

package/src/plugins/cms/api/plugin.ts

@@ -14,8 +14,6 @@ import type {
 	ContentRelation,
 	CMSBackendConfig,
 	CMSHookContext,
-	SerializedContentType,
-	SerializedContentItem,
 	SerializedContentItemWithType,
 	RelationConfig,
 	RelationValue,
@@ -23,97 +21,14 @@ import type {
 } from "../types";
 import { listContentQuerySchema } from "../schemas";
 import { slugify } from "../utils";
-
-/**
- * Migrate a legacy JSON Schema (version 1) to unified format (version 2)
- * by merging fieldConfig values into the JSON Schema properties
- */
-function migrateToUnifiedSchema(
-	jsonSchemaStr: string,
-	fieldConfigStr: string | null | undefined,
-): string {
-	if (!fieldConfigStr) {
-		return jsonSchemaStr;
-	}
-
-	try {
-		const jsonSchema = JSON.parse(jsonSchemaStr);
-		const fieldConfig = JSON.parse(fieldConfigStr);
-
-		if (!jsonSchema.properties || typeof fieldConfig !== "object") {
-			return jsonSchemaStr;
-		}
-
-		// Merge fieldType from fieldConfig into each property
-		for (const [key, config] of Object.entries(fieldConfig)) {
-			if (
-				jsonSchema.properties[key] &&
-				typeof config === "object" &&
-				config !== null &&
-				"fieldType" in config
-			) {
-				jsonSchema.properties[key].fieldType = (
-					config as { fieldType: string }
-				).fieldType;
-			}
-		}
-
-		return JSON.stringify(jsonSchema);
-	} catch {
-		// If parsing fails, return original
-		return jsonSchemaStr;
-	}
-}
-
-/**
- * Serialize a ContentType for API response (convert dates to strings)
- * Also applies lazy migration for legacy schemas (version 1 → 2)
- */
-function serializeContentType(ct: ContentType): SerializedContentType {
-	// Check if this is a legacy schema that needs migration
-	const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
-
-	// Apply lazy migration: merge fieldConfig into jsonSchema on read
-	const migratedJsonSchema = needsMigration
-		? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig)
-		: ct.jsonSchema;
-
-	return {
-		id: ct.id,
-		name: ct.name,
-		slug: ct.slug,
-		description: ct.description,
-		jsonSchema: migratedJsonSchema,
-		createdAt: ct.createdAt.toISOString(),
-		updatedAt: ct.updatedAt.toISOString(),
-	};
-}
-
-/**
- * Serialize a ContentItem for API response (convert dates to strings)
- */
-function serializeContentItem(item: ContentItem): SerializedContentItem {
-	return {
-		...item,
-		createdAt: item.createdAt.toISOString(),
-		updatedAt: item.updatedAt.toISOString(),
-	};
-}
-
-/**
- * Serialize a ContentItem with parsed data and joined ContentType
- */
-function serializeContentItemWithType(
-	item: ContentItemWithType,
-): SerializedContentItemWithType {
-	return {
-		...serializeContentItem(item),
-		parsedData: JSON.parse(item.data),
-		contentType: item.contentType
-			? serializeContentType(item.contentType)
-			: undefined,
-	};
-}
+import {
+	getAllContentTypes,
+	getAllContentItems,
+	getContentItemBySlug,
+	serializeContentType,
+	serializeContentItem,
+	serializeContentItemWithType,
+} from "./getters";
 
 /**
  * Sync content types from config to database
@@ -511,34 +426,52 @@ async function populateRelations(
  *
  * @param config - Configuration with content types and optional hooks
  */
-export const cmsBackendPlugin = (config: CMSBackendConfig) =>
-	defineBackendPlugin({
+export const cmsBackendPlugin = (config: CMSBackendConfig) => {
+	// Shared sync state — used by both the api factory and routes handlers so
+	// that calling a getter before any HTTP request has been made still
+	// triggers the one-time content-type sync.
+	let syncPromise: Promise<void> | null = null;
+
+	const ensureSynced = (adapter: Adapter) => {
+		if (!syncPromise) {
+			syncPromise = syncContentTypes(adapter, config).catch((err) => {
+				// Allow retry on next call if sync fails
+				syncPromise = null;
+				throw err;
+			});
+		}
+		return syncPromise;
+	};
+
+	return defineBackendPlugin({
 		name: "cms",
 
 		dbPlugin: dbSchema,
 
-		routes: (adapter: Adapter) => {
-			// Sync content types on first request using promise-based lock
-			// This prevents race conditions when multiple concurrent requests arrive
-			// on cold start within the same instance
-			let syncPromise: Promise<void> | null = null;
-
-			const ensureSynced = async () => {
-				if (!syncPromise) {
-					syncPromise = syncContentTypes(adapter, config).catch((err) => {
-						// If sync fails, allow retry on next request
-						syncPromise = null;
-						throw err;
-					});
-				}
-				await syncPromise;
-			};
+		api: (adapter) => ({
+			getAllContentTypes: async () => {
+				await ensureSynced(adapter);
+				return getAllContentTypes(adapter);
+			},
+			getAllContentItems: async (
+				contentTypeSlug: string,
+				params?: Parameters<typeof getAllContentItems>[2],
+			) => {
+				await ensureSynced(adapter);
+				return getAllContentItems(adapter, contentTypeSlug, params);
+			},
+			getContentItemBySlug: async (contentTypeSlug: string, slug: string) => {
+				await ensureSynced(adapter);
+				return getContentItemBySlug(adapter, contentTypeSlug, slug);
+			},
+		}),
 
+		routes: (adapter: Adapter) => {
 			// Helper to get content type by slug
 			const getContentType = async (
 				slug: string,
 			): Promise<ContentType | null> => {
-				await ensureSynced();
+				await ensureSynced(adapter);
 				return adapter.findOne<ContentType>({
 					model: "contentType",
 					where: [{ field: "slug", value: slug, operator: "eq" as const }],
@@ -560,7 +493,7 @@ export const cmsBackendPlugin = (config: CMSBackendConfig) =>
 				"/content-types",
 				{ method: "GET" },
 				async (ctx) => {
-					await ensureSynced();
+					await ensureSynced(adapter);
 
 					const contentTypes = await adapter.findMany<ContentType>({
 						model: "contentType",
@@ -627,45 +560,7 @@ export const cmsBackendPlugin = (config: CMSBackendConfig) =>
 						throw ctx.error(404, { message: "Content type not found" });
 					}
 
-					const whereConditions = [
-						{
-							field: "contentTypeId",
-							value: contentType.id,
-							operator: "eq" as const,
-						},
-					];
-
-					if (slug) {
-						whereConditions.push({
-							field: "slug",
-							value: slug,
-							operator: "eq" as const,
-						});
-					}
-
-					// Get total count
-					const allItems = await adapter.findMany<ContentItem>({
-						model: "contentItem",
-						where: whereConditions,
-					});
-					const total = allItems.length;
-
-					// Get paginated items
-					const items = await adapter.findMany<ContentItemWithType>({
-						model: "contentItem",
-						where: whereConditions,
-						limit,
-						offset,
-						sortBy: { field: "createdAt", direction: "desc" },
-						join: { contentType: true },
-					});
-
-					return {
-						items: items.map(serializeContentItemWithType),
-						total,
-						limit,
-						offset,
-					};
+					return getAllContentItems(adapter, typeSlug, { slug, limit, offset });
 				},
 			);
 
@@ -1139,7 +1034,7 @@ export const cmsBackendPlugin = (config: CMSBackendConfig) =>
 					const { slug } = ctx.params;
 					const { itemId } = ctx.query;
 
-					await ensureSynced();
+					await ensureSynced(adapter);
 
 					// Get the target content type
 					const targetContentType = await getContentType(slug);
@@ -1239,7 +1134,7 @@ export const cmsBackendPlugin = (config: CMSBackendConfig) =>
 					const { slug, sourceType } = ctx.params;
 					const { itemId, fieldName, limit, offset } = ctx.query;
 
-					await ensureSynced();
+					await ensureSynced(adapter);
 
 					// Verify target content type exists
 					const targetContentType = await getContentType(slug);
@@ -1317,6 +1212,7 @@ export const cmsBackendPlugin = (config: CMSBackendConfig) =>
 			};
 		},
 	});
+};
 
 export type CMSApiRouter = ReturnType<
 	ReturnType<typeof cmsBackendPlugin>["routes"]

package/src/plugins/cms/client/components/pages/content-editor-page.internal.tsx

@@ -241,7 +241,7 @@ export function ContentEditorPage({ typeSlug, id }: ContentEditorPageProps) {
 					contentType={contentType}
 					initialData={
 						isEditing
-							? item?.parsedData
+							? (item?.parsedData ?? undefined)
 							: Object.keys(prefillParams).length > 0
 								? convertPrefillToFormData(
 										prefillParams,

package/src/plugins/cms/client/hooks/cms-hooks.tsx

@@ -608,9 +608,11 @@ export function useCreateContent<TData = Record<string, unknown>>(
 		onSuccess: async () => {
 			await queryClient.invalidateQueries({
 				queryKey: queries.cmsContent.list._def,
+				refetchType: "all",
 			});
 			await queryClient.invalidateQueries({
 				queryKey: queries.cmsTypes.list._def,
+				refetchType: "all",
 			});
 			if (refresh) {
 				await refresh();
@@ -675,6 +677,7 @@ export function useUpdateContent<TData = Record<string, unknown>>(
 			}
 			await queryClient.invalidateQueries({
 				queryKey: queries.cmsContent.list._def,
+				refetchType: "all",
 			});
 			if (refresh) {
 				await refresh();

package/src/plugins/cms/types.ts

@@ -178,7 +178,7 @@ export interface SerializedContentItem
  */
 export interface SerializedContentItemWithType<TData = Record<string, unknown>>
 	extends SerializedContentItem {
-	/** Parsed data object (JSON.parse of data field) */
+	/** Parsed data object (JSON.parse of data field). */
 	parsedData: TData;
 	/** Joined content type */
 	contentType?: SerializedContentType;

package/src/plugins/form-builder/__tests__/getters.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { defineDb } from "@btst/db";
+import type { Adapter } from "@btst/db";
+import { formBuilderSchema } from "../db";
+import { getAllForms, getFormBySlug, getFormSubmissions } from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(formBuilderSchema);
+	return createMemoryAdapter(db)({});
+};
+
+const SIMPLE_SCHEMA = JSON.stringify({
+	type: "object",
+	properties: { name: { type: "string" } },
+});
+
+async function createForm(
+	adapter: Adapter,
+	slug: string,
+	status = "active",
+): Promise<any> {
+	return adapter.create({
+		model: "form",
+		data: {
+			name: `Form ${slug}`,
+			slug,
+			schema: SIMPLE_SCHEMA,
+			status,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		},
+	});
+}
+
+describe("form-builder getters", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	describe("getAllForms", () => {
+		it("returns empty result when no forms exist", async () => {
+			const result = await getAllForms(adapter);
+			expect(result.items).toEqual([]);
+			expect(result.total).toBe(0);
+		});
+
+		it("returns all forms serialized", async () => {
+			await createForm(adapter, "contact");
+			await createForm(adapter, "feedback");
+
+			const result = await getAllForms(adapter);
+			expect(result.items).toHaveLength(2);
+			expect(result.total).toBe(2);
+			expect(typeof result.items[0]!.createdAt).toBe("string");
+		});
+
+		it("filters forms by status", async () => {
+			await createForm(adapter, "active-form", "active");
+			await createForm(adapter, "inactive-form", "inactive");
+
+			const active = await getAllForms(adapter, { status: "active" });
+			expect(active.items).toHaveLength(1);
+			expect(active.items[0]!.slug).toBe("active-form");
+
+			const inactive = await getAllForms(adapter, { status: "inactive" });
+			expect(inactive.items).toHaveLength(1);
+			expect(inactive.items[0]!.slug).toBe("inactive-form");
+		});
+
+		it("respects limit and offset", async () => {
+			for (let i = 1; i <= 4; i++) {
+				await createForm(adapter, `form-${i}`);
+			}
+
+			const page1 = await getAllForms(adapter, { limit: 2, offset: 0 });
+			expect(page1.items).toHaveLength(2);
+			expect(page1.total).toBe(4);
+
+			const page2 = await getAllForms(adapter, { limit: 2, offset: 2 });
+			expect(page2.items).toHaveLength(2);
+		});
+	});
+
+	describe("getFormBySlug", () => {
+		it("returns null when form does not exist", async () => {
+			const form = await getFormBySlug(adapter, "nonexistent");
+			expect(form).toBeNull();
+		});
+
+		it("returns the form when it exists", async () => {
+			await createForm(adapter, "contact");
+
+			const form = await getFormBySlug(adapter, "contact");
+			expect(form).not.toBeNull();
+			expect(form!.slug).toBe("contact");
+			expect(typeof form!.createdAt).toBe("string");
+		});
+	});
+
+	describe("getFormSubmissions", () => {
+		it("returns empty result when form does not exist", async () => {
+			const result = await getFormSubmissions(adapter, "nonexistent-id");
+			expect(result.items).toEqual([]);
+			expect(result.total).toBe(0);
+		});
+
+		it("returns submissions for a form", async () => {
+			const form = (await createForm(adapter, "contact")) as any;
+
+			await adapter.create({
+				model: "formSubmission",
+				data: {
+					formId: form.id,
+					data: JSON.stringify({ name: "Alice" }),
+					submittedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "formSubmission",
+				data: {
+					formId: form.id,
+					data: JSON.stringify({ name: "Bob" }),
+					submittedAt: new Date(),
+				},
+			});
+
+			const result = await getFormSubmissions(adapter, form.id);
+			expect(result.items).toHaveLength(2);
+			expect(result.total).toBe(2);
+			expect(typeof result.items[0]!.submittedAt).toBe("string");
+			expect(result.items[0]!.parsedData).toBeDefined();
+		});
+
+		it("respects pagination", async () => {
+			const form = (await createForm(adapter, "survey")) as any;
+
+			for (let i = 1; i <= 5; i++) {
+				await adapter.create({
+					model: "formSubmission",
+					data: {
+						formId: form.id,
+						data: JSON.stringify({ name: `User ${i}` }),
+						submittedAt: new Date(Date.now() + i * 1000),
+					},
+				});
+			}
+
+			const page1 = await getFormSubmissions(adapter, form.id, {
+				limit: 2,
+				offset: 0,
+			});
+			expect(page1.items).toHaveLength(2);
+			expect(page1.total).toBe(5);
+		});
+	});
+});

package/src/plugins/form-builder/api/getters.ts

@@ -0,0 +1,203 @@
+import type { Adapter } from "@btst/db";
+import type {
+	Form,
+	FormSubmission,
+	FormSubmissionWithForm,
+	SerializedForm,
+	SerializedFormSubmission,
+	SerializedFormSubmissionWithData,
+} from "../types";
+
+/**
+ * Serialize a Form for SSR/SSG use (convert dates to strings).
+ */
+export function serializeForm(form: Form): SerializedForm {
+	return {
+		id: form.id,
+		name: form.name,
+		slug: form.slug,
+		description: form.description,
+		schema: form.schema,
+		successMessage: form.successMessage,
+		redirectUrl: form.redirectUrl,
+		status: form.status,
+		createdBy: form.createdBy,
+		createdAt: form.createdAt.toISOString(),
+		updatedAt: form.updatedAt.toISOString(),
+	};
+}
+
+/**
+ * Serialize a FormSubmission for SSR/SSG use (convert dates to strings).
+ */
+export function serializeFormSubmission(
+	submission: FormSubmission,
+): SerializedFormSubmission {
+	return {
+		...submission,
+		submittedAt: submission.submittedAt.toISOString(),
+	};
+}
+
+/**
+ * Serialize a FormSubmission with parsed data and joined Form.
+ * If `submission.data` is corrupted JSON, `parsedData` is set to `null` rather
+ * than throwing, so one bad row cannot crash the entire list or SSG build.
+ */
+export function serializeFormSubmissionWithData(
+	submission: FormSubmissionWithForm,
+): SerializedFormSubmissionWithData {
+	let parsedData: Record<string, unknown> | null = null;
+	try {
+		parsedData = JSON.parse(submission.data);
+	} catch {
+		// Corrupted JSON — leave parsedData as null so callers can handle it
+	}
+	return {
+		...serializeFormSubmission(submission),
+		parsedData,
+		form: submission.form ? serializeForm(submission.form) : undefined,
+	};
+}
+
+/**
+ * Retrieve all forms with optional status filter and pagination.
+ * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @remarks **Security:** Authorization hooks (e.g. `onBeforeListForms`) are NOT
+ * called. The caller is responsible for any access-control checks before
+ * invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param params - Optional filter/pagination parameters
+ */
+export async function getAllForms(
+	adapter: Adapter,
+	params?: { status?: string; limit?: number; offset?: number },
+): Promise<{
+	items: SerializedForm[];
+	total: number;
+	limit?: number;
+	offset?: number;
+}> {
+	const whereConditions: Array<{
+		field: string;
+		value: string;
+		operator: "eq";
+	}> = [];
+
+	if (params?.status) {
+		whereConditions.push({
+			field: "status",
+			value: params.status,
+			operator: "eq" as const,
+		});
+	}
+
+	// TODO: remove cast once @btst/db types expose adapter.count()
+	const total: number = await adapter.count({
+		model: "form",
+		where: whereConditions.length > 0 ? whereConditions : undefined,
+	});
+
+	const forms = await adapter.findMany<Form>({
+		model: "form",
+		where: whereConditions.length > 0 ? whereConditions : undefined,
+		limit: params?.limit,
+		offset: params?.offset,
+		sortBy: { field: "createdAt", direction: "desc" },
+	});
+
+	return {
+		items: forms.map(serializeForm),
+		total,
+		limit: params?.limit,
+		offset: params?.offset,
+	};
+}
+
+/**
+ * Retrieve a single form by its slug.
+ * Returns null if the form is not found.
+ * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @remarks **Security:** Authorization hooks are NOT called. The caller is
+ * responsible for any access-control checks before invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param slug - The form slug
+ */
+export async function getFormBySlug(
+	adapter: Adapter,
+	slug: string,
+): Promise<SerializedForm | null> {
+	const form = await adapter.findOne<Form>({
+		model: "form",
+		where: [{ field: "slug", value: slug, operator: "eq" as const }],
+	});
+
+	if (!form) {
+		return null;
+	}
+
+	return serializeForm(form);
+}
+
+/**
+ * Retrieve submissions for a form by form ID, with optional pagination.
+ * Returns an empty result if the form does not exist.
+ * Pure DB function — no hooks, no HTTP context. Safe for server-side use.
+ *
+ * @remarks **Security:** Authorization hooks are NOT called. The caller is
+ * responsible for any access-control checks before invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param formId - The form ID
+ * @param params - Optional pagination parameters
+ */
+export async function getFormSubmissions(
+	adapter: Adapter,
+	formId: string,
+	params?: { limit?: number; offset?: number },
+): Promise<{
+	items: SerializedFormSubmissionWithData[];
+	total: number;
+	limit?: number;
+	offset?: number;
+}> {
+	const form = await adapter.findOne<Form>({
+		model: "form",
+		where: [{ field: "id", value: formId, operator: "eq" as const }],
+	});
+
+	if (!form) {
+		return {
+			items: [],
+			total: 0,
+			limit: params?.limit,
+			offset: params?.offset,
+		};
+	}
+
+	// TODO: remove cast once @btst/db types expose adapter.count()
+	const total: number = await adapter.count({
+		model: "formSubmission",
+		where: [{ field: "formId", value: formId, operator: "eq" as const }],
+	});
+
+	const submissions = await adapter.findMany<FormSubmissionWithForm>({
+		model: "formSubmission",
+		where: [{ field: "formId", value: formId, operator: "eq" as const }],
+		limit: params?.limit,
+		offset: params?.offset,
+		sortBy: { field: "submittedAt", direction: "desc" },
+		join: { form: true },
+	});
+
+	return {
+		items: submissions.map(serializeFormSubmissionWithData),
+		total,
+		limit: params?.limit,
+		offset: params?.offset,
+	};
+}

package/src/plugins/form-builder/api/index.ts

@@ -1 +1,2 @@
 export { formBuilderBackendPlugin, type FormBuilderApiRouter } from "./plugin";
+export { getAllForms, getFormBySlug, getFormSubmissions } from "./getters";