ruflo 3.5.2 → 3.5.3

package/src/ruvocal/src/lib/server/api/__tests__/conversations.spec.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it, afterEach } from "vitest";
+import superjson from "superjson";
+import { collections } from "$lib/server/database";
+import { CONV_NUM_PER_PAGE } from "$lib/constants/pagination";
+import {
+	createTestLocals,
+	createTestUser,
+	createTestConversation,
+	cleanupTestData,
+} from "./testHelpers";
+
+import { GET, DELETE } from "../../../../routes/api/v2/conversations/+server";
+
+async function parseResponse<T = unknown>(res: Response): Promise<T> {
+	return superjson.parse(await res.text()) as T;
+}
+
+function mockUrl(params?: Record<string, string>): URL {
+	const url = new URL("http://localhost:5173/api/v2/conversations");
+	if (params) {
+		for (const [key, value] of Object.entries(params)) {
+			url.searchParams.set(key, value);
+		}
+	}
+	return url;
+}
+
+describe.sequential("GET /api/v2/conversations", () => {
+	afterEach(async () => {
+		await cleanupTestData();
+	});
+
+	it("returns conversations for authenticated user", { timeout: 30000 }, async () => {
+		const { locals } = await createTestUser();
+		const conv = await createTestConversation(locals, { title: "My Chat" });
+
+		const res = await GET({
+			locals,
+			url: mockUrl(),
+		} as never);
+
+		expect(res.status).toBe(200);
+		const data = await parseResponse<{
+			conversations: Array<{ title: string; _id: { toString(): string } }>;
+			hasMore: boolean;
+		}>(res);
+		expect(data.conversations).toHaveLength(1);
+		expect(data.conversations[0].title).toBe("My Chat");
+		expect(data.conversations[0]._id.toString()).toBe(conv._id.toString());
+		expect(data.hasMore).toBe(false);
+	});
+
+	it("returns empty array for user with no conversations", async () => {
+		const { locals } = await createTestUser();
+
+		const res = await GET({
+			locals,
+			url: mockUrl(),
+		} as never);
+
+		expect(res.status).toBe(200);
+		const data = await parseResponse<{ conversations: unknown[]; hasMore: boolean }>(res);
+		expect(data.conversations).toHaveLength(0);
+		expect(data.hasMore).toBe(false);
+	});
+
+	it("supports pagination with p=0 and p=1", async () => {
+		const { locals } = await createTestUser();
+
+		// Create CONV_NUM_PER_PAGE + 5 conversations with distinct updatedAt values
+		for (let i = 0; i < CONV_NUM_PER_PAGE + 5; i++) {
+			await createTestConversation(locals, {
+				title: `Conv ${i}`,
+				updatedAt: new Date(Date.now() - (CONV_NUM_PER_PAGE + 5 - i) * 1000),
+			});
+		}
+
+		const resPage0 = await GET({
+			locals,
+			url: mockUrl({ p: "0" }),
+		} as never);
+
+		const dataPage0 = await parseResponse<{
+			conversations: Array<{ title: string }>;
+			hasMore: boolean;
+		}>(resPage0);
+		expect(dataPage0.conversations).toHaveLength(CONV_NUM_PER_PAGE);
+		expect(dataPage0.hasMore).toBe(true);
+
+		const resPage1 = await GET({
+			locals,
+			url: mockUrl({ p: "1" }),
+		} as never);
+
+		const dataPage1 = await parseResponse<{
+			conversations: Array<{ title: string }>;
+			hasMore: boolean;
+		}>(resPage1);
+		expect(dataPage1.conversations).toHaveLength(5);
+		expect(dataPage1.hasMore).toBe(false);
+	});
+
+	it("returns hasMore=true when more than CONV_NUM_PER_PAGE exist", async () => {
+		const { locals } = await createTestUser();
+
+		for (let i = 0; i < CONV_NUM_PER_PAGE + 1; i++) {
+			await createTestConversation(locals, {
+				title: `Conv ${i}`,
+				updatedAt: new Date(Date.now() - i * 1000),
+			});
+		}
+
+		const res = await GET({
+			locals,
+			url: mockUrl(),
+		} as never);
+
+		const data = await parseResponse<{ conversations: unknown[]; hasMore: boolean }>(res);
+		expect(data.conversations).toHaveLength(CONV_NUM_PER_PAGE);
+		expect(data.hasMore).toBe(true);
+	});
+
+	it("sorts by updatedAt descending", async () => {
+		const { locals } = await createTestUser();
+
+		await createTestConversation(locals, {
+			title: "Oldest",
+			updatedAt: new Date("2024-01-01"),
+		});
+		await createTestConversation(locals, {
+			title: "Newest",
+			updatedAt: new Date("2024-06-01"),
+		});
+		await createTestConversation(locals, {
+			title: "Middle",
+			updatedAt: new Date("2024-03-01"),
+		});
+
+		const res = await GET({
+			locals,
+			url: mockUrl(),
+		} as never);
+
+		const data = await parseResponse<{ conversations: Array<{ title: string }> }>(res);
+		expect(data.conversations[0].title).toBe("Newest");
+		expect(data.conversations[1].title).toBe("Middle");
+		expect(data.conversations[2].title).toBe("Oldest");
+	});
+
+	it("throws 401 for unauthenticated request", async () => {
+		const locals = createTestLocals({ sessionId: undefined, user: undefined });
+
+		try {
+			await GET({
+				locals,
+				url: mockUrl(),
+			} as never);
+			expect.fail("Should have thrown");
+		} catch (e: unknown) {
+			expect((e as { status: number }).status).toBe(401);
+		}
+	});
+
+	it("does not return other users' conversations", async () => {
+		const { locals: localsA } = await createTestUser();
+		const { locals: localsB } = await createTestUser();
+
+		await createTestConversation(localsA, { title: "User A Chat" });
+		await createTestConversation(localsB, { title: "User B Chat" });
+
+		const res = await GET({
+			locals: localsA,
+			url: mockUrl(),
+		} as never);
+
+		const data = await parseResponse<{ conversations: Array<{ title: string }> }>(res);
+		expect(data.conversations).toHaveLength(1);
+		expect(data.conversations[0].title).toBe("User A Chat");
+	});
+});
+
+describe.sequential("DELETE /api/v2/conversations", () => {
+	afterEach(async () => {
+		await cleanupTestData();
+	});
+
+	it("removes all conversations for authenticated user", async () => {
+		const { locals } = await createTestUser();
+
+		await createTestConversation(locals, { title: "Chat 1" });
+		await createTestConversation(locals, { title: "Chat 2" });
+		await createTestConversation(locals, { title: "Chat 3" });
+
+		const res = await DELETE({ locals } as never);
+		expect(res.status).toBe(200);
+
+		const data = await parseResponse<number>(res);
+		expect(data).toBe(3);
+
+		const remaining = await collections.conversations.countDocuments();
+		expect(remaining).toBe(0);
+	});
+
+	it("throws 401 for unauthenticated request", async () => {
+		const locals = createTestLocals({ sessionId: undefined, user: undefined });
+
+		try {
+			await DELETE({ locals } as never);
+			expect.fail("Should have thrown");
+		} catch (e: unknown) {
+			expect((e as { status: number }).status).toBe(401);
+		}
+	});
+
+	it("does not remove other users' conversations", async () => {
+		const { locals: localsA } = await createTestUser();
+		const { locals: localsB } = await createTestUser();
+
+		await createTestConversation(localsA, { title: "User A Chat" });
+		await createTestConversation(localsB, { title: "User B Chat" });
+
+		const res = await DELETE({ locals: localsA } as never);
+		const data = await parseResponse<number>(res);
+		expect(data).toBe(1);
+
+		const remaining = await collections.conversations.countDocuments();
+		expect(remaining).toBe(1);
+
+		const userBConvs = await collections.conversations
+			.find({ userId: localsB.user?._id })
+			.toArray();
+		expect(userBConvs).toHaveLength(1);
+		expect(userBConvs[0].title).toBe("User B Chat");
+	});
+});

