@btst/stack 1.2.2 → 1.3.1

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

@@ -3,7 +3,7 @@ import { defineBackendPlugin } from "@btst/stack/plugins/api";
 import { createEndpoint } from "@btst/stack/plugins/api";
 import { z } from "zod";
 import { blogSchema as dbSchema } from "../db";
-import type { Post, Tag } from "../types";
+import type { Post, PostWithPostTag, Tag } from "../types";
 import { slugify } from "../utils";
 import { createPostSchema, updatePostSchema } from "../schemas";
 
@@ -169,68 +169,10 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 		dbPlugin: dbSchema,
 
 		routes: (adapter: Adapter) => {
-			const createTagCache = () => {
-				let cache: Tag[] | null = null;
-				return {
-					getAllTags: async (): Promise<Tag[]> => {
-						if (!cache) {
-							cache = await adapter.findMany<Tag>({
-								model: "tag",
-							});
-						}
-						return cache;
-					},
-					invalidate: () => {
-						cache = null;
-					},
-					addTag: (tag: Tag) => {
-						if (cache) {
-							cache.push(tag);
-						}
-					},
-				};
-			};
-
-			const createPostTagCache = () => {
-				let cache: Array<{ postId: string; tagId: string }> | null = null;
-				const getAllPostTags = async (): Promise<
-					Array<{ postId: string; tagId: string }>
-				> => {
-					if (!cache) {
-						cache = await adapter.findMany<{
-							postId: string;
-							tagId: string;
-						}>({
-							model: "postTag",
-						});
-					}
-					return cache;
-				};
-				return {
-					getAllPostTags,
-					invalidate: () => {
-						cache = null;
-					},
-					getByTagId: async (
-						tagId: string,
-					): Promise<Array<{ postId: string; tagId: string }>> => {
-						const allPostTags = await getAllPostTags();
-						return allPostTags.filter((pt) => pt.tagId === tagId);
-					},
-					getByPostId: async (
-						postId: string,
-					): Promise<Array<{ postId: string; tagId: string }>> => {
-						const allPostTags = await getAllPostTags();
-						return allPostTags.filter((pt) => pt.postId === postId);
-					},
-				};
-			};
-
 			const findOrCreateTags = async (
 				tagInputs: Array<
 					{ name: string } | { id: string; name: string; slug: string }
 				>,
-				tagCache: ReturnType<typeof createTagCache>,
 			): Promise<Tag[]> => {
 				if (tagInputs.length === 0) return [];
 
@@ -259,7 +201,9 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 					return tagsWithIds;
 				}
 
-				const allTags = await tagCache.getAllTags();
+				const allTags = await adapter.findMany<Tag>({
+					model: "tag",
+				});
 				const tagMapBySlug = new Map<string, Tag>();
 				for (const tag of allTags) {
 					tagMapBySlug.set(tag.slug, tag);
@@ -296,45 +240,11 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						},
 					});
 					createdTags.push(newTag);
-					tagCache.addTag(newTag);
 				}
 
 				return [...tagsWithIds, ...foundTags, ...createdTags];
 			};
 
