ruflo 3.10.36 → 3.10.37

package/src/ruvocal/src/lib/utils/tree/addChildren.spec.ts

@@ -1,102 +1,102 @@
-import { collections } from "$lib/server/database";
-import { ObjectId } from "mongodb";
-import { describe, expect, it } from "vitest";
-
-import { insertLegacyConversation, insertSideBranchesConversation } from "./treeHelpers.spec";
-import { addChildren } from "./addChildren";
-import type { Message } from "$lib/types/Message";
-
-const newMessage: Omit<Message, "id"> = {
-	content: "new message",
-	from: "user",
-};
-
-Object.freeze(newMessage);
-
-describe("addChildren", async () => {
-	it("should let you append on legacy conversations", async () => {
-		const convId = await insertLegacyConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		const convLength = conv.messages.length;
-
-		addChildren(conv, newMessage, conv.messages[conv.messages.length - 1].id);
-		expect(conv.messages.length).toEqual(convLength + 1);
-	});
-	it("should not let you create branches on legacy conversations", async () => {
-		const convId = await insertLegacyConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		expect(() => addChildren(conv, newMessage, conv.messages[0].id)).toThrow();
-	});
-	it("should not let you create a message that already exists", async () => {
-		const convId = await insertLegacyConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		const messageThatAlreadyExists: Message = {
-			id: conv.messages[0].id,
-			content: "new message",
-			from: "user",
-		};
-
-		expect(() => addChildren(conv, messageThatAlreadyExists, conv.messages[0].id)).toThrow();
-	});
-	it("should let you create branches on conversations with subtrees", async () => {
-		const convId = await insertSideBranchesConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		const nChildren = conv.messages[0].children?.length;
-		if (!nChildren) throw new Error("No children found");
-		addChildren(conv, newMessage, conv.messages[0].id);
-		expect(conv.messages[0].children?.length).toEqual(nChildren + 1);
-	});
-
-	it("should let you create a new leaf", async () => {
-		const convId = await insertSideBranchesConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		const parentId = conv.messages[conv.messages.length - 1].id;
-		const nChildren = conv.messages[conv.messages.length - 1].children?.length;
-
-		if (nChildren === undefined) throw new Error("No children found");
-		expect(nChildren).toEqual(0);
-
-		addChildren(conv, newMessage, parentId);
-		expect(conv.messages[conv.messages.length - 2].children?.length).toEqual(nChildren + 1);
-	});
-
-	it("should let you append to an empty conversation without specifying a parentId", async () => {
-		const conv = {
-			_id: new ObjectId(),
-			rootMessageId: undefined,
-			messages: [] as Message[],
-		};
-
-		addChildren(conv, newMessage);
-		expect(conv.messages.length).toEqual(1);
-		expect(conv.rootMessageId).toEqual(conv.messages[0].id);
-	});
-
-	it("should throw if you don't specify a parentId in a conversation with messages", async () => {
-		const convId = await insertLegacyConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		expect(() => addChildren(conv, newMessage)).toThrow();
-	});
-
-	it("should return the id of the new message", async () => {
-		const convId = await insertLegacyConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		expect(addChildren(conv, newMessage, conv.messages[conv.messages.length - 1].id)).toEqual(
-			conv.messages[conv.messages.length - 1].id
-		);
-	});
-});
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+import { insertLegacyConversation, insertSideBranchesConversation } from "./treeHelpers.spec";
+import { addChildren } from "./addChildren";
+import type { Message } from "$lib/types/Message";
+
+const newMessage: Omit<Message, "id"> = {
+	content: "new message",
+	from: "user",
+};
+
+Object.freeze(newMessage);
+
+describe("addChildren", async () => {
+	it("should let you append on legacy conversations", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const convLength = conv.messages.length;
+
+		addChildren(conv, newMessage, conv.messages[conv.messages.length - 1].id);
+		expect(conv.messages.length).toEqual(convLength + 1);
+	});
+	it("should not let you create branches on legacy conversations", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addChildren(conv, newMessage, conv.messages[0].id)).toThrow();
+	});
+	it("should not let you create a message that already exists", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const messageThatAlreadyExists: Message = {
+			id: conv.messages[0].id,
+			content: "new message",
+			from: "user",
+		};
+
+		expect(() => addChildren(conv, messageThatAlreadyExists, conv.messages[0].id)).toThrow();
+	});
+	it("should let you create branches on conversations with subtrees", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const nChildren = conv.messages[0].children?.length;
+		if (!nChildren) throw new Error("No children found");
+		addChildren(conv, newMessage, conv.messages[0].id);
+		expect(conv.messages[0].children?.length).toEqual(nChildren + 1);
+	});
+
+	it("should let you create a new leaf", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const parentId = conv.messages[conv.messages.length - 1].id;
+		const nChildren = conv.messages[conv.messages.length - 1].children?.length;
+
+		if (nChildren === undefined) throw new Error("No children found");
+		expect(nChildren).toEqual(0);
+
+		addChildren(conv, newMessage, parentId);
+		expect(conv.messages[conv.messages.length - 2].children?.length).toEqual(nChildren + 1);
+	});
+
+	it("should let you append to an empty conversation without specifying a parentId", async () => {
+		const conv = {
+			_id: new ObjectId(),
+			rootMessageId: undefined,
+			messages: [] as Message[],
+		};
+
+		addChildren(conv, newMessage);
+		expect(conv.messages.length).toEqual(1);
+		expect(conv.rootMessageId).toEqual(conv.messages[0].id);
+	});
+
+	it("should throw if you don't specify a parentId in a conversation with messages", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addChildren(conv, newMessage)).toThrow();
+	});
+
+	it("should return the id of the new message", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(addChildren(conv, newMessage, conv.messages[conv.messages.length - 1].id)).toEqual(
+			conv.messages[conv.messages.length - 1].id
+		);
+	});
+});

