@btst/stack 1.2.1 → 1.3.0

package/dist/plugins/blog/query-keys.d.ts

@@ -1,7 +1,7 @@
 import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
 import * as better_call from 'better-call';
 import { z } from 'zod';
-import { c as createPostSchema, u as updatePostSchema, P as Post, T as Tag, S as SerializedPost, a as SerializedTag } from '../../shared/stack.Cr2JoQdo.js';
+import { c as createPostSchema, u as updatePostSchema, P as Post, T as Tag, S as SerializedPost, a as SerializedTag } from '../../shared/stack.DLhzx1-D.js';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { createApiClient } from '@btst/stack/plugins/client';
 
@@ -199,8 +199,6 @@ declare const blogBackendPlugin: (hooks?: BlogBackendHooks) => _btst_stack_plugi
                 slug?: string | undefined;
                 published?: boolean | undefined;
                 createdAt?: unknown;
-                publishedAt?: unknown;
-                updatedAt?: unknown;
                 image?: string | undefined;
                 tags?: ({
                     name: string;
@@ -209,6 +207,8 @@ declare const blogBackendPlugin: (hooks?: BlogBackendHooks) => _btst_stack_plugi
                     name: string;
                     slug: string;
                 })[] | undefined;
+                publishedAt?: unknown;
+                updatedAt?: unknown;
             };
         } & {
             method?: "POST" | undefined;
@@ -239,8 +239,6 @@ declare const blogBackendPlugin: (hooks?: BlogBackendHooks) => _btst_stack_plugi
                 slug: z.ZodOptional<z.ZodString>;
                 published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-                publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-                updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
                 content: z.ZodString;
                 excerpt: z.ZodString;
                 image: z.ZodOptional<z.ZodString>;
@@ -251,6 +249,8 @@ declare const blogBackendPlugin: (hooks?: BlogBackendHooks) => _btst_stack_plugi
                     name: z.ZodString;
                     slug: z.ZodString;
                 }, z.core.$strip>]>>>>;
+                publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
             }, z.core.$strip>;
         };
         path: "/posts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btst/stack",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "A composable, plugin-based library for building full-stack applications.",
   "repository": {
     "type": "git",
@@ -157,7 +157,7 @@
     }
   },
   "dependencies": {
-    "@btst/db": "2.0.1",
+    "@btst/db": "2.0.2",
     "@lukemorales/query-key-factory": "^1.3.4",
     "@milkdown/crepe": "^7.17.1",
     "@milkdown/kit": "^7.17.1",
@@ -196,7 +196,7 @@
     "zod": ">=3.24.0"
   },
   "devDependencies": {
-    "@btst/adapter-memory": "2.0.1",
+    "@btst/adapter-memory": "2.0.2",
     "@btst/yar": "1.1.1",
     "@types/react": "^19.0.0",
     "@types/slug": "^5.0.9",

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,46 @@ 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);
+								}
+							}
+						}
 