-			const loadTagsForPosts = async (
-				postIds: string[],
-				tagCache: ReturnType<typeof createTagCache>,
-				postTagCache: ReturnType<typeof createPostTagCache>,
-			): Promise<Map<string, Tag[]>> => {
-				if (postIds.length === 0) return new Map();
-
-				const allPostTags = await postTagCache.getAllPostTags();
-				const relevantPostTags = allPostTags.filter((pt) =>
-					postIds.includes(pt.postId),
-				);
-
-				const tagIds = [...new Set(relevantPostTags.map((pt) => pt.tagId))];
-				if (tagIds.length === 0) return new Map();
-
-				const allTags = await tagCache.getAllTags();
-				const tagMap = new Map<string, Tag>();
-				for (const tag of allTags) {
-					tagMap.set(tag.id, tag);
-				}
-
-				const postTagsMap = new Map<string, Tag[]>();
-				for (const postTag of relevantPostTags) {
-					const tag = tagMap.get(postTag.tagId);
-					if (tag) {
-						const existing = postTagsMap.get(postTag.postId) || [];
-						postTagsMap.set(postTag.postId, [...existing, { ...tag }]);
-					}
-				}
-
-				return postTagsMap;
-			};
-
 			const listPosts = createEndpoint(
 				"/posts",
 				{
@@ -344,8 +254,6 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 				async (ctx) => {
 					const { query, headers } = ctx;
 					const context: BlogApiContext = { query, headers };
-					const tagCache = createTagCache();
-					const postTagCache = createPostTagCache();
 
 					try {
 						if (hooks?.onBeforeListPosts) {
@@ -360,14 +268,34 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						let tagFilterPostIds: Set<string> | null = null;
 
 						if (query.tagSlug) {
-							const allTags = await tagCache.getAllTags();
-							const tag = allTags.find((t) => t.slug === query.tagSlug);
+							const tag = await adapter.findOne<Tag>({
+								model: "tag",
+								where: [
+									{
+										field: "slug",
+										value: query.tagSlug,
+										operator: "eq" as const,
+									},
+								],
+							});
 
 							if (!tag) {
 								return [];
 							}
 
-							const postTags = await postTagCache.getByTagId(tag.id);
+							const postTags = await adapter.findMany<{
+								postId: string;
+								tagId: string;
+							}>({
+								model: "postTag",
+								where: [
+									{
+										field: "tagId",
+										value: tag.id,
+										operator: "eq" as const,
+									},
+								],
+							});
 							tagFilterPostIds = new Set(postTags.map((pt) => pt.postId));
 							if (tagFilterPostIds.size === 0) {
 								return [];
@@ -392,7 +320,7 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							});
 						}
 
-						const posts = await adapter.findMany<Post>({
+						const posts = await adapter.findMany<PostWithPostTag>({
 							model: "post",
 							limit:
 								query.query || query.tagSlug ? undefined : (query.limit ?? 10),
@@ -403,18 +331,49 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 								field: "createdAt",
 								direction: "desc",
 							},
+							join: {
+								postTag: true,
+							},
 						});
 
-						const postTagsMap = await loadTagsForPosts(
-							posts.map((post) => post.id),
-							tagCache,
-							postTagCache,
-						);
+						// Collect unique tag IDs from joined postTag data
+						const tagIds = new Set<string>();
+						for (const post of posts) {
+							if (post.postTag) {
+								for (const pt of post.postTag) {
+									tagIds.add(pt.tagId);
+								}
+							}
+						}
+
+						// Fetch all tags at once
+						const tags =
+							tagIds.size > 0
+								? await adapter.findMany<Tag>({
+										model: "tag",
+									})
+								: [];
+						const tagMap = new Map<string, Tag>();
+						for (const tag of tags) {
+							if (tagIds.has(tag.id)) {
+								tagMap.set(tag.id, tag);
+							}
+						}
 
-						let result = posts.map((post) => ({
-							...post,
-							tags: postTagsMap.get(post.id) || [],
-						}));
+						// Map tags to posts (spread to avoid circular references)
+						let result = posts.map((post) => {
+							const postTags = (post.postTag || [])
+								.map((pt) => {
+									const tag = tagMap.get(pt.tagId);
+									return tag ? { ...tag } : undefined;
+								})
+								.filter((tag): tag is Tag => tag !== undefined);
+							const { postTag: _, ...postWithoutJoin } = post;
+							return {
+								...postWithoutJoin,
+								tags: postTags,
+							};
+						});
 
 						if (tagFilterPostIds) {
 							result = result.filter((post) => tagFilterPostIds!.has(post.id));
@@ -466,7 +425,6 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						body: ctx.body,
 						headers: ctx.headers,
 					};
-					const tagCache = createTagCache();
 
 					try {
 						if (hooks?.onBeforeCreatePost) {
@@ -496,7 +454,7 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						});
 
 						if (tagNames.length > 0) {
-							const createdTags = await findOrCreateTags(tagNames, tagCache);
+							const createdTags = await findOrCreateTags(tagNames);
 
 							await adapter.transaction(async (tx) => {
 								for (const tag of createdTags) {
@@ -540,7 +498,6 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						params: ctx.params,
 						headers: ctx.headers,
 					};
-					const tagCache = createTagCache();
 
 					try {
 						if (hooks?.onBeforeUpdatePost) {
@@ -608,7 +565,7 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							}
 
 							if (tagNames.length > 0) {
-								const createdTags = await findOrCreateTags(tagNames, tagCache);
+								const createdTags = await findOrCreateTags(tagNames);
 
 								for (const tag of createdTags) {
 									await tx.create<{ postId: string; tagId: string }>({
@@ -666,16 +623,9 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							}
 						}
 
-						await adapter.transaction(async (tx) => {
-							await tx.delete({
-								model: "postTag",
-								where: [{ field: "postId", value: ctx.params.id }],
-							});
-
-							await tx.delete<Post>({
-								model: "post",
-								where: [{ field: "id", value: ctx.params.id }],
-							});
+						await adapter.delete<Post>({
+							model: "post",
+							where: [{ field: "id", value: ctx.params.id }],
 						});
 
 						// Lifecycle hook
@@ -703,8 +653,6 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 				async (ctx) => {
 					const { query, headers } = ctx;
 					const context: BlogApiContext = { query, headers };
-					const tagCache = createTagCache();
-					const postTagCache = createPostTagCache();
 
 					try {
 						if (hooks?.onBeforeListPosts) {
@@ -722,7 +670,7 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						const date = query.date;
 
 						// Get previous post (createdAt < date, newest first)
-						const previousPost = await adapter.findMany<Post>({
+						const previousPosts = await adapter.findMany<PostWithPostTag>({
 							model: "post",
 							limit: 1,
 							where: [
@@ -741,9 +689,12 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 								field: "createdAt",
 								direction: "desc",
 							},
+							join: {
+								postTag: true,
+							},
 						});
 
-						const nextPost = await adapter.findMany<Post>({
+						const nextPosts = await adapter.findMany<PostWithPostTag>({
 							model: "post",
 							limit: 1,
 							where: [
@@ -762,31 +713,55 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 								field: "createdAt",
 								direction: "asc",
 							},
+							join: {
+								postTag: true,
+							},
 						});
 
-						const postIds = [
-							...(previousPost?.[0] ? [previousPost[0].id] : []),
-							...(nextPost?.[0] ? [nextPost[0].id] : []),
-						];
-						const postTagsMap = await loadTagsForPosts(
-							postIds,
-							tagCache,
-							postTagCache,
-						);
+						// Collect unique tag IDs from joined data
+						const tagIds = new Set<string>();
+						const allPosts = [...previousPosts, ...nextPosts];
+						for (const post of allPosts) {
+							if (post.postTag) {
+								for (const pt of post.postTag) {
+									tagIds.add(pt.tagId);
+								}
+							}
+						}
+
+						// Fetch tags if needed
+						const tagMap = new Map<string, Tag>();
+						if (tagIds.size > 0) {
+							const tags = await adapter.findMany<Tag>({
+								model: "tag",
+							});
+							for (const tag of tags) {
+								if (tagIds.has(tag.id)) {
+									tagMap.set(tag.id, tag);
+								}
+							}
+						}
+
+						// Helper to map post with tags (spread to avoid circular references)
+						const mapPostWithTags = (post: PostWithPostTag) => {
+							const tags = (post.postTag || [])
+								.map((pt) => {
+									const tag = tagMap.get(pt.tagId);
+									return tag ? { ...tag } : undefined;
+								})
+								.filter((tag): tag is Tag => tag !== undefined);
+							const { postTag: _, ...postWithoutJoin } = post;
+							return {
+								...postWithoutJoin,
+								tags,
+							};
+						};
 
 						return {
-							previous: previousPost?.[0]
-								? {
-										...previousPost[0],
-										tags: postTagsMap.get(previousPost[0].id) || [],
-									}
-								: null,
-							next: nextPost?.[0]
-								? {
-										...nextPost[0],
-										tags: postTagsMap.get(nextPost[0].id) || [],
-									}
+							previous: previousPosts[0]
+								? mapPostWithTags(previousPosts[0])
 								: null,
+							next: nextPosts[0] ? mapPostWithTags(nextPosts[0]) : null,
 						};
 					} catch (error) {
 						// Error hook

package/src/plugins/blog/client/components/pages/post-page.internal.tsx

@@ -71,7 +71,7 @@ export function PostPage({ slug }: { slug: string }) {
 	}
 
 	return (
-		<PageWrapper className="gap-0 px-4 lg:px-4 py-0 pb-18" testId="post-page">
+		<PageWrapper className="gap-0 px-4 lg:px-2 py-0 pb-18" testId="post-page">
 			<div className="flex items-start w-full">
 				<div className="w-44 shrink-0 hidden xl:flex mr-auto" />
 				<div className="flex flex-col items-center flex-1 mx-auto w-full max-w-4xl min-w-0">

package/src/plugins/blog/client/components/shared/on-this-page.tsx

@@ -63,7 +63,7 @@ export function OnThisPage({ markdown, className }: OnThisPageProps) {
 			aria-label="Table of contents"
 		>
 			<div className="overflow-y-auto px-2">
-				<div className="flex flex-col gap-1 p-4 pt-0 text-sm">
+				<div className="flex flex-col gap-1 p-2 pt-0 text-sm">
 					<p className="flex items-center gap-2 font-semibold text-muted-foreground sticky top-0 h-6 text-xs">
 						<TextAlignStart className="w-3 h-3" />{" "}
 						{localization.BLOG_POST_ON_THIS_PAGE}

package/src/plugins/blog/client/components/shared/recent-posts-carousel.tsx

@@ -68,8 +68,8 @@ export function RecentPostsCarousel({ posts, ref }: RecentPostsCarouselProps) {
 									</CarouselItem>
 								))}
 							</CarouselContent>
-							<CarouselPrevious className="-left-4 lg:-left-12 hover:cursor-pointer" />
-							<CarouselNext className="-right-4 lg:-right-12 hover:cursor-pointer" />
+							<CarouselPrevious className="-left-4 z-50 hover:cursor-pointer" />
+							<CarouselNext className="-right-4 z-50 hover:cursor-pointer" />
 						</Carousel>
 					</div>
 				</>

package/src/plugins/blog/db.ts

@@ -80,10 +80,20 @@ export const blogSchema = createDbPlugin("blog", {
 			postId: {
 				type: "string",
 				required: true,
+				references: {
+					model: "post",
+					field: "id",
+					onDelete: "cascade",
+				},
 			},
 			tagId: {
 				type: "string",
 				required: true,
+				references: {
+					model: "tag",
+					field: "id",
+					onDelete: "cascade",
+				},
 			},
 		},
 	},

package/src/plugins/blog/types.ts

@@ -23,6 +23,13 @@ export type Tag = {
 	updatedAt: Date;
 };
 
+/**
+ * Post with joined postTag relationships from the database
+ */
+export type PostWithPostTag = Post & {
+	postTag?: Array<{ postId: string; tagId: string }>;
+};
+
 export interface SerializedPost
 	extends Omit<Post, "createdAt" | "updatedAt" | "publishedAt" | "tags"> {
 	tags: SerializedTag[];

package/dist/shared/{stack.Cr2JoQdo.d.cts → stack.CbuN2zVV.d.cts}

@@ -35,15 +35,15 @@ interface SerializedTag extends Omit<Tag, "createdAt" | "updatedAt"> {
 }
 
 declare const createPostSchema: z.ZodObject<{
-    title: z.ZodString;
     slug: z.ZodOptional<z.ZodString>;
-    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    title: z.ZodString;
     content: z.ZodString;
     excerpt: z.ZodString;
     image: z.ZodOptional<z.ZodString>;
+    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{

package/dist/shared/{stack.Cr2JoQdo.d.mts → stack.CbuN2zVV.d.mts}

@@ -35,15 +35,15 @@ interface SerializedTag extends Omit<Tag, "createdAt" | "updatedAt"> {
 }
 
 declare const createPostSchema: z.ZodObject<{
-    title: z.ZodString;
     slug: z.ZodOptional<z.ZodString>;
-    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    title: z.ZodString;
     content: z.ZodString;
     excerpt: z.ZodString;
     image: z.ZodOptional<z.ZodString>;
+    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{

package/dist/shared/{stack.Cr2JoQdo.d.ts → stack.CbuN2zVV.d.ts}

@@ -35,15 +35,15 @@ interface SerializedTag extends Omit<Tag, "createdAt" | "updatedAt"> {
 }
 
 declare const createPostSchema: z.ZodObject<{
-    title: z.ZodString;
     slug: z.ZodOptional<z.ZodString>;
-    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    title: z.ZodString;
     content: z.ZodString;
     excerpt: z.ZodString;
     image: z.ZodOptional<z.ZodString>;
+    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{