@btst/stack 5.0.0 → 5.1.0

package/src/plugins/cms/__tests__/content-read.typecheck.ts

@@ -0,0 +1,351 @@
+import type { DBAdapter } from "@btst/db";
+import { createBackendStack } from "../../../api";
+import {
+	cmsBackendPlugin,
+	getContentItemById,
+	getContentItemBySlug,
+	getAllContentItems,
+	getContentItemsByRelation,
+	type CMSReadOptions,
+} from "../api";
+import {
+	useContent,
+	useContentOptions,
+	useContentItem,
+	useContentItemBySlug,
+	useSuspenseContent,
+	useSuspenseContentItem,
+	useContentByRelation,
+	useSuspenseContentByRelation,
+	useInverseRelationItems,
+} from "../client/hooks";
+import { createCMSQueryKeys } from "../query-keys";
+import { createApiClient } from "../../client";
+import type { CMSApiRouter } from "../api";
+
+async function cmsContentReadTypes(
+	adapter: DBAdapter,
+	request: Request,
+	options: CMSReadOptions,
+) {
+	const backend = createBackendStack({
+		basePath: "/api",
+		adapter: () => adapter,
+		plugins: { cms: cmsBackendPlugin({ contentTypes: [] }) },
+	});
+	const selected = await backend.trusted.cms.getContentItem({
+		typeSlug: "article",
+		id: "id",
+		view: "content",
+		fields: ["title"] as const,
+	});
+	selected.parsedData.title satisfies unknown;
+	// @ts-expect-error A literal selection excludes other content properties.
+	selected.parsedData.body;
+	const selectedList = await backend.trusted.cms.listContentItems({
+		typeSlug: "article",
+		query: { view: "content", fields: ["title"] as const },
+	});
+	// @ts-expect-error Projected list operations exclude unselected properties.
+	selectedList.items[0]?.parsedData.body;
+	const selectedGetter = await getContentItemById(adapter, "id", {
+		view: "content",
+		fields: ["title"],
+	});
+	// @ts-expect-error Getters preserve the selected property set.
+	selectedGetter?.parsedData.body;
+	const selectedSlug = await getContentItemBySlug(adapter, "article", "slug", {
+		view: "content",
+		fields: ["title"],
+	});
+	// @ts-expect-error Slug getter selections stay literal.
+	selectedSlug?.parsedData.body;
+	const selectedRelated = await getContentItemsByRelation(adapter, "article", {
+		field: "authorId",
+		targetId: "author-1",
+		view: "content",
+		fields: ["title"],
+	});
+	// @ts-expect-error Related getters exclude unselected properties.
+	selectedRelated.items[0]?.parsedData.body;
+	const full = await backend.trusted.cms.listContentItems({
+		typeSlug: "article",
+		query: {},
+	});
+	full.items[0]!.data satisfies string;
+	const content = await backend.trusted.cms.listContentItems({
+		typeSlug: "article",
+		query: { view: "content" },
+	});
+	content.items[0]!.slug satisfies string;
+	// @ts-expect-error Content view omits duplicated raw JSON.
+	content.items[0]!.data;
+	const item = await backend.forRequest(request).operations.cms.getContentItem({
+		typeSlug: "article",
+		id: "id",
+		view: "content",
+	});
+	// @ts-expect-error Content view omits schema and editor metadata.
+	item.contentType;
+	const defaultItem = await backend.trusted.cms.getContentItem({
+		typeSlug: "article",
+		id: "id",
+	});
+	defaultItem.data satisfies string;
+	const dynamic = await backend.trusted.cms.getContentItem({
+		typeSlug: "article",
+		id: "id",
+		...options,
+	});
+	// @ts-expect-error A dynamic output view cannot promise raw JSON.
+	dynamic.data;
+	const getterItem = await getContentItemById(adapter, "id", {
+		view: "content",
+	});
+	// @ts-expect-error Adapter getters have the same reduced envelope.
+	getterItem?.authorId;
+	(await getContentItemBySlug(adapter, "article", "slug"))?.data satisfies
+		| string
+		| undefined;
+	const getterList = await getAllContentItems(adapter, "article", {
+		view: "content",
+	});
+	// @ts-expect-error Content list getters omit duplicated raw JSON.
+	getterList.items[0]?.data;
+	const queries = createCMSQueryKeys(
+		createApiClient<CMSApiRouter>({
+			baseURL: "https://example.com",
+			basePath: "/api",
+		}),
+	);
+	const selectedQuery = await queries.cmsContent
+		.detail("article", "id", { view: "content", fields: ["title"] })
+		.queryFn();
+	// @ts-expect-error Query factories expose selected content only.
+	selectedQuery?.parsedData.body;
+	const selectedRelationQuery = await queries.cmsContent
+		.byRelation({
+			typeSlug: "article",
+			field: "authorId",
+			targetId: "author-1",
+			view: "content",
+			fields: ["title"],
+		})
+		.queryFn();
+	// @ts-expect-error Relation query factories keep selected content types.
+	selectedRelationQuery.items[0]?.parsedData.body;
+	const selectedOptions = await queries.cmsContent
+		.options({ typeSlug: "article", view: "content", fields: ["title"] })
+		.queryFn();
+	// @ts-expect-error Picker query factories omit unselected properties.
+	selectedOptions[0]?.parsedData.body;
+	(await queries.cmsContent.list({ typeSlug: "article" }).queryFn()).items[0]!
+		.data satisfies string;
+	const contentPage = await queries.cmsContent
+		.list({ typeSlug: "article", view: "content" })
+		.queryFn();
+	// @ts-expect-error Content query factories omit the editor envelope too.
+	contentPage.items[0]?.contentType;
+	const queryItem = await queries.cmsContent
+		.detail("article", "id", { view: "content" })
+		.queryFn();
+	// @ts-expect-error Content detail query factories omit duplicated raw JSON.
+	queryItem?.data;
+	const querySlug = await queries.cmsContent
+		.bySlug("article", "slug", { view: "content" })
+		.queryFn();
+	// @ts-expect-error Content slug query factories omit duplicated raw JSON.
+	querySlug?.data;
+	const relationParams = { field: "authorId", targetId: "author-1" };
+	(
+		await backend.trusted.cms.listContentByRelation({
+			typeSlug: "article",
+			query: relationParams,
+		})
+	).items[0]!.data satisfies string;
+	const related = await backend
+		.forRequest(request)
+		.operations.cms.listContentByRelation({
+			typeSlug: "article",
+			query: { ...relationParams, view: "content" },
+		});
+	// @ts-expect-error Content relation operations omit editor metadata.
+	related.items[0]?.contentType;
+	const inverseParams = { itemId: "author-1", fieldName: "authorId" };
+	(
+		await backend.trusted.cms.listInverseRelationItems({
+			slug: "author",
+			sourceType: "article",
+			query: inverseParams,
+		})
+	).items[0]!.data satisfies string;
+	const inverse = await backend.trusted.cms.listInverseRelationItems({
+		slug: "author",
+		sourceType: "article",
+		query: { ...inverseParams, view: "content" },
+	});
+	// @ts-expect-error Content inverse operations omit raw JSON.
+	inverse.items[0]?.data;
+	const getterRelated = await getContentItemsByRelation(adapter, "article", {
+		...relationParams,
+		view: "content",
+	});
+	// @ts-expect-error Content relation getters omit raw JSON.
+	getterRelated.items[0]?.data;
+	(await getContentItemsByRelation(adapter, "article", relationParams))
+		.items[0]!.data satisfies string;
+	const relatedQuery = await queries.cmsContent
+		.byRelation({ typeSlug: "article", ...relationParams, view: "content" })
+		.queryFn();
+	// @ts-expect-error Content relation query factories omit raw JSON.
+	relatedQuery.items[0]?.data;
+	(
+		await queries.cmsContent
+			.byRelation({ typeSlug: "article", ...relationParams })
+			.queryFn()
+	).items[0]!.data satisfies string;
+	const inverseQuery = await queries.cmsTypes
+		.inverseRelationItems({
+			slug: "author",
+			sourceType: "article",
+			...inverseParams,
+			view: "content",
+		})
+		.queryFn();
+	// @ts-expect-error Content inverse query factories omit raw JSON.
+	inverseQuery.items[0]?.data;
+	(
+		await queries.cmsTypes
+			.inverseRelationItems({
+				slug: "author",
+				sourceType: "article",
+				...inverseParams,
+			})
+			.queryFn()
+	).items[0]!.data satisfies string;
+}
+void cmsContentReadTypes;
+
+function useCMSContentReadTypes() {
+	type Types = { article: { title: string; author: string } };
+	useContent<Types, "article">("article").items[0]!.data satisfies string;
+	const list = useContent<Types, "article">("article", { view: "content" });
+	list.items[0]!.parsedData.author satisfies string;
+	// @ts-expect-error Content hooks omit editor metadata with an explicit data map too.
+	list.items[0]!.contentTypeId;
+	const item = useContentItem<Types, "article">("article", "id", {
+		view: "content",
+	});
+	item.item?.parsedData.title satisfies string | undefined;
+	// @ts-expect-error Content detail hooks omit raw JSON.
+	item.item?.data;
+	// @ts-expect-error Content slug hooks omit raw JSON.
+	useContentItemBySlug("article", "slug", { view: "content" }).item?.data;
+	// @ts-expect-error Suspense content list hooks omit raw JSON.
+	useSuspenseContent("article", { view: "content" }).items[0]?.data;
+	// @ts-expect-error Suspense content detail hooks omit raw JSON.
+	useSuspenseContentItem("article", "id", { view: "content" }).item?.data;
+	useContentByRelation<Types, "article">("article", "authorId", "author-1")
+		.items[0]!.data satisfies string;
+	const related = useContentByRelation<Types, "article">(
+		"article",
+		"authorId",
+		"author-1",
+		{ view: "content" },
+	);
+	related.items[0]!.parsedData.author satisfies string;
+	// @ts-expect-error Content relation hooks omit editor metadata with a data map.
+	related.items[0]?.contentTypeId;
+	const suspenseRelated = useSuspenseContentByRelation(
+		"article",
+		"authorId",
+		"author-1",
+		{
+			view: "content",
+		},
+	);
+	// @ts-expect-error Suspense relation hooks omit raw JSON.
+	suspenseRelated.items[0]?.data;
+	const inverse = useInverseRelationItems(
+		{
+			contentTypeSlug: "author",
+			sourceType: "article",
+			itemId: "author-1",
+			fieldName: "authorId",
+		},
+		{ view: "content" },
+	);
+	// @ts-expect-error Content inverse hooks omit raw JSON.
+	inverse.items[0]?.data;
+}
+function useCMSSelectedContentTypes() {
+	type Types = { article: { title: string; body: string; optional?: string } };
+	const inferred = useContentItem("article", "id", {
+		view: "content",
+		fields: ["title"],
+	});
+	// @ts-expect-error Literal selections omit unrequested properties without new schema inference.
+	inferred.item?.parsedData.body;
+	const typed = useContent<Types, "article", readonly ["title", "optional"]>(
+		"article",
+		{ view: "content", fields: ["title", "optional"] },
+	);
+	typed.items[0]?.parsedData.title satisfies string | undefined;
+	typed.items[0]?.parsedData.optional satisfies string | undefined;
+	// @ts-expect-error Explicit data-map selection tuples preserve omitted fields.
+	typed.items[0]?.parsedData.body;
+	const dynamicFields: string[] = ["title"];
+	const dynamic = useContent<Types, "article">("article", {
+		view: "content",
+		fields: dynamicFields,
+	});
+	dynamic.items[0]?.parsedData.title satisfies string | undefined;
+	// @ts-expect-error Dynamic arrays cannot promise any field is returned.
+	dynamic.items[0]!.parsedData.title satisfies string;
+	const related = useContentByRelation("article", "authorId", "author-1", {
+		view: "content",
+		fields: ["title"],
+	});
+	// @ts-expect-error Direct relation selections omit unrequested properties.
+	related.items[0]?.parsedData.body;
+	const inverse = useInverseRelationItems(
+		{
+			contentTypeSlug: "author",
+			sourceType: "article",
+			itemId: "author-1",
+			fieldName: "authorId",
+		},
+		{ view: "content", fields: ["title"] },
+	);
+	// @ts-expect-error Inverse relation selections omit unrequested properties.
+	inverse.items[0]?.parsedData.body;
+}
+void useCMSSelectedContentTypes;
+function useCMSPickerTypes() {
+	const full = useContentOptions({
+		targetType: "article",
+		value: [],
+		getOptionLabel: (item) => item.data,
+	});
+	full.options[0]?.item?.data satisfies string | undefined;
+	const selected = useContentOptions({
+		targetType: "article",
+		value: [],
+		view: "content",
+		fields: ["title"],
+		getOptionLabel: (item) => {
+			// @ts-expect-error A projected option label cannot read editor metadata.
+			item.data;
+			// @ts-expect-error A projected option label cannot read unselected content.
+			item.parsedData.body;
+			return String(item.parsedData.title);
+		},
+	});
+	// @ts-expect-error Projected selected option records omit metadata too.
+	selected.selectedOptions[0]?.item?.data;
+	// @ts-expect-error Selected-ID preloads retain the projection's field type.
+	selected.selectedOptions[0]?.item?.parsedData.body;
+}
+void useCMSPickerTypes;
+
+void useCMSContentReadTypes;

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

