@jant/core 0.3.22 → 0.3.24

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

@@ -16,62 +16,59 @@ describe("PostService", () => {
   describe("create", () => {
     it("creates a note post with required fields", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "Hello world",
+        format: "note",
+        body: "Hello world",
       });
 
       expect(post.id).toBe(1);
-      expect(post.type).toBe("note");
-      expect(post.content).toBe("Hello world");
-      expect(post.visibility).toBe("quiet"); // default
-      expect(post.contentHtml).toContain("<p>Hello world</p>");
+      expect(post.format).toBe("note");
+      expect(post.body).toBe("Hello world");
+      expect(post.status).toBe("published"); // default
+      expect(post.featured).toBe(0);
+      expect(post.pinned).toBe(0);
+      expect(post.bodyHtml).toContain("<p>Hello world</p>");
       expect(post.deletedAt).toBeNull();
     });
 
     it("creates a post with all fields", async () => {
       const post = await postService.create({
-        type: "article",
-        title: "My Article",
-        content: "# Introduction\n\nSome content.",
-        visibility: "featured",
-        path: "my-article",
-        sourceUrl: "https://example.com/source",
-        sourceName: "Example",
-      });
-
-      expect(post.type).toBe("article");
-      expect(post.title).toBe("My Article");
-      expect(post.visibility).toBe("featured");
-      expect(post.path).toBe("my-article");
-      expect(post.sourceUrl).toBe("https://example.com/source");
-      expect(post.sourceName).toBe("Example");
-      expect(post.sourceDomain).toBe("example.com");
-      expect(post.contentHtml).toContain("<h1>");
-    });
-
-    it("renders markdown content to HTML", async () => {
+        format: "link",
+        title: "My Link",
+        body: "# Introduction\n\nSome content.",
+        status: "published",
+        featured: true,
+        pinned: true,
+        slug: "my-link",
+        url: "https://example.com/source",
+        quoteText: "A notable quote",
+        rating: 5,
+      });
+
+      expect(post.format).toBe("link");
+      expect(post.title).toBe("My Link");
+      expect(post.status).toBe("published");
+      expect(post.featured).toBe(1);
+      expect(post.pinned).toBe(1);
+      expect(post.slug).toBe("my-link");
+      expect(post.url).toBe("https://example.com/source");
+      expect(post.quoteText).toBe("A notable quote");
+      expect(post.rating).toBe(5);
+      expect(post.bodyHtml).toContain("<h1>");
+    });
+
+    it("renders markdown body to HTML", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "This is **bold** text",
+        format: "note",
+        body: "This is **bold** text",
       });
 