package/src/ruvocal/src/lib/server/api/__tests__/misc.spec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import superjson from "superjson";
+import { createTestLocals, createTestUser, cleanupTestData } from "./testHelpers";
+import { GET as featureFlagsGET } from "../../../../routes/api/v2/feature-flags/+server";
+import { GET as publicConfigGET } from "../../../../routes/api/v2/public-config/+server";
+import type { FeatureFlags } from "$lib/server/api/types";
+
+async function parseResponse<T = unknown>(res: Response): Promise<T> {
+	return superjson.parse(await res.text()) as T;
+}
+
+function mockRequestEvent(locals: App.Locals) {
+	return {
+		locals,
+		url: new URL("http://localhost"),
+		request: new Request("http://localhost"),
+	} as Parameters<typeof featureFlagsGET>[0];
+}
+
+describe("GET /api/v2/feature-flags", () => {
+	beforeEach(async () => {
+		await cleanupTestData();
+	}, 20000);
+
+	it("returns correct shape with expected fields", async () => {
+		const locals = createTestLocals();
+
+		const res = await featureFlagsGET(mockRequestEvent(locals));
+		const data = await parseResponse<FeatureFlags>(res);
+
+		expect(data).toHaveProperty("enableAssistants");
+		expect(data).toHaveProperty("loginEnabled");
+		expect(data).toHaveProperty("isAdmin");
+		expect(data).toHaveProperty("transcriptionEnabled");
+		expect(typeof data.enableAssistants).toBe("boolean");
+		expect(typeof data.loginEnabled).toBe("boolean");
+		expect(typeof data.isAdmin).toBe("boolean");
+		expect(typeof data.transcriptionEnabled).toBe("boolean");
+	});
+
+	it("reflects isAdmin from locals for non-admin user", async () => {
+		const locals = createTestLocals({ isAdmin: false });
+
+		const res = await featureFlagsGET(mockRequestEvent(locals));
+		const data = await parseResponse<FeatureFlags>(res);
+
+		expect(data.isAdmin).toBe(false);
+	});
+
+	it("reflects isAdmin from locals for admin user", async () => {
+		const { locals } = await createTestUser();
+		locals.isAdmin = true;
+
+		const res = await featureFlagsGET(mockRequestEvent(locals));
+		const data = await parseResponse<FeatureFlags>(res);
+
+		expect(data.isAdmin).toBe(true);
+	});
+});
+
+describe("GET /api/v2/public-config", () => {
+	it("returns an object", async () => {
+		const locals = createTestLocals();
+
+		const res = await publicConfigGET(mockRequestEvent(locals));
+		const data = await parseResponse<Record<string, unknown>>(res);
+
+		expect(data).toBeDefined();
+		expect(typeof data).toBe("object");
+		expect(data).not.toBeNull();
+	});
+});

