@btst/stack 2.11.1 → 2.11.2

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

@@ -0,0 +1,287 @@
+import type { DBAdapter as Adapter } from "@btst/db";
+import type { Post, Tag } from "../types";
+import { slugify } from "../utils";
+
+type TagInput = { name: string } | { id: string; name: string; slug: string };
+
+/**
+ * Find existing tags by slug or create missing ones, then return the resolved Tag records.
+ * Tags that already carry an `id` are returned as-is (after name normalisation).
+ */
+async function findOrCreateTags(
+	adapter: Adapter,
+	tagInputs: TagInput[],
+): Promise<Tag[]> {
+	if (tagInputs.length === 0) return [];
+
+	const normalizeTagName = (name: string): string => name.trim();
+
+	const tagsWithIds: Tag[] = [];
+	const tagsToFindOrCreate: Array<{ name: string }> = [];
+
+	for (const tagInput of tagInputs) {
+		if ("id" in tagInput && tagInput.id) {
+			tagsWithIds.push({
+				id: tagInput.id,
+				name: normalizeTagName(tagInput.name),
+				slug: tagInput.slug,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			} as Tag);
+		} else {
+			tagsToFindOrCreate.push({ name: normalizeTagName(tagInput.name) });
+		}
+	}
+
+	if (tagsToFindOrCreate.length === 0) {
+		return tagsWithIds;
+	}
+
+	const allTags = await adapter.findMany<Tag>({ model: "tag" });
+	const tagMapBySlug = new Map<string, Tag>();
+	for (const tag of allTags) {
+		tagMapBySlug.set(tag.slug, tag);
+	}
+
+	const tagSlugs = tagsToFindOrCreate.map((tag) => slugify(tag.name));
+	const foundTags: Tag[] = [];
+	for (const slug of tagSlugs) {
+		const tag = tagMapBySlug.get(slug);
+		if (tag) {
+			foundTags.push(tag);
+		}
+	}
+
+	const existingSlugs = new Set([
+		...tagsWithIds.map((tag) => tag.slug),
+		...foundTags.map((tag) => tag.slug),
+	]);
+	const tagsToCreate = tagsToFindOrCreate.filter(
+		(tag) => !existingSlugs.has(slugify(tag.name)),
+	);
+
+	const createdTags: Tag[] = [];
+	for (const tag of tagsToCreate) {
+		const normalizedName = normalizeTagName(tag.name);
+		const newTag = await adapter.create<Tag>({
+			model: "tag",
+			data: {
+				name: normalizedName,
+				slug: slugify(normalizedName),
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		createdTags.push(newTag);
+	}
+
+	return [...tagsWithIds, ...foundTags, ...createdTags];
+}
+
+/**
+ * Input for creating a new blog post.
+ * `slug` must already be slugified by the caller.
+ */
+export interface CreatePostInput {
+	title: string;
+	content: string;
+	excerpt: string;
+	/** Pre-slugified URL slug — use {@link slugify} before passing. */
+	slug: string;
+	image?: string;
+	published?: boolean;
+	publishedAt?: Date;
+	createdAt?: Date;
+	updatedAt?: Date;
+	tags?: TagInput[];
+}
+
+/**
+ * Input for updating an existing blog post.
+ * If `slug` is provided it must already be slugified by the caller.
+ */
+export interface UpdatePostInput {
+	title?: string;
+	content?: string;
+	excerpt?: string;
+	/** Pre-slugified URL slug — use {@link slugify} before passing. */
+	slug?: string;
+	image?: string;
+	published?: boolean;
+	publishedAt?: Date;
+	createdAt?: Date;
+	updatedAt?: Date;
+	tags?: TagInput[];
+}
+
+/**
+ * Create a new blog post with optional tag associations.
+ * Pure DB function — no hooks, no HTTP context. Safe for server-side and SSG use.
+ *
+ * @remarks **Security:** Authorization hooks (e.g. `onBeforeCreatePost`) are NOT
+ * called. The caller is responsible for any access-control checks before
+ * invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param input - Post data; `slug` must be pre-slugified
+ */
+export async function createPost(
+	adapter: Adapter,
+	input: CreatePostInput,
+): Promise<Post> {
+	const { tags: tagInputs, ...postData } = input;
+	const tagList = tagInputs ?? [];
+
+	const newPost = await adapter.create<Post>({
+		model: "post",
+		data: {
+			...postData,
+			published: postData.published ?? false,
+			tags: [] as Tag[],
+			createdAt: postData.createdAt ?? new Date(),
+			updatedAt: postData.updatedAt ?? new Date(),
+		},
+	});
+
+	if (tagList.length > 0) {
+		const resolvedTags = await findOrCreateTags(adapter, tagList);
+
+		await adapter.transaction(async (tx) => {
+			for (const tag of resolvedTags) {
+				await tx.create<{ postId: string; tagId: string }>({
+					model: "postTag",
+					data: {
+						postId: newPost.id,
+						tagId: tag.id,
+					},
+				});
+			}
+		});
+
+		newPost.tags = resolvedTags.map((tag) => ({ ...tag }));
+	} else {
+		newPost.tags = [];
+	}
+
+	return newPost;
+}
+
+/**
+ * Update an existing blog post and reconcile its tag associations.
+ * Returns `null` if no post with the given `id` exists.
+ * Pure DB function — no hooks, no HTTP context. Safe for server-side use.
+ *
+ * @remarks **Security:** Authorization hooks (e.g. `onBeforeUpdatePost`) are NOT
+ * called. The caller is responsible for any access-control checks before
+ * invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param id - The post ID to update
+ * @param input - Partial post data to apply; `slug` must be pre-slugified if provided
+ */
+export async function updatePost(
+	adapter: Adapter,
+	id: string,
+	input: UpdatePostInput,
+): Promise<Post | null> {
+	const { tags: tagInputs, ...postData } = input;
+
+	return adapter.transaction(async (tx) => {
+		const updatedPost = await tx.update<Post>({
+			model: "post",
+			where: [{ field: "id", value: id }],
+			update: {
+				...postData,
+				updatedAt: new Date(),
+			},
+		});
+
+		if (!updatedPost) return null;
+
+		if (tagInputs !== undefined) {
+			const existingPostTags = await tx.findMany<{
+				postId: string;
+				tagId: string;
+			}>({
+				model: "postTag",
+				where: [{ field: "postId", value: id, operator: "eq" as const }],
+			});
+
+			for (const postTag of existingPostTags) {
+				await tx.delete<{ postId: string; tagId: string }>({
+					model: "postTag",
+					where: [
+						{
+							field: "postId",
+							value: postTag.postId,
+							operator: "eq" as const,
+						},
+						{
+							field: "tagId",
+							value: postTag.tagId,
+							operator: "eq" as const,
+						},
+					],
+				});
+			}
+
+			if (tagInputs.length > 0) {
+				const resolvedTags = await findOrCreateTags(adapter, tagInputs);
+
+				for (const tag of resolvedTags) {
+					await tx.create<{ postId: string; tagId: string }>({
+						model: "postTag",
+						data: {
+							postId: id,
+							tagId: tag.id,
+						},
+					});
+				}
+
+				updatedPost.tags = resolvedTags.map((tag) => ({ ...tag }));
+			} else {
+				updatedPost.tags = [];
+			}
+		} else {
+			const existingPostTags = await tx.findMany<{
+				postId: string;
+				tagId: string;
+			}>({
+				model: "postTag",
+				where: [{ field: "postId", value: id, operator: "eq" as const }],
+			});
+
+			if (existingPostTags.length > 0) {
+				const tagIds = existingPostTags.map((pt) => pt.tagId);
+				const tags = await tx.findMany<Tag>({
+					model: "tag",
+				});
+				updatedPost.tags = tags
+					.filter((tag) => tagIds.includes(tag.id))
+					.map((tag) => ({ ...tag }));
+			} else {
+				updatedPost.tags = [];
+			}
+		}
+
+		return updatedPost;
+	});
+}
+
+/**
+ * Delete a blog post by ID.
+ * Pure DB function — no hooks, no HTTP context. Safe for server-side use.
+ *
+ * @remarks **Security:** Authorization hooks (e.g. `onBeforeDeletePost`) are NOT
+ * called. The caller is responsible for any access-control checks before
+ * invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param id - The post ID to delete
+ */
+export async function deletePost(adapter: Adapter, id: string): Promise<void> {
+	await adapter.delete<Post>({
+		model: "post",
+		where: [{ field: "id", value: id }],
+	});
+}

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

@@ -7,6 +7,13 @@ import type { Post, PostWithPostTag, Tag } from "../types";
 import { slugify } from "../utils";
 import { createPostSchema, updatePostSchema } from "../schemas";
 import { getAllPosts, getPostBySlug, getAllTags } from "./getters";
+import {
+	createPost as createPostMutation,
+	updatePost as updatePostMutation,
+	deletePost as deletePostMutation,
+	type CreatePostInput,
+	type UpdatePostInput,
+} from "./mutations";
 import { BLOG_QUERY_KEYS } from "./query-key-defs";
 import { serializePost, serializeTag } from "./serializers";
 import type { QueryClient } from "@tanstack/react-query";
@@ -260,85 +267,15 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 			getPostBySlug: (slug: string) => getPostBySlug(adapter, slug),
 			getAllTags: () => getAllTags(adapter),
 			prefetchForRoute: createBlogPrefetchForRoute(adapter),
+			// Mutations
+			createPost: (input: CreatePostInput) =>
+				createPostMutation(adapter, input),
+			updatePost: (id: string, input: UpdatePostInput) =>
+				updatePostMutation(adapter, id, input),
+			deletePost: (id: string) => deletePostMutation(adapter, id),
 		}),
 
 		routes: (adapter: Adapter) => {
-			const findOrCreateTags = async (
-				tagInputs: Array<
-					{ name: string } | { id: string; name: string; slug: string }
-				>,
-			): Promise<Tag[]> => {
-				if (tagInputs.length === 0) return [];
-
-				const normalizeTagName = (name: string): string => {
-					return name.trim();
-				};
-
-				const tagsWithIds: Tag[] = [];
-				const tagsToFindOrCreate: Array<{ name: string }> = [];
-
-				for (const tagInput of tagInputs) {
-					if ("id" in tagInput && tagInput.id) {
-						tagsWithIds.push({
-							id: tagInput.id,
-							name: normalizeTagName(tagInput.name),
-							slug: tagInput.slug,
-							createdAt: new Date(),
-							updatedAt: new Date(),
-						} as Tag);
-					} else {
-						tagsToFindOrCreate.push({ name: normalizeTagName(tagInput.name) });
-					}
-				}
-
-				if (tagsToFindOrCreate.length === 0) {
-					return tagsWithIds;
-				}
-
-				const allTags = await adapter.findMany<Tag>({
-					model: "tag",
-				});
-				const tagMapBySlug = new Map<string, Tag>();
-				for (const tag of allTags) {
-					tagMapBySlug.set(tag.slug, tag);
-				}
-
-				const tagSlugs = tagsToFindOrCreate.map((tag) => slugify(tag.name));
-				const foundTags: Tag[] = [];
-
-				for (const slug of tagSlugs) {
-					const tag = tagMapBySlug.get(slug);
-					if (tag) {
-						foundTags.push(tag);
-					}
-				}
-
-				const existingSlugs = new Set([
-					...tagsWithIds.map((tag) => tag.slug),
-					...foundTags.map((tag) => tag.slug),
-				]);
-				const tagsToCreate = tagsToFindOrCreate.filter(
-					(tag) => !existingSlugs.has(slugify(tag.name)),
-				);
-
-				const createdTags: Tag[] = [];
-				for (const tag of tagsToCreate) {
-					const normalizedName = normalizeTagName(tag.name);
-					const newTag = await adapter.create<Tag>({
-						model: "tag",
-						data: {
-							name: normalizedName,
-							slug: slugify(normalizedName),
-							createdAt: new Date(),
-							updatedAt: new Date(),
-						},
-					});
-					createdTags.push(newTag);
-				}
-
-				return [...tagsWithIds, ...foundTags, ...createdTags];
-			};
-
 			const listPosts = createEndpoint(
 				"/posts",
 				{
@@ -394,11 +331,17 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							);
 						}
 
-						const { tags, ...postData } = ctx.body;
-						const tagNames = tags || [];
+						// Destructure and discard createdAt/updatedAt — timestamps are always server-generated
+						const {
+							tags,
+							slug: rawSlug,
+							createdAt: _ca,
+							updatedAt: _ua,
+							...postData
+						} = ctx.body;
 
 						// Always slugify to ensure URL-safe slug, whether provided or generated from title
-						const slug = slugify(postData.slug || postData.title);
+						const slug = slugify(rawSlug || postData.title);
 
 						// Validate that slugification produced a non-empty result
 						if (!slug) {
@@ -408,37 +351,14 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							});
 						}
 
