@btst/stack 2.0.1 → 2.2.0

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

@@ -11,9 +11,6 @@ import type {
 	FormBuilderBackendConfig,
 	FormBuilderHookContext,
 	SubmissionHookContext,
-	SerializedForm,
-	SerializedFormSubmission,
-	SerializedFormSubmissionWithData,
 	FormInput,
 	FormUpdate,
 } from "../types";
@@ -24,50 +21,14 @@ import {
 	listSubmissionsQuerySchema,
 } from "../schemas";
 import { slugify, extractIpAddress, extractUserAgent } from "../utils";
-
-/**
- * Serialize a Form for API response (convert dates to strings)
- */
-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 API response (convert dates to strings)
- */
-function serializeFormSubmission(
-	submission: FormSubmission,
-): SerializedFormSubmission {
-	return {
-		...submission,
-		submittedAt: submission.submittedAt.toISOString(),
-	};
-}
-
-/**
- * Serialize a FormSubmission with parsed data and joined Form
- */
-function serializeFormSubmissionWithData(
-	submission: FormSubmissionWithForm,
-): SerializedFormSubmissionWithData {
-	return {
-		...serializeFormSubmission(submission),
-		parsedData: JSON.parse(submission.data),
-		form: submission.form ? serializeForm(submission.form) : undefined,
-	};
-}
+import {
+	getAllForms,
+	getFormBySlug as getFormBySlugFromDb,
+	getFormSubmissions,
+	serializeForm,
+	serializeFormSubmission,
+	serializeFormSubmissionWithData,
+} from "./getters";
 
 /**
  * Form Builder backend plugin
@@ -83,6 +44,16 @@ export const formBuilderBackendPlugin = (
 
 		dbPlugin: dbSchema,
 
+		api: (adapter) => ({
+			getAllForms: (params?: Parameters<typeof getAllForms>[1]) =>
+				getAllForms(adapter, params),
+			getFormBySlug: (slug: string) => getFormBySlugFromDb(adapter, slug),
+			getFormSubmissions: (
+				formId: string,
+				params?: Parameters<typeof getFormSubmissions>[2],
+			) => getFormSubmissions(adapter, formId, params),
+		}),
+
 		routes: (adapter: Adapter) => {
 			// Helper to create hook context from request
 			const createContext = (headers?: Headers): FormBuilderHookContext => ({
@@ -114,7 +85,6 @@ export const formBuilderBackendPlugin = (
 					const { status, limit, offset } = ctx.query;
 					const context = createContext(ctx.headers);
 
-					// Call before hook for auth check
 					if (config.hooks?.onBeforeListForms) {
 						const canList = await config.hooks.onBeforeListForms(context);
 						if (!canList) {
@@ -122,41 +92,7 @@ export const formBuilderBackendPlugin = (
 						}
 					}
 
-					const whereConditions: Array<{
-						field: string;
-						value: string;
-						operator: "eq";
-					}> = [];
-					if (status) {
-						whereConditions.push({
-							field: "status",
-							value: status,
-							operator: "eq" as const,
-						});
-					}
-
-					// Get total count
-					const allForms = await adapter.findMany<Form>({
-						model: "form",
-						where: whereConditions.length > 0 ? whereConditions : undefined,
-					});
-					const total = allForms.length;
-
-					// Get paginated forms
-					const forms = await adapter.findMany<Form>({
-						model: "form",
-						where: whereConditions.length > 0 ? whereConditions : undefined,
-						limit,
-						offset,
-						sortBy: { field: "createdAt", direction: "desc" },
-					});
-
-					return {
-						items: forms.map(serializeForm),
-						total,
-						limit,
-						offset,
-					};
+					return getAllForms(adapter, { status, limit, offset });
 				},
 			);
 
@@ -178,16 +114,13 @@ export const formBuilderBackendPlugin = (
 						}
 					}
 
-					const form = await adapter.findOne<Form>({
-						model: "form",
-						where: [{ field: "slug", value: slug, operator: "eq" as const }],
-					});
+					const form = await getFormBySlugFromDb(adapter, slug);
 
 					if (!form) {
 						throw ctx.error(404, { message: "Form not found" });
 					}
 
-					return serializeForm(form);
+					return form;
 				},
 			);
 
@@ -647,33 +580,7 @@ export const formBuilderBackendPlugin = (
 						}
 					}
 
-					// Get total count
-					const allSubmissions = await adapter.findMany<FormSubmission>({
-						model: "formSubmission",
-						where: [
-							{ field: "formId", value: formId, operator: "eq" as const },
-						],
-					});
-					const total = allSubmissions.length;
-
-					// Get paginated submissions
-					const submissions = await adapter.findMany<FormSubmissionWithForm>({
-						model: "formSubmission",
-						where: [
-							{ field: "formId", value: formId, operator: "eq" as const },
-						],
-						limit,
-						offset,
-						sortBy: { field: "submittedAt", direction: "desc" },
-						join: { form: true },
-					});
-
-					return {
-						items: submissions.map(serializeFormSubmissionWithData),
-						total,
-						limit,
-						offset,
-					};
+					return getFormSubmissions(adapter, formId, { limit, offset });
 				},
 			);
 

package/src/plugins/form-builder/client/components/pages/submissions-page.internal.tsx

@@ -147,7 +147,7 @@ export function SubmissionsPage({ formId }: SubmissionsPageProps) {
 												{sub.id.slice(0, 8)}...
 											</TableCell>
 											<TableCell className="max-w-xs truncate text-sm text-muted-foreground">
-												{formatSubmissionData(sub.parsedData)}
+												{formatSubmissionData(sub.parsedData ?? {})}
 											</TableCell>
 											<TableCell className="text-muted-foreground">
 												{new Date(sub.submittedAt).toLocaleString()}

package/src/plugins/form-builder/types.ts

@@ -82,8 +82,8 @@ export interface SerializedFormSubmission
 export interface SerializedFormSubmissionWithData<
 	TData = Record<string, unknown>,
 > extends SerializedFormSubmission {
-	/** Parsed data object (JSON.parse of data field) */
-	parsedData: TData;
+	/** Parsed data object (JSON.parse of data field). Null when the stored JSON is corrupted. */
+	parsedData: TData | null;
 	/** Joined form */
 	form?: SerializedForm;
 }

