@jant/core 0.3.35 → 0.3.36

package/src/routes/pages/__tests__/featured.test.ts

@@ -26,24 +26,23 @@ describe("Featured Page - Data Logic", () => {
     await postService.create({
       format: "note",
       body: "Featured post",
-      featured: true,
+      visibility: "featured",
       status: "published",
     });
     await postService.create({
       format: "note",
       body: "Normal post",
-      featured: false,
       status: "published",
     });
     await postService.create({
       format: "note",
       body: "Draft featured",
-      featured: true,
+      visibility: "featured",
       status: "draft",
     });
 
     const posts = await postService.list({
-      featured: true,
+      visibility: "featured",
       status: "published",
       excludeReplies: true,
     });
@@ -60,7 +59,7 @@ describe("Featured Page - Data Logic", () => {
     });
 
     const posts = await postService.list({
-      featured: true,
+      visibility: "featured",
       status: "published",
       excludeReplies: true,
     });
@@ -72,7 +71,7 @@ describe("Featured Page - Data Logic", () => {
     const root = await postService.create({
       format: "note",
       body: "Featured root",
-      featured: true,
+      visibility: "featured",
       status: "published",
     });
 
@@ -84,7 +83,7 @@ describe("Featured Page - Data Logic", () => {
     });
 
     const posts = await postService.list({
-      featured: true,
+      visibility: "featured",
       status: "published",
       excludeReplies: true,
     });

package/src/routes/pages/archive.tsx

@@ -1,13 +1,13 @@
 /**
  * Archive Page Route
  *
- * Shows all posts, optionally filtered by format or featured status
+ * Shows all posts, optionally filtered by format or visibility
  */
 
 import { Hono } from "hono";
-import type { Bindings, Format } from "../../types.js";
+import type { Bindings, Format, Visibility } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
-import { FORMATS } from "../../types.js";
+import { FORMATS, VISIBILITIES } from "../../types.js";
 import { ArchivePage } from "../../ui/pages/ArchivePage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
@@ -24,8 +24,12 @@ archiveRoutes.get("/", async (c) => {
   const formatParam = c.req.query("format") as Format | undefined;
   const format =
     formatParam && FORMATS.includes(formatParam) ? formatParam : undefined;
-  const featuredParam = c.req.query("featured");
-  const featured = featuredParam === "true" ? true : undefined;
+  const visibilityParam = c.req.query("visibility") as Visibility | undefined;
+  const visibility =
+    visibilityParam &&
+    (VISIBILITIES as readonly string[]).includes(visibilityParam)
+      ? visibilityParam
+      : undefined;
 
   // Parse cursor
   const cursorParam = c.req.query("cursor");
@@ -37,7 +41,7 @@ archiveRoutes.get("/", async (c) => {
   const posts = await c.var.services.posts.list({
     format,
     status: "published",
-    featured,
+    visibility,
     excludeReplies: true,
     cursor,
     limit: PAGE_SIZE + 1,
@@ -78,7 +82,7 @@ archiveRoutes.get("/", async (c) => {
         hasMore={hasMore}
         nextCursor={nextCursor}
         format={format}
-        featured={featured}
+        visibility={visibility}
       />
     ),
   });

package/src/routes/pages/collection.tsx

@@ -8,11 +8,7 @@ import type { AppVariables } from "../../types/app-context.js";
 import { CollectionPage } from "../../ui/pages/CollectionPage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
-import {
-  createMediaContext,
-  toPostViewsFromPosts,
-  toPostViews,
-} from "../../lib/view.js";
+import { createMediaContext, toPostViews } from "../../lib/view.js";
 import { defaultRssRenderer } from "../../lib/feed.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
 import { CollectionsSidebar } from "../../ui/shared/CollectionsSidebar.js";
@@ -27,35 +23,56 @@ collectionRoutes.get("/:slug", async (c) => {
   const collection = await c.var.services.collections.getBySlug(slug);
   if (!collection) return c.notFound();
 
-  // Fetch posts and all collections in parallel
-  const [posts, allCollections] = await Promise.all([
+  // Fetch posts, all collections, dividers, and post counts in parallel
+  const [posts, allCollections, dividers, postCounts] = await Promise.all([
     c.var.services.posts.list({
       collectionId: collection.id,
       status: "published",
       excludeReplies: true,
     }),
     c.var.services.collections.list(),
+    c.var.services.collections.listDividers(),
+    c.var.services.collections.getPostCounts(),
   ]);
 
   const navData = await getNavigationData(c);
 
-  // Transform to View Models
+  // Batch-load media for posts
+  const postIds = posts.map((p) => p.id);
+  const rawMediaMap = await c.var.services.media.getByPostIds(postIds);
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const postViews = toPostViewsFromPosts(posts, mediaCtx);
+  const mediaMap = buildMediaMap(
+    rawMediaMap,
+    mediaCtx.r2PublicUrl,
+    mediaCtx.imageTransformUrl,
+    mediaCtx.s3PublicUrl,
+  );
+
+  const postViews = toPostViews(
+    posts.map((p) => ({
+      ...p,
+      mediaAttachments: mediaMap.get(p.id) ?? [],
+    })),
+    mediaCtx,
+  );
+
+  const items = postViews.map((post) => ({ post }));
 
   return renderPublicPage(c, {
     title: `${collection.title} - ${navData.siteName}`,
     description: collection.description ?? undefined,
     navData,
     sidebar: (
-      <CollectionsSidebar collections={allCollections} activeSlug={slug} />
+      <CollectionsSidebar
+        collections={allCollections}
+        dividers={dividers}
+        activeSlug={slug}
+        isAuthenticated={navData.isAuthenticated}
+        postCounts={postCounts}
+      />
     ),
     content: (
-      <CollectionPage
-        collection={collection}
-        posts={postViews}
-        hasMore={false}
-      />
+      <CollectionPage collection={collection} items={items} hasMore={false} />
     ),
   });
 });

package/src/routes/pages/collections.tsx

@@ -17,8 +17,9 @@ type Env = { Bindings: Bindings; Variables: AppVariables };
 export const collectionsPageRoutes = new Hono<Env>();
 
 collectionsPageRoutes.get("/", async (c) => {
-  const [allCollections, postCounts] = await Promise.all([
+  const [allCollections, dividers, postCounts] = await Promise.all([
     c.var.services.collections.list(),
+    c.var.services.collections.listDividers(),
     c.var.services.collections.getPostCounts(),
   ]);
 
@@ -32,7 +33,15 @@ collectionsPageRoutes.get("/", async (c) => {
   return renderPublicPage(c, {
     title: `Collections - ${navData.siteName}`,
     navData,
-    sidebar: <CollectionsSidebar collections={allCollections} />,
+    sidebar: (
+      <CollectionsSidebar
+        collections={allCollections}
+        dividers={dividers}
+        activeSlug={undefined}
+        isAuthenticated={navData.isAuthenticated}
+        postCounts={postCounts}
+      />
+    ),
     content: <CollectionsPage collections={collections} />,
   });
 });

package/src/routes/pages/featured.tsx

@@ -25,7 +25,7 @@ featuredRoutes.get("/", async (c) => {
   }
 
   const posts = await c.var.services.posts.list({
-    featured: true,
+    visibility: "featured",
     status: "published",
     excludeReplies: true,
   });

package/src/routes/pages/home.tsx

@@ -28,7 +28,7 @@ homeRoutes.get("/", async (c) => {
   if (navData.homeDefaultView === "featured") {
     // Show featured posts on homepage
     const posts = await c.var.services.posts.list({
-      featured: true,
+      visibility: "featured",
       status: "published",
       excludeReplies: true,
     });

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

@@ -22,28 +22,51 @@ describe("PostService", () => {
 
   describe("create", () => {
     it("creates a note post with required fields", async () => {
+      const body = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: "Hello world" }],
+          },
+        ],
+      });
       const post = await postService.create({
         format: "note",
-        body: "Hello world",
+        body,
       });
 
       expect(post.id).toBe(1);
       expect(post.format).toBe("note");
-      expect(post.body).toBe("Hello world");
+      expect(post.body).toBe(body);
       expect(post.status).toBe("published"); // default
-      expect(post.featured).toBe(0);
+      expect(post.visibility).toBe("listed");
       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 body = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "heading",
+            attrs: { level: 1 },
+            content: [{ type: "text", text: "Introduction" }],
+          },
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: "Some content." }],
+          },
+        ],
+      });
       const post = await postService.create({
         format: "link",
         title: "My Link",
-        body: "# Introduction\n\nSome content.",
+        body,
         status: "published",
-        featured: true,
+        visibility: "featured",
         pinned: true,
         path: "my-link",
         url: "https://example.com/source",
@@ -54,7 +77,7 @@ describe("PostService", () => {
       expect(post.format).toBe("link");
       expect(post.title).toBe("My Link");
       expect(post.status).toBe("published");
-      expect(post.featured).toBe(1);
+      expect(post.visibility).toBe("featured");
       expect(post.pinned).toBe(1);
       expect(post.path).toBe("my-link");
       expect(post.url).toBe("https://example.com/source");
@@ -63,10 +86,27 @@ describe("PostService", () => {
       expect(post.bodyHtml).toContain("<h1>");
     });
 
-    it("renders markdown body to HTML", async () => {
+    it("renders Tiptap JSON body to HTML", async () => {
+      const body = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "This is " },
+              {
+                type: "text",
+                marks: [{ type: "bold" }],
+                text: "bold",
+              },
+              { type: "text", text: " text" },
+            ],
+          },
+        ],
+      });
       const post = await postService.create({
         format: "note",
-        body: "This is **bold** text",
+        body,
       });
 
       expect(post.bodyHtml).toContain("<strong>bold</strong>");
@@ -267,26 +307,60 @@ describe("PostService", () => {
       expect(published[0]?.status).toBe("published");
     });
 
-    it("filters by featured", async () => {
+    it("filters by visibility", async () => {
       await postService.create({
         format: "note",
         body: "featured post",
-        featured: true,
+        visibility: "featured",
       });
       await postService.create({
         format: "note",
         body: "normal post",
       });
+      await postService.create({
+        format: "note",
+        body: "unlisted post",
+        visibility: "unlisted",
+      });
 
-      const featured = await postService.list({ featured: true });
+      const featured = await postService.list({ visibility: "featured" });
       expect(featured).toHaveLength(1);
-      expect(featured[0]?.featured).toBe(1);
+      expect(featured[0]?.visibility).toBe("featured");
       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");
+      const listed = await postService.list({ visibility: "listed" });
+      expect(listed).toHaveLength(1);
+      expect(listed[0]?.visibility).toBe("listed");
+      expect(listed[0]?.body).toBe("normal post");
+
+      const unlisted = await postService.list({ visibility: "unlisted" });
+      expect(unlisted).toHaveLength(1);
+      expect(unlisted[0]?.visibility).toBe("unlisted");
+      expect(unlisted[0]?.body).toBe("unlisted post");
+    });
+
+    it("excludes unlisted posts when requested", async () => {
+      await postService.create({
+        format: "note",
+        body: "listed post",
+      });
+      await postService.create({
+        format: "note",
+        body: "unlisted post",
+        visibility: "unlisted",
+      });
+      await postService.create({
+        format: "note",
+        body: "featured post",
+        visibility: "featured",
+      });
+
+      const posts = await postService.list({ excludeUnlisted: true });
+      expect(posts).toHaveLength(2);
+      expect(posts.map((p) => p.body).sort()).toEqual([
+        "featured post",
+        "listed post",
+      ]);
     });
 
     it("filters by pinned", async () => {
@@ -426,15 +500,15 @@ describe("PostService", () => {
       expect(count).toBe(1);
     });
 
-    it("filters by featured", async () => {
+    it("filters by visibility", async () => {
       await postService.create({
         format: "note",
         body: "featured",
-        featured: true,
+        visibility: "featured",
       });
       await postService.create({ format: "note", body: "normal" });
 
-      const count = await postService.count({ featured: true });
+      const count = await postService.count({ visibility: "featured" });
       expect(count).toBe(1);
     });
 
@@ -470,15 +544,32 @@ describe("PostService", () => {
     it("updates post body", async () => {
       const post = await postService.create({
         format: "note",
-        body: "original",
+        body: JSON.stringify({
+          type: "doc",
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "original" }],
+            },
+          ],
+        }),
+      });
+
+      const updatedBody = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: "updated content" }],
+          },
+        ],
       });
-
       const updated = await postService.update(post.id, {
-        body: "updated content",
+        body: updatedBody,
       });
 
       expect(updated).not.toBeNull();
-      expect(updated?.body).toBe("updated content");
+      expect(updated?.body).toBe(updatedBody);
       expect(updated?.bodyHtml).toContain("updated content");
     });
 
@@ -547,19 +638,19 @@ describe("PostService", () => {
       expect(updated?.updatedAt).toBeGreaterThanOrEqual(originalUpdatedAt);
     });
 
-    it("updates featured flag", async () => {
+    it("updates visibility", async () => {
       const post = await postService.create({
         format: "note",
         body: "test",
       });
 
-      expect(post.featured).toBe(0);
+      expect(post.visibility).toBe("listed");
 
       const updated = await postService.update(post.id, {
-        featured: true,
+        visibility: "featured",
       });
 
-      expect(updated?.featured).toBe(1);
+      expect(updated?.visibility).toBe("featured");
     });
 
     it("updates pinned flag", async () => {
@@ -723,11 +814,11 @@ describe("PostService", () => {
       expect(reply.status).toBe("draft");
     });
 
-    it("inherits featured from root post", async () => {
+    it("inherits visibility from root post", async () => {
       const root = await postService.create({
         format: "note",
         body: "root",
-        featured: true,
+        visibility: "featured",
       });
       const reply = await postService.create({
         format: "note",
@@ -735,7 +826,7 @@ describe("PostService", () => {
         replyToId: root.id,
       });
 
-      expect(reply.featured).toBe(1);
+      expect(reply.visibility).toBe("featured");
     });
 
     it("getThread returns all posts in a thread", async () => {
@@ -797,7 +888,7 @@ describe("PostService", () => {
       }
     });
 
-    it("cascades featured changes from root to thread", async () => {
+    it("cascades visibility changes from root to thread", async () => {
       const root = await postService.create({
         format: "note",
         body: "root",
@@ -808,11 +899,11 @@ describe("PostService", () => {
         replyToId: root.id,
       });
 
-      await postService.update(root.id, { featured: true });
+      await postService.update(root.id, { visibility: "featured" });
 
       const thread = await postService.getThread(root.id);
       for (const post of thread) {
-        expect(post.featured).toBe(1);
+        expect(post.visibility).toBe("featured");
       }
     });
   });

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

@@ -102,7 +102,7 @@ describe("SettingsService", () => {
       siteFooter: "",
       siteLanguage: "en",
       homeDefaultView: "latest",
-      headerNavMaxVisible: "3",
+      headerNavMaxVisible: "2",
       timeZone: "UTC",
     };
 
@@ -154,10 +154,10 @@ describe("SettingsService", () => {
       expect(await settingsService.get("HOME_DEFAULT_VIEW")).toBe("featured");
     });
 
-    it("removes HEADER_NAV_MAX_VISIBLE when set to default (3)", async () => {
+    it("removes HEADER_NAV_MAX_VISIBLE when set to default (2)", async () => {
       await settingsService.set("HEADER_NAV_MAX_VISIBLE", "5");
       await settingsService.updateGeneral(
-        { ...defaults, headerNavMaxVisible: "3" },
+        { ...defaults, headerNavMaxVisible: "2" },
         { oldLanguage: "en", fallbackSiteName: "Jant" },
       );
 

package/src/services/page.ts

@@ -27,10 +27,23 @@ export interface PageService {
   delete(id: number): Promise<boolean>;
 }
 
-/** Check if an error is a SQLite UNIQUE constraint violation (D1 or better-sqlite3) */
+/** Check if an error (or any of its causes) is a SQLite UNIQUE constraint violation */
 function isUniqueConstraintError(err: unknown): boolean {
-  const msg = String(err);
-  return msg.includes("UNIQUE constraint") || msg.includes("SQLITE_CONSTRAINT");
+  let current: unknown = err;
+  while (current) {
+    const msg = String(current);
+    if (
+      msg.includes("UNIQUE constraint") ||
+      msg.includes("SQLITE_CONSTRAINT")
+    ) {
+      return true;
+    }
+    current =
+      current instanceof Error && current.cause !== current
+        ? current.cause
+        : undefined;
+  }
+  return false;
 }
 
 export function createPageService(