-						const newPost = await adapter.create<Post>({
-							model: "post",
-							data: {
-								...postData,
-								slug,
-								tags: [],
-								createdAt: new Date(),
-								updatedAt: new Date(),
-							},
+						const newPost = await createPostMutation(adapter, {
+							...postData,
+							slug,
+							tags: tags ?? [],
+							createdAt: new Date(),
+							updatedAt: new Date(),
 						});
 
-						if (tagNames.length > 0) {
-							const createdTags = await findOrCreateTags(tagNames);
-
-							await adapter.transaction(async (tx) => {
-								for (const tag of createdTags) {
-									await tx.create<{ postId: string; tagId: string }>({
-										model: "postTag",
-										data: {
-											postId: newPost.id,
-											tagId: tag.id,
-										},
-									});
-								}
-							});
-
-							newPost.tags = createdTags.map((tag) => ({ ...tag }));
-						} else {
-							newPost.tags = [];
-						}
-
 						if (hooks?.onPostCreated) {
 							await hooks.onPostCreated(newPost, context);
 						}
@@ -475,8 +395,14 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							);
 						}
 
-						const { tags, slug: rawSlug, ...restPostData } = ctx.body;
-						const tagNames = tags || [];
+						// Destructure and discard createdAt/updatedAt — timestamps are always server-generated
+						const {
+							tags,
+							slug: rawSlug,
+							createdAt: _ca,
+							updatedAt: _ua,
+							...restPostData
+						} = ctx.body;
 
 						// Sanitize slug if provided to ensure it's URL-safe
 						const slugified = rawSlug ? slugify(rawSlug) : undefined;
