@jant/core 0.3.36 → 0.3.38

package/src/services/__tests__/collection.test.ts

@@ -1,8 +1,9 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { collections, sidebarItems } from "../../db/schema.js";
 import { createCollectionService } from "../collection.js";
+import { createPathService } from "../path.js";
 import { createPostService } from "../post.js";
-import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 
 describe("CollectionService", () => {
@@ -14,7 +15,7 @@ describe("CollectionService", () => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
     collectionService = createCollectionService(db);
-    postService = createPostService(db, createPathRegistryService(db));
+    postService = createPostService(db, { slugIdLength: 5 });
   });
 
   describe("create", () => {
@@ -24,7 +25,8 @@ describe("CollectionService", () => {
         title: "My Collection",
       });
 
-      expect(collection.id).toBe(1);
+      expect(typeof collection.id).toBe("string");
+      expect(collection.id.length).toBeGreaterThan(0);
       expect(collection.slug).toBe("my-collection");
       expect(collection.title).toBe("My Collection");
       expect(collection.description).toBeNull();
@@ -39,7 +41,6 @@ describe("CollectionService", () => {
         description: "Posts about technology",
         icon: "laptop",
         sortOrder: "oldest",
-        position: 5,
       });
 
       expect(collection.slug).toBe("tech");
@@ -47,7 +48,6 @@ describe("CollectionService", () => {
       expect(collection.description).toBe("Posts about technology");
       expect(collection.icon).toBe("laptop");
       expect(collection.sortOrder).toBe("oldest");
-      expect(collection.position).toBe(5);
     });
 
     it("sets timestamps", async () => {
@@ -60,23 +60,41 @@ describe("CollectionService", () => {
       expect(collection.updatedAt).toBeGreaterThan(0);
     });
 
-    it("auto-assigns position when not provided", async () => {
-      const first = await collectionService.create({
-        slug: "first",
-        title: "First",
-      });
-      const second = await collectionService.create({
-        slug: "second",
-        title: "Second",
+    it("auto-creates a sidebar item", async () => {
+      const collection = await collectionService.create({
+        slug: "test",
+        title: "Test",
       });
-      const third = await collectionService.create({
-        slug: "third",
-        title: "Third",
+
+      const sidebarItems = await collectionService.listSidebarItems();
+      expect(sidebarItems).toHaveLength(1);
+      expect(sidebarItems[0]?.type).toBe("collection");
+      expect(sidebarItems[0]?.collectionId).toBe(collection.id);
+      expect(typeof sidebarItems[0]?.position).toBe("string");
+    });
+
+    it("rolls back the collection insert when slug persistence fails inside the batch", async () => {
+      await collectionService.create({
+        slug: "race-condition",
+        title: "Existing",
       });
 
-      expect(first.position).toBe(0);
-      expect(second.position).toBe(1);
-      expect(third.position).toBe(2);
+      const paths = createPathService(db);
+      const raceyPaths = {
+        ...paths,
+        isPathAvailable: async () => true,
+      };
+      const raceyCollectionService = createCollectionService(db, raceyPaths);
+
+      await expect(
+        raceyCollectionService.create({
+          slug: "race-condition",
+          title: "Race Condition",
+        }),
+      ).rejects.toThrow('Slug "race-condition" is already in use');
+
+      const rows = await db.select({ id: collections.id }).from(collections);
+      expect(rows).toHaveLength(1);
     });
   });
 
@@ -94,7 +112,9 @@ describe("CollectionService", () => {
     });
 
     it("returns null for non-existent ID", async () => {
-      const found = await collectionService.getById(9999);
+      const found = await collectionService.getById(
+        "00000000-0000-0000-0000-000000009999",
+      );
       expect(found).toBeNull();
     });
   });
@@ -129,29 +149,6 @@ describe("CollectionService", () => {
       const list = await collectionService.list();
       expect(list).toHaveLength(3);
     });
-
-    it("orders by position ASC, then createdAt DESC", async () => {
-      const a = await collectionService.create({
-        slug: "a",
-        title: "A",
-        position: 2,
-      });
-      const b = await collectionService.create({
-        slug: "b",
-        title: "B",
-        position: 0,
-      });
-      const c = await collectionService.create({
-        slug: "c",
-        title: "C",
-        position: 1,
-      });
-
-      const list = await collectionService.list();
-      expect(list[0]?.id).toBe(b.id);
-      expect(list[1]?.id).toBe(c.id);
-      expect(list[2]?.id).toBe(a.id);
-    });
   });
 
   describe("update", () => {
@@ -212,7 +209,7 @@ describe("CollectionService", () => {
       expect(updated?.icon).toBeNull();
     });
 
-    it("updates icon, sortOrder, and position", async () => {
+    it("updates icon and sortOrder", async () => {
       const collection = await collectionService.create({
         slug: "test",
         title: "Test",
@@ -221,12 +218,10 @@ describe("CollectionService", () => {
       const updated = await collectionService.update(collection.id, {
         icon: "rocket",
         sortOrder: "rating_desc",
-        position: 10,
       });
 
       expect(updated?.icon).toBe("rocket");
       expect(updated?.sortOrder).toBe("rating_desc");
-      expect(updated?.position).toBe(10);
     });
 
     it("updates updatedAt timestamp", async () => {
@@ -243,7 +238,10 @@ describe("CollectionService", () => {
     });
 
     it("returns null for non-existent collection", async () => {
-      const result = await collectionService.update(9999, { title: "X" });
+      const result = await collectionService.update(
+        "00000000-0000-0000-0000-000000009999",
+        { title: "X" },
+      );
       expect(result).toBeNull();
     });
   });
@@ -269,7 +267,7 @@ describe("CollectionService", () => {
       });
       const post = await postService.create({
         format: "note",
-        body: "test post",
+        bodyMarkdown: "test post",
       });
 
       await collectionService.addPost(collection.id, post.id);
@@ -289,58 +287,213 @@ describe("CollectionService", () => {
       expect(after).toHaveLength(0);
     });
 
+    it("removes sidebar item when collection is deleted", async () => {
+      const collection = await collectionService.create({
+        slug: "test",
+        title: "Test",
+      });
+
+      // Verify sidebar item exists
+      const before = await collectionService.listSidebarItems();
+      expect(before).toHaveLength(1);
+
+      await collectionService.delete(collection.id);
+
+      // Sidebar item should be gone
+      const after = await collectionService.listSidebarItems();
+      expect(after).toHaveLength(0);
+    });
+
     it("returns false for non-existent collection", async () => {
-      const result = await collectionService.delete(9999);
+      const result = await collectionService.delete(
+        "00000000-0000-0000-0000-000000009999",
+      );
       expect(result).toBe(false);
     });
   });
 
-  describe("reorder", () => {
-    it("updates positions based on array order", async () => {
-      const a = await collectionService.create({ slug: "a", title: "A" });
-      const b = await collectionService.create({ slug: "b", title: "B" });
-      const c = await collectionService.create({ slug: "c", title: "C" });
+  describe("listSidebarItems", () => {
+    it("returns empty array when no items exist", async () => {
+      const items = await collectionService.listSidebarItems();
+      expect(items).toEqual([]);
+    });
+
+    it("returns items ordered by position", async () => {
+      await collectionService.create({ slug: "first", title: "First" });
+      await collectionService.create({ slug: "second", title: "Second" });
+
+      const items = await collectionService.listSidebarItems();
+      expect(items).toHaveLength(2);
+      expect(items[0]?.type).toBe("collection");
+      expect(items[1]?.type).toBe("collection");
+      // First created should come first (string comparison for fractional indexing)
+      const pos0 = items[0]?.position ?? "";
+      const pos1 = items[1]?.position ?? "";
+      expect(pos0 < pos1).toBe(true);
+    });
+
+    it("includes dividers", async () => {
+      await collectionService.create({ slug: "a", title: "A" });
+      await collectionService.createSidebarItem("divider");
+      await collectionService.create({ slug: "b", title: "B" });
 
-      // Reverse the order: C, B, A
-      await collectionService.reorder([c.id, b.id, a.id]);
+      const items = await collectionService.listSidebarItems();
+      expect(items).toHaveLength(3);
+      expect(items[0]?.type).toBe("collection");
+      expect(items[1]?.type).toBe("divider");
+      expect(items[2]?.type).toBe("collection");
+    });
+  });
 
-      const reorderedC = await collectionService.getById(c.id);
-      const reorderedB = await collectionService.getById(b.id);
-      const reorderedA = await collectionService.getById(a.id);
+  describe("createSidebarItem", () => {
+    it("creates a divider", async () => {
+      const item = await collectionService.createSidebarItem("divider");
 
-      expect(reorderedC?.position).toBe(0);
-      expect(reorderedB?.position).toBe(1);
-      expect(reorderedA?.position).toBe(2);
+      expect(item.type).toBe("divider");
+      expect(item.collectionId).toBeNull();
+      expect(typeof item.position).toBe("string");
+      expect(item.createdAt).toBeGreaterThan(0);
     });
 
-    it("updates updatedAt when reordering", async () => {
-      const a = await collectionService.create({ slug: "a", title: "A" });
-      const b = await collectionService.create({ slug: "b", title: "B" });
+    it("creates items with incrementing positions", async () => {
+      const first = await collectionService.createSidebarItem("divider");
+      const second = await collectionService.createSidebarItem("divider");
 
-      await collectionService.reorder([b.id, a.id]);
+      expect(first.position < second.position).toBe(true);
+    });
+
+    it("rejects adding the same collection twice", async () => {
+      const collection = await collectionService.create({
+        slug: "notes",
+        title: "Notes",
+      });
 
-      const reorderedA = await collectionService.getById(a.id);
-      expect(reorderedA?.updatedAt).toBeGreaterThanOrEqual(a.updatedAt);
+      await expect(
+        collectionService.createSidebarItem("collection", collection.id),
+      ).rejects.toThrow("Collection is already in the sidebar.");
     });
 
-    it("handles empty array", async () => {
-      await collectionService.reorder([]);
-      // Should not throw
-      const list = await collectionService.list();
-      expect(list).toEqual([]);
+    it("rejects duplicate sidebar positions at the database layer", async () => {
+      const item = await collectionService.createSidebarItem("divider");
+
+      await expect(
+        db.insert(sidebarItems).values({
+          id: "00000000-0000-7000-8000-000000000001",
+          type: "divider",
+          collectionId: null,
+          position: item.position,
+          createdAt: item.createdAt,
+          updatedAt: item.updatedAt,
+        }),
+      ).rejects.toThrow();
     });
+  });
 
-    it("reflects new order in list()", async () => {
-      const a = await collectionService.create({ slug: "a", title: "A" });
-      const b = await collectionService.create({ slug: "b", title: "B" });
-      const c = await collectionService.create({ slug: "c", title: "C" });
+  describe("deleteSidebarItem", () => {
+    it("deletes a sidebar item", async () => {
+      const item = await collectionService.createSidebarItem("divider");
+      const result = await collectionService.deleteSidebarItem(item.id);
+      expect(result).toBe(true);
 
-      await collectionService.reorder([c.id, a.id, b.id]);
+      const items = await collectionService.listSidebarItems();
+      expect(items).toHaveLength(0);
+    });
 
-      const list = await collectionService.list();
-      expect(list[0]?.id).toBe(c.id);
-      expect(list[1]?.id).toBe(a.id);
-      expect(list[2]?.id).toBe(b.id);
+    it("returns false for non-existent item", async () => {
+      const result = await collectionService.deleteSidebarItem(
+        "00000000-0000-0000-0000-000000009999",
+      );
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("moveSidebarItem", () => {
+    it("moves an item between two others", async () => {
+      const col1 = await collectionService.create({ slug: "a", title: "A" });
+      const col2 = await collectionService.create({ slug: "b", title: "B" });
+      const col3 = await collectionService.create({ slug: "c", title: "C" });
+
+      // Get sidebar items (A, B, C order)
+      const items = await collectionService.listSidebarItems();
+      expect(items).toHaveLength(3);
+      const itemA = items.find((i) => i.collectionId === col1.id);
+      const itemB = items.find((i) => i.collectionId === col2.id);
+      const itemC = items.find((i) => i.collectionId === col3.id);
+      expect(itemA).toBeDefined();
+      expect(itemB).toBeDefined();
+      expect(itemC).toBeDefined();
+
+      // Move C between A and B
+      const moved = await collectionService.moveSidebarItem(
+        itemC?.id ?? "",
+        itemA?.id ?? "",
+        itemB?.id ?? "",
+      );
+
+      expect(moved).not.toBeNull();
+
+      // Verify new order: A, C, B
+      const reordered = await collectionService.listSidebarItems();
+      expect(reordered[0]?.collectionId).toBe(col1.id);
+      expect(reordered[1]?.collectionId).toBe(col3.id);
+      expect(reordered[2]?.collectionId).toBe(col2.id);
+    });
+
+    it("moves an item to the beginning", async () => {
+      const col1 = await collectionService.create({ slug: "a", title: "A" });
+      const col2 = await collectionService.create({ slug: "b", title: "B" });
+      const col3 = await collectionService.create({ slug: "c", title: "C" });
+
+      const items = await collectionService.listSidebarItems();
+      const itemA = items.find((i) => i.collectionId === col1.id);
+      const itemC = items.find((i) => i.collectionId === col3.id);
+      expect(itemA).toBeDefined();
+      expect(itemC).toBeDefined();
+
+      // Move C to the beginning (before A, no after)
+      await collectionService.moveSidebarItem(
+        itemC?.id ?? "",
+        null,
+        itemA?.id ?? "",
+      );
+
+      const reordered = await collectionService.listSidebarItems();
+      expect(reordered[0]?.collectionId).toBe(col3.id);
+      expect(reordered[1]?.collectionId).toBe(col1.id);
+      expect(reordered[2]?.collectionId).toBe(col2.id);
+    });
+
+    it("moves an item to the end", async () => {
+      const col1 = await collectionService.create({ slug: "a", title: "A" });
+      const col2 = await collectionService.create({ slug: "b", title: "B" });
+      const col3 = await collectionService.create({ slug: "c", title: "C" });
+
+      const items = await collectionService.listSidebarItems();
+      const itemA = items.find((i) => i.collectionId === col1.id);
+      const itemC = items.find((i) => i.collectionId === col3.id);
+      expect(itemA).toBeDefined();
+      expect(itemC).toBeDefined();
+
+      // Move A to the end (after C, no before)
+      await collectionService.moveSidebarItem(
+        itemA?.id ?? "",
+        itemC?.id ?? "",
+        null,
+      );
+
+      const reordered = await collectionService.listSidebarItems();
+      expect(reordered[0]?.collectionId).toBe(col2.id);
+      expect(reordered[1]?.collectionId).toBe(col3.id);
+      expect(reordered[2]?.collectionId).toBe(col1.id);
+    });
+
+    it("returns null for non-existent item", async () => {
+      const result = await collectionService.moveSidebarItem(
+        "00000000-0000-0000-0000-000000009999",
+        null,
+        null,
+      );
+      expect(result).toBeNull();
     });
   });
 
@@ -362,9 +515,18 @@ describe("CollectionService", () => {
         title: "Col 2",
       });
 
-      const p1 = await postService.create({ format: "note", body: "post 1" });
-      const p2 = await postService.create({ format: "note", body: "post 2" });
-      const p3 = await postService.create({ format: "note", body: "post 3" });
+      const p1 = await postService.create({
+        format: "note",
+        bodyMarkdown: "post 1",
+      });
+      const p2 = await postService.create({
+        format: "note",
+        bodyMarkdown: "post 2",
+      });
+      const p3 = await postService.create({
+        format: "note",
+        bodyMarkdown: "post 3",
+      });
 
       await collectionService.addPost(col1.id, p1.id);
       await collectionService.addPost(col1.id, p2.id);
@@ -383,9 +545,12 @@ describe("CollectionService", () => {
 
       const p1 = await postService.create({
         format: "note",
-        body: "with collection",
+        bodyMarkdown: "with collection",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "no collection",
       });
-      await postService.create({ format: "note", body: "no collection" });
 
       await collectionService.addPost(col.id, p1.id);
 
@@ -402,11 +567,11 @@ describe("CollectionService", () => {
 
       const post = await postService.create({
         format: "note",
-        body: "will be deleted",
+        bodyMarkdown: "will be deleted",
       });
       const post2 = await postService.create({
         format: "note",
-        body: "still alive",
+        bodyMarkdown: "still alive",
       });
 
       await collectionService.addPost(col.id, post.id);
@@ -428,7 +593,7 @@ describe("CollectionService", () => {
       });
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       await collectionService.addPost(col.id, post.id);
@@ -447,7 +612,7 @@ describe("CollectionService", () => {
       });
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       await collectionService.addPost(col.id, post.id);
@@ -464,7 +629,7 @@ describe("CollectionService", () => {
       });
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       await collectionService.addPost(col.id, post.id);
@@ -479,37 +644,35 @@ describe("CollectionService", () => {
 
   describe("getCollectionsByPostId", () => {
     it("returns all collections a post belongs to", async () => {
-      const col1 = await collectionService.create({
+      await collectionService.create({
         slug: "col1",
         title: "Col 1",
-        position: 0,
       });
-      const col2 = await collectionService.create({
+      await collectionService.create({
         slug: "col2",
         title: "Col 2",
-        position: 1,
       });
 
+      const cols = await collectionService.list();
+      expect(cols).toHaveLength(2);
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
-      await collectionService.addPost(col1.id, post.id);
-      await collectionService.addPost(col2.id, post.id);
+      await collectionService.addPost(cols[0]?.id ?? "", post.id);
+      await collectionService.addPost(cols[1]?.id ?? "", post.id);
 
       const collections = await collectionService.getCollectionsByPostId(
         post.id,
       );
       expect(collections).toHaveLength(2);
-      expect(collections[0]?.slug).toBe("col1");
-      expect(collections[1]?.slug).toBe("col2");
     });
 
     it("returns empty array for post with no collections", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const collections = await collectionService.getCollectionsByPostId(
@@ -525,8 +688,14 @@ describe("CollectionService", () => {
         slug: "test",
         title: "Test",
       });
-      const p1 = await postService.create({ format: "note", body: "one" });
-      const p2 = await postService.create({ format: "note", body: "two" });
+      const p1 = await postService.create({
+        format: "note",
+        bodyMarkdown: "one",
+      });
+      const p2 = await postService.create({
+        format: "note",
+        bodyMarkdown: "two",
+      });
 
       await collectionService.addPost(col.id, p1.id);
       await collectionService.addPost(col.id, p2.id);
@@ -538,127 +707,6 @@ describe("CollectionService", () => {
     });
   });
 
-  describe("createDivider", () => {
-    it("creates a divider with auto-assigned position", async () => {
-      const divider = await collectionService.createDivider();
-
-      expect(divider.id).toBe(1);
-      expect(divider.position).toBe(0);
-      expect(divider.createdAt).toBeGreaterThan(0);
-      expect(divider.updatedAt).toBeGreaterThan(0);
-    });
-
-    it("assigns position after existing collections", async () => {
-      await collectionService.create({ slug: "a", title: "A" }); // position 0
-      await collectionService.create({ slug: "b", title: "B" }); // position 1
-
-      const divider = await collectionService.createDivider();
-      expect(divider.position).toBe(2);
-    });
-
-    it("assigns position after existing dividers", async () => {
-      const d1 = await collectionService.createDivider(); // position 0
-      const d2 = await collectionService.createDivider(); // position 1
-
-      expect(d1.position).toBe(0);
-      expect(d2.position).toBe(1);
-    });
-
-    it("considers both collections and dividers for position", async () => {
-      await collectionService.create({ slug: "a", title: "A" }); // position 0
-      await collectionService.createDivider(); // position 1
-      await collectionService.create({ slug: "b", title: "B" }); // position 2
-
-      const divider = await collectionService.createDivider();
-      expect(divider.position).toBe(3);
-    });
-  });
-
-  describe("deleteDivider", () => {
-    it("deletes a divider by ID", async () => {
-      const divider = await collectionService.createDivider();
-
-      const result = await collectionService.deleteDivider(divider.id);
-      expect(result).toBe(true);
-
-      const list = await collectionService.listDividers();
-      expect(list).toHaveLength(0);
-    });
-
-    it("returns false for non-existent divider", async () => {
-      const result = await collectionService.deleteDivider(9999);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("listDividers", () => {
-    it("returns empty array when no dividers exist", async () => {
-      const list = await collectionService.listDividers();
-      expect(list).toEqual([]);
-    });
-
-    it("returns dividers ordered by position", async () => {
-      const d1 = await collectionService.createDivider();
-      const d2 = await collectionService.createDivider();
-
-      const list = await collectionService.listDividers();
-      expect(list).toHaveLength(2);
-      expect(list[0]?.id).toBe(d1.id);
-      expect(list[1]?.id).toBe(d2.id);
-    });
-  });
-
-  describe("reorderAll", () => {
-    it("handles mixed prefixed IDs correctly", async () => {
-      const a = await collectionService.create({ slug: "a", title: "A" });
-      const b = await collectionService.create({ slug: "b", title: "B" });
-      const d1 = await collectionService.createDivider();
-
-      // Reorder: divider first, then B, then A
-      await collectionService.reorderAll([
-        `d-${d1.id}`,
-        `c-${b.id}`,
-        `c-${a.id}`,
-      ]);
-
-      const dividers = await collectionService.listDividers();
-      expect(dividers[0]?.position).toBe(0);
-
-      const colB = await collectionService.getById(b.id);
-      const colA = await collectionService.getById(a.id);
-      expect(colB?.position).toBe(1);
-      expect(colA?.position).toBe(2);
-    });
-
-    it("handles empty array", async () => {
-      await collectionService.reorderAll([]);
-      // Should not throw
-      const list = await collectionService.list();
-      expect(list).toEqual([]);
-    });
-
-    it("reflects new order in combined list", async () => {
-      const a = await collectionService.create({ slug: "a", title: "A" });
-      const d1 = await collectionService.createDivider();
-      const b = await collectionService.create({ slug: "b", title: "B" });
-
-      // Put divider between B and A
-      await collectionService.reorderAll([
-        `c-${b.id}`,
-        `d-${d1.id}`,
-        `c-${a.id}`,
-      ]);
-
-      const cols = await collectionService.list();
-      const divs = await collectionService.listDividers();
-
-      // B at position 0, divider at 1, A at 2
-      expect(cols.find((c) => c.id === b.id)?.position).toBe(0);
-      expect(divs[0]?.position).toBe(1);
-      expect(cols.find((c) => c.id === a.id)?.position).toBe(2);
-    });
-  });
-
   describe("syncPostCollections", () => {
     it("replaces all collection memberships for a post", async () => {
       const col1 = await collectionService.create({
@@ -676,7 +724,7 @@ describe("CollectionService", () => {
 
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       // Initially in col1 and col2
@@ -703,7 +751,7 @@ describe("CollectionService", () => {
       });
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       await collectionService.addPost(col.id, post.id);