package/src/ruvocal/src/lib/server/api/__tests__/testHelpers.ts

@@ -0,0 +1,86 @@
+import { ObjectId } from "mongodb";
+import { collections } from "$lib/server/database";
+import type { User } from "$lib/types/User";
+import type { Session } from "$lib/types/Session";
+import type { Conversation } from "$lib/types/Conversation";
+
+export function createTestLocals(overrides?: Partial<App.Locals>): App.Locals {
+	return {
+		sessionId: "test-session-id",
+		isAdmin: false,
+		user: undefined,
+		token: undefined,
+		...overrides,
+	};
+}
+
+export async function createTestUser(): Promise<{
+	user: User;
+	session: Session;
+	locals: App.Locals;
+}> {
+	const userId = new ObjectId();
+	const sessionId = `test-session-${userId.toString()}`;
+
+	const user: User = {
+		_id: userId,
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		username: `user-${userId.toString().slice(0, 8)}`,
+		name: "Test User",
+		avatarUrl: "https://example.com/avatar.png",
+		hfUserId: `hf-${userId.toString()}`,
+	};
+
+	const session: Session = {
+		_id: new ObjectId(),
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		userId,
+		sessionId,
+		expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24),
+	};
+
+	await collections.users.insertOne(user);
+	await collections.sessions.insertOne(session);
+
+	return {
+		user,
+		session,
+		locals: {
+			user,
+			sessionId,
+			isAdmin: false,
+			token: undefined,
+		},
+	};
+}
+
+export async function createTestConversation(
+	locals: App.Locals,
+	overrides?: Partial<Conversation>
+): Promise<Conversation> {
+	const conv: Conversation = {
+		_id: new ObjectId(),
+		title: "Test Conversation",
+		model: "test-model",
+		messages: [],
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		...(locals.user ? { userId: locals.user._id } : { sessionId: locals.sessionId }),
+		...overrides,
+	};
+
+	await collections.conversations.insertOne(conv);
+	return conv;
+}
+
+export async function cleanupTestData() {
+	await collections.conversations.deleteMany({});
+	await collections.abortedGenerations.deleteMany({});
+	await collections.users.deleteMany({});
+	await collections.sessions.deleteMany({});
+	await collections.settings.deleteMany({});
+	await collections.sharedConversations.deleteMany({});
+	await collections.reports.deleteMany({});
+}