@@ -489,80 +415,16 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							});
 						}
 
-						const postData = {
+						const updated = await updatePostMutation(adapter, ctx.params.id, {
 							...restPostData,
 							...(slugified ? { slug: slugified } : {}),
-						};
-
-						const updated = await adapter.transaction(async (tx) => {
-							const existingPostTags = await tx.findMany<{
-								postId: string;
-								tagId: string;
-							}>({
-								model: "postTag",
-								where: [
-									{
-										field: "postId",
-										value: ctx.params.id,
-										operator: "eq" as const,
-									},
-								],
-							});
-
-							const updatedPost = await tx.update<Post>({
-								model: "post",
-								where: [{ field: "id", value: ctx.params.id }],
-								update: {
-									...postData,
-									updatedAt: new Date(),
-								},
-							});
-
-							if (!updatedPost) {
-								throw ctx.error(404, {
-									message: "Post not found",
-								});
-							}
-
-							for (const postTag of existingPostTags) {
-								await tx.delete<{ postId: string; tagId: string }>({
-									model: "postTag",
-									where: [
-										{
-											field: "postId",
-											value: postTag.postId,
-											operator: "eq" as const,
-										},
-										{
-											field: "tagId",
-											value: postTag.tagId,
-											operator: "eq" as const,
-										},
-									],
-								});
-							}
-
-							if (tagNames.length > 0) {
-								const createdTags = await findOrCreateTags(tagNames);
-
-								for (const tag of createdTags) {
-									await tx.create<{ postId: string; tagId: string }>({
-										model: "postTag",
-										data: {
-											postId: ctx.params.id,
-											tagId: tag.id,
-										},
-									});
-								}
-
-								updatedPost.tags = createdTags.map((tag) => ({ ...tag }));
-							} else {
-								updatedPost.tags = [];
-							}
-
-							return updatedPost;
+							tags: tags ?? [],
 						});
 
+						if (!updated) {
+							throw ctx.error(404, { message: "Post not found" });
+						}
+
 						if (hooks?.onPostUpdated) {
 							await hooks.onPostUpdated(updated, context);
 						}
@@ -597,10 +459,7 @@ export const blogBackendPlugin = (hooks?: BlogBackendHooks) =>
 							);
 						}
 