package/src/ruvocal/src/lib/utils/tree/addChildren.ts

@@ -1,48 +1,48 @@
-import { v4 } from "uuid";
-import type { Tree, TreeId, NewNode, TreeNode } from "./tree";
-
-export function addChildren<T>(conv: Tree<T>, message: NewNode<T>, parentId?: TreeId): TreeId {
-	// if this is the first message we just push it
-	if (conv.messages.length === 0) {
-		const messageId = v4();
-		conv.rootMessageId = messageId;
-		conv.messages.push({
-			...message,
-			ancestors: [],
-			id: messageId,
-		} as TreeNode<T>);
-		return messageId;
-	}
-
-	if (!parentId) {
-		throw new Error("You need to specify a parentId if this is not the first message");
-	}
-
-	const messageId = v4();
-	if (!conv.rootMessageId) {
-		// if there is no parentId we just push the message
-		if (!!parentId && parentId !== conv.messages[conv.messages.length - 1].id) {
-			throw new Error("This is a legacy conversation, you can only append to the last message");
-		}
-		conv.messages.push({ ...message, id: messageId } as TreeNode<T>);
-		return messageId;
-	}
-
-	const ancestors = [...(conv.messages.find((m) => m.id === parentId)?.ancestors ?? []), parentId];
-	conv.messages.push({
-		...message,
-		ancestors,
-		id: messageId,
-		children: [],
-	} as TreeNode<T>);
-
-	const parent = conv.messages.find((m) => m.id === parentId);
-
-	if (parent) {
-		if (parent.children) {
-			parent.children.push(messageId);
-		} else parent.children = [messageId];
-	}
-
-	return messageId;
-}
+import { v4 } from "uuid";
+import type { Tree, TreeId, NewNode, TreeNode } from "./tree";
+
+export function addChildren<T>(conv: Tree<T>, message: NewNode<T>, parentId?: TreeId): TreeId {
+	// if this is the first message we just push it
+	if (conv.messages.length === 0) {
+		const messageId = v4();
+		conv.rootMessageId = messageId;
+		conv.messages.push({
+			...message,
+			ancestors: [],
+			id: messageId,
+		} as TreeNode<T>);
+		return messageId;
+	}
+
+	if (!parentId) {
+		throw new Error("You need to specify a parentId if this is not the first message");
+	}
+
+	const messageId = v4();
+	if (!conv.rootMessageId) {
+		// if there is no parentId we just push the message
+		if (!!parentId && parentId !== conv.messages[conv.messages.length - 1].id) {
+			throw new Error("This is a legacy conversation, you can only append to the last message");
+		}
+		conv.messages.push({ ...message, id: messageId } as TreeNode<T>);
+		return messageId;
+	}
+
+	const ancestors = [...(conv.messages.find((m) => m.id === parentId)?.ancestors ?? []), parentId];
+	conv.messages.push({
+		...message,
+		ancestors,
+		id: messageId,
+		children: [],
+	} as TreeNode<T>);
+
+	const parent = conv.messages.find((m) => m.id === parentId);
+
+	if (parent) {
+		if (parent.children) {
+			parent.children.push(messageId);
+		} else parent.children = [messageId];
+	}
+
+	return messageId;
+}