package/src/ruvocal/src/lib/server/api/__tests__/user-reports.spec.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { ObjectId } from "mongodb";
+import superjson from "superjson";
+import { collections } from "$lib/server/database";
+import { createTestLocals, createTestUser, cleanupTestData } from "./testHelpers";
+import { GET } from "../../../../routes/api/v2/user/reports/+server";
+import type { Report } from "$lib/types/Report";
+
+async function parseResponse<T = unknown>(res: Response): Promise<T> {
+	return superjson.parse(await res.text()) as T;
+}
+
+function mockRequestEvent(locals: App.Locals) {
+	return {
+		locals,
+		url: new URL("http://localhost"),
+		request: new Request("http://localhost"),
+	} as Parameters<typeof GET>[0];
+}
+
+describe("GET /api/v2/user/reports", () => {
+	beforeEach(async () => {
+		await cleanupTestData();
+	}, 20000);
+
+	it("returns empty array for unauthenticated user", async () => {
+		const locals = createTestLocals();
+
+		const res = await GET(mockRequestEvent(locals));
+		const data = await parseResponse<unknown[]>(res);
+
+		expect(data).toEqual([]);
+	});
+
+	it("returns reports for authenticated user", async () => {
+		const { user, locals } = await createTestUser();
+
+		const report1: Report = {
+			_id: new ObjectId(),
+			createdBy: user._id,
+			object: "assistant",
+			contentId: new ObjectId(),
+			reason: "Inappropriate content",
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+
+		const report2: Report = {
+			_id: new ObjectId(),
+			createdBy: user._id,
+			object: "tool",
+			contentId: new ObjectId(),
+			reason: "Broken tool",
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+
+		await collections.reports.insertMany([report1, report2]);
+
+		const res = await GET(mockRequestEvent(locals));
+		const data = await parseResponse<Report[]>(res);
+
+		expect(data).toHaveLength(2);
+		expect(data[0]._id.toString()).toBe(report1._id.toString());
+		expect(data[1]._id.toString()).toBe(report2._id.toString());
+		expect(data[0].reason).toBe("Inappropriate content");
+		expect(data[1].reason).toBe("Broken tool");
+	});
+
+	it("returns empty array when authenticated user has no reports", async () => {
+		const { locals } = await createTestUser();
+
+		const res = await GET(mockRequestEvent(locals));
+		const data = await parseResponse<unknown[]>(res);
+
+		expect(data).toEqual([]);
+	});
+});

package/src/ruvocal/src/lib/server/api/__tests__/user.spec.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import superjson from "superjson";
+import { collections } from "$lib/server/database";
+import { createTestLocals, createTestUser, cleanupTestData } from "./testHelpers";
+import { GET as userGET } from "../../../../routes/api/v2/user/+server";
+import {
+	GET as settingsGET,
+	POST as settingsPOST,
+} from "../../../../routes/api/v2/user/settings/+server";
+
+async function parseResponse<T = unknown>(res: Response): Promise<T> {
+	return superjson.parse(await res.text()) as T;
+}
+
+function mockRequestEvent(locals: App.Locals, overrides?: Record<string, unknown>) {
+	return {
+		locals,
+		url: new URL("http://localhost"),
+		request: new Request("http://localhost"),
+		...overrides,
+	} as Parameters<typeof userGET>[0];
+}
+
+describe("GET /api/v2/user", () => {
+	beforeEach(async () => {
+		await cleanupTestData();
+	}, 20000);
+
+	it("returns user info for authenticated user", async () => {
+		const { user, locals } = await createTestUser();
+
+		const res = await userGET(mockRequestEvent(locals));
+		const data = await parseResponse<Record<string, unknown>>(res);
+
+		expect(data).not.toBeNull();
+		expect(data).toMatchObject({
+			id: user._id.toString(),
+			username: user.username,
+			avatarUrl: user.avatarUrl,
+			isAdmin: false,
+			isEarlyAccess: false,
+		});
+	});
+
+	it("returns null for unauthenticated user", async () => {
+		const locals = createTestLocals();
+
+		const res = await userGET(mockRequestEvent(locals));
+		const data = await parseResponse(res);
+
+		expect(data).toBeNull();
+	});
+});
+
+describe("GET /api/v2/user/settings", () => {
+	beforeEach(async () => {
+		await cleanupTestData();
+	}, 20000);
+
+	it("returns default settings when none exist", async () => {
+		const { locals } = await createTestUser();
+
+		const res = await settingsGET(mockRequestEvent(locals));
+		const data = await parseResponse<Record<string, unknown>>(res);
+
+		expect(data).toMatchObject({
+			welcomeModalSeen: false,
+			welcomeModalSeenAt: null,
+			streamingMode: "smooth",
+			directPaste: false,
+			shareConversationsWithModelAuthors: true,
+			customPrompts: {},
+			multimodalOverrides: {},
+			toolsOverrides: {},
+			providerOverrides: {},
+		});
+	});
+
+	it("returns stored settings with canonical streaming mode", async () => {
+		const { user, locals } = await createTestUser();
+
+		await collections.settings.insertOne({
+			userId: user._id,
+			shareConversationsWithModelAuthors: false,
+			activeModel: "custom-model",
+			streamingMode: "raw",
+			directPaste: true,
+			hapticsEnabled: true,
+			customPrompts: { "my-model": "Be helpful" },
+			multimodalOverrides: {},
+			toolsOverrides: {},
+			hidePromptExamples: {},
+			providerOverrides: {},
+			welcomeModalSeenAt: new Date("2024-01-01"),
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		});
+
+		const res = await settingsGET(mockRequestEvent(locals));
+		const data = await parseResponse<Record<string, unknown>>(res);
+
+		expect(data).toMatchObject({
+			welcomeModalSeen: true,
+			shareConversationsWithModelAuthors: false,
+			streamingMode: "raw",
+			directPaste: true,
+			customPrompts: { "my-model": "Be helpful" },
+		});
+	});
+
+	it("maps legacy stored streamingMode=final to smooth", async () => {
+		const { user, locals } = await createTestUser();
+
+		const legacySettingsWithFinal = {
+			userId: user._id,
+			shareConversationsWithModelAuthors: true,
+			activeModel: "custom-model",
+			streamingMode: "final",
+			directPaste: false,
+			customPrompts: {},
+			multimodalOverrides: {},
+			toolsOverrides: {},
+			hidePromptExamples: {},
+			providerOverrides: {},
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+
+		await collections.settings.insertOne(
+			legacySettingsWithFinal as unknown as Parameters<typeof collections.settings.insertOne>[0]
+		);
+
+		const res = await settingsGET(mockRequestEvent(locals));
+		const data = await parseResponse<Record<string, unknown>>(res);
+
+		expect(data).toMatchObject({
+			streamingMode: "smooth",
+		});
+	});
+});
+
+describe("POST /api/v2/user/settings", () => {
+	beforeEach(async () => {
+		await cleanupTestData();
+	}, 20000);
+
+	it("creates settings with upsert", async () => {
+		const { user, locals } = await createTestUser();
+
+		const body = {
+			shareConversationsWithModelAuthors: false,
+			activeModel: "test-model",
+			customPrompts: {},
+			multimodalOverrides: {},
+			toolsOverrides: {},
+			providerOverrides: {},
+			streamingMode: "raw",
+			directPaste: false,
+			hidePromptExamples: {},
+		};
+
+		const res = await settingsPOST(
+			mockRequestEvent(locals, {
+				request: new Request("http://localhost", {
+					method: "POST",
+					body: JSON.stringify(body),
+					headers: { "Content-Type": "application/json" },
+				}),
+			})
+		);
+
+		expect(res.status).toBe(200);
+
+		const stored = await collections.settings.findOne({ userId: user._id });
+		expect(stored).not.toBeNull();
+		expect(stored?.shareConversationsWithModelAuthors).toBe(false);
+		expect(stored?.streamingMode).toBe("raw");
+		expect(stored?.createdAt).toBeInstanceOf(Date);
+		expect(stored?.updatedAt).toBeInstanceOf(Date);
+	});
+
+	it("sets welcomeModalSeenAt when welcomeModalSeen is true", async () => {
+		const { user, locals } = await createTestUser();
+
+		const body = {
+			welcomeModalSeen: true,
+			shareConversationsWithModelAuthors: true,
+			activeModel: "test-model",
+			customPrompts: {},
+			multimodalOverrides: {},
+			toolsOverrides: {},
+			providerOverrides: {},
+			streamingMode: "smooth",
+			directPaste: false,
+			hidePromptExamples: {},
+		};
+
+		await settingsPOST(
+			mockRequestEvent(locals, {
+				request: new Request("http://localhost", {
+					method: "POST",
+					body: JSON.stringify(body),
+					headers: { "Content-Type": "application/json" },
+				}),
+			})
+		);
+
+		const stored = await collections.settings.findOne({ userId: user._id });
+		expect(stored).not.toBeNull();
+		expect(stored?.welcomeModalSeenAt).toBeInstanceOf(Date);
+	});
+
+	it("validates body with Zod and applies defaults for missing fields", async () => {
+		const { user, locals } = await createTestUser();
+
+		// POST with minimal body — Zod defaults should fill in the rest
+		const body = {};
+
+		const res = await settingsPOST(
+			mockRequestEvent(locals, {
+				request: new Request("http://localhost", {
+					method: "POST",
+					body: JSON.stringify(body),
+					headers: { "Content-Type": "application/json" },
+				}),
+			})
+		);
+
+		expect(res.status).toBe(200);
+
+		const stored = await collections.settings.findOne({ userId: user._id });
+		expect(stored).not.toBeNull();
+		// Zod defaults should be applied
+		expect(stored?.shareConversationsWithModelAuthors).toBe(true);
+		expect(stored?.streamingMode).toBe("smooth");
+		expect(stored?.directPaste).toBe(false);
+		expect(stored?.customPrompts).toEqual({});
+	});
+});