-						let result = posts.map((post) => ({
-							...post,
-							tags: postTagsMap.get(post.id) || [],
-						}));
+						// 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);
+							}
+						}
+
+						// Map tags to posts
+						let result = posts.map((post) => {
+							const postTags = (post.postTag || [])
+								.map((pt) => tagMap.get(pt.tagId))
+								.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 +422,6 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						body: ctx.body,
 						headers: ctx.headers,
 					};
-					const tagCache = createTagCache();
 
 					try {
 						if (hooks?.onBeforeCreatePost) {
@@ -496,7 +451,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 +495,6 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						params: ctx.params,
 						headers: ctx.headers,
 					};
-					const tagCache = createTagCache();
 
 					try {
 						if (hooks?.onBeforeUpdatePost) {
@@ -608,7 +562,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 +620,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 +650,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) {
@@ -720,27 +665,17 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 						}
 
 						const date = query.date;
-						const targetTime = new Date(date).getTime();
-
-						// Window-based approach for finding next/previous posts
-						// This avoids relying on comparison operators (lt/gt) which may not be
-						// consistently implemented across all database adapters (e.g., Drizzle).
-						//
-						// Strategy:
-						// 1. Fetch a window of recent published posts (sorted by date DESC)
-						// 2. Filter in memory to find posts immediately before/after target date
-						//
-						// Trade-offs:
-						// - Works reliably across all adapters (only uses eq operator and sorting)
-						// - Efficient for typical blog sizes (100 most recent posts)
-						// - Limitation: If target post is outside the window, we may not find neighbors
-						//   (acceptable for typical blog navigation where users browse recent content)
-						const WINDOW_SIZE = 100;
-
-						const allPosts = await adapter.findMany<Post>({
+
+						// Get previous post (createdAt < date, newest first)
+						const previousPosts = await adapter.findMany<PostWithPostTag>({
 							model: "post",
-							limit: WINDOW_SIZE,
+							limit: 1,
 							where: [
+								{
+									field: "createdAt",
+									value: date,
+									operator: "lt" as const,
+								},
 								{
 									field: "published",
 									value: true,
@@ -751,62 +686,76 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 								field: "createdAt",
 								direction: "desc",
 							},
+							join: {
+								postTag: true,
+							},
 						});
 
-						// Sort posts by createdAt descending (newest first)
-						const sortedPosts = allPosts.sort((a, b) => {
-							const timeA = new Date(a.createdAt).getTime();
-							const timeB = new Date(b.createdAt).getTime();
-							return timeB - timeA;
+						const nextPosts = await adapter.findMany<PostWithPostTag>({
+							model: "post",
+							limit: 1,
+							where: [
+								{
+									field: "createdAt",
+									value: date,
+									operator: "gt" as const,
+								},
+								{
+									field: "published",
+									value: true,
+									operator: "eq" as const,
+								},
+							],
+							sortBy: {
+								field: "createdAt",
+								direction: "asc",
+							},
+							join: {
+								postTag: true,
+							},
 						});
 
-						// Find posts immediately before and after the target date
-						// In DESC sorted array: newer posts come before, older posts come after
-						let previousPost: Post | null = null;
-						let nextPost: Post | null = null;
-
-						for (let i = 0; i < sortedPosts.length; i++) {
-							const post = sortedPosts[i];
-							if (!post) continue;
-
-							const postTime = new Date(post.createdAt).getTime();
-
-							if (postTime > targetTime) {
-								// This post is newer than target - it's a next post candidate
-								// Keep the last one we find (closest to target date)
-								nextPost = post;
-							} else if (postTime < targetTime) {
-								// This is the first post older than target - this is the previous post
-								previousPost = post;
-								// We've found both neighbors, no need to continue
-								break;
+						// 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);
+								}
 							}
-							// Skip posts with exactly the same timestamp (the current post itself)
 						}
 
-						const postIds = [
-							...(previousPost ? [previousPost.id] : []),
-							...(nextPost ? [nextPost.id] : []),
-						];
-						const postTagsMap = await loadTagsForPosts(
-							postIds,
-							tagCache,
-							postTagCache,
-						);
+						// Helper to map post with tags
+						const mapPostWithTags = (post: PostWithPostTag) => {
+							const tags = (post.postTag || [])
+								.map((pt) => tagMap.get(pt.tagId))
+								.filter((tag): tag is Tag => tag !== undefined);
+							const { postTag: _, ...postWithoutJoin } = post;
+							return {
+								...postWithoutJoin,
+								tags,
+							};
+						};
 
 						return {
-							previous: previousPost
-								? {
-										...previousPost,
-										tags: postTagsMap.get(previousPost.id) || [],
-									}
-								: null,
-							next: nextPost
-								? {
-										...nextPost,
-										tags: postTagsMap.get(nextPost.id) || [],
-									}
+							previous: previousPosts[0]
+								? mapPostWithTags(previousPosts[0])
 								: null,
+							next: nextPosts[0] ? mapPostWithTags(nextPosts[0]) : null,
 						};
 					} catch (error) {
 						// Error hook

package/src/plugins/blog/client/plugin.tsx

@@ -755,6 +755,12 @@ export const blogClientPlugin = (config: BlogClientConfig) =>
 				offset += limit;
 			}
 
+			// Fetch all tags
+			const tagsRes = await client("/tags", {
+				method: "GET",
+			});
+			const tags = (tagsRes.data ?? []) as unknown as SerializedTag[];
+
 			const getLastModified = (p: SerializedPost): Date | undefined => {
 				const dates = [p.updatedAt, p.publishedAt, p.createdAt].filter(
 					Boolean,
@@ -784,6 +790,12 @@ export const blogClientPlugin = (config: BlogClientConfig) =>
 					changeFrequency: "monthly" as const,
 					priority: 0.6,
 				})),
+				...tags.map((t) => ({
+					url: `${origin}/blog/tag/${t.slug}`,
+					lastModified: t.updatedAt ? new Date(t.updatedAt) : undefined,
+					changeFrequency: "weekly" as const,
+					priority: 0.5,
+				})),
 			];
 
 			return entries;

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.DLhzx1-D.d.cts}

@@ -39,8 +39,6 @@ declare const createPostSchema: z.ZodObject<{
     slug: z.ZodOptional<z.ZodString>;
     published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     content: z.ZodString;
     excerpt: z.ZodString;
     image: z.ZodOptional<z.ZodString>;
@@ -51,6 +49,8 @@ declare const createPostSchema: z.ZodObject<{
         name: z.ZodString;
         slug: z.ZodString;
     }, z.core.$strip>]>>>>;
+    publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
 declare const updatePostSchema: z.ZodObject<{
     publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;

package/dist/shared/{stack.Cr2JoQdo.d.mts → stack.DLhzx1-D.d.mts}

@@ -39,8 +39,6 @@ declare const createPostSchema: z.ZodObject<{
     slug: z.ZodOptional<z.ZodString>;
     published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     content: z.ZodString;
     excerpt: z.ZodString;
     image: z.ZodOptional<z.ZodString>;
@@ -51,6 +49,8 @@ declare const createPostSchema: z.ZodObject<{
         name: z.ZodString;
         slug: z.ZodString;
     }, z.core.$strip>]>>>>;
+    publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
 declare const updatePostSchema: z.ZodObject<{
     publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;

package/dist/shared/{stack.Cr2JoQdo.d.ts → stack.DLhzx1-D.d.ts}

@@ -39,8 +39,6 @@ declare const createPostSchema: z.ZodObject<{
     slug: z.ZodOptional<z.ZodString>;
     published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     content: z.ZodString;
     excerpt: z.ZodString;
     image: z.ZodOptional<z.ZodString>;
@@ -51,6 +49,8 @@ declare const createPostSchema: z.ZodObject<{
         name: z.ZodString;
         slug: z.ZodString;
     }, z.core.$strip>]>>>>;
+    publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
 declare const updatePostSchema: z.ZodObject<{
     publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;