@jant/core 0.6.15 → 0.7.0

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

@@ -400,7 +400,7 @@ describe("PostService - Timeline features", () => {
     });
   });
 
-  describe("getLastPostIdsByThread", () => {
+  describe("getThreadTailIds", () => {
     it("keeps independent root threads separate", async () => {
       const root1 = await postService.create({
         format: "note",
@@ -412,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);
@@ -436,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", () => {
@@ -586,7 +626,98 @@ describe("PostService - Timeline features", () => {
       expect(rootIds).toEqual([newerRoot.id, olderRoot.id]);
     });
 
-    it("orders a Thread by a newer root edit", async () => {
+    // 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",
@@ -617,7 +748,7 @@ describe("PostService - Timeline features", () => {
         },
       );
 
-      expect(rootIds).toEqual([editedRoot.id, newerRoot.id]);
+      expect(rootIds).toEqual([newerRoot.id, editedRoot.id]);
     });
   });
 

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

@@ -570,20 +570,53 @@ describe("PostService", () => {
       const descending = await postService.list({
         sortOrder: "rating_desc",
       });
-      const ascending = await postService.list({
-        sortOrder: "rating_asc",
-      });
 
       expect(descending.map((post) => post.bodyText)).toEqual([
         "five stars",
         "three stars",
         "unrated newest",
       ]);
-      expect(ascending.map((post) => post.bodyText)).toEqual([
-        "three stars",
-        "five stars",
-        "unrated newest",
+    });
+
+    it("orders by time for an explicit newest, ratings and all", async () => {
+      // `newest` used to have no branch of its own in the ORDER BY and fell
+      // into the one written for the ascending rating order, so anything that
+      // named it — a smart collection page, most visibly — got its posts
+      // grouped by rating instead of dated. Rated rows here on purpose.
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "oldest, best",
+        publishedAt: 1000,
+        rating: 5,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "middle, worst",
+        publishedAt: 2000,
+        rating: 1,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "newest, unrated",
+        publishedAt: 3000,
+      });
+
+      const ordered = await postService.list({ sortOrder: "newest" });
+      expect(ordered.map((post) => post.bodyText)).toEqual([
+        "newest, unrated",
+        "middle, worst",
+        "oldest, best",
       ]);
+
+      // The keyset cursor reads the same keys or pagination skips rows.
+      expect(
+        (
+          await postService.list({
+            sortOrder: "newest",
+            cursor: ordered[0]?.id,
+          })
+        ).map((post) => post.bodyText),
+      ).toEqual(["middle, worst", "oldest, best"]);
     });
 
     it("orders drafts by updatedAt descending", async () => {
@@ -1470,6 +1503,9 @@ describe("PostService", () => {
       expect(published?.status).toBe("published");
       expect(published?.publishedAt).toBeTypeOf("number");
       expect((published?.publishedAt ?? 0) >= post.updatedAt).toBe(true);
+      expect(
+        (await postService.list({ status: "draft" })).map((draft) => draft.id),
+      ).not.toContain(post.id);
     });
 
     it("clears publishedAt when converting a published post back to draft", async () => {
@@ -1567,7 +1603,7 @@ describe("PostService", () => {
       expect(updated?.pinnedAt).toBeTypeOf("number");
     });
 
-    it("updates slug and its page navigation URL", async () => {
+    it("updates slug and title on its page navigation entry", async () => {
       const post = await postService.create({
         format: "note",
         title: "Test page",
@@ -1582,11 +1618,15 @@ describe("PostService", () => {
 
       const updated = await postService.update(post.id, {
         slug: "new-slug",
+        title: "Renamed page",
       });
 
       expect(updated?.slug).toBe("new-slug");
+      // The URL is synced on write; the title is read through, so renaming the
+      // page carries its navigation entry along with no sync step at all.
       expect(await navItemService.getById(navItem.id)).toMatchObject({
-        label: "Test page",
+        label: "",
+        targetTitle: "Renamed page",
         url: "/new-slug",
       });
     });
@@ -1856,6 +1896,92 @@ describe("PostService", () => {
     });
   });
 
+  describe("createThreadWithAttachments", () => {
+    // No attachments in these cases, so only the up-front id check is reached.
+    const deps = {
+      media: { validateIds: async () => [] },
+    } as unknown as Parameters<
+      typeof postService.createThreadWithAttachments
+    >[1];
+
+    it("dates every reply from the root when the root is backdated", async () => {
+      const backdated = 1710000000; // 2024-03-09
+
+      const created = await postService.createThreadWithAttachments(
+        [
+          {
+            data: {
+              format: "note",
+              bodyMarkdown: "root",
+              publishedAt: backdated,
+            },
+            attachments: [],
+          },
+          { data: { format: "note", bodyMarkdown: "second" }, attachments: [] },
+          { data: { format: "note", bodyMarkdown: "third" }, attachments: [] },
+        ],
+        deps,
+        undefined,
+      );
+
+      // Without inheritance the replies would land on today and the thread
+      // would read as if it spanned two years.
+      expect(created.map((p) => p.publishedAt)).toEqual([
+        backdated,
+        backdated,
+        backdated,
+      ]);
+      // Order still comes from createdAt/id, so the chain is intact.
+      expect(created[1].replyToId).toBe(created[0].id);
+      expect(created[2].replyToId).toBe(created[1].id);
+    });
+
+    it("keeps a reply's own date when one is given", async () => {
+      const rootAt = 1710000000;
+      const replyAt = 1720000000;
+
+      const created = await postService.createThreadWithAttachments(
+        [
+          {
+            data: { format: "note", bodyMarkdown: "root", publishedAt: rootAt },
+            attachments: [],
+          },
+          {
+            data: {
+              format: "note",
+              bodyMarkdown: "second",
+              publishedAt: replyAt,
+            },
+            attachments: [],
+          },
+        ],
+        deps,
+        undefined,
+      );
+
+      expect(created.map((p) => p.publishedAt)).toEqual([rootAt, replyAt]);
+    });
+
+    it("leaves draft threads undated", async () => {
+      const created = await postService.createThreadWithAttachments(
+        [
+          {
+            data: { format: "note", bodyMarkdown: "root", status: "draft" },
+            attachments: [],
+          },
+          {
+            data: { format: "note", bodyMarkdown: "second", status: "draft" },
+            attachments: [],
+          },
+        ],
+        deps,
+        undefined,
+      );
+
+      expect(created.map((p) => p.publishedAt)).toEqual([null, null]);
+    });
+  });
+
   describe("threads", () => {
     it("sets threadId on reply to a root post", async () => {
       const root = await postService.create({
@@ -1915,6 +2041,143 @@ describe("PostService", () => {
       );
     });
 
+    it("refuses to feature an unpublished post", async () => {
+      await expect(
+        postService.create({
+          format: "note",
+          bodyMarkdown: "not ready",
+          status: "draft",
+          featured: true,
+        }),
+      ).rejects.toThrow("Publish this post before featuring it.");
+
+      const draft = await postService.create({
+        format: "note",
+        bodyMarkdown: "not ready",
+        status: "draft",
+      });
+      await expect(
+        postService.update(draft.id, { featured: true }),
+      ).rejects.toThrow("Publish this post before featuring it.");
+    });
+
+    it("keeps a featured flag through a trip back to draft", async () => {
+      const post = await postService.create({
+        format: "note",
+        bodyMarkdown: "published",
+        featured: true,
+      });
+
+      const unpublished = await postService.update(post.id, {
+        status: "draft",
+      });
+
+      expect(unpublished?.status).toBe("draft");
+      expect(unpublished?.featuredAt).not.toBeNull();
+    });
+
+    it("publishes a reply whose parent is still a draft", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const draft = await postService.create({
+        format: "note",
+        bodyMarkdown: "unfinished",
+        replyToId: root.id,
+        status: "draft",
+      });
+
+      const next = await postService.create({
+        format: "note",
+        bodyMarkdown: "continues past the draft",
+        replyToId: draft.id,
+      });
+
+      // Readers never saw the draft, so publishing past it reads as
+      // continuous. The draft stays parked until it is dealt with on its own.
+      expect(next.status).toBe("published");
+      expect(draft.status).toBe("draft");
+    });
+
+    it("publishes only the post asked for, leaving other drafts alone", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const first = await postService.create({
+        format: "note",
+        bodyMarkdown: "first draft",
+        replyToId: root.id,
+        status: "draft",
+      });
+      const second = await postService.create({
+        format: "note",
+        bodyMarkdown: "second draft",
+        replyToId: first.id,
+        status: "draft",
+      });
+
+      await postService.update(second.id, { status: "published" });
+
+      const statusById = new Map(
+        (await postService.getThread(root.id)).map((p) => [p.id, p.status]),
+      );
+      expect(statusById.get(first.id)).toBe("draft");
+      expect(statusById.get(second.id)).toBe("published");
+    });
+
+    it("keeps a draft between two published replies", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const middle = await postService.create({
+        format: "note",
+        bodyMarkdown: "middle",
+        replyToId: root.id,
+      });
+      const last = await postService.create({
+        format: "note",
+        bodyMarkdown: "last",
+        replyToId: middle.id,
+      });
+
+      await postService.update(middle.id, { status: "draft" });
+
+      const statusById = new Map(
+        (await postService.getThread(root.id)).map((p) => [p.id, p.status]),
+      );
+      // Unpublishing one post touches only that post. The public thread simply
+      // skips it; nothing else in the chain changes.
+      expect(statusById.get(root.id)).toBe("published");
+      expect(statusById.get(middle.id)).toBe("draft");
+      expect(statusById.get(last.id)).toBe("published");
+    });
+
+    it("names the draft when an unpublished reply holds the thread tail", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "unfinished",
+        replyToId: root.id,
+        status: "draft",
+      });
+
+      await expect(
+        postService.create({
+          format: "note",
+          bodyMarkdown: "reply",
+          replyToId: root.id,
+        }),
+      ).rejects.toThrow(
+        "This thread ends with an unpublished draft. Finish that draft or discard it, then reply.",
+      );
+    });
+
     it("inherits status from root post", async () => {
       const root = await postService.create({
         format: "note",
@@ -2025,6 +2288,57 @@ describe("PostService", () => {
       expect(thread[0]?.bodyText).toBe("root");
     });
 
+    it("getThreadPosition counts the chain from the root down to a post", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const reply1 = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply1",
+        replyToId: root.id,
+      });
+      const reply2 = await postService.create({
+        format: "note",
+        bodyMarkdown: "reply2",
+        replyToId: reply1.id,
+      });
+
+      expect(await postService.getThreadPosition(root.id)).toBe(1);
+      expect(await postService.getThreadPosition(reply1.id)).toBe(2);
+      expect(await postService.getThreadPosition(reply2.id)).toBe(3);
+    });
+
+    it("getThreadPosition walks the reply chain rather than counting members", async () => {
+      // `create` only allows replying to the tail, so today a thread is a
+      // straight chain and depth happens to equal its size. The walk is what
+      // makes the two agree — counting `threadId` members would give the same
+      // answer here and the wrong one the moment a draft chain is incomplete.
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const tail = await postService.create({
+        format: "note",
+        bodyMarkdown: "tail",
+        replyToId: root.id,
+      });
+
+      // A second post filed under the same thread without joining the chain:
+      // it is not above the tail, so it must not push the tail's position.
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "unrelated",
+      });
+
+      expect(await postService.getThreadPosition(tail.id)).toBe(2);
+      expect(await postService.getThread(root.id)).toHaveLength(2);
+    });
+
+    it("getThreadPosition returns 0 for a post that does not exist", async () => {
+      expect(await postService.getThreadPosition("pst_missing")).toBe(0);
+    });
+
     it("getThread excludes deleted posts", async () => {
       const root = await postService.create({
         format: "note",