@jant/core 0.3.35 → 0.3.37

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

@@ -1,20 +1,16 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createNavItemService } from "../navigation.js";
-import { createPageService } from "../page.js";
-import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 
 describe("NavItemService", () => {
   let db: Database;
   let navItemService: ReturnType<typeof createNavItemService>;
-  let pageService: ReturnType<typeof createPageService>;
 
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
     navItemService = createNavItemService(db);
-    pageService = createPageService(db, createPathRegistryService(db));
   });
 
   describe("create", () => {
@@ -28,29 +24,13 @@ describe("NavItemService", () => {
       expect(item.type).toBe("link");
       expect(item.label).toBe("Home");
       expect(item.url).toBe("/");
-      expect(item.pageId).toBeNull();
-      expect(item.position).toBe(0);
-      expect(item.id).toBe(1);
-    });
-
-    it("creates a page-type nav item with pageId", async () => {
-      const page = await pageService.create({ slug: "about", title: "About" });
-
-      const item = await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: page.id,
-      });
-
-      expect(item.type).toBe("page");
-      expect(item.label).toBe("About");
-      expect(item.url).toBe("/about");
-      expect(item.pageId).toBe(page.id);
+      expect(typeof item.position).toBe("string");
+      expect(typeof item.id).toBe("string");
+      expect(item.id.length).toBeGreaterThan(0);
     });
 
     it("auto-increments position for subsequent items", async () => {
-      await navItemService.create({
+      const first = await navItemService.create({
         type: "link",
         label: "Home",
         url: "/",
@@ -61,7 +41,7 @@ describe("NavItemService", () => {
         url: "/archive",
       });
 
-      expect(second.position).toBe(1);
+      expect(second.position > first.position).toBe(true);
     });
 
     it("uses provided position when specified", async () => {
@@ -69,10 +49,28 @@ describe("NavItemService", () => {
         type: "link",
         label: "Home",
         url: "/",
-        position: 5,
+        position: "z99",
+      });
+
+      expect(item.position).toBe("z99");
+    });
+
+    it("rejects duplicate provided positions", async () => {
+      await navItemService.create({
+        type: "link",
+        label: "Home",
+        url: "/",
+        position: "m0",
       });
 
-      expect(item.position).toBe(5);
+      await expect(
+        navItemService.create({
+          type: "link",
+          label: "Archive",
+          url: "/archive",
+          position: "m0",
+        }),
+      ).rejects.toThrow();
     });
 
     it("sets createdAt and updatedAt timestamps", async () => {
@@ -103,7 +101,9 @@ describe("NavItemService", () => {
     });
 
     it("returns null for non-existent ID", async () => {
-      const found = await navItemService.getById(9999);
+      const found = await navItemService.getById(
+        "00000000-0000-0000-0000-000000009999",
+      );
       expect(found).toBeNull();
     });
   });
@@ -119,19 +119,19 @@ describe("NavItemService", () => {
         type: "link",
         label: "C",
         url: "/c",
-        position: 2,
+        position: "c0",
       });
       await navItemService.create({
         type: "link",
         label: "A",
         url: "/a",
-        position: 0,
+        position: "a0",
       });
       await navItemService.create({
-        type: "page",
+        type: "link",
         label: "B",
         url: "/b",
-        position: 1,
+        position: "b0",
       });
 
       const items = await navItemService.list();
@@ -142,25 +142,21 @@ describe("NavItemService", () => {
     });
 
     it("returns items with correct types", async () => {
-      const page = await pageService.create({ slug: "about", title: "About" });
-
       await navItemService.create({
         type: "link",
         label: "External",
         url: "https://example.com",
       });
       await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: page.id,
+        type: "system",
+        label: "Settings",
+        url: "/settings",
       });
 
       const items = await navItemService.list();
       expect(items).toHaveLength(2);
       expect(items[0]?.type).toBe("link");
-      expect(items[1]?.type).toBe("page");
-      expect(items[1]?.pageId).toBe(page.id);
+      expect(items[1]?.type).toBe("system");
     });
   });
 
@@ -196,24 +192,6 @@ describe("NavItemService", () => {
       expect(updated?.label).toBe("Blog");
     });
 
