@btst/stack 2.11.0 → 2.11.2

package/dist/shared/{stack.D6zyQnMo.d.cts → stack.vVFh38aS.d.cts}

@@ -1,9 +1,10 @@
 import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
-import { a as StorageAdapter, b as S3UploadToken } from './stack.DO6vOGQG.cjs';
+import { S as StorageAdapter, b as S3UploadToken } from './stack.lkebw2nj.cjs';
 import { d as AssetListResult, l as listAssets, a as listFolders, A as AssetListParams } from './stack.jU2iG86n.cjs';
 import * as better_call from 'better-call';
 import { z } from 'zod';
 import { A as Asset, F as Folder } from './stack.BMlLOMED.cjs';
+import { DBAdapter } from '@btst/db';
 
 declare const AssetListQuerySchema: z.ZodObject<{
     folderId: z.ZodOptional<z.ZodString>;
@@ -21,6 +22,75 @@ declare const createFolderSchema: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
+/**
+ * Input for creating a new asset record.
+ */
+interface CreateAssetInput {
+    filename: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    url: string;
+    folderId?: string;
+    alt?: string;
+    tenantId?: string;
+}
+/**
+ * Input for updating an existing asset record.
+ */
+interface UpdateAssetInput {
+    alt?: string;
+    folderId?: string | null;
+}
+/**
+ * Input for creating a new folder.
+ */
+interface CreateFolderInput {
+    name: string;
+    parentId?: string;
+    tenantId?: string;
+}
+/**
+ * Create an asset record in the database.
+ * Pure DB function — no authorization hooks, no HTTP context.
+ *
+ * @remarks **Security:** No authorization hooks (e.g. `onBeforeUpload`) are called.
+ * The caller is responsible for any access-control checks before invoking this function.
+ */
+declare function createAsset(adapter: DBAdapter, input: CreateAssetInput): Promise<Asset>;
+/**
+ * Update an asset's `alt` text or `folderId`.
+ * Pure DB function — no authorization hooks, no HTTP context.
+ *
+ * @remarks **Security:** No authorization hooks are called.
+ */
+declare function updateAsset(adapter: DBAdapter, id: string, input: UpdateAssetInput): Promise<Asset | null>;
+/**
+ * Delete an asset record from the database by its ID.
+ * Does NOT delete the underlying file — the caller must do that via the storage adapter.
+ * Pure DB function — no authorization hooks, no HTTP context.
+ *
+ * @remarks **Security:** No authorization hooks are called.
+ */
+declare function deleteAsset(adapter: DBAdapter, id: string): Promise<void>;
+/**
+ * Create a folder record in the database.
+ * Pure DB function — no authorization hooks, no HTTP context.
+ *
+ * @remarks **Security:** No authorization hooks are called.
+ */
+declare function createFolder(adapter: DBAdapter, input: CreateFolderInput): Promise<Folder>;
+/**
+ * Delete a folder record from the database by its ID.
+ * Child folders are cascade-deleted automatically. Throws if the folder or
+ * any of its descendants contain assets (which have associated storage files
+ * that must be deleted via the storage adapter first).
+ * Pure DB function — no authorization hooks, no HTTP context.
+ *
+ * @remarks **Security:** No authorization hooks are called.
+ */
+declare function deleteFolder(adapter: DBAdapter, id: string): Promise<void>;
+
 /**
  * Context passed to media API hooks.
  */
@@ -270,9 +340,12 @@ declare const mediaBackendPlugin: (config: MediaBackendConfig) => _btst_stack_pl
 }, {
     listAssets: (params?: Parameters<typeof listAssets>[1]) => Promise<AssetListResult>;
     getAssetById: (id: string) => Promise<Asset | null>;
+    createAsset: (input: Parameters<typeof createAsset>[1]) => Promise<Asset>;
+    updateAsset: (id: string, input: Parameters<typeof updateAsset>[2]) => Promise<Asset | null>;
     listFolders: (params?: Parameters<typeof listFolders>[1]) => Promise<Folder[]>;
     getFolderById: (id: string) => Promise<Folder | null>;
     getFolderByName: (name: string, parentId?: string | null, tenantId?: string) => Promise<Folder | null>;
+    createFolder: (input: Parameters<typeof createFolder>[1]) => Promise<Folder>;
 }>;
 type MediaApiRouter = ReturnType<ReturnType<typeof mediaBackendPlugin>["routes"]>;
 
@@ -300,5 +373,5 @@ declare const MEDIA_QUERY_KEYS: {
     foldersList: (parentId?: string | null) => readonly ["media", "folders", "list", string];
 };
 
-export { MEDIA_QUERY_KEYS as a, assetListDiscriminator as b, mediaBackendPlugin as m };
-export type { AssetListDiscriminator as A, MediaApiRouter as M, MediaApiContext as c, MediaBackendHooks as d, MediaBackendConfig as e };
+export { MEDIA_QUERY_KEYS as M, createFolder as a, deleteFolder as b, createAsset as c, deleteAsset as d, assetListDiscriminator as f, mediaBackendPlugin as m, updateAsset as u };
+export type { AssetListDiscriminator as A, CreateAssetInput as C, UpdateAssetInput as U, CreateFolderInput as e, MediaApiContext as g, MediaBackendHooks as h, MediaBackendConfig as i, MediaApiRouter as j };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btst/stack",
-  "version": "2.11.0",
+  "version": "2.11.2",
   "description": "A composable, plugin-based library for building full-stack applications.",
   "repository": {
     "type": "git",
@@ -424,6 +424,16 @@
         "default": "./dist/plugins/media/api/index.cjs"
       }
     },
+    "./plugins/media/api/adapters/local": {
+      "import": {
+        "types": "./dist/plugins/media/api/adapters/local.d.ts",
+        "default": "./dist/plugins/media/api/adapters/local.mjs"
+      },
+      "require": {
+        "types": "./dist/plugins/media/api/adapters/local.d.cts",
+        "default": "./dist/plugins/media/api/adapters/local.cjs"
+      }
+    },
     "./plugins/media/api/adapters/s3": {
       "import": {
         "types": "./dist/plugins/media/api/adapters/s3.d.ts",
@@ -684,6 +694,9 @@
       "plugins/media/api": [
         "./dist/plugins/media/api/index.d.ts"
       ],
+      "plugins/media/api/adapters/local": [
+        "./dist/plugins/media/api/adapters/local.d.ts"
+      ],
       "plugins/media/api/adapters/s3": [
         "./dist/plugins/media/api/adapters/s3.d.ts"
       ],

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

@@ -6,6 +6,13 @@ export {
 	type PostListParams,
 	type PostListResult,
 } from "./getters";
+export {
+	createPost,
+	updatePost,
+	deletePost,
+	type CreatePostInput,
+	type UpdatePostInput,
+} from "./mutations";
 export { serializePost, serializeTag } from "./serializers";
 export { BLOG_QUERY_KEYS } from "./query-key-defs";
 export { createBlogQueryKeys } from "../query-keys";

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 }],
+	});
+}