@btst/stack 2.0.1 → 2.2.0

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

@@ -0,0 +1,206 @@
+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 { cmsSchema } from "../db";
+import {
+	getAllContentTypes,
+	getAllContentItems,
+	getContentItemBySlug,
+} from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(cmsSchema);
+	return createMemoryAdapter(db)({});
+};
+
+const SIMPLE_SCHEMA = JSON.stringify({
+	type: "object",
+	properties: {
+		title: { type: "string" },
+	},
+	autoFormVersion: 2,
+});
+
+describe("cms getters", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	describe("getAllContentTypes", () => {
+		it("returns empty array when no content types exist", async () => {
+			const types = await getAllContentTypes(adapter);
+			expect(types).toEqual([]);
+		});
+
+		it("returns serialized content types sorted by name", async () => {
+			await adapter.create({
+				model: "contentType",
+				data: {
+					name: "Post",
+					slug: "post",
+					jsonSchema: SIMPLE_SCHEMA,
+					autoFormVersion: 2,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "contentType",
+				data: {
+					name: "Article",
+					slug: "article",
+					jsonSchema: SIMPLE_SCHEMA,
+					autoFormVersion: 2,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const types = await getAllContentTypes(adapter);
+			expect(types).toHaveLength(2);
+			// Sorted by name
+			expect(types[0]!.slug).toBe("article");
+			expect(types[1]!.slug).toBe("post");
+			// Dates are serialized as strings
+			expect(typeof types[0]!.createdAt).toBe("string");
+		});
+	});
+
+	describe("getAllContentItems", () => {
+		it("returns empty result when content type does not exist", async () => {
+			const result = await getAllContentItems(adapter, "nonexistent");
+			expect(result.items).toEqual([]);
+			expect(result.total).toBe(0);
+		});
+
+		it("returns items for a content type", async () => {
+			const ct = (await adapter.create({
+				model: "contentType",
+				data: {
+					name: "Post",
+					slug: "post",
+					jsonSchema: SIMPLE_SCHEMA,
+					autoFormVersion: 2,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			})) as any;
+
+			await adapter.create({
+				model: "contentItem",
+				data: {
+					contentTypeId: ct.id,
+					slug: "my-post",
+					data: JSON.stringify({ title: "My Post" }),
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const result = await getAllContentItems(adapter, "post");
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.slug).toBe("my-post");
+			expect(result.items[0]!.parsedData).toEqual({ title: "My Post" });
+		});
+
+		it("filters items by slug", async () => {
+			const ct = (await adapter.create({
+				model: "contentType",
+				data: {
+					name: "Post",
+					slug: "post",
+					jsonSchema: SIMPLE_SCHEMA,
+					autoFormVersion: 2,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			})) as any;
+
+			await adapter.create({
+				model: "contentItem",
+				data: {
+					contentTypeId: ct.id,
+					slug: "first",
+					data: JSON.stringify({ title: "First" }),
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "contentItem",
+				data: {
+					contentTypeId: ct.id,
+					slug: "second",
+					data: JSON.stringify({ title: "Second" }),
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const result = await getAllContentItems(adapter, "post", {
+				slug: "first",
+			});
+			expect(result.items).toHaveLength(1);
+			expect(result.items[0]!.slug).toBe("first");
+		});
+	});
+
+	describe("getContentItemBySlug", () => {
+		it("returns null when content type does not exist", async () => {
+			const item = await getContentItemBySlug(adapter, "nonexistent", "item");
+			expect(item).toBeNull();
+		});
+
+		it("returns null when item does not exist", async () => {
+			await adapter.create({
+				model: "contentType",
+				data: {
+					name: "Post",
+					slug: "post",
+					jsonSchema: SIMPLE_SCHEMA,
+					autoFormVersion: 2,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const item = await getContentItemBySlug(adapter, "post", "nonexistent");
+			expect(item).toBeNull();
+		});
+
+		it("returns the serialized item when it exists", async () => {
+			const ct = (await adapter.create({
+				model: "contentType",
+				data: {
+					name: "Post",
+					slug: "post",
+					jsonSchema: SIMPLE_SCHEMA,
+					autoFormVersion: 2,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			})) as any;
+
+			await adapter.create({
+				model: "contentItem",
+				data: {
+					contentTypeId: ct.id,
+					slug: "hello",
+					data: JSON.stringify({ title: "Hello" }),
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const item = await getContentItemBySlug(adapter, "post", "hello");
+			expect(item).not.toBeNull();
+			expect(item!.slug).toBe("hello");
+			expect(item!.parsedData).toEqual({ title: "Hello" });
+			expect(typeof item!.createdAt).toBe("string");
+		});
+	});
+});

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

@@ -0,0 +1,244 @@
+import type { Adapter } from "@btst/db";
+import type {
+	ContentType,
+	ContentItem,
+	ContentItemWithType,
+	SerializedContentType,
+	SerializedContentItem,
+	SerializedContentItemWithType,
+} from "../types";
+
+/**
+ * Serialize a ContentType for SSR/SSG use (convert dates to strings).
+ * Applies lazy migration for legacy schemas (version 1 → 2).
+ */
+export function serializeContentType(ct: ContentType): SerializedContentType {
+	const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
+	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(),
+	};
+}
+
+export 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;
+		}
+		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 {
+		return jsonSchemaStr;
+	}
+}
+
+/**
+ * Serialize a ContentItem for SSR/SSG use (convert dates to strings).
+ */
+export function serializeContentItem(item: ContentItem): SerializedContentItem {
+	return {
+		...item,
+		createdAt: item.createdAt.toISOString(),
+		updatedAt: item.updatedAt.toISOString(),
+	};
+}
+
+/**
+ * Serialize a ContentItem with parsed data and joined ContentType.
+ * Throws a SyntaxError if `item.data` is not valid JSON, so corrupted rows
+ * produce a visible, debuggable error rather than silently returning null.
+ */
+export function serializeContentItemWithType(
+	item: ContentItemWithType,
+): SerializedContentItemWithType {
+	const parsedData = JSON.parse(item.data) as Record<string, unknown>;
+	return {
+		...serializeContentItem(item),
+		parsedData,
+		contentType: item.contentType
+			? serializeContentType(item.contentType)
+			: undefined,
+	};
+}
+
+/**
+ * Retrieve all content types.
+ * 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
+ */
+export async function getAllContentTypes(
+	adapter: Adapter,
+): Promise<SerializedContentType[]> {
+	const contentTypes = await adapter.findMany<ContentType>({
+		model: "contentType",
+		sortBy: { field: "name", direction: "asc" },
+	});
+	return contentTypes.map(serializeContentType);
+}
+
+/**
+ * Retrieve all content items for a given content type, with optional pagination.
+ * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @remarks **Security:** Authorization hooks (e.g. `onBeforeListItems`) are NOT
+ * called. The caller is responsible for any access-control checks before
+ * invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param contentTypeSlug - The slug of the content type to query
+ * @param params - Optional filter/pagination parameters
+ */
+export async function getAllContentItems(
+	adapter: Adapter,
+	contentTypeSlug: string,
+	params?: { slug?: string; limit?: number; offset?: number },
+): Promise<{
+	items: SerializedContentItemWithType[];
+	total: number;
+	limit?: number;
+	offset?: number;
+}> {
+	const contentType = await adapter.findOne<ContentType>({
+		model: "contentType",
+		where: [
+			{
+				field: "slug",
+				value: contentTypeSlug,
+				operator: "eq" as const,
+			},
+		],
+	});
+
+	if (!contentType) {
+		return {
+			items: [],
+			total: 0,
+			limit: params?.limit,
+			offset: params?.offset,
+		};
+	}
+
+	const whereConditions: Array<{
+		field: string;
+		value: string;
+		operator: "eq";
+	}> = [
+		{
+			field: "contentTypeId",
+			value: contentType.id,
+			operator: "eq" as const,
+		},
+	];
+
+	if (params?.slug) {
+		whereConditions.push({
+			field: "slug",
+			value: params.slug,
+			operator: "eq" as const,
+		});
+	}
+
+	// TODO: remove cast once @btst/db types expose adapter.count()
+	const total: number = await adapter.count({
+		model: "contentItem",
+		where: whereConditions,
+	});
+
+	const items = await adapter.findMany<ContentItemWithType>({
+		model: "contentItem",
+		where: whereConditions,
+		limit: params?.limit,
+		offset: params?.offset,
+		sortBy: { field: "createdAt", direction: "desc" },
+		join: { contentType: true },
+	});
+
+	return {
+		items: items.map(serializeContentItemWithType),
+		total,
+		limit: params?.limit,
+		offset: params?.offset,
+	};
+}
+
+/**
+ * Retrieve a single content item by its slug within a content type.
+ * Returns null if the content type or item 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 contentTypeSlug - The slug of the content type
+ * @param slug - The slug of the content item
+ */
+export async function getContentItemBySlug(
+	adapter: Adapter,
+	contentTypeSlug: string,
+	slug: string,
+): Promise<SerializedContentItemWithType | null> {
+	const contentType = await adapter.findOne<ContentType>({
+		model: "contentType",
+		where: [
+			{
+				field: "slug",
+				value: contentTypeSlug,
+				operator: "eq" as const,
+			},
+		],
+	});
+
+	if (!contentType) {
+		return null;
+	}
+
+	const item = await adapter.findOne<ContentItemWithType>({
+		model: "contentItem",
+		where: [
+			{
+				field: "contentTypeId",
+				value: contentType.id,
+				operator: "eq" as const,
+			},
+			{ field: "slug", value: slug, operator: "eq" as const },
+		],
+		join: { contentType: true },
+	});
+
+	if (!item) {
+		return null;
+	}
+
+	return serializeContentItemWithType(item);
+}

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

@@ -1 +1,6 @@
 export { cmsBackendPlugin, type CMSApiRouter } from "./plugin";
+export {
+	getAllContentTypes,
+	getAllContentItems,
+	getContentItemBySlug,
+} from "./getters";