@jant/core 0.6.14 → 0.6.15

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

@@ -11,6 +11,8 @@ const TEST_COLLECTION_ID = "col_test00000000000000000000001";
 const TEST_COLLECTION_ID_2 = "col_test00000000000000000000002";
 const TEST_POST_ID = "pst_test00000000000000000000001";
 const TEST_POST_ID_2 = "pst_test00000000000000000000002";
+const TEST_POST_ID_3 = "pst_test00000000000000000000003";
+const TEST_POST_ID_4 = "pst_test00000000000000000000004";
 
 function insertTestPath(
   sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
@@ -76,6 +78,7 @@ function insertTestPost(
     id: string;
     slug: string;
     title: string | null;
+    format?: "note" | "link" | "quote";
     status?: "draft" | "published";
     visibility?: "public" | "latest_hidden" | "private";
   },
@@ -87,11 +90,12 @@ function insertTestPost(
         id, site_id, format, status, visibility, title, thread_id,
         published_at, last_activity_at, created_at, updated_at
       )
-       VALUES (?, ?, 'note', ?, ?, ?, ?, ?, ?, ?, ?)`,
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     )
     .run(
       input.id,
       DEFAULT_TEST_SITE_ID,
+      input.format ?? "note",
       input.status ?? "published",
       input.visibility ?? "latest_hidden",
       input.title,
@@ -232,15 +236,71 @@ describe("NavItemService", () => {
         }),
       ).rejects.toThrow("Built-in navigation item already exists");
     });
+
+    it("creates a page nav item from an eligible titled note", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about-me",
+        title: "About me",
+      });
+
+      const item = await navItemService.create({
+        type: "page",
+        postId: TEST_POST_ID,
+      });
+
+      expect(item).toMatchObject({
+        type: "page",
+        postId: TEST_POST_ID,
+        label: "About me",
+        url: "/about-me",
+        placement: "header",
+      });
+    });
+
+    it("rejects duplicate and ineligible page nav items", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "private-page",
+        title: "Private page",
+        visibility: "private",
+      });
+      await navItemService.create({ type: "page", postId: TEST_POST_ID });
+
+      await expect(
+        navItemService.create({ type: "page", postId: TEST_POST_ID }),
+      ).rejects.toThrow("Page already added to navigation");
+      await expect(
+        navItemService.create({ type: "page", postId: TEST_POST_ID_2 }),
+      ).rejects.toThrow("Page must be a published, non-private titled note");
+    });
+
+    it("truncates a page's default navigation label", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "long-title",
+        title: "A".repeat(150),
+      });
+
+      const item = await navItemService.create({
+        type: "page",
+        postId: TEST_POST_ID,
+      });
+
+      expect(item.label).toBe("A".repeat(100));
+    });
   });
 
-  describe("ensureSystemDefaults", () => {
-    it("creates the six default system items once", async () => {
-      const created = await navItemService.ensureSystemDefaults();
+  describe("materializeDefaultNavigation", () => {
+    it("creates the five-item default profile without Latest", async () => {
+      const created = await navItemService.materializeDefaultNavigation();
 
-      expect(created).toHaveLength(6);
       expect(created.map((item) => item.systemKey)).toEqual([
-        "latest",
         "featured",
         "collections",
         "archive",
@@ -251,39 +311,86 @@ describe("NavItemService", () => {
         "header",
         "header",
         "header",
-        "header",
         "more",
         "more",
       ]);
+      expect(created.map((item) => item.systemKey)).not.toContain("latest");
     });
 
-    it("creates only missing default system items", async () => {
-      await navItemService.create({
+    it("preserves an existing optional Latest item", async () => {
+      const latest = await navItemService.create({
         type: "system",
-        systemKey: "archive",
+        systemKey: "latest",
+      });
+      const customizedLatest = await navItemService.update(latest.id, {
+        label: "Recent writing",
+        placement: "more",
+        position: "a3",
       });
 
-      const created = await navItemService.ensureSystemDefaults();
+      const created = await navItemService.materializeDefaultNavigation();
       const items = await navItemService.list();
 
       expect(created.map((item) => item.systemKey)).toEqual([
-        "latest",
         "featured",
         "collections",
+        "archive",
         "rss",
         "settings",
       ]);
+      expect(items.find((item) => item.id === latest.id)).toEqual(
+        customizedLatest,
+      );
       expect(items.filter((item) => item.type === "system")).toHaveLength(6);
     });
 
-    it("is idempotent when defaults already exist", async () => {
-      await navItemService.ensureSystemDefaults();
+    it("only appends missing profile items during recovery", async () => {
+      const archive = await navItemService.create({
+        type: "system",
+        systemKey: "archive",
+      });
+      const customizedArchive = await navItemService.update(archive.id, {
+        label: "All posts",
+        placement: "more",
+        position: "a2",
+      });
+      const customLink = await navItemService.create({
+        type: "link",
+        label: "Elsewhere",
+        url: "https://example.com",
+        position: "a3",
+      });
+
+      const created = await navItemService.materializeDefaultNavigation();
+      const items = await navItemService.list();
+
+      expect(created.map((item) => item.systemKey)).toEqual([
+        "featured",
+        "collections",
+        "rss",
+        "settings",
+      ]);
+      expect(items.slice(0, 2).map((item) => item.id)).toEqual([
+        archive.id,
+        customLink.id,
+      ]);
+      expect(items.find((item) => item.id === archive.id)).toEqual(
+        customizedArchive,
+      );
+      expect(items.find((item) => item.id === customLink.id)).toEqual(
+        customLink,
+      );
+      expect(items.map((item) => item.systemKey)).not.toContain("latest");
+    });
+
+    it("is idempotent when the current profile already exists", async () => {
+      await navItemService.materializeDefaultNavigation();
 
-      const created = await navItemService.ensureSystemDefaults();
+      const created = await navItemService.materializeDefaultNavigation();
       const items = await navItemService.list();
 
       expect(created).toEqual([]);
-      expect(items.filter((item) => item.type === "system")).toHaveLength(6);
+      expect(items.filter((item) => item.type === "system")).toHaveLength(5);
     });
   });
 
@@ -361,8 +468,53 @@ describe("NavItemService", () => {
     });
   });
 
+  describe("listPageCandidates", () => {
+    it("returns eligible notes by title and excludes added pages", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About this site",
+        visibility: "latest_hidden",
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "another-note",
+        title: "Another note",
+        visibility: "public",
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_3,
+        slug: "about-link",
+        title: "About link",
+        format: "link",
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_4,
+        slug: "about-draft",
+        title: "About draft",
+        status: "draft",
+      });
+
+      expect(
+        await navItemService.listPageCandidates({ query: "ABOUT" }),
+      ).toEqual([
+        {
+          id: TEST_POST_ID,
+          title: "About this site",
+          slug: "about",
+          updatedAt: expect.any(Number),
+        },
+      ]);
+
+      await navItemService.create({ type: "page", postId: TEST_POST_ID });
+      expect(
+        await navItemService.listPageCandidates({ query: "about" }),
+      ).toEqual([]);
+    });
+  });
+
   describe("listSuggestedLinks", () => {
-    it("suggests a published /about page as a normal link", async () => {
+    it("suggests a published /about page as a page nav item", async () => {
       insertTestPost(sqlite, {
         id: TEST_POST_ID,
         slug: "about",
@@ -377,7 +529,8 @@ describe("NavItemService", () => {
           label: "About me",
           url: "/about",
           targetType: "page",
-          navItemType: "link",
+          navItemType: "page",
+          postId: TEST_POST_ID,
         },
       ]);
     });
@@ -786,6 +939,32 @@ describe("NavItemService", () => {
     });
   });
 
+  describe("page nav items", () => {
+    beforeEach(() => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+      });
+    });
+
+    it("allows label updates but keeps the page URL managed", async () => {
+      const item = await navItemService.create({
+        type: "page",
+        postId: TEST_POST_ID,
+      });
+
+      const updated = await navItemService.update(item.id, {
+        label: "Start here",
+      });
+      expect(updated?.label).toBe("Start here");
+
+      await expect(
+        navItemService.update(item.id, { url: "/other" }),
+      ).rejects.toThrow("Page navigation URLs are managed automatically");
+    });
+  });
+
   describe("getCollectionFreshness", () => {
     beforeEach(() => {
       insertTestCollection(sqlite, TEST_COLLECTION_ID, "design", "Design");
@@ -810,7 +989,7 @@ describe("NavItemService", () => {
       // Add it to the collection recently
       sqlite
         .prepare(
-          `INSERT INTO post_collection (site_id, post_id, collection_id, created_at, position)
+          `INSERT INTO thread_collection (site_id, thread_id, collection_id, created_at, position)
            VALUES (?, ?, ?, ?, 0)`,
         )
         .run(DEFAULT_TEST_SITE_ID, "pst_test001", TEST_COLLECTION_ID, ts);