@@ -7,7 +7,10 @@ import {
 	getAllContentTypes,
 	getAllContentItems,
 	getContentItemBySlug,
+	getContentItemById,
+	getContentItemsByRelation,
 } from "../api/getters";
+import type { ContentItem, ContentType } from "../types";
 
 const createTestAdapter = (): Adapter => {
 	const db = defineDb({}).use(cmsSchema);
@@ -29,6 +32,289 @@ describe("cms getters", () => {
 		adapter = createTestAdapter();
 	});
 
+	it("supports content-only list, ID and slug reads without changing defaults or errors", async () => {
+		const contentType = await adapter.create<{ id: string }>({
+			model: "contentType",
+			data: {
+				name: "Article",
+				slug: "article",
+				jsonSchema: SIMPLE_SCHEMA,
+				autoFormVersion: 2,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		const now = new Date("2026-01-01T00:00:00.000Z");
+		const item = await adapter.create<{ id: string }>({
+			model: "contentItem",
+			data: {
+				contentTypeId: contentType.id,
+				slug: "content-only",
+				data: JSON.stringify({
+					title: "Article",
+					author: "Visible content author",
+					nested: { tags: ["one"] },
+				}),
+				authorId: "private-author",
+				createdAt: now,
+				updatedAt: now,
+			},
+		});
+		const expected = {
+			id: item.id,
+			slug: "content-only",
+			parsedData: {
+				title: "Article",
+				author: "Visible content author",
+				nested: { tags: ["one"] },
+			},
+			createdAt: now.toISOString(),
+			updatedAt: now.toISOString(),
+		};
+		expect(
+			await getContentItemById(adapter, item.id, { view: "content" }),
+		).toEqual(expected);
+		expect(
+			await getContentItemBySlug(adapter, "article", "content-only", {
+				view: "content",
+			}),
+		).toEqual(expected);
+		expect(
+			(
+				await getAllContentItems(adapter, "article", {
+					view: "content",
+					search: "Visible content author",
+				})
+			).items,
+		).toEqual([expected]);
+		const selection = { view: "content", fields: ["title"] } as const;
+		expect(
+			(await getContentItemById(adapter, item.id, selection))?.parsedData,
+		).toEqual({ title: "Article" });
+		expect(
+			(
+				await getContentItemBySlug(
+					adapter,
+					"article",
+					"content-only",
+					selection,
+				)
+			)?.parsedData,
+		).toEqual({ title: "Article" });
+		expect(
+			(
+				await getAllContentItems(adapter, "article", {
+					...selection,
+					search: "Visible content author",
+				})
+			).items[0]?.parsedData,
+		).toEqual({ title: "Article" });
+		await expect(
+			getAllContentItems(adapter, "article", {
+				view: "content",
+				fields: ["unknown"],
+				offset: 100,
+			}),
+		).rejects.toThrow("Unknown top-level");
+		await expect(
+			getContentItemById(adapter, item.id, { fields: ["title"] }),
+		).rejects.toThrow("requires view");
+		await expect(
+			getContentItemBySlug(adapter, "article", "content-only", {
+				view: "content",
+				fields: [],
+			}),
+		).rejects.toThrow();
+		expect(await getContentItemById(adapter, item.id)).toHaveProperty("data");
+		expect(
+			await getContentItemById(adapter, "missing", { view: "content" }),
+		).toBeNull();
+		expect(
+			await getContentItemBySlug(adapter, "missing", "content-only", {
+				view: "content",
+			}),
+		).toBeNull();
+		await adapter.update({
+			model: "contentType",
+			where: [{ field: "id", value: contentType.id }],
+			update: {
+				jsonSchema: JSON.stringify({
+					type: "object",
+					properties: Object.fromEntries([
+						["__proto__", { type: "object" }],
+						["title", { type: "string" }],
+					]),
+				}),
+			},
+		});
+		await adapter.update({
+			model: "contentItem",
+			where: [{ field: "id", value: item.id }],
+			update: {
+				data: JSON.stringify(
+					Object.fromEntries([
+						["__proto__", { safe: true }],
+						["title", "Article"],
+					]),
+				),
+			},
+		});
+		const literalPrototype = await getContentItemById(adapter, item.id, {
+			view: "content",
+			fields: ["__proto__"],
+		});
+		expect(Object.hasOwn(literalPrototype!.parsedData, "__proto__")).toBe(true);
+		expect(Object.getPrototypeOf(literalPrototype!.parsedData)).toBe(
+			Object.prototype,
+		);
+		expect(
+			Object.getOwnPropertyDescriptor(literalPrototype!.parsedData, "__proto__")
+				?.value,
+		).toEqual({ safe: true });
+		await adapter.update({
+			model: "contentItem",
+			where: [{ field: "id", value: item.id, operator: "eq" }],
+			update: { data: "{" },
+		});
+		await expect(
+			getContentItemById(adapter, item.id, { view: "content" }),
+		).rejects.toThrow(SyntaxError);
+	});
+
+	it("reads related pages with default pagination and preserves returned corruption errors", async () => {
+		const params = { field: "categoryId", targetId: "category-1" };
+		expect(await getContentItemsByRelation(adapter, "missing", params)).toEqual(
+			{ items: [], total: 0, limit: 20, offset: 0 },
+		);
+		const type = await adapter.create<ContentType>({
+			model: "contentType",
+			data: {
+				name: "Article",
+				slug: "article",
+				jsonSchema: SIMPLE_SCHEMA,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		expect(await getContentItemsByRelation(adapter, "article", params)).toEqual(
+			{ items: [], total: 0, limit: 20, offset: 0 },
+		);
+		for (const [id, date] of [
+			["older", "2026-01-01"],
+			["newer", "2026-01-02"],
+		] as const) {
+			await adapter.create<ContentItem>({
+				model: "contentItem",
+				forceAllowId: true,
+				data: {
+					id,
+					contentTypeId: type.id,
+					slug: id,
+					data: JSON.stringify({ title: id }),
+					createdAt: new Date(date),
+					updatedAt: new Date(date),
+				} as ContentItem,
+			});
+			await adapter.create({
+				model: "contentRelation",
+				data: {
+					sourceId: id,
+					targetId: params.targetId,
+					fieldName: params.field,
+					createdAt: new Date(),
+				},
+			});
+		}
+		expect(
+			(
+				await getContentItemsByRelation(adapter, "article", {
+					...params,
+					view: "content",
+					fields: ["title"],
+					limit: 1,
+				})
+			).items[0]?.parsedData,
+		).toEqual({ title: "newer" });
+		await expect(
+			getContentItemsByRelation(adapter, "article", {
+				...params,
+				view: "content",
+				fields: ["unknown"],
+				offset: 100,
+			}),
+		).rejects.toThrow("Unknown top-level");
+		const first = await getContentItemsByRelation(adapter, "article", {
+			...params,
+			limit: 1,
+		});
+		expect(first).toMatchObject({
+			items: [
+				{
+					id: "newer",
+					parsedData: { title: "newer" },
+					createdAt: "2026-01-02T00:00:00.000Z",
+				},
+			],
+			total: 2,
+			limit: 1,
+			offset: 0,
+		});
+		expect(
+			await getContentItemsByRelation(adapter, "article", {
+				...params,
+				limit: 1,
+				view: "content",
+			}),
+		).toEqual({
+			items: [
+				{
+					id: "newer",
+					slug: "newer",
+					parsedData: { title: "newer" },
+					createdAt: "2026-01-02T00:00:00.000Z",
+					updatedAt: "2026-01-02T00:00:00.000Z",
+				},
+			],
+			total: 2,
+			limit: 1,
+			offset: 0,
+		});
+		await adapter.update({
+			model: "contentItem",
+			where: [{ field: "id", value: "older" }],
+			update: { data: "invalid json" },
+		});
+		expect(
+			(
+				await getContentItemsByRelation(adapter, "article", {
+					...params,
+					limit: 1,
+				})
+			).items[0]?.id,
+		).toBe("newer");
+		await expect(
+			getContentItemsByRelation(adapter, "article", {
+				...params,
+				limit: 1,
+				offset: 1,
+			}),
+		).rejects.toBeInstanceOf(SyntaxError);
+		await expect(
+			getContentItemsByRelation(adapter, "article", {
+				...params,
+				limit: 1,
+				offset: 1,
+				view: "content",
+			}),
+		).rejects.toBeInstanceOf(SyntaxError);
+		expect(
+			await getContentItemsByRelation(adapter, "article", {
+				...params,
+				offset: 2,
+			}),
+		).toMatchObject({ items: [], total: 2 });
+	});
+
 	describe("getAllContentTypes", () => {
 		it("returns empty array when no content types exist", async () => {
 			const types = await getAllContentTypes(adapter);