package/src/ruvocal/src/lib/utils/tree/addSibling.spec.ts

@@ -1,81 +1,81 @@
-import { collections } from "$lib/server/database";
-import { ObjectId } from "mongodb";
-import { describe, expect, it } from "vitest";
-
-import { insertLegacyConversation, insertSideBranchesConversation } from "./treeHelpers.spec";
-import type { Message } from "$lib/types/Message";
-import { addSibling } from "./addSibling";
-import type { Conversation } from "$lib/types/Conversation";
-
-const newMessage = {
-	content: "new message",
-	from: "user" as const,
-};
-
-Object.freeze(newMessage);
-
-describe("addSibling", async () => {
-	it("should fail on empty conversations", () => {
-		const conv = {
-			_id: new ObjectId(),
-			rootMessageId: undefined,
-			messages: [] as Message[],
-		} satisfies Pick<Conversation, "_id" | "rootMessageId" | "messages">;
-
-		expect(() => addSibling(conv, newMessage, "not-a-real-id-test")).toThrow(
-			"Cannot add a sibling to an empty conversation"
-		);
-	});
-
-	it("should fail on legacy conversations", async () => {
-		const convId = await insertLegacyConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		expect(() => addSibling(conv, newMessage, conv.messages[0].id)).toThrow(
-			"Cannot add a sibling to a legacy conversation"
-		);
-	});
-
-	it("should fail if the sibling message doesn't exist", async () => {
-		const convId = await insertSideBranchesConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		expect(() => addSibling(conv, newMessage, "not-a-real-id-test")).toThrow(
-			"The sibling message doesn't exist"
-		);
-	});
-
-	// TODO: This behaviour should be fixed, we do not need to fail on the root message.
-	it("should fail if the sibling message is the root message", async () => {
-		const convId = await insertSideBranchesConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-		if (!conv.rootMessageId) throw new Error("Root message not found");
-
-		expect(() => addSibling(conv, newMessage, conv.rootMessageId as Message["id"])).toThrow(
-			"The sibling message is the root message, therefore we can't add a sibling"
-		);
-	});
-
-	it("should add a sibling to a message", async () => {
-		const convId = await insertSideBranchesConversation();
-		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
-		if (!conv) throw new Error("Conversation not found");
-
-		// add sibling and check children count for parnets
-
-		const nChildren = conv.messages[1].children?.length;
-		const siblingId = addSibling(conv, newMessage, conv.messages[2].id);
-		const nChildrenNew = conv.messages[1].children?.length;
-
-		if (!nChildren) throw new Error("No children found");
-
-		expect(nChildrenNew).toBe(nChildren + 1);
-
-		// make sure siblings have the same ancestors
-		const sibling = conv.messages.find((m) => m.id === siblingId);
-		expect(sibling?.ancestors).toEqual(conv.messages[2].ancestors);
-	});
-});
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+import { insertLegacyConversation, insertSideBranchesConversation } from "./treeHelpers.spec";
+import type { Message } from "$lib/types/Message";
+import { addSibling } from "./addSibling";
+import type { Conversation } from "$lib/types/Conversation";
+
+const newMessage = {
+	content: "new message",
+	from: "user" as const,
+};
+
+Object.freeze(newMessage);
+
+describe("addSibling", async () => {
+	it("should fail on empty conversations", () => {
+		const conv = {
+			_id: new ObjectId(),
+			rootMessageId: undefined,
+			messages: [] as Message[],
+		} satisfies Pick<Conversation, "_id" | "rootMessageId" | "messages">;
+
+		expect(() => addSibling(conv, newMessage, "not-a-real-id-test")).toThrow(
+			"Cannot add a sibling to an empty conversation"
+		);
+	});
+
+	it("should fail on legacy conversations", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addSibling(conv, newMessage, conv.messages[0].id)).toThrow(
+			"Cannot add a sibling to a legacy conversation"
+		);
+	});
+
+	it("should fail if the sibling message doesn't exist", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addSibling(conv, newMessage, "not-a-real-id-test")).toThrow(
+			"The sibling message doesn't exist"
+		);
+	});
+
+	// TODO: This behaviour should be fixed, we do not need to fail on the root message.
+	it("should fail if the sibling message is the root message", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+		if (!conv.rootMessageId) throw new Error("Root message not found");
+
+		expect(() => addSibling(conv, newMessage, conv.rootMessageId as Message["id"])).toThrow(
+			"The sibling message is the root message, therefore we can't add a sibling"
+		);
+	});
+
+	it("should add a sibling to a message", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		// add sibling and check children count for parnets
+
+		const nChildren = conv.messages[1].children?.length;
+		const siblingId = addSibling(conv, newMessage, conv.messages[2].id);
+		const nChildrenNew = conv.messages[1].children?.length;
+
+		if (!nChildren) throw new Error("No children found");
+
+		expect(nChildrenNew).toBe(nChildren + 1);
+
+		// make sure siblings have the same ancestors
+		const sibling = conv.messages.find((m) => m.id === siblingId);
+		expect(sibling?.ancestors).toEqual(conv.messages[2].ancestors);
+	});
+});