package/src/plugins/kanban/__tests__/getters.test.ts

@@ -0,0 +1,172 @@
+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 { kanbanSchema } from "../db";
+import { getAllBoards, getBoardById } from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(kanbanSchema);
+	return createMemoryAdapter(db)({});
+};
+
+async function createBoard(
+	adapter: Adapter,
+	name: string,
+	slug: string,
+	ownerId?: string,
+): Promise<any> {
+	return adapter.create({
+		model: "kanbanBoard",
+		data: {
+			name,
+			slug,
+			...(ownerId ? { ownerId } : {}),
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		},
+	});
+}
+
+async function createColumn(
+	adapter: Adapter,
+	boardId: string,
+	title: string,
+	order: number,
+): Promise<any> {
+	return adapter.create({
+		model: "kanbanColumn",
+		data: {
+			boardId,
+			title,
+			order,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		},
+	});
+}
+
+async function createTask(
+	adapter: Adapter,
+	columnId: string,
+	title: string,
+	order: number,
+): Promise<any> {
+	return adapter.create({
+		model: "kanbanTask",
+		data: {
+			columnId,
+			title,
+			priority: "MEDIUM",
+			order,
+			isArchived: false,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		},
+	});
+}
+
+describe("kanban getters", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	describe("getAllBoards", () => {
+		it("returns empty array when no boards exist", async () => {
+			const { items, total } = await getAllBoards(adapter);
+			expect(items).toEqual([]);
+			expect(total).toBe(0);
+		});
+
+		it("returns all boards with columns and tasks", async () => {
+			const board = (await createBoard(adapter, "My Board", "my-board")) as any;
+			const col = (await createColumn(adapter, board.id, "To Do", 0)) as any;
+			await createTask(adapter, col.id, "Task 1", 0);
+
+			const { items: boards, total } = await getAllBoards(adapter);
+			expect(boards).toHaveLength(1);
+			expect(total).toBe(1);
+			expect(boards[0]!.slug).toBe("my-board");
+			expect(boards[0]!.columns).toHaveLength(1);
+			expect(boards[0]!.columns[0]!.title).toBe("To Do");
+			expect(boards[0]!.columns[0]!.tasks).toHaveLength(1);
+			expect(boards[0]!.columns[0]!.tasks[0]!.title).toBe("Task 1");
+		});
+
+		it("returns boards with empty columns array when no columns exist", async () => {
+			await createBoard(adapter, "Empty Board", "empty-board");
+
+			const { items: boards } = await getAllBoards(adapter);
+			expect(boards).toHaveLength(1);
+			expect(boards[0]!.columns).toEqual([]);
+		});
+
+		it("filters boards by slug", async () => {
+			await createBoard(adapter, "Board A", "board-a");
+			await createBoard(adapter, "Board B", "board-b");
+
+			const { items, total } = await getAllBoards(adapter, { slug: "board-a" });
+			expect(items).toHaveLength(1);
+			expect(total).toBe(1);
+			expect(items[0]!.slug).toBe("board-a");
+		});
+
+		it("filters boards by ownerId", async () => {
+			await createBoard(adapter, "Alice Board", "alice-board", "user-alice");
+			await createBoard(adapter, "Bob Board", "bob-board", "user-bob");
+
+			const { items, total } = await getAllBoards(adapter, {
+				ownerId: "user-alice",
+			});
+			expect(items).toHaveLength(1);
+			expect(total).toBe(1);
+			expect(items[0]!.slug).toBe("alice-board");
+		});
+
+		it("sorts columns by order", async () => {
+			const board = (await createBoard(adapter, "Board", "board")) as any;
+			// Create columns out of order
+			await createColumn(adapter, board.id, "Done", 2);
+			await createColumn(adapter, board.id, "To Do", 0);
+			await createColumn(adapter, board.id, "In Progress", 1);
+
+			const { items: boards } = await getAllBoards(adapter);
+			expect(boards[0]!.columns[0]!.title).toBe("To Do");
+			expect(boards[0]!.columns[1]!.title).toBe("In Progress");
+			expect(boards[0]!.columns[2]!.title).toBe("Done");
+		});
+	});
+
+	describe("getBoardById", () => {
+		it("returns null when board does not exist", async () => {
+			const board = await getBoardById(adapter, "nonexistent");
+			expect(board).toBeNull();
+		});
+
+		it("returns the board with columns and tasks", async () => {
+			const board = (await createBoard(adapter, "My Board", "my-board")) as any;
+			const col1 = (await createColumn(adapter, board.id, "To Do", 0)) as any;
+			const col2 = (await createColumn(adapter, board.id, "Done", 1)) as any;
+			await createTask(adapter, col1.id, "Task A", 0);
+			await createTask(adapter, col1.id, "Task B", 1);
+			await createTask(adapter, col2.id, "Task C", 0);
+
+			const result = await getBoardById(adapter, board.id);
+			expect(result).not.toBeNull();
+			expect(result!.id).toBe(board.id);
+			expect(result!.columns).toHaveLength(2);
+			expect(result!.columns[0]!.tasks).toHaveLength(2);
+			expect(result!.columns[1]!.tasks).toHaveLength(1);
+		});
+
+		it("returns board with empty columns when no columns exist", async () => {
+			const board = (await createBoard(adapter, "Empty Board", "empty")) as any;
+
+			const result = await getBoardById(adapter, board.id);
+			expect(result).not.toBeNull();
+			expect(result!.columns).toEqual([]);
+		});
+	});
+});