-    it("updates a nav item's type", async () => {
-      const page = await pageService.create({ slug: "about", title: "About" });
-
-      const created = await navItemService.create({
-        type: "link",
-        label: "About",
-        url: "/about",
-      });
-
-      const updated = await navItemService.update(created.id, {
-        type: "page",
-        pageId: page.id,
-      });
-
-      expect(updated?.type).toBe("page");
-      expect(updated?.pageId).toBe(page.id);
-    });
-
     it("updates updatedAt timestamp", async () => {
       const created = await navItemService.create({
         type: "link",
@@ -229,7 +207,10 @@ describe("NavItemService", () => {
     });
 
     it("returns null for non-existent ID", async () => {
-      const result = await navItemService.update(9999, { label: "Nope" });
+      const result = await navItemService.update(
+        "00000000-0000-0000-0000-000000009999",
+        { label: "Nope" },
+      );
       expect(result).toBeNull();
     });
   });
@@ -250,13 +231,15 @@ describe("NavItemService", () => {
     });
 
     it("returns false for non-existent ID", async () => {
-      const result = await navItemService.delete(9999);
+      const result = await navItemService.delete(
+        "00000000-0000-0000-0000-000000009999",
+      );
       expect(result).toBe(false);
     });
   });
 
-  describe("reorder", () => {
-    it("updates positions to match array order", async () => {
+  describe("move", () => {
+    it("moves an item between two others", async () => {
       const a = await navItemService.create({
         type: "link",
         label: "A",
@@ -273,16 +256,74 @@ describe("NavItemService", () => {
         url: "/c",
       });
 
-      // Reverse the order
-      await navItemService.reorder([c.id, b.id, a.id]);
+      // Move C between A and B
+      await navItemService.move(c.id, a.id, b.id);
+
+      const items = await navItemService.list();
+      expect(items[0]?.label).toBe("A");
+      expect(items[1]?.label).toBe("C");
+      expect(items[2]?.label).toBe("B");
+    });
+
+    it("moves an item to the beginning", async () => {
+      const a = await navItemService.create({
+        type: "link",
+        label: "A",
+        url: "/a",
+      });
+      await navItemService.create({
+        type: "link",
+        label: "B",
+        url: "/b",
+      });
+      const c = await navItemService.create({
+        type: "link",
+        label: "C",
+        url: "/c",
+      });
+
+      // Move C before A
+      await navItemService.move(c.id, null, a.id);
 
       const items = await navItemService.list();
       expect(items[0]?.label).toBe("C");
-      expect(items[0]?.position).toBe(0);
-      expect(items[1]?.label).toBe("B");
-      expect(items[1]?.position).toBe(1);
+      expect(items[1]?.label).toBe("A");
+      expect(items[2]?.label).toBe("B");
+    });
+
+    it("moves an item to the end", async () => {
+      const a = await navItemService.create({
+        type: "link",
+        label: "A",
+        url: "/a",
+      });
+      await navItemService.create({
+        type: "link",
+        label: "B",
+        url: "/b",
+      });
+      const c = await navItemService.create({
+        type: "link",
+        label: "C",
+        url: "/c",
+      });
+
+      // Move A after C
+      await navItemService.move(a.id, c.id, null);
+
+      const items = await navItemService.list();
+      expect(items[0]?.label).toBe("B");
+      expect(items[1]?.label).toBe("C");
       expect(items[2]?.label).toBe("A");
-      expect(items[2]?.position).toBe(2);
+    });
+
+    it("returns null for non-existent item", async () => {
+      const result = await navItemService.move(
+        "00000000-0000-0000-0000-000000009999",
+        null,
+        null,
+      );
+      expect(result).toBeNull();
     });
   });
 });

package/src/services/__tests__/post-timeline.test.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createPostService } from "../post.js";
-import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 
 describe("PostService - Timeline features", () => {
@@ -11,20 +10,20 @@ describe("PostService - Timeline features", () => {
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    postService = createPostService(db, createPathRegistryService(db));
+    postService = createPostService(db, { slugIdLength: 5 });
   });
 
   describe("format filter", () => {
     it("filters by format", async () => {
-      await postService.create({ format: "note", body: "a note" });
+      await postService.create({ format: "note", bodyMarkdown: "a note" });
       await postService.create({
         format: "link",
-        body: "a link",
+        bodyMarkdown: "a link",
         url: "https://example.com",
       });
       await postService.create({
         format: "quote",
-        body: "a quote",
+        bodyMarkdown: "a quote",
         quoteText: "something wise",
       });
 
@@ -36,17 +35,17 @@ describe("PostService - Timeline features", () => {
     it("combines format and status filters", async () => {
       await postService.create({
         format: "note",
-        body: "published note",
+        bodyMarkdown: "published note",
         status: "published",
       });
       await postService.create({
         format: "note",
-        body: "draft note",
+        bodyMarkdown: "draft note",
         status: "draft",
       });
       await postService.create({
         format: "link",
-        body: "published link",
+        bodyMarkdown: "published link",
         status: "published",
         url: "https://example.com",
       });
@@ -70,16 +69,16 @@ describe("PostService - Timeline features", () => {
     it("returns preview replies for a thread root", async () => {
       const root = await postService.create({
         format: "note",
-        body: "root",
+        bodyMarkdown: "root",
       });
       await postService.create({
         format: "note",
-        body: "reply 1",
+        bodyMarkdown: "reply 1",
         replyToId: root.id,
       });
       await postService.create({
         format: "note",
-        body: "reply 2",
+        bodyMarkdown: "reply 2",
         replyToId: root.id,
       });
 
@@ -87,19 +86,19 @@ describe("PostService - Timeline features", () => {
       const replies = previews.get(root.id);
       expect(replies).toBeDefined();
       expect(replies).toHaveLength(2);
-      expect(replies?.[0]?.body).toBe("reply 1");
-      expect(replies?.[1]?.body).toBe("reply 2");
+      expect(replies?.[0]?.bodyText).toBe("reply 1");
+      expect(replies?.[1]?.bodyText).toBe("reply 2");
     });
 
     it("limits preview replies to previewCount", async () => {
       const root = await postService.create({
         format: "note",
-        body: "root",
+        bodyMarkdown: "root",
       });
       for (let i = 0; i < 5; i++) {
         await postService.create({
           format: "note",
-          body: `reply ${i}`,
+          bodyMarkdown: `reply ${i}`,
           replyToId: root.id,
         });
       }
@@ -107,19 +106,19 @@ describe("PostService - Timeline features", () => {
       const previews = await postService.getThreadPreviews([root.id], 2);
       const replies = previews.get(root.id);
       expect(replies).toHaveLength(2);
-      expect(replies?.[0]?.body).toBe("reply 0");
-      expect(replies?.[1]?.body).toBe("reply 1");
+      expect(replies?.[0]?.bodyText).toBe("reply 0");
+      expect(replies?.[1]?.bodyText).toBe("reply 1");
     });
 
     it("defaults to 3 preview replies", async () => {
       const root = await postService.create({
         format: "note",
-        body: "root",
+        bodyMarkdown: "root",
       });
       for (let i = 0; i < 5; i++) {
         await postService.create({
           format: "note",
-          body: `reply ${i}`,
+          bodyMarkdown: `reply ${i}`,
           replyToId: root.id,
         });
       }
@@ -132,20 +131,20 @@ describe("PostService - Timeline features", () => {
     it("handles multiple thread roots", async () => {
       const root1 = await postService.create({
         format: "note",
-        body: "root 1",
+        bodyMarkdown: "root 1",
       });
       const root2 = await postService.create({
         format: "note",
-        body: "root 2",
+        bodyMarkdown: "root 2",
       });
       await postService.create({
         format: "note",
-        body: "reply to root 1",
+        bodyMarkdown: "reply to root 1",
         replyToId: root1.id,
       });
       await postService.create({
         format: "note",
-        body: "reply to root 2",
+        bodyMarkdown: "reply to root 2",
         replyToId: root2.id,
       });
 
@@ -161,16 +160,16 @@ describe("PostService - Timeline features", () => {
     it("excludes deleted replies", async () => {
       const root = await postService.create({
         format: "note",
-        body: "root",
+        bodyMarkdown: "root",
       });
       const reply1 = await postService.create({
         format: "note",
-        body: "reply 1",
+        bodyMarkdown: "reply 1",
         replyToId: root.id,
       });
       await postService.create({
         format: "note",
-        body: "reply 2",
+        bodyMarkdown: "reply 2",
         replyToId: root.id,
       });
 
@@ -179,13 +178,36 @@ describe("PostService - Timeline features", () => {
       const previews = await postService.getThreadPreviews([root.id]);
       const replies = previews.get(root.id);
       expect(replies).toHaveLength(1);
-      expect(replies?.[0]?.body).toBe("reply 2");
+      expect(replies?.[0]?.bodyText).toBe("reply 2");
+    });
+
+    it("excludes draft replies", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "published reply",
+        replyToId: root.id,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "draft reply",
+        replyToId: root.id,
+        status: "draft",
+      });
+
+      const previews = await postService.getThreadPreviews([root.id]);
+      const replies = previews.get(root.id);
+      expect(replies).toHaveLength(1);
+      expect(replies?.[0]?.bodyText).toBe("published reply");
     });
 
     it("returns empty for roots with no replies", async () => {
       const root = await postService.create({
         format: "note",
-        body: "root with no replies",
+        bodyMarkdown: "root with no replies",
       });
 
       const previews = await postService.getThreadPreviews([root.id]);
@@ -193,22 +215,173 @@ describe("PostService - Timeline features", () => {
     });
   });
 
+  describe("getThreadTimelineContext", () => {
+    it("returns empty map for empty input", async () => {
+      const result = await postService.getThreadTimelineContext([]);
+      expect(result.size).toBe(0);
+    });
+
+    it("returns latestReply with no parentReply for a 2-post thread", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const reply = await postService.create({
+        format: "note",
+        bodyMarkdown: "only reply",
+        replyToId: root.id,
+      });
+
+      const result = await postService.getThreadTimelineContext([root.id]);
+      const ctx = result.get(root.id);
+      expect(ctx).toBeDefined();
+      expect(ctx?.latestReply.id).toBe(reply.id);
+      expect(ctx?.parentReply).toBeNull();
+      expect(ctx?.totalReplyCount).toBe(1);
+    });
+
+    it("returns latestReply + parentReply for a 3-post thread", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const reply1 = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply 1",
+        replyToId: root.id,
+      });
+      const reply2 = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply 2",
+        replyToId: reply1.id,
+      });
+
+      const result = await postService.getThreadTimelineContext([root.id]);
+      const ctx = result.get(root.id);
+      expect(ctx).toBeDefined();
+      expect(ctx?.latestReply.id).toBe(reply2.id);
+      expect(ctx?.parentReply?.id).toBe(reply1.id);
+      expect(ctx?.totalReplyCount).toBe(2);
+    });
+
+    it("returns correct totalReplyCount for 4+ post thread", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      let prev = root;
+      for (let i = 0; i < 5; i++) {
+        prev = await postService.create({
+          format: "note",
+          bodyMarkdown: `reply ${i}`,
+          replyToId: prev.id,
+        });
+      }
+
+      const result = await postService.getThreadTimelineContext([root.id]);
+      const ctx = result.get(root.id);
+      expect(ctx).toBeDefined();
+      expect(ctx?.latestReply.bodyText).toBe("reply 4");
+      expect(ctx?.parentReply?.bodyText).toBe("reply 3");
+      expect(ctx?.totalReplyCount).toBe(5);
+    });
+
+    it("excludes deleted replies", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const reply1 = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply 1",
+        replyToId: root.id,
+      });
+      const reply2 = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply 2",
+        replyToId: reply1.id,
+      });
+
+      // Delete the latest reply — reply1 should become the latest
+      await postService.delete(reply2.id);
+
+      const result = await postService.getThreadTimelineContext([root.id]);
+      const ctx = result.get(root.id);
+      expect(ctx).toBeDefined();
+      expect(ctx?.latestReply.id).toBe(reply1.id);
+      expect(ctx?.totalReplyCount).toBe(1);
+    });
+
+    it("excludes draft replies from thread context", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const publishedReply = await postService.create({
+        format: "note",
+        bodyMarkdown: "published reply",
+        replyToId: root.id,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "draft reply",
+        replyToId: root.id,
+        status: "draft",
+      });
+
+      const result = await postService.getThreadTimelineContext([root.id]);
+      const ctx = result.get(root.id);
+      expect(ctx).toBeDefined();
+      expect(ctx?.latestReply.id).toBe(publishedReply.id);
+      expect(ctx?.totalReplyCount).toBe(1);
+    });
+
+    it("handles multiple roots in batch", async () => {
+      const root1 = await postService.create({
+        format: "note",
+        bodyMarkdown: "root 1",
+      });
+      const root2 = await postService.create({
+        format: "note",
+        bodyMarkdown: "root 2",
+      });
+      const r1Reply = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply to root 1",
+        replyToId: root1.id,
+      });
+      const r2Reply = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply to root 2",
+        replyToId: root2.id,
+      });
+
+      const result = await postService.getThreadTimelineContext([
+        root1.id,
+        root2.id,
+      ]);
+      expect(result.size).toBe(2);
+      expect(result.get(root1.id)?.latestReply.id).toBe(r1Reply.id);
+      expect(result.get(root2.id)?.latestReply.id).toBe(r2Reply.id);
+    });
+  });
+
   describe("timeline assembly", () => {
     it("fetches published non-reply posts for the timeline", async () => {
       const root = await postService.create({
         format: "note",
-        body: "a published note",
+        bodyMarkdown: "a published note",
         status: "published",
       });
       await postService.create({
         format: "note",
-        body: "a reply",
+        bodyMarkdown: "a reply",
         status: "published",
         replyToId: root.id,
       });
       await postService.create({
         format: "note",
-        body: "a draft",
+        bodyMarkdown: "a draft",
         status: "draft",
       });
 
@@ -219,7 +392,7 @@ describe("PostService - Timeline features", () => {
       });
 
       expect(posts).toHaveLength(1);
-      expect(posts[0]?.body).toBe("a published note");
+      expect(posts[0]?.bodyText).toBe("a published note");
     });
   });
 });