package/src/ruvocal/src/lib/utils/tree/addSibling.ts

@@ -1,41 +1,41 @@
-import { v4 } from "uuid";
-import type { Tree, TreeId, NewNode, TreeNode } from "./tree";
-
-export function addSibling<T>(conv: Tree<T>, message: NewNode<T>, siblingId: TreeId): TreeId {
-	if (conv.messages.length === 0) {
-		throw new Error("Cannot add a sibling to an empty conversation");
-	}
-	if (!conv.rootMessageId) {
-		throw new Error("Cannot add a sibling to a legacy conversation");
-	}
-
-	const sibling = conv.messages.find((m) => m.id === siblingId);
-
-	if (!sibling) {
-		throw new Error("The sibling message doesn't exist");
-	}
-
-	if (!sibling.ancestors || sibling.ancestors?.length === 0) {
-		throw new Error("The sibling message is the root message, therefore we can't add a sibling");
-	}
-
-	const messageId = v4();
-
-	conv.messages.push({
-		...message,
-		id: messageId,
-		ancestors: sibling.ancestors,
-		children: [],
-	} as TreeNode<T>);
-
-	const nearestAncestorId = sibling.ancestors[sibling.ancestors.length - 1];
-	const nearestAncestor = conv.messages.find((m) => m.id === nearestAncestorId);
-
-	if (nearestAncestor) {
-		if (nearestAncestor.children) {
-			nearestAncestor.children.push(messageId);
-		} else nearestAncestor.children = [messageId];
-	}
-
-	return messageId;
-}
+import { v4 } from "uuid";
+import type { Tree, TreeId, NewNode, TreeNode } from "./tree";
+
+export function addSibling<T>(conv: Tree<T>, message: NewNode<T>, siblingId: TreeId): TreeId {
+	if (conv.messages.length === 0) {
+		throw new Error("Cannot add a sibling to an empty conversation");
+	}
+	if (!conv.rootMessageId) {
+		throw new Error("Cannot add a sibling to a legacy conversation");
+	}
+
+	const sibling = conv.messages.find((m) => m.id === siblingId);
+
+	if (!sibling) {
+		throw new Error("The sibling message doesn't exist");
+	}
+
+	if (!sibling.ancestors || sibling.ancestors?.length === 0) {
+		throw new Error("The sibling message is the root message, therefore we can't add a sibling");
+	}
+
+	const messageId = v4();
+
+	conv.messages.push({
+		...message,
+		id: messageId,
+		ancestors: sibling.ancestors,
+		children: [],
+	} as TreeNode<T>);
+
+	const nearestAncestorId = sibling.ancestors[sibling.ancestors.length - 1];
+	const nearestAncestor = conv.messages.find((m) => m.id === nearestAncestorId);
+
+	if (nearestAncestor) {
+		if (nearestAncestor.children) {
+			nearestAncestor.children.push(messageId);
+		} else nearestAncestor.children = [messageId];
+	}
+
+	return messageId;
+}