407 lines
14 KiB
TypeScript
407 lines
14 KiB
TypeScript
import { and, desc, eq, isNull, lt } from "drizzle-orm";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { chatConversations, chatMessages } from "@paperclipai/db";
|
|
import { chatService } from "../services/chat.js";
|
|
|
|
/**
|
|
* Build a query chain mock.
|
|
* - `selectResult`: what `db.select()...limit()` resolves to (array)
|
|
* - `returningResult`: what `db.insert/update()...returning()` resolves to (array)
|
|
*/
|
|
function makeSelectChain(rows: unknown[], opts: { terminalAtWhere?: boolean } = {}) {
|
|
const chain: any = {};
|
|
const methods = ["select", "from", "orderBy"];
|
|
for (const m of methods) {
|
|
chain[m] = vi.fn(() => chain);
|
|
}
|
|
chain.limit = vi.fn(() => Promise.resolve(rows));
|
|
if (opts.terminalAtWhere) {
|
|
// getConversation: select().from().where() — no orderBy/limit
|
|
chain.where = vi.fn(() => Promise.resolve(rows));
|
|
} else {
|
|
// listConversations / listMessages: select().from().where().orderBy().limit()
|
|
chain.where = vi.fn(() => chain);
|
|
}
|
|
return chain;
|
|
}
|
|
|
|
function makeUpdateChain(rows: unknown[]) {
|
|
const chain: any = {};
|
|
chain.set = vi.fn(() => chain);
|
|
chain.where = vi.fn(() => chain);
|
|
chain.returning = vi.fn(() => Promise.resolve(rows));
|
|
return chain;
|
|
}
|
|
|
|
function makeInsertChain(rows: unknown[]) {
|
|
const chain: any = {};
|
|
chain.values = vi.fn(() => chain);
|
|
chain.returning = vi.fn(() => Promise.resolve(rows));
|
|
return chain;
|
|
}
|
|
|
|
function makeDb() {
|
|
return {
|
|
select: vi.fn(),
|
|
insert: vi.fn(),
|
|
update: vi.fn(),
|
|
delete: vi.fn(),
|
|
};
|
|
}
|
|
|
|
describe("chatService", () => {
|
|
let db: ReturnType<typeof makeDb>;
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
db = makeDb();
|
|
});
|
|
|
|
describe("createConversation", () => {
|
|
it("inserts into chatConversations and returns the created row", async () => {
|
|
const inserted = {
|
|
id: "conv-1",
|
|
companyId: "company-1",
|
|
title: "Hello",
|
|
agentId: null,
|
|
pinnedAt: null,
|
|
archivedAt: null,
|
|
deletedAt: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
};
|
|
|
|
const chain = makeInsertChain([inserted]);
|
|
db.insert.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.createConversation("company-1", { title: "Hello" });
|
|
|
|
expect(db.insert).toHaveBeenCalledWith(chatConversations);
|
|
expect(chain.values).toHaveBeenCalledWith(
|
|
expect.objectContaining({ companyId: "company-1", title: "Hello" }),
|
|
);
|
|
expect(result).toEqual(inserted);
|
|
});
|
|
|
|
it("returns the created conversation with id and timestamps", async () => {
|
|
const now = new Date();
|
|
const inserted = {
|
|
id: "conv-1",
|
|
companyId: "company-1",
|
|
title: null,
|
|
agentId: null,
|
|
pinnedAt: null,
|
|
archivedAt: null,
|
|
deletedAt: null,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
};
|
|
const chain = makeInsertChain([inserted]);
|
|
db.insert.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.createConversation("company-1", {});
|
|
|
|
expect(result.id).toBe("conv-1");
|
|
expect(result.createdAt).toBe(now);
|
|
});
|
|
});
|
|
|
|
describe("listConversations", () => {
|
|
it("returns conversations sorted by updatedAt DESC", async () => {
|
|
const rows = [
|
|
{ id: "conv-2", updatedAt: new Date("2024-01-02") },
|
|
{ id: "conv-1", updatedAt: new Date("2024-01-01") },
|
|
];
|
|
|
|
const chain = makeSelectChain(rows);
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.listConversations("company-1", {});
|
|
|
|
expect(db.select).toHaveBeenCalled();
|
|
expect(chain.orderBy).toHaveBeenCalledWith(desc(chatConversations.updatedAt));
|
|
});
|
|
|
|
it("excludes soft-deleted conversations", async () => {
|
|
const chain = makeSelectChain([]);
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.listConversations("company-1", {});
|
|
|
|
// where should be called with a combined condition that includes isNull(deletedAt)
|
|
expect(chain.where).toHaveBeenCalled();
|
|
});
|
|
|
|
it("supports cursor-based pagination with hasMore", async () => {
|
|
// Return limit+1 rows to trigger hasMore=true
|
|
const rows = Array.from({ length: 31 }, (_, i) => ({
|
|
id: `conv-${i}`,
|
|
updatedAt: new Date(2024, 0, 31 - i),
|
|
}));
|
|
|
|
const chain = makeSelectChain(rows);
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.listConversations("company-1", { limit: 30 });
|
|
|
|
expect(result.hasMore).toBe(true);
|
|
expect(result.items.length).toBe(30);
|
|
});
|
|
|
|
it("limits results to max 100", async () => {
|
|
const chain = makeSelectChain([]);
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.listConversations("company-1", { limit: 9999 });
|
|
|
|
// limit should be called with 101 (100 + 1 for hasMore detection)
|
|
expect(chain.limit).toHaveBeenCalledWith(101);
|
|
});
|
|
});
|
|
|
|
describe("getConversation", () => {
|
|
it("returns conversation by id", async () => {
|
|
const conv = { id: "conv-1", companyId: "company-1", deletedAt: null };
|
|
const chain = makeSelectChain([conv], { terminalAtWhere: true });
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.getConversation("conv-1");
|
|
|
|
expect(result).toEqual(conv);
|
|
});
|
|
|
|
it("throws notFound for non-existent conversation", async () => {
|
|
const chain = makeSelectChain([], { terminalAtWhere: true });
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await expect(svc.getConversation("no-such-id")).rejects.toMatchObject({
|
|
status: 404,
|
|
});
|
|
});
|
|
|
|
it("throws notFound for soft-deleted conversation", async () => {
|
|
// When deletedAt is set, the WHERE clause won't match — returns empty
|
|
const chain = makeSelectChain([], { terminalAtWhere: true });
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await expect(svc.getConversation("deleted-id")).rejects.toMatchObject({
|
|
status: 404,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("updateConversation", () => {
|
|
it("updates title and bumps updatedAt", async () => {
|
|
const updated = { id: "conv-1", title: "New Title", updatedAt: new Date() };
|
|
const chain = makeUpdateChain([updated]);
|
|
db.update.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.updateConversation("conv-1", { title: "New Title" });
|
|
|
|
expect(db.update).toHaveBeenCalledWith(chatConversations);
|
|
expect(chain.set).toHaveBeenCalledWith(
|
|
expect.objectContaining({ title: "New Title", updatedAt: expect.any(Date) }),
|
|
);
|
|
expect(result).toEqual(updated);
|
|
});
|
|
|
|
it("sets pinnedAt timestamp when provided as string", async () => {
|
|
const pinnedAt = "2024-06-01T00:00:00.000Z";
|
|
const updated = { id: "conv-1", pinnedAt: new Date(pinnedAt) };
|
|
const chain = makeUpdateChain([updated]);
|
|
db.update.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.updateConversation("conv-1", { pinnedAt });
|
|
|
|
expect(chain.set).toHaveBeenCalledWith(
|
|
expect.objectContaining({ pinnedAt: new Date(pinnedAt) }),
|
|
);
|
|
});
|
|
|
|
it("clears pinnedAt when set to null", async () => {
|
|
const updated = { id: "conv-1", pinnedAt: null };
|
|
const chain = makeUpdateChain([updated]);
|
|
db.update.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.updateConversation("conv-1", { pinnedAt: null });
|
|
|
|
expect(chain.set).toHaveBeenCalledWith(
|
|
expect.objectContaining({ pinnedAt: null }),
|
|
);
|
|
});
|
|
|
|
it("bumps updatedAt on every update", async () => {
|
|
const before = new Date("2024-01-01");
|
|
const updated = { id: "conv-1", updatedAt: new Date() };
|
|
const chain = makeUpdateChain([updated]);
|
|
db.update.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.updateConversation("conv-1", { title: "x" });
|
|
|
|
const setCall = chain.set.mock.calls[0][0];
|
|
expect(setCall.updatedAt).toBeInstanceOf(Date);
|
|
expect(setCall.updatedAt.getTime()).toBeGreaterThan(before.getTime());
|
|
});
|
|
});
|
|
|
|
describe("softDeleteConversation", () => {
|
|
it("sets deletedAt and returns the updated row", async () => {
|
|
const deleted = { id: "conv-1", deletedAt: new Date() };
|
|
const chain = makeUpdateChain([deleted]);
|
|
db.update.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.softDeleteConversation("conv-1");
|
|
|
|
expect(db.update).toHaveBeenCalledWith(chatConversations);
|
|
expect(chain.set).toHaveBeenCalledWith(
|
|
expect.objectContaining({ deletedAt: expect.any(Date) }),
|
|
);
|
|
expect(result).toEqual(deleted);
|
|
});
|
|
|
|
it("throws notFound if conversation is already deleted (no row returned)", async () => {
|
|
const chain = makeUpdateChain([]);
|
|
db.update.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await expect(svc.softDeleteConversation("gone-id")).rejects.toMatchObject({
|
|
status: 404,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("addMessage", () => {
|
|
it("inserts a message row with conversationId and role", async () => {
|
|
const message = { id: "msg-1", conversationId: "conv-1", role: "user", content: "Hi" };
|
|
const insertChain = makeInsertChain([message]);
|
|
const updateChain = makeUpdateChain([]);
|
|
|
|
db.insert.mockReturnValue(insertChain);
|
|
db.update.mockReturnValue(updateChain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.addMessage("conv-1", { role: "user", content: "Hi" });
|
|
|
|
expect(db.insert).toHaveBeenCalledWith(chatMessages);
|
|
expect(insertChain.values).toHaveBeenCalledWith(
|
|
expect.objectContaining({ conversationId: "conv-1", role: "user", content: "Hi" }),
|
|
);
|
|
expect(result).toEqual({ ...message, files: [] });
|
|
});
|
|
|
|
it("bumps conversation updatedAt after insert (Pitfall 3)", async () => {
|
|
const message = { id: "msg-1", conversationId: "conv-1", role: "user", content: "Hi" };
|
|
const insertChain = makeInsertChain([message]);
|
|
const updateChain = makeUpdateChain([]);
|
|
|
|
db.insert.mockReturnValue(insertChain);
|
|
db.update.mockReturnValue(updateChain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.addMessage("conv-1", { role: "user", content: "Hi" });
|
|
|
|
expect(db.update).toHaveBeenCalledWith(chatConversations);
|
|
});
|
|
|
|
it("auto-sets title from first user message when title is null (Pitfall 5)", async () => {
|
|
const content = "This is a long message that should be truncated to 60 chars when used as title";
|
|
const message = { id: "msg-1", conversationId: "conv-1", role: "user", content };
|
|
const insertChain = makeInsertChain([message]);
|
|
const updateChain = makeUpdateChain([]);
|
|
|
|
db.insert.mockReturnValue(insertChain);
|
|
db.update.mockReturnValue(updateChain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.addMessage("conv-1", { role: "user", content });
|
|
|
|
// Should be called twice: once for updatedAt bump, once for title auto-set
|
|
expect(db.update).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("does not auto-set title for assistant/system messages", async () => {
|
|
const content = "Response from assistant";
|
|
const message = { id: "msg-1", conversationId: "conv-1", role: "assistant", content };
|
|
const insertChain = makeInsertChain([message]);
|
|
const updateChain = makeUpdateChain([]);
|
|
|
|
db.insert.mockReturnValue(insertChain);
|
|
db.update.mockReturnValue(updateChain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.addMessage("conv-1", { role: "assistant", content });
|
|
|
|
// Only one update: updatedAt bump (no auto-title for non-user messages)
|
|
expect(db.update).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|
|
|
|
describe("listMessages", () => {
|
|
it("returns messages for conversation sorted by createdAt DESC", async () => {
|
|
const rows = [
|
|
{ id: "msg-2", createdAt: new Date("2024-01-02") },
|
|
{ id: "msg-1", createdAt: new Date("2024-01-01") },
|
|
];
|
|
|
|
const chain = makeSelectChain(rows);
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
await svc.listMessages("conv-1", {});
|
|
|
|
expect(db.select).toHaveBeenCalled();
|
|
expect(chain.orderBy).toHaveBeenCalledWith(desc(chatMessages.createdAt));
|
|
});
|
|
|
|
it("supports cursor-based pagination", async () => {
|
|
const rows = Array.from({ length: 51 }, (_, i) => ({
|
|
id: `msg-${i}`,
|
|
createdAt: new Date(2024, 0, 51 - i),
|
|
}));
|
|
|
|
const chain = makeSelectChain(rows);
|
|
db.select.mockReturnValue(chain);
|
|
|
|
const svc = chatService(db as any);
|
|
const result = await svc.listMessages("conv-1", { limit: 50 });
|
|
|
|
expect(result.hasMore).toBe(true);
|
|
expect(result.items.length).toBe(50);
|
|
});
|
|
});
|
|
|
|
describe("searchMessages", () => {
|
|
it.todo("returns ranked results for matching term");
|
|
it.todo("returns empty for no match");
|
|
it.todo("respects companyId scope");
|
|
});
|
|
|
|
describe("toggleBookmark", () => {
|
|
it.todo("creates bookmark when not exists");
|
|
it.todo("removes bookmark when exists");
|
|
});
|
|
|
|
describe("branchConversation", () => {
|
|
it.todo("creates child conversation with copied messages");
|
|
it.todo("throws not found for invalid message id");
|
|
});
|
|
|
|
describe("exportConversation", () => {
|
|
it.todo("exports as markdown with agent names");
|
|
it.todo("exports as JSON with all messages");
|
|
});
|
|
});
|