@jant/core 0.6.14 → 0.6.16

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,14 +393,14 @@ 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);
     });
   });
 
-  describe("getLastPostIdsByThread", () => {
+  describe("getThreadTailIds", () => {
     it("keeps independent root threads separate", async () => {
       const root1 = await postService.create({
         format: "note",
@@ -400,10 +412,7 @@ describe("PostService - Timeline features", () => {
         quoteText: "quoted",
       });
 
-      const result = await postService.getLastPostIdsByThread([
-        root1.id,
-        root2.id,
-      ]);
+      const result = await postService.getThreadTailIds([root1.id, root2.id]);
 
       expect(result.get(root1.id)).toBe(root1.id);
       expect(result.get(root2.id)).toBe(root2.id);
@@ -424,14 +433,57 @@ describe("PostService - Timeline features", () => {
         replyToId: root1.id,
       });
 
-      const result = await postService.getLastPostIdsByThread([
-        root1.id,
-        root2.id,
-      ]);
+      const result = await postService.getThreadTailIds([root1.id, root2.id]);
 
       expect(result.get(root1.id)).toBe(reply1.id);
       expect(result.get(root2.id)).toBe(root2.id);
     });
+
+    it("skips a trailing draft by default", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const reply = await postService.create({
+        format: "note",
+        bodyMarkdown: "published reply",
+        replyToId: root.id,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "unfinished",
+        replyToId: reply.id,
+        status: "draft",
+      });
+
+      const result = await postService.getThreadTailIds([root.id]);
+
+      expect(result.get(root.id)).toBe(reply.id);
+    });
+
+    it("returns a trailing draft when drafts are included", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const reply = await postService.create({
+        format: "note",
+        bodyMarkdown: "published reply",
+        replyToId: root.id,
+      });
+      const draft = await postService.create({
+        format: "note",
+        bodyMarkdown: "unfinished",
+        replyToId: reply.id,
+        status: "draft",
+      });
+
+      const result = await postService.getThreadTailIds([root.id], {
+        includeDrafts: true,
+      });
+
+      expect(result.get(root.id)).toBe(draft.id);
+    });
   });
 
   describe("timeline assembly", () => {
@@ -464,6 +516,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 +567,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 +604,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 +625,131 @@ describe("PostService - Timeline features", () => {
 
       expect(rootIds).toEqual([newerRoot.id, olderRoot.id]);
     });
+
+    // Quietness used to live only in control flow: the reply skipped the
+    // recalculation and nothing recorded that it had. Any later recalculation
+    // recomputed MAX(published_at) over the whole Thread, swallowed the quiet
+    // reply, and bumped the Thread anyway. It is a stored column now, so the
+    // decision survives whatever else happens to the Thread.
+    it("keeps a quiet reply quiet after an unrelated post is deleted", async () => {
+      const collection = await collectionService.create({
+        slug: "durable",
+        title: "Durable",
+      });
+      const olderRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Older root",
+        publishedAt: 1000,
+      });
+      const newerRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Newer root",
+        publishedAt: 2000,
+      });
+      await collectionService.addThread(collection.id, olderRoot.id);
+      await collectionService.addThread(collection.id, newerRoot.id);
+
+      const normalReply = await postService.create({
+        format: "note",
+        bodyMarkdown: "Normal reply",
+        replyToId: olderRoot.id,
+        publishedAt: 1500,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Quiet reply",
+        replyToId: normalReply.id,
+        publishedAt: 3000,
+        quietReply: true,
+      });
+
+      // Triggers a full recalculation of the Thread.
+      await postService.delete(normalReply.id);
+
+      const root = await postService.getById(olderRoot.id);
+      expect(root?.lastActivityAt).toBe(1000);
+      expect(root?.threadUpdatedAt).toBe(3000);
+
+      const rootIds = await postService.listCollectionThreadRootIds(
+        collection.id,
+        { status: "published", sortOrder: "newest" },
+      );
+      expect(rootIds).toEqual([newerRoot.id, olderRoot.id]);
+    });
+
+    it("records both activity timestamps for a quiet reply", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "Root",
+        publishedAt: 1000,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Quiet reply",
+        replyToId: root.id,
+        publishedAt: 3000,
+        quietReply: true,
+      });
+
+      const updated = await postService.getById(root.id);
+      expect(updated?.lastActivityAt).toBe(1000);
+      expect(updated?.threadUpdatedAt).toBe(3000);
+    });
+
+    it("moves both timestamps for a normal reply", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "Root",
+        publishedAt: 1000,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "Normal reply",
+        replyToId: root.id,
+        publishedAt: 3000,
+      });
+
+      const updated = await postService.getById(root.id);
+      expect(updated?.lastActivityAt).toBe(3000);
+      expect(updated?.threadUpdatedAt).toBe(3000);
+    });
+
+    // Activity means the Thread gained a post. Editing an old post is not
+    // activity — otherwise fixing a typo would drag it back to the top of its
+    // collection, and "recently updated" would stop meaning anything.
+    it("does not reorder a Thread when its root is only edited", 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([newerRoot.id, editedRoot.id]);
+    });
   });
 
   describe("listCollectionFeedEntries", () => {
@@ -562,16 +772,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 +817,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 +880,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 +932,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",