@btst/stack 2.0.1 → 2.2.0

package/src/plugins/ai-chat/api/getters.ts

@@ -0,0 +1,71 @@
+import type { Adapter } from "@btst/db";
+import type { Conversation, ConversationWithMessages, Message } from "../types";
+
+/**
+ * Retrieve all conversations, optionally filtered by userId.
+ * Pure DB function - no hooks, no HTTP context. Safe for server-side use.
+ *
+ * @param adapter - The database adapter
+ * @param userId - Optional user ID to filter conversations by owner
+ */
+export async function getAllConversations(
+	adapter: Adapter,
+	userId?: string,
+): Promise<Conversation[]> {
+	const whereConditions: Array<{
+		field: string;
+		value: string;
+		operator: "eq";
+	}> = [];
+
+	if (userId) {
+		whereConditions.push({
+			field: "userId",
+			value: userId,
+			operator: "eq" as const,
+		});
+	}
+
+	return adapter.findMany<Conversation>({
+		model: "conversation",
+		where: whereConditions.length > 0 ? whereConditions : undefined,
+		sortBy: { field: "updatedAt", direction: "desc" },
+	});
+}
+
+/**
+ * Retrieve a single conversation by its ID, including all messages.
+ * Returns null if the conversation is not found.
+ * Pure DB function - no hooks, no HTTP context. Safe for server-side use.
+ *
+ * @param adapter - The database adapter
+ * @param id - The conversation ID
+ */
+export async function getConversationById(
+	adapter: Adapter,
+	id: string,
+): Promise<(Conversation & { messages: Message[] }) | null> {
+	const conversations = await adapter.findMany<ConversationWithMessages>({
+		model: "conversation",
+		where: [{ field: "id", value: id, operator: "eq" as const }],
+		limit: 1,
+		join: {
+			message: true,
+		},
+	});
+
+	if (!conversations.length) {
+		return null;
+	}
+
+	const conversation = conversations[0]!;
+	const messages = (conversation.message || []).sort(
+		(a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+	);
+
+	const { message: _, ...conversationWithoutJoin } = conversation;
+	return {
+		...conversationWithoutJoin,
+		messages,
+	};
+}

package/src/plugins/ai-chat/api/index.ts

@@ -1,2 +1,3 @@
 export * from "./plugin";
+export { getAllConversations, getConversationById } from "./getters";
 export { createAiChatQueryKeys } from "../query-keys";

package/src/plugins/ai-chat/api/plugin.ts

@@ -16,6 +16,7 @@ import {
 	updateConversationSchema,
 } from "../schemas";
 import type { Conversation, ConversationWithMessages, Message } from "../types";
+import { getAllConversations, getConversationById } from "./getters";
 
 /**
  * Context passed to AI Chat API hooks
@@ -286,6 +287,13 @@ export const aiChatBackendPlugin = (config: AiChatBackendConfig) =>
 		name: "ai-chat",
 		// Always include db schema - in public mode we just don't use it
 		dbPlugin: dbSchema,
+
+		api: (adapter) => ({
+			getAllConversations: (userId?: string) =>
+				getAllConversations(adapter, userId),
+			getConversationById: (id: string) => getConversationById(adapter, id),
+		}),
+
 		routes: (adapter: Adapter) => {
 			const mode = config.mode ?? "authenticated";
 			const isPublicMode = mode === "public";

package/src/plugins/api/index.ts

@@ -42,9 +42,11 @@ export { createDbPlugin } from "@btst/db";
  * ```
  *
  * @template TRoutes - The exact shape of routes (auto-inferred from routes function)
+ * @template TApi - The shape of the server-side api surface (auto-inferred from api factory)
  */
 export function defineBackendPlugin<
 	TRoutes extends Record<string, Endpoint> = Record<string, Endpoint>,
->(plugin: BackendPlugin<TRoutes>): BackendPlugin<TRoutes> {
+	TApi extends Record<string, (...args: any[]) => any> = never,
+>(plugin: BackendPlugin<TRoutes, TApi>): BackendPlugin<TRoutes, TApi> {
 	return plugin;
 }

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

@@ -0,0 +1,540 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { defineDb } from "@btst/db";
+import type { Adapter } from "@btst/db";
+import { blogSchema } from "../db";
+import { getAllPosts, getPostBySlug, getAllTags } from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(blogSchema);
+	return createMemoryAdapter(db)({});
+};
+
+describe("blog getters", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	describe("getAllPosts", () => {
+		it("returns empty result when no posts exist", async () => {
+			const result = await getAllPosts(adapter);
+			expect(result.items).toEqual([]);
+			expect(result.total).toBe(0);
+		});
+
+		it("returns all posts with empty tags array", async () => {
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "Hello World",
+					slug: "hello-world",
+					content: "Content here",
+					excerpt: "Excerpt",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const result = await getAllPosts(adapter);
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.slug).toBe("hello-world");
+			expect(result.items[0]!.tags).toEqual([]);
+		});
+
+		it("filters posts by published status", async () => {
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "Published Post",
+					slug: "published",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "Draft Post",
+					slug: "draft",
+					content: "Content",
+					excerpt: "",
+					published: false,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const published = await getAllPosts(adapter, { published: true });
+			expect(published.items).toHaveLength(1);
+			expect(published.total).toBe(1);
+			expect(published.items[0]!.slug).toBe("published");
+
+			const drafts = await getAllPosts(adapter, { published: false });
+			expect(drafts.items).toHaveLength(1);
+			expect(drafts.total).toBe(1);
+			expect(drafts.items[0]!.slug).toBe("draft");
+		});
+
+		it("filters posts by slug", async () => {
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "Post A",
+					slug: "post-a",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "Post B",
+					slug: "post-b",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const result = await getAllPosts(adapter, { slug: "post-a" });
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.slug).toBe("post-a");
+		});
+
+		it("searches posts by query string", async () => {
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "TypeScript Tips",
+					slug: "ts-tips",
+					content: "Using generics",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "React Hooks",
+					slug: "react-hooks",
+					content: "Using hooks",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const result = await getAllPosts(adapter, { query: "typescript" });
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.slug).toBe("ts-tips");
+		});
+
+		it("respects limit and offset", async () => {
+			for (let i = 1; i <= 5; i++) {
+				await adapter.create({
+					model: "post",
+					data: {
+						title: `Post ${i}`,
+						slug: `post-${i}`,
+						content: "Content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(Date.now() + i * 1000),
+						updatedAt: new Date(),
+					},
+				});
+			}
+
+			const page1 = await getAllPosts(adapter, { limit: 2, offset: 0 });
+			expect(page1.items).toHaveLength(2);
+			expect(page1.total).toBe(5);
+
+			const page2 = await getAllPosts(adapter, { limit: 2, offset: 2 });
+			expect(page2.items).toHaveLength(2);
+			expect(page2.total).toBe(5);
+
+			// Pages should be different posts
+			expect(page1.items[0]!.slug).not.toBe(page2.items[0]!.slug);
+		});
+
+		it("attaches tags to posts", async () => {
+			const post = await adapter.create({
+				model: "post",
+				data: {
+					title: "Tagged Post",
+					slug: "tagged",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			const tag = await adapter.create({
+				model: "tag",
+				data: {
+					name: "JavaScript",
+					slug: "javascript",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "postTag",
+				data: { postId: (post as any).id, tagId: (tag as any).id },
+			});
+
+			const result = await getAllPosts(adapter);
+			expect(result.items[0]!.tags).toHaveLength(1);
+			expect(result.items[0]!.tags[0]!.slug).toBe("javascript");
+		});
+
+		it("filters posts by tagSlug and returns empty for missing tag", async () => {
+			const result = await getAllPosts(adapter, { tagSlug: "nonexistent" });
+			expect(result.items).toEqual([]);
+			expect(result.total).toBe(0);
+		});
+
+		it("filters posts by tagSlug - returns only tagged posts", async () => {
+			const taggedPost = await adapter.create({
+				model: "post",
+				data: {
+					title: "Tagged Post",
+					slug: "tagged-post",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			for (let i = 1; i <= 3; i++) {
+				await adapter.create({
+					model: "post",
+					data: {
+						title: `Untagged Post ${i}`,
+						slug: `untagged-${i}`,
+						content: "Content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(),
+						updatedAt: new Date(),
+					},
+				});
+			}
+			const tag = await adapter.create({
+				model: "tag",
+				data: {
+					name: "TypeScript",
+					slug: "typescript",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "postTag",
+				data: { postId: (taggedPost as any).id, tagId: (tag as any).id },
+			});
+
+			const result = await getAllPosts(adapter, { tagSlug: "typescript" });
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.slug).toBe("tagged-post");
+		});
+
+		it("paginates tagSlug results at the DB level - limit/offset respected", async () => {
+			// Create a tag and 5 posts tagged with it, plus 10 untagged posts.
+			// With DB-level filtering the findMany should only receive 5 rows,
+			// never loading the 10 untagged posts into memory.
+			const tag = await adapter.create({
+				model: "tag",
+				data: {
+					name: "JS",
+					slug: "js",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			for (let i = 1; i <= 5; i++) {
+				const post = await adapter.create({
+					model: "post",
+					data: {
+						title: `JS Post ${i}`,
+						slug: `js-post-${i}`,
+						content: "Content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(Date.now() + i * 1000),
+						updatedAt: new Date(),
+					},
+				});
+				await adapter.create({
+					model: "postTag",
+					data: { postId: (post as any).id, tagId: (tag as any).id },
+				});
+			}
+			for (let i = 1; i <= 10; i++) {
+				await adapter.create({
+					model: "post",
+					data: {
+						title: `Noise Post ${i}`,
+						slug: `noise-${i}`,
+						content: "Content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(),
+						updatedAt: new Date(),
+					},
+				});
+			}
+
+			const page1 = await getAllPosts(adapter, {
+				tagSlug: "js",
+				limit: 2,
+				offset: 0,
+			});
+			expect(page1.items).toHaveLength(2);
+			expect(page1.total).toBe(5);
+			expect(page1.items.every((p) => p.slug.startsWith("js-post"))).toBe(true);
+
+			const page2 = await getAllPosts(adapter, {
+				tagSlug: "js",
+				limit: 2,
+				offset: 2,
+			});
+			expect(page2.items).toHaveLength(2);
+			expect(page2.total).toBe(5);
+
+			const page3 = await getAllPosts(adapter, {
+				tagSlug: "js",
+				limit: 2,
+				offset: 4,
+			});
+			expect(page3.items).toHaveLength(1);
+			expect(page3.total).toBe(5);
+
+			// Pages must be disjoint
+			const allSlugs = [...page1.items, ...page2.items, ...page3.items].map(
+				(p) => p.slug,
+			);
+			expect(new Set(allSlugs).size).toBe(5);
+		});
+
+		it("tagSlug combined with published filter only returns published tagged posts", async () => {
+			const tag = await adapter.create({
+				model: "tag",
+				data: {
+					name: "CSS",
+					slug: "css",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			const published = await adapter.create({
+				model: "post",
+				data: {
+					title: "Published CSS Post",
+					slug: "pub-css",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			const draft = await adapter.create({
+				model: "post",
+				data: {
+					title: "Draft CSS Post",
+					slug: "draft-css",
+					content: "Content",
+					excerpt: "",
+					published: false,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "postTag",
+				data: { postId: (published as any).id, tagId: (tag as any).id },
+			});
+			await adapter.create({
+				model: "postTag",
+				data: { postId: (draft as any).id, tagId: (tag as any).id },
+			});
+
+			const result = await getAllPosts(adapter, {
+				tagSlug: "css",
+				published: true,
+			});
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.slug).toBe("pub-css");
+		});
+
+		it("returns all posts when no limit is specified (DB path - more than 10)", async () => {
+			for (let i = 1; i <= 15; i++) {
+				await adapter.create({
+					model: "post",
+					data: {
+						title: `Post ${i}`,
+						slug: `post-${i}`,
+						content: "Content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(Date.now() + i * 1000),
+						updatedAt: new Date(),
+					},
+				});
+			}
+
+			const result = await getAllPosts(adapter);
+			expect(result.items).toHaveLength(15);
+			expect(result.total).toBe(15);
+			expect(result.limit).toBeUndefined();
+		});
+
+		it("returns all matching posts when no limit is specified (in-memory query path - more than 10)", async () => {
+			for (let i = 1; i <= 15; i++) {
+				await adapter.create({
+					model: "post",
+					data: {
+						title: `TypeScript Post ${i}`,
+						slug: `ts-post-${i}`,
+						content: "TypeScript content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(Date.now() + i * 1000),
+						updatedAt: new Date(),
+					},
+				});
+			}
+
+			const result = await getAllPosts(adapter, { query: "TypeScript" });
+			expect(result.items).toHaveLength(15);
+			expect(result.total).toBe(15);
+			expect(result.limit).toBeUndefined();
+		});
+
+		it("total reflects count before pagination slice for in-memory filters", async () => {
+			for (let i = 1; i <= 4; i++) {
+				await adapter.create({
+					model: "post",
+					data: {
+						title: `TypeScript Post ${i}`,
+						slug: `ts-post-${i}`,
+						content: "TypeScript content",
+						excerpt: "",
+						published: true,
+						tags: [],
+						createdAt: new Date(Date.now() + i * 1000),
+						updatedAt: new Date(),
+					},
+				});
+			}
+
+			const result = await getAllPosts(adapter, {
+				query: "TypeScript",
+				limit: 2,
+				offset: 0,
+			});
+			expect(result.items).toHaveLength(2);
+			expect(result.total).toBe(4);
+		});
+	});
+
+	describe("getPostBySlug", () => {
+		it("returns null when post does not exist", async () => {
+			const post = await getPostBySlug(adapter, "nonexistent");
+			expect(post).toBeNull();
+		});
+
+		it("returns the post when it exists", async () => {
+			await adapter.create({
+				model: "post",
+				data: {
+					title: "My Post",
+					slug: "my-post",
+					content: "Content",
+					excerpt: "",
+					published: true,
+					tags: [],
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const post = await getPostBySlug(adapter, "my-post");
+			expect(post).not.toBeNull();
+			expect(post!.slug).toBe("my-post");
+			expect(post!.title).toBe("My Post");
+		});
+	});
+
+	describe("getAllTags", () => {
+		it("returns empty array when no tags exist", async () => {
+			const tags = await getAllTags(adapter);
+			expect(tags).toEqual([]);
+		});
+
+		it("returns all tags sorted alphabetically by name", async () => {
+			await adapter.create({
+				model: "tag",
+				data: {
+					name: "TypeScript",
+					slug: "typescript",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+			await adapter.create({
+				model: "tag",
+				data: {
+					name: "React",
+					slug: "react",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			const tags = await getAllTags(adapter);
+			expect(tags).toHaveLength(2);
+			expect(tags[0]!.name).toBe("React");
+			expect(tags[1]!.name).toBe("TypeScript");
+		});
+	});
+});