package/src/plugins/kanban/api/getters.ts

@@ -0,0 +1,149 @@
+import type { Adapter } from "@btst/db";
+import type {
+	BoardWithKanbanColumn,
+	BoardWithColumns,
+	ColumnWithTasks,
+	Task,
+} from "../types";
+import type { z } from "zod";
+import type { BoardListQuerySchema } from "../schemas";
+
+/**
+ * Paginated result returned by {@link getAllBoards}.
+ */
+export interface BoardListResult {
+	items: BoardWithColumns[];
+	total: number;
+	limit?: number;
+	offset?: number;
+}
+
+/**
+ * Given a raw board record (with a `column` join), fetches tasks for every
+ * column in parallel and returns the sorted columns with their tasks attached.
+ * Strips the raw `column` join field from the returned board object.
+ */
+async function hydrateColumnsWithTasks(
+	adapter: Adapter,
+	board: BoardWithKanbanColumn,
+): Promise<BoardWithColumns> {
+	const columnIds = (board.column || []).map((c) => c.id);
+	const tasksByColumn = new Map<string, Task[]>();
+
+	if (columnIds.length > 0) {
+		const taskResults = await Promise.all(
+			columnIds.map((columnId) =>
+				adapter.findMany<Task>({
+					model: "kanbanTask",
+					where: [
+						{ field: "columnId", value: columnId, operator: "eq" as const },
+					],
+					sortBy: { field: "order", direction: "asc" },
+				}),
+			),
+		);
+		for (let i = 0; i < columnIds.length; i++) {
+			const columnId = columnIds[i];
+			const tasks = taskResults[i];
+			if (columnId && tasks) {
+				tasksByColumn.set(columnId, tasks);
+			}
+		}
+	}
+
+	const columns: ColumnWithTasks[] = (board.column || [])
+		.sort((a, b) => a.order - b.order)
+		.map((col) => ({ ...col, tasks: tasksByColumn.get(col.id) || [] }));
+
+	const { column: _, ...boardWithoutJoin } = board;
+	return { ...boardWithoutJoin, columns };
+}
+
+/**
+ * Retrieve all boards matching optional filter criteria, with columns and tasks.
+ * Pure DB function - no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @param adapter - The database adapter
+ * @param params - Optional filter/pagination parameters (same shape as the list API query)
+ */
+export async function getAllBoards(
+	adapter: Adapter,
+	params?: z.infer<typeof BoardListQuerySchema>,
+): Promise<BoardListResult> {
+	const query = params ?? {};
+
+	const whereConditions: Array<{
+		field: string;
+		value: string;
+		operator: "eq";
+	}> = [];
+
+	if (query.slug) {
+		whereConditions.push({
+			field: "slug",
+			value: query.slug,
+			operator: "eq" as const,
+		});
+	}
+
+	if (query.ownerId) {
+		whereConditions.push({
+			field: "ownerId",
+			value: query.ownerId,
+			operator: "eq" as const,
+		});
+	}
+
+	if (query.organizationId) {
+		whereConditions.push({
+			field: "organizationId",
+			value: query.organizationId,
+			operator: "eq" as const,
+		});
+	}
+
+	const where = whereConditions.length > 0 ? whereConditions : undefined;
+
+	const [boards, total] = await Promise.all([
+		adapter.findMany<BoardWithKanbanColumn>({
+			model: "kanbanBoard",
+			limit: query.limit ?? 50,
+			offset: query.offset ?? 0,
+			where,
+			sortBy: { field: "createdAt", direction: "desc" },
+			join: { kanbanColumn: true },
+		}),
+		adapter.count({ model: "kanbanBoard", where }),
+	]);
+
+	const items = await Promise.all(
+		boards.map((board) => hydrateColumnsWithTasks(adapter, board)),
+	);
+
+	return { items, total, limit: query.limit, offset: query.offset };
+}
+
+/**
+ * Retrieve a single board by its ID, with all columns and tasks.
+ * Returns null if the board is not found.
+ * Pure DB function - no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @param adapter - The database adapter
+ * @param id - The board ID
+ */
+export async function getBoardById(
+	adapter: Adapter,
+	id: string,
+): Promise<BoardWithColumns | null> {
+	const board = await adapter.findOne<BoardWithKanbanColumn>({
+		model: "kanbanBoard",
+		where: [{ field: "id", value: id, operator: "eq" as const }],
+		join: { kanbanColumn: true },
+	});
+
+	if (!board) {
+		return null;
+	}
+
+	return hydrateColumnsWithTasks(adapter, board);
+}

package/src/plugins/kanban/api/index.ts

@@ -4,3 +4,4 @@ export {
 	type KanbanApiContext,
 	type KanbanBackendHooks,
 } from "./plugin";
+export { getAllBoards, getBoardById, type BoardListResult } from "./getters";