-      expect(post.contentHtml).toContain("<strong>bold</strong>");
-    });
-
-    it("extracts domain from source URL", async () => {
-      const post = await postService.create({
-        type: "link",
-        content: "Check this out",
-        sourceUrl: "https://blog.example.org/article",
-      });
-
-      expect(post.sourceDomain).toBe("blog.example.org");
+      expect(post.bodyHtml).toContain("<strong>bold</strong>");
     });
 
     it("sets publishedAt and timestamps", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       expect(post.publishedAt).toBeGreaterThan(0);
@@ -82,8 +79,8 @@ describe("PostService", () => {
     it("allows custom publishedAt", async () => {
       const customTime = 1706745600;
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
         publishedAt: customTime,
       });
 
@@ -92,29 +89,52 @@ describe("PostService", () => {
 
     it("creates incrementing IDs", async () => {
       const post1 = await postService.create({
-        type: "note",
-        content: "first",
+        format: "note",
+        body: "first",
       });
       const post2 = await postService.create({
-        type: "note",
-        content: "second",
+        format: "note",
+        body: "second",
       });
 
       expect(post2.id).toBeGreaterThan(post1.id);
     });
+
+    it("creates a quote post", async () => {
+      const post = await postService.create({
+        format: "quote",
+        quoteText: "To be or not to be",
+        body: "Shakespeare's famous line",
+        url: "https://example.com/hamlet",
+      });
+
+      expect(post.format).toBe("quote");
+      expect(post.quoteText).toBe("To be or not to be");
+      expect(post.url).toBe("https://example.com/hamlet");
+    });
+
+    it("creates a draft post", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "draft content",
+        status: "draft",
+      });
+
+      expect(post.status).toBe("draft");
+    });
   });
 
   describe("getById", () => {
     it("returns a post by ID", async () => {
       const created = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       const found = await postService.getById(created.id);
       expect(found).not.toBeNull();
       expect(found?.id).toBe(created.id);
-      expect(found?.content).toBe("test");
+      expect(found?.body).toBe("test");
     });
 
     it("returns null for non-existent ID", async () => {
@@ -124,8 +144,8 @@ describe("PostService", () => {
 
     it("excludes soft-deleted posts", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
       await postService.delete(post.id);
 
@@ -134,33 +154,33 @@ describe("PostService", () => {
     });
   });
 
-  describe("getByPath", () => {
-    it("returns a post by path", async () => {
+  describe("getBySlug", () => {
+    it("returns a post by slug", async () => {
       await postService.create({
-        type: "page",
-        content: "About page",
-        path: "about",
+        format: "note",
+        body: "About page",
+        slug: "about",
       });
 
-      const found = await postService.getByPath("about");
+      const found = await postService.getBySlug("about");
       expect(found).not.toBeNull();
-      expect(found?.path).toBe("about");
+      expect(found?.slug).toBe("about");
     });
 
-    it("returns null for non-existent path", async () => {
-      const found = await postService.getByPath("nonexistent");
+    it("returns null for non-existent slug", async () => {
+      const found = await postService.getBySlug("nonexistent");
       expect(found).toBeNull();
     });
 
     it("excludes soft-deleted posts", async () => {
       const post = await postService.create({
-        type: "page",
-        content: "test",
-        path: "test-page",
+        format: "note",
+        body: "test",
+        slug: "test-page",
       });
       await postService.delete(post.id);
 
-      const found = await postService.getByPath("test-page");
+      const found = await postService.getBySlug("test-page");
       expect(found).toBeNull();
     });
   });
@@ -172,9 +192,9 @@ describe("PostService", () => {
     });
 
     it("returns all non-deleted posts", async () => {
-      await postService.create({ type: "note", content: "first" });
-      await postService.create({ type: "note", content: "second" });
-      await postService.create({ type: "note", content: "third" });
+      await postService.create({ format: "note", body: "first" });
+      await postService.create({ format: "note", body: "second" });
+      await postService.create({ format: "note", body: "third" });
 
       const posts = await postService.list();
       expect(posts).toHaveLength(3);
@@ -182,91 +202,113 @@ describe("PostService", () => {
 
     it("orders by publishedAt descending", async () => {
       await postService.create({
-        type: "note",
-        content: "old",
+        format: "note",
+        body: "old",
         publishedAt: 1000,
       });
       await postService.create({
-        type: "note",
-        content: "new",
+        format: "note",
+        body: "new",
         publishedAt: 2000,
       });
 
       const posts = await postService.list();
-      expect(posts[0]?.content).toBe("new");
-      expect(posts[1]?.content).toBe("old");
+      expect(posts[0]?.body).toBe("new");
+      expect(posts[1]?.body).toBe("old");
     });
 
-    it("filters by type", async () => {
-      await postService.create({ type: "note", content: "a note" });
+    it("filters by format", async () => {
+      await postService.create({ format: "note", body: "a note" });
       await postService.create({
-        type: "article",
-        content: "an article",
-        title: "Article",
+        format: "link",
+        body: "a link",
+        title: "Link",
+        url: "https://example.com",
       });
 
-      const notes = await postService.list({ type: "note" });
+      const notes = await postService.list({ format: "note" });
       expect(notes).toHaveLength(1);
-      expect(notes[0]?.type).toBe("note");
+      expect(notes[0]?.format).toBe("note");
     });
 
-    it("filters by single visibility", async () => {
+    it("filters by status", async () => {
       await postService.create({
-        type: "note",
-        content: "featured",
-        visibility: "featured",
+        format: "note",
+        body: "published post",
+        status: "published",
       });
       await postService.create({
-        type: "note",
-        content: "draft",
-        visibility: "draft",
+        format: "note",
+        body: "draft post",
+        status: "draft",
       });
 
-      const featured = await postService.list({ visibility: "featured" });
-      expect(featured).toHaveLength(1);
-      expect(featured[0]?.visibility).toBe("featured");
+      const published = await postService.list({ status: "published" });
+      expect(published).toHaveLength(1);
+      expect(published[0]?.status).toBe("published");
     });
 
-    it("filters by multiple visibility levels", async () => {
+    it("filters by featured", async () => {
+      await postService.create({
+        format: "note",
+        body: "featured post",
+        featured: true,
+      });
       await postService.create({
-        type: "note",
-        content: "featured",
-        visibility: "featured",
+        format: "note",
+        body: "normal post",
       });
+
+      const featured = await postService.list({ featured: true });
+      expect(featured).toHaveLength(1);
+      expect(featured[0]?.featured).toBe(1);
+      expect(featured[0]?.body).toBe("featured post");
+
+      const notFeatured = await postService.list({ featured: false });
+      expect(notFeatured).toHaveLength(1);
+      expect(notFeatured[0]?.featured).toBe(0);
+      expect(notFeatured[0]?.body).toBe("normal post");
+    });
+
+    it("filters by pinned", async () => {
       await postService.create({
-        type: "note",
-        content: "quiet",
-        visibility: "quiet",
+        format: "note",
+        body: "pinned post",
+        pinned: true,
       });
       await postService.create({
-        type: "note",
-        content: "draft",
-        visibility: "draft",
+        format: "note",
+        body: "normal post",
       });
 
-      const publicPosts = await postService.list({
-        visibility: ["featured", "quiet"],
-      });
-      expect(publicPosts).toHaveLength(2);
+      const pinned = await postService.list({ pinned: true });
+      expect(pinned).toHaveLength(1);
+      expect(pinned[0]?.pinned).toBe(1);
+      expect(pinned[0]?.body).toBe("pinned post");
+
+      const notPinned = await postService.list({ pinned: false });
+      expect(notPinned).toHaveLength(1);
+      expect(notPinned[0]?.pinned).toBe(0);
+      expect(notPinned[0]?.body).toBe("normal post");
     });
 
     it("excludes deleted posts by default", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
-      await postService.create({ type: "note", content: "kept" });
+      await postService.create({ format: "note", body: "kept" });
       await postService.delete(post.id);
 
       const posts = await postService.list();
       expect(posts).toHaveLength(1);
-      expect(posts[0]?.content).toBe("kept");
+      expect(posts[0]?.body).toBe("kept");
     });
 
     it("includes deleted posts when requested", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
       await postService.delete(post.id);
 
@@ -276,7 +318,7 @@ describe("PostService", () => {
 
     it("supports limit", async () => {
       for (let i = 0; i < 5; i++) {
-        await postService.create({ type: "note", content: `post ${i}` });
+        await postService.create({ format: "note", body: `post ${i}` });
       }
 
       const posts = await postService.list({ limit: 2 });
@@ -288,8 +330,8 @@ describe("PostService", () => {
       for (let i = 0; i < 5; i++) {
         created.push(
           await postService.create({
-            type: "note",
-            content: `post ${i}`,
+            format: "note",
+            body: `post ${i}`,
             publishedAt: 1000 + i,
           }),
         );
@@ -303,42 +345,43 @@ describe("PostService", () => {
 
     it("excludes replies when requested", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root post",
+        format: "note",
+        body: "root post",
       });
       await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
 
       const posts = await postService.list({ excludeReplies: true });
       expect(posts).toHaveLength(1);
-      expect(posts[0]?.content).toBe("root post");
+      expect(posts[0]?.body).toBe("root post");
     });
   });
 
   describe("update", () => {
-    it("updates post content", async () => {
+    it("updates post body", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "original",
+        format: "note",
+        body: "original",
       });
 
       const updated = await postService.update(post.id, {
-        content: "updated content",
+        body: "updated content",
       });
 
       expect(updated).not.toBeNull();
-      expect(updated?.content).toBe("updated content");
-      expect(updated?.contentHtml).toContain("updated content");
+      expect(updated?.body).toBe("updated content");
+      expect(updated?.bodyHtml).toContain("updated content");
     });
 
     it("updates post title", async () => {
       const post = await postService.create({
-        type: "article",
-        content: "body",
+        format: "link",
+        body: "body",
         title: "Original Title",
+        url: "https://example.com",
       });
 
       const updated = await postService.update(post.id, {
@@ -348,44 +391,43 @@ describe("PostService", () => {
       expect(updated?.title).toBe("New Title");
     });
 
-    it("updates source URL and extracts domain", async () => {
+    it("updates post url", async () => {
       const post = await postService.create({
-        type: "link",
-        content: "link post",
+        format: "link",
+        body: "link post",
+        url: "https://old.com",
       });
 
       const updated = await postService.update(post.id, {
-        sourceUrl: "https://new-source.com/path",
+        url: "https://new-source.com/path",
       });
 
-      expect(updated?.sourceUrl).toBe("https://new-source.com/path");
-      expect(updated?.sourceDomain).toBe("new-source.com");
+      expect(updated?.url).toBe("https://new-source.com/path");
     });
 
-    it("clears source domain when URL cleared", async () => {
+    it("clears url when set to null", async () => {
       const post = await postService.create({
-        type: "link",
-        content: "test",
-        sourceUrl: "https://example.com",
+        format: "link",
+        body: "test",
+        url: "https://example.com",
       });
 
       const updated = await postService.update(post.id, {
-        sourceUrl: null,
+        url: null,
       });
 
-      expect(updated?.sourceUrl).toBeNull();
-      expect(updated?.sourceDomain).toBeNull();
+      expect(updated?.url).toBeNull();
     });
 
     it("returns null for non-existent post", async () => {
-      const result = await postService.update(9999, { content: "test" });
+      const result = await postService.update(9999, { body: "test" });
       expect(result).toBeNull();
     });
 
     it("updates updatedAt timestamp", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
       const originalUpdatedAt = post.updatedAt;
 
@@ -393,18 +435,78 @@ describe("PostService", () => {
       await new Promise((r) => setTimeout(r, 1100));
 
       const updated = await postService.update(post.id, {
-        content: "modified",
+        body: "modified",
       });
 
       expect(updated?.updatedAt).toBeGreaterThanOrEqual(originalUpdatedAt);
     });
+
+    it("updates featured flag", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      expect(post.featured).toBe(0);
+
+      const updated = await postService.update(post.id, {
+        featured: true,
+      });
+
+      expect(updated?.featured).toBe(1);
+    });
+
+    it("updates pinned flag", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      expect(post.pinned).toBe(0);
+
+      const updated = await postService.update(post.id, {
+        pinned: true,
+      });
+
+      expect(updated?.pinned).toBe(1);
+    });
+
+    it("updates slug", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+        slug: "old-slug",
+      });
+
+      const updated = await postService.update(post.id, {
+        slug: "new-slug",
+      });
+
+      expect(updated?.slug).toBe("new-slug");
+    });
+
+    it("updates quoteText and rating", async () => {
+      const post = await postService.create({
+        format: "quote",
+        quoteText: "Original quote",
+        rating: 3,
+      });
+
+      const updated = await postService.update(post.id, {
+        quoteText: "Updated quote",
+        rating: 5,
+      });
+
+      expect(updated?.quoteText).toBe("Updated quote");
+      expect(updated?.rating).toBe(5);
+    });
   });
 
   describe("delete (soft delete)", () => {
     it("soft-deletes a post", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "test",
+        format: "note",
+        body: "test",
       });
 
       const result = await postService.delete(post.id);
@@ -422,12 +524,12 @@ describe("PostService", () => {
 
     it("cascade deletes thread when deleting root post", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       const reply = await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
 
@@ -440,17 +542,17 @@ describe("PostService", () => {
 
     it("only deletes single post when deleting a reply", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       const reply1 = await postService.create({
-        type: "note",
-        content: "reply1",
+        format: "note",
+        body: "reply1",
         replyToId: root.id,
       });
       await postService.create({
-        type: "note",
-        content: "reply2",
+        format: "note",
+        body: "reply2",
         replyToId: root.id,
       });
 
@@ -466,12 +568,12 @@ describe("PostService", () => {
   describe("threads", () => {
     it("sets threadId on reply to a root post", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       const reply = await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
 
@@ -481,17 +583,17 @@ describe("PostService", () => {
 
     it("inherits threadId from parent in nested replies", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       const reply1 = await postService.create({
-        type: "note",
-        content: "reply1",
+        format: "note",
+        body: "reply1",
         replyToId: root.id,
       });
       const reply2 = await postService.create({
-        type: "note",
-        content: "reply2",
+        format: "note",
+        body: "reply2",
         replyToId: reply1.id,
       });
 
@@ -500,51 +602,66 @@ describe("PostService", () => {
       expect(reply2.threadId).toBe(root.id);
     });
 
-    it("inherits visibility from root post", async () => {
+    it("inherits status from root post", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
-        visibility: "featured",
+        format: "note",
+        body: "root",
+        status: "draft",
       });
       const reply = await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
 
-      expect(reply.visibility).toBe("featured");
+      expect(reply.status).toBe("draft");
+    });
+
+    it("inherits featured from root post", async () => {
+      const root = await postService.create({
+        format: "note",
+        body: "root",
+        featured: true,
+      });
+      const reply = await postService.create({
+        format: "note",
+        body: "reply",
+        replyToId: root.id,
+      });
+
+      expect(reply.featured).toBe(1);
     });
 
     it("getThread returns all posts in a thread", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       await postService.create({
-        type: "note",
-        content: "reply1",
+        format: "note",
+        body: "reply1",
         replyToId: root.id,
       });
       await postService.create({
-        type: "note",
-        content: "reply2",
+        format: "note",
+        body: "reply2",
         replyToId: root.id,
       });
 
       const thread = await postService.getThread(root.id);
       expect(thread).toHaveLength(3);
       // Ordered by createdAt
-      expect(thread[0]?.content).toBe("root");
+      expect(thread[0]?.body).toBe("root");
     });
 
     it("getThread excludes deleted posts", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       const reply = await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
 
@@ -554,23 +671,42 @@ describe("PostService", () => {
       expect(thread).toHaveLength(1);
     });
 
-    it("cascades visibility changes from root to thread", async () => {
+    it("cascades status changes from root to thread", async () => {
+      const root = await postService.create({
+        format: "note",
+        body: "root",
+        status: "published",
+      });
+      await postService.create({
+        format: "note",
+        body: "reply",
+        replyToId: root.id,
+      });
+
+      await postService.update(root.id, { status: "draft" });
+
+      const thread = await postService.getThread(root.id);
+      for (const post of thread) {
+        expect(post.status).toBe("draft");
+      }
+    });
+
+    it("cascades featured changes from root to thread", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
-        visibility: "quiet",
+        format: "note",
+        body: "root",
       });
       await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
 
-      await postService.update(root.id, { visibility: "featured" });
+      await postService.update(root.id, { featured: true });
 
       const thread = await postService.getThread(root.id);
       for (const post of thread) {
-        expect(post.visibility).toBe("featured");
+        expect(post.featured).toBe(1);
       }
     });
   });
@@ -583,17 +719,17 @@ describe("PostService", () => {
 
     it("returns reply counts for posts", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       await postService.create({
-        type: "note",
-        content: "reply1",
+        format: "note",
+        body: "reply1",
         replyToId: root.id,
       });
       await postService.create({
-        type: "note",
-        content: "reply2",
+        format: "note",
+        body: "reply2",
         replyToId: root.id,
       });
 
@@ -603,8 +739,8 @@ describe("PostService", () => {
 
     it("returns 0 (missing) for posts without replies", async () => {
       const post = await postService.create({
-        type: "note",
-        content: "no replies",
+        format: "note",
+        body: "no replies",
       });
 
       const counts = await postService.getReplyCounts([post.id]);
@@ -613,17 +749,17 @@ describe("PostService", () => {
 
     it("excludes deleted replies from count", async () => {
       const root = await postService.create({
-        type: "note",
-        content: "root",
+        format: "note",
+        body: "root",
       });
       const reply = await postService.create({
-        type: "note",
-        content: "reply",
+        format: "note",
+        body: "reply",
         replyToId: root.id,
       });
       await postService.create({
-        type: "note",
-        content: "reply2",
+        format: "note",
+        body: "reply2",
         replyToId: root.id,
       });