-						await adapter.delete<Post>({
-							model: "post",
-							where: [{ field: "id", value: ctx.params.id }],
-						});
+						await deletePostMutation(adapter, ctx.params.id);
 
 						// Lifecycle hook
 						if (hooks?.onPostDeleted) {

package/dist/shared/{stack.BOokfhZD.d.cts → stack.B6S3cgwN.d.cts}

@@ -7,12 +7,12 @@ import { QueryClient } from '@tanstack/react-query';
 
 declare const createBoardSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
-    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     slug: z.ZodOptional<z.ZodString>;
     ownerId: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    name: z.ZodString;
 }, z.core.$strip>;
 declare const updateBoardSchema: z.ZodObject<{
     createdAt: z.ZodOptional<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
@@ -28,8 +28,8 @@ declare const createColumnSchema: z.ZodObject<{
     title: z.ZodString;
     createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
-    boardId: z.ZodString;
     order: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    boardId: z.ZodString;
 }, z.core.$strip>;
 declare const updateColumnSchema: z.ZodObject<{
     createdAt: z.ZodOptional<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
@@ -331,19 +331,19 @@ declare const kanbanBackendPlugin: (hooks?: KanbanBackendHooks) => _btst_stack_p
         body: better_call.StandardSchemaV1<{
             name: string;
             description?: string | undefined;
-            createdAt?: unknown;
-            updatedAt?: unknown;
             slug?: string | undefined;
             ownerId?: string | undefined;
             organizationId?: string | undefined;
+            createdAt?: unknown;
+            updatedAt?: unknown;
         }, {
             name: string;
             description?: string | undefined;
-            createdAt?: unknown;
-            updatedAt?: unknown;
             slug?: string | undefined;
             ownerId?: string | undefined;
             organizationId?: string | undefined;
+            createdAt?: unknown;
+            updatedAt?: unknown;
         }>;
     }, {
         columns: ColumnWithTasks[];
@@ -360,20 +360,20 @@ declare const kanbanBackendPlugin: (hooks?: KanbanBackendHooks) => _btst_stack_p
         method: "PUT";
         body: better_call.StandardSchemaV1<{
             description?: string | undefined;
-            name?: string | undefined;
-            createdAt?: unknown;
-            updatedAt?: unknown;
             slug?: string | undefined;
             ownerId?: string | undefined;
             organizationId?: string | undefined;
-        }, {
-            description?: string | undefined;
-            name?: string | undefined;
             createdAt?: unknown;
             updatedAt?: unknown;
+            name?: string | undefined;
+        }, {
+            description?: string | undefined;
             slug?: string | undefined;
             ownerId?: string | undefined;
             organizationId?: string | undefined;
+            createdAt?: unknown;
+            updatedAt?: unknown;
+            name?: string | undefined;
         }>;
     }, Board>;
     readonly deleteBoard: better_call.StrictEndpoint<"/boards/:id", {} & {
@@ -404,14 +404,14 @@ declare const kanbanBackendPlugin: (hooks?: KanbanBackendHooks) => _btst_stack_p
             title?: string | undefined;
             createdAt?: unknown;
             updatedAt?: unknown;
-            boardId?: string | undefined;
             order?: number | undefined;
+            boardId?: string | undefined;
         }, {
             title?: string | undefined;
             createdAt?: unknown;
             updatedAt?: unknown;
-            boardId?: string | undefined;
             order?: number | undefined;
+            boardId?: string | undefined;
         }>;
     }, Column>;
     readonly deleteColumn: better_call.StrictEndpoint<"/columns/:id", {} & {

package/dist/shared/{stack.Sod_PZhB.d.cts → stack.BWp0hcm9.d.cts}

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