@btst/stack 2.1.0 → 2.3.0

package/src/plugins/blog/query-keys.ts

@@ -5,6 +5,7 @@ import {
 import type { BlogApiRouter } from "./api";
 import { createApiClient } from "@btst/stack/plugins/client";
 import type { SerializedPost, SerializedTag } from "./types";
+import { postsListDiscriminator } from "./api/query-key-defs";
 
 interface PostsListParams {
 	query?: string;
@@ -71,15 +72,12 @@ function createPostsQueries(
 	return createQueryKeys("posts", {
 		list: (params?: PostsListParams) => ({
 			queryKey: [
-				{
-					query:
-						params?.query !== undefined && params?.query?.trim() === ""
-							? undefined
-							: params?.query,
-					limit: params?.limit ?? 10,
+				postsListDiscriminator({
 					published: params?.published ?? true,
+					limit: params?.limit ?? 10,
 					tagSlug: params?.tagSlug,
-				},
+					query: params?.query,
+				}),
 			],
 			queryFn: async ({ pageParam }: { pageParam?: number }) => {
 				try {
@@ -99,13 +97,14 @@ function createPostsQueries(
 						},
 						headers,
 					});
-					// Check for errors (better-call returns Error$1<unknown> | Data<Post[]>)
+					// Check for errors (better-call returns Error$1<unknown> | Data<PostListResult>)
 					if (isErrorResponse(response)) {
 						const errorResponse = response as { error: unknown };
 						throw toError(errorResponse.error);
 					}
-					// Type narrowed to Data<Post[]> after error check
-					return ((response as { data?: unknown }).data ??
+					// Extract .items from the paginated response for infinite scroll compatibility
+					const dataResponse = response as { data?: { items?: unknown[] } };
+					return (dataResponse.data?.items ??
 						[]) as unknown as SerializedPost[];
 				} catch (error) {
 					// Re-throw errors so React Query can catch them
@@ -126,14 +125,14 @@ function createPostsQueries(
 						query: { slug, limit: 1 },
 						headers,
 					});
-					// Check for errors (better-call returns Error$1<unknown> | Data<Post[]>)
+					// Check for errors (better-call returns Error$1<unknown> | Data<PostListResult>)
 					if (isErrorResponse(response)) {
 						const errorResponse = response as { error: unknown };
 						throw toError(errorResponse.error);
 					}
-					// Type narrowed to Data<Post[]> after error check
-					const dataResponse = response as { data?: unknown[] };
-					return (dataResponse.data?.[0] ??
+					// Type narrowed to Data<PostListResult> after error check — access .items[0]
+					const dataResponse = response as { data?: { items?: unknown[] } };
+					return (dataResponse.data?.items?.[0] ??
 						null) as unknown as SerializedPost | null;
 				} catch (error) {
 					// Re-throw errors so React Query can catch them
@@ -181,13 +180,14 @@ function createPostsQueries(
 						},
 						headers,
 					});
-					// Check for errors (better-call returns Error$1<unknown> | Data<Post[]>)
+					// Check for errors (better-call returns Error$1<unknown> | Data<PostListResult>)
 					if (isErrorResponse(response)) {
 						const errorResponse = response as { error: unknown };
 						throw toError(errorResponse.error);
 					}
-					// Type narrowed to Data<Post[]> after error check
-					let posts = ((response as { data?: unknown }).data ??
+					// Extract .items from the paginated response
+					const recentResponse = response as { data?: { items?: unknown[] } };
+					let posts = (recentResponse.data?.items ??
 						[]) as unknown as SerializedPost[];
 
 					// Exclude current post if specified
@@ -228,13 +228,14 @@ function createDraftsQueries(
 						},
 						headers,
 					});
-					// Check for errors (better-call returns Error$1<unknown> | Data<Post[]>)
+					// Check for errors (better-call returns Error$1<unknown> | Data<PostListResult>)
 					if (isErrorResponse(response)) {
 						const errorResponse = response as { error: unknown };
 						throw toError(errorResponse.error);
 					}
-					// Type narrowed to Data<Post[]> after error check
-					return ((response as { data?: unknown }).data ??
+					// Extract .items from the paginated response for infinite scroll compatibility
+					const draftsResponse = response as { data?: { items?: unknown[] } };
+					return (draftsResponse.data?.items ??
 						[]) as unknown as SerializedPost[];
 				} catch (error) {
 					// Re-throw errors so React Query can catch them

package/src/plugins/client/index.ts

@@ -18,7 +18,7 @@ export type {
 	PluginOverrides,
 } from "../../types";
 
-export { createApiClient } from "../utils";
+export { createApiClient, isConnectionError } from "../utils";
 
 // Re-export Yar types needed for plugins
 export type { Route } from "@btst/yar";

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,268 @@
+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 ID.
+ * Returns null if the 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 id - The content item ID (UUID)
+ */
+export async function getContentItemById(
+	adapter: Adapter,
+	id: string,
+): Promise<SerializedContentItemWithType | null> {
+	const item = await adapter.findOne<ContentItemWithType>({
+		model: "contentItem",
+		where: [{ field: "id", value: id, operator: "eq" as const }],
+		join: { contentType: true },
+	});
+	if (!item) return null;
+	return serializeContentItemWithType(item);
+}
+
+/**
+ * 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,15 @@
-export { cmsBackendPlugin, type CMSApiRouter } from "./plugin";
+export {
+	cmsBackendPlugin,
+	type CMSApiRouter,
+	type CMSRouteKey,
+} from "./plugin";
+export {
+	getAllContentTypes,
+	getAllContentItems,
+	getContentItemBySlug,
+	getContentItemById,
+	serializeContentType,
+	serializeContentItem,
+	serializeContentItemWithType,
+} from "./getters";
+export { CMS_QUERY_KEYS } from "./query-key-defs";