@@ -838,7 +1017,7 @@ describe("NavItemService", () => {
         );
       sqlite
         .prepare(
-          `INSERT INTO post_collection (site_id, post_id, collection_id, created_at, position)
+          `INSERT INTO thread_collection (site_id, thread_id, collection_id, created_at, position)
            VALUES (?, ?, ?, ?, 0)`,
         )
         .run(DEFAULT_TEST_SITE_ID, "pst_test002", TEST_COLLECTION_ID, oldTs);
@@ -849,6 +1028,35 @@ describe("NavItemService", () => {
       expect(result.has(TEST_COLLECTION_ID)).toBe(false);
     });
 
+    it("detects freshness from a recent root edit even when Thread activity is old", async () => {
+      const oldTs = now() - 60 * 60 * 72;
+      const recentTs = now();
+      sqlite
+        .prepare(
+          `INSERT INTO post (id, site_id, thread_id, format, status, visibility, created_at, updated_at, last_activity_at)
+           VALUES (?, ?, ?, 'note', 'published', 'public', ?, ?, ?)`,
+        )
+        .run(
+          "pst_edited",
+          DEFAULT_TEST_SITE_ID,
+          "pst_edited",
+          oldTs,
+          recentTs,
+          oldTs,
+        );
+      sqlite
+        .prepare(
+          `INSERT INTO thread_collection (site_id, thread_id, collection_id, created_at, position)
+           VALUES (?, ?, ?, ?, 0)`,
+        )
+        .run(DEFAULT_TEST_SITE_ID, "pst_edited", TEST_COLLECTION_ID, oldTs);
+
+      const result = await navItemService.getCollectionFreshness([
+        TEST_COLLECTION_ID,
+      ]);
+      expect(result.get(TEST_COLLECTION_ID)).toBe(recentTs);
+    });
+
     it("detects freshness from recent thread replies", async () => {
       const oldTs = now() - 60 * 60 * 72; // 72 hours ago
       const recentTs = now();
@@ -871,7 +1079,7 @@ describe("NavItemService", () => {
       // Add the root to the collection (old)
       sqlite
         .prepare(
-          `INSERT INTO post_collection (site_id, post_id, collection_id, created_at, position)
+          `INSERT INTO thread_collection (site_id, thread_id, collection_id, created_at, position)
            VALUES (?, ?, ?, ?, 0)`,
         )
         .run(DEFAULT_TEST_SITE_ID, "pst_root", TEST_COLLECTION_ID, oldTs);

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

@@ -1,9 +1,10 @@
+import { eq } from "drizzle-orm";
 import { describe, it, expect, beforeEach } from "vitest";
 import {
   createTestDatabase,
   DEFAULT_TEST_SITE_ID,
 } from "../../__tests__/helpers/db.js";
-import { postCollections } from "../../db/schema.js";
+import { posts, threadCollections } from "../../db/schema.js";
 import { createPostService } from "../post.js";
 import { createCollectionService } from "../collection.js";
 import type { Database } from "../../db/index.js";
@@ -236,7 +237,7 @@ describe("PostService - Timeline features", () => {
       expect(result.size).toBe(0);
     });
 
-    it("returns second and latest as the same post for a 2-post thread", async () => {
+    it("returns the only reply as leading and latest context", async () => {
       const root = await postService.create({
         format: "note",
         bodyMarkdown: "root",
@@ -250,13 +251,13 @@ describe("PostService - Timeline features", () => {
       const result = await postService.getThreadTimelineContext([root.id]);
       const ctx = result.get(root.id);
       expect(ctx).toBeDefined();
-      expect(ctx?.secondReply?.id).toBe(reply.id);
-      expect(ctx?.penultimateReply).toBeNull();
+      expect(ctx?.leadingReplies.map((post) => post.id)).toEqual([reply.id]);
+      expect(ctx?.trailingReplies).toEqual([]);
       expect(ctx?.latestReply.id).toBe(reply.id);
       expect(ctx?.totalReplyCount).toBe(1);
     });
 
-    it("returns second, penultimate, and latest slots for a 3-post thread", async () => {
+    it("returns overlapping leading and trailing context for short threads", async () => {
       const root = await postService.create({
         format: "note",
         bodyMarkdown: "root",
@@ -275,13 +276,16 @@ describe("PostService - Timeline features", () => {
       const result = await postService.getThreadTimelineContext([root.id]);
       const ctx = result.get(root.id);
       expect(ctx).toBeDefined();
-      expect(ctx?.secondReply?.id).toBe(reply1.id);
-      expect(ctx?.penultimateReply?.id).toBe(reply1.id);
+      expect(ctx?.leadingReplies.map((post) => post.id)).toEqual([
+        reply1.id,
+        reply2.id,
+      ]);
+      expect(ctx?.trailingReplies.map((post) => post.id)).toEqual([reply1.id]);
       expect(ctx?.latestReply.id).toBe(reply2.id);
       expect(ctx?.totalReplyCount).toBe(2);
     });
 
-    it("returns second, penultimate, and latest slots for longer threads", async () => {
+    it("returns the first two and last three reply positions for longer threads", async () => {
       const root = await postService.create({
         format: "note",
         bodyMarkdown: "root",
@@ -298,8 +302,14 @@ describe("PostService - Timeline features", () => {
       const result = await postService.getThreadTimelineContext([root.id]);
       const ctx = result.get(root.id);
       expect(ctx).toBeDefined();
-      expect(ctx?.secondReply?.bodyText).toBe("reply 0");
-      expect(ctx?.penultimateReply?.bodyText).toBe("reply 3");
+      expect(ctx?.leadingReplies.map((post) => post.bodyText)).toEqual([
+        "reply 0",
+        "reply 1",
+      ]);
+      expect(ctx?.trailingReplies.map((post) => post.bodyText)).toEqual([
+        "reply 2",
+        "reply 3",
+      ]);
       expect(ctx?.latestReply.bodyText).toBe("reply 4");
       expect(ctx?.totalReplyCount).toBe(5);
     });
@@ -326,7 +336,7 @@ describe("PostService - Timeline features", () => {
       const result = await postService.getThreadTimelineContext([root.id]);
       const ctx = result.get(root.id);
       expect(ctx).toBeDefined();
-      expect(ctx?.secondReply?.id).toBe(reply1.id);
+      expect(ctx?.leadingReplies.map((post) => post.id)).toEqual([reply1.id]);
       expect(ctx?.latestReply.id).toBe(reply1.id);
       expect(ctx?.totalReplyCount).toBe(1);
     });
@@ -351,7 +361,9 @@ describe("PostService - Timeline features", () => {
       const result = await postService.getThreadTimelineContext([root.id]);
       const ctx = result.get(root.id);
       expect(ctx).toBeDefined();
-      expect(ctx?.secondReply?.id).toBe(publishedReply.id);
+      expect(ctx?.leadingReplies.map((post) => post.id)).toEqual([
+        publishedReply.id,
+      ]);
       expect(ctx?.latestReply.id).toBe(publishedReply.id);
       expect(ctx?.totalReplyCount).toBe(1);
     });
@@ -381,8 +393,8 @@ describe("PostService - Timeline features", () => {
         root2.id,
       ]);
       expect(result.size).toBe(2);
-      expect(result.get(root1.id)?.secondReply?.id).toBe(r1Reply.id);
-      expect(result.get(root2.id)?.secondReply?.id).toBe(r2Reply.id);
+      expect(result.get(root1.id)?.leadingReplies[0]?.id).toBe(r1Reply.id);
+      expect(result.get(root2.id)?.leadingReplies[0]?.id).toBe(r2Reply.id);
       expect(result.get(root1.id)?.latestReply.id).toBe(r1Reply.id);
       expect(result.get(root2.id)?.latestReply.id).toBe(r2Reply.id);
     });
@@ -464,6 +476,39 @@ describe("PostService - Timeline features", () => {
     });
   });
 
+  describe("countCollectionThreadRootsForCollections", () => {
+    it("counts rated Threads once even when multiple children are rated", async () => {
+      const collection = await collectionService.create({
+        slug: "rated-threads",
+        title: "Rated Threads",
+      });
+      const ratedRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Rated root",
+        rating: 5,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Rated child",
+        rating: 4,
+        replyToId: ratedRoot.id,
+      });
+      const unratedRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Unrated root",
+      });
+      await collectionService.addThread(collection.id, ratedRoot.id);
+      await collectionService.addThread(collection.id, unratedRoot.id);
+
+      const count = await postService.countCollectionThreadRootsForCollections(
+        [collection.id],
+        { status: "published", hasRating: true },
+      );
+
+      expect(count).toBe(1);
+    });
+  });
+
   describe("listCollectionThreadRootIds", () => {
     it("bumps a hidden collection thread when a non-quiet reply is published", async () => {
       const collection = await collectionService.create({
@@ -482,8 +527,8 @@ describe("PostService - Timeline features", () => {
         publishedAt: 2000,
       });
 
-      await collectionService.addPost(collection.id, hiddenRoot.id);
-      await collectionService.addPost(collection.id, newerRoot.id);
+      await collectionService.addThread(collection.id, hiddenRoot.id);
+      await collectionService.addThread(collection.id, newerRoot.id);
 
       await postService.create({
         format: "note",
@@ -519,8 +564,8 @@ describe("PostService - Timeline features", () => {
         publishedAt: 2000,
       });
 
-      await collectionService.addPost(collection.id, olderRoot.id);
-      await collectionService.addPost(collection.id, newerRoot.id);
+      await collectionService.addThread(collection.id, olderRoot.id);
+      await collectionService.addThread(collection.id, newerRoot.id);
 
       await postService.create({
         format: "note",
@@ -540,6 +585,40 @@ describe("PostService - Timeline features", () => {
 
       expect(rootIds).toEqual([newerRoot.id, olderRoot.id]);
     });
+
+    it("orders a Thread by a newer root edit", async () => {
+      const collection = await collectionService.create({
+        slug: "edited",
+        title: "Edited",
+      });
+      const editedRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Edited root",
+        publishedAt: 1000,
+      });
+      const newerRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Newer root",
+        publishedAt: 2000,
+      });
+
+      await collectionService.addThread(collection.id, editedRoot.id);
+      await collectionService.addThread(collection.id, newerRoot.id);
+      await db
+        .update(posts)
+        .set({ createdAt: 500, updatedAt: 3000 })
+        .where(eq(posts.id, editedRoot.id));
+
+      const rootIds = await postService.listCollectionThreadRootIds(
+        collection.id,
+        {
+          status: "published",
+          sortOrder: "newest",
+        },
+      );
+
+      expect(rootIds).toEqual([editedRoot.id, newerRoot.id]);
+    });
   });
 
   describe("listCollectionFeedEntries", () => {
@@ -562,16 +641,16 @@ describe("PostService - Timeline features", () => {
         bodyMarkdown: "Second root",
       });
 
-      await db.insert(postCollections).values([
+      await db.insert(threadCollections).values([
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: collectedReply.id,
+          threadId: firstRoot.id,
           collectionId: collection.id,
           createdAt: 100,
         },
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: secondRoot.id,
+          threadId: secondRoot.id,
           collectionId: collection.id,
           createdAt: 200,
         },
@@ -607,17 +686,17 @@ describe("PostService - Timeline features", () => {
         publishedAt: 2000,
       });
 
-      await db.insert(postCollections).values([
+      await db.insert(threadCollections).values([
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: olderRoot.id,
+          threadId: olderRoot.id,
           collectionId: collection.id,
           createdAt: 100,
           pinnedAt: 5000,
         },
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: newerRoot.id,
+          threadId: newerRoot.id,
           collectionId: collection.id,
           createdAt: 200,
         },
@@ -670,22 +749,22 @@ describe("PostService - Timeline features", () => {
         bodyMarkdown: "Second root",
       });
 
-      await db.insert(postCollections).values([
+      await db.insert(threadCollections).values([
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: sharedRoot.id,
+          threadId: sharedRoot.id,
           collectionId: smart.id,
           createdAt: 100,
         },
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: sharedReply.id,
+          threadId: sharedRoot.id,
           collectionId: movies.id,
           createdAt: 300,
         },
         {
           siteId: DEFAULT_TEST_SITE_ID,
-          postId: secondRoot.id,
+          threadId: secondRoot.id,
           collectionId: movies.id,
           createdAt: 200,
         },
@@ -722,8 +801,8 @@ describe("PostService - Timeline features", () => {
         publishedAt: 2000,
       });
 
-      await collectionService.addPost(collection.id, hiddenRoot.id);
-      await collectionService.addPost(collection.id, newerRoot.id);
+      await collectionService.addThread(collection.id, hiddenRoot.id);
+      await collectionService.addThread(collection.id, newerRoot.id);
 
       await postService.create({
         format: "note",