@jant/core 0.3.34 → 0.3.36

package/src/routes/feed/__tests__/rss.test.ts

@@ -28,7 +28,7 @@ function createFeedTestApp(envOverrides: Partial<Bindings> = {}) {
 
   app.use("*", async (c, next) => {
     const env = {
-      SITE_URL: "http://localhost:9019",
+      SITE_URL: "http://localhost:9020",
       ...envOverrides,
     } as Bindings;
     c.env = env;
@@ -46,17 +46,255 @@ function createFeedTestApp(envOverrides: Partial<Bindings> = {}) {
 }
 
 describe("RSS Feed Routes", () => {
+  describe("/feed — featured only", () => {
+    it("returns only featured posts", async () => {
+      const { app, services } = createFeedTestApp();
+
+      // Create a mix of featured and non-featured posts
+      await services.posts.create({
+        format: "note",
+        title: "Regular Post",
+        body: "Not featured",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Featured Post",
+        body: "This is featured",
+        status: "published",
+        visibility: "featured",
+      });
+
+      const res = await app.request("/feed");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      expect(xml).toContain("Featured Post");
+      expect(xml).not.toContain("Regular Post");
+    });
+
+    it("returns empty feed when no featured posts exist", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "Regular Post",
+        body: "Not featured",
+        status: "published",
+      });
+
+      const res = await app.request("/feed");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      expect(xml).not.toContain("Regular Post");
+    });
+
+    it("returns RSS content type", async () => {
+      const { app } = createFeedTestApp();
+
+      const res = await app.request("/feed");
+      expect(res.headers.get("Content-Type")).toBe(
+        "application/rss+xml; charset=utf-8",
+      );
+    });
+  });
+
+  describe("/feed/atom.xml — featured only (Atom)", () => {
+    it("returns only featured posts in Atom format", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "Regular Post",
+        body: "Not featured",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Featured Post",
+        body: "This is featured",
+        status: "published",
+        visibility: "featured",
+      });
+
+      const res = await app.request("/feed/atom.xml");
+      expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe(
+        "application/atom+xml; charset=utf-8",
+      );
+
+      const xml = await res.text();
+      expect(xml).toContain("Featured Post");
+      expect(xml).not.toContain("Regular Post");
+    });
+  });
+
+  describe("/feed/all — all published posts", () => {
+    it("returns all published posts", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "Regular Post",
+        body: "Not featured",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Featured Post",
+        body: "This is featured",
+        status: "published",
+        visibility: "featured",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Draft Post",
+        body: "Draft",
+        status: "draft",
+      });
+
+      const res = await app.request("/feed/all");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      expect(xml).toContain("Regular Post");
+      expect(xml).toContain("Featured Post");
+      expect(xml).not.toContain("Draft Post");
+    });
+
+    it("filters by format query parameter", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "My Note",
+        body: "A note",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "link",
+        title: "My Link",
+        url: "https://example.com",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "quote",
+        title: "My Quote",
+        quoteText: "Something wise",
+        status: "published",
+      });
+
+      const res = await app.request("/feed/all?format=note");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      expect(xml).toContain("My Note");
+      expect(xml).not.toContain("My Link");
+      expect(xml).not.toContain("My Quote");
+    });
+
+    it("ignores invalid format query parameter", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "My Note",
+        body: "A note",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "link",
+        title: "My Link",
+        url: "https://example.com",
+        status: "published",
+      });
+
+      const res = await app.request("/feed/all?format=invalid");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      // Invalid format is ignored — all posts returned
+      expect(xml).toContain("My Note");
+      expect(xml).toContain("My Link");
+    });
+
+    it("returns RSS content type", async () => {
+      const { app } = createFeedTestApp();
+
+      const res = await app.request("/feed/all");
+      expect(res.headers.get("Content-Type")).toBe(
+        "application/rss+xml; charset=utf-8",
+      );
+    });
+  });
+
+  describe("/feed/all/atom.xml — all published posts (Atom)", () => {
+    it("returns all published posts in Atom format", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "Regular Post",
+        body: "Not featured",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Featured Post",
+        body: "This is featured",
+        status: "published",
+        visibility: "featured",
+      });
+
+      const res = await app.request("/feed/all/atom.xml");
+      expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe(
+        "application/atom+xml; charset=utf-8",
+      );
+
+      const xml = await res.text();
+      expect(xml).toContain("Regular Post");
+      expect(xml).toContain("Featured Post");
+    });
+
+    it("supports format filtering", async () => {
+      const { app, services } = createFeedTestApp();
+
+      await services.posts.create({
+        format: "note",
+        title: "My Note",
+        body: "A note",
+        status: "published",
+      });
+      await services.posts.create({
+        format: "link",
+        title: "My Link",
+        url: "https://example.com",
+        status: "published",
+      });
+
+      const res = await app.request("/feed/all/atom.xml?format=link");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      expect(xml).not.toContain("My Note");
+      expect(xml).toContain("My Link");
+    });
+  });
+
   describe("RSS_FEED_LIMIT env var", () => {
     it("defaults to 50 when RSS_FEED_LIMIT is not set", async () => {
       const { app, services } = createFeedTestApp();
 
-      // Create 3 posts
+      // Create 3 featured posts
       for (let i = 0; i < 3; i++) {
         await services.posts.create({
           format: "note",
           title: `Post ${i}`,
           body: `Body ${i}`,
           status: "published",
+          visibility: "featured",
         });
       }
 
@@ -75,7 +313,7 @@ describe("RSS Feed Routes", () => {
         RSS_FEED_LIMIT: "2",
       });
 
-      // Create 5 posts
+      // Create 5 posts on /feed/all
       for (let i = 0; i < 5; i++) {
         await services.posts.create({
           format: "note",
@@ -85,7 +323,7 @@ describe("RSS Feed Routes", () => {
         });
       }
 
-      const res = await app.request("/feed");
+      const res = await app.request("/feed/all");
       expect(res.status).toBe(200);
 
       const xml = await res.text();
@@ -103,7 +341,7 @@ describe("RSS Feed Routes", () => {
         RSS_FEED_LIMIT: "not-a-number",
       });
 
-      // Create 2 posts
+      // Create 2 posts on /feed/all
       for (let i = 0; i < 2; i++) {
         await services.posts.create({
           format: "note",
@@ -113,7 +351,7 @@ describe("RSS Feed Routes", () => {
         });
       }
 
-      const res = await app.request("/feed");
+      const res = await app.request("/feed/all");
       expect(res.status).toBe(200);
 
       const xml = await res.text();
@@ -133,6 +371,7 @@ describe("RSS Feed Routes", () => {
           title: `Post ${i}`,
           body: `Body ${i}`,
           status: "published",
+          visibility: "featured",
         });
       }
 

package/src/routes/feed/rss.ts

@@ -1,13 +1,19 @@
 /**
  * RSS Feed Routes
+ *
+ * Three-level hierarchy:
+ * - /feed          — featured posts only (curated feed for subscribers)
+ * - /feed/all      — all published posts (with optional ?format= filter)
+ * - /c/{slug}/feed — per-collection feed (handled in collection routes)
  */
 
 import { Hono } from "hono";
 import type { Context } from "hono";
-import type { Bindings, FeedData } from "../../types.js";
+import type { Bindings, FeedData, Format } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { defaultRssRenderer, defaultAtomRenderer } from "../../lib/feed.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
+import { FORMATS } from "../../types/constants.js";
 
 import { createMediaContext, toPostViews } from "../../lib/view.js";
 
@@ -15,10 +21,23 @@ type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const rssRoutes = new Hono<Env>();
 
+interface FeedOptions {
+  visibility?: "featured";
+  excludeUnlisted?: boolean;
+  format?: Format;
+}
+
 /**
  * Build FeedData from the Hono context.
+ *
+ * @param c - Hono context
+ * @param opts - Filter options for the feed
+ * @returns Feed data ready for rendering
  */
-async function buildFeedData(c: Context<Env>): Promise<FeedData> {
+async function buildFeedData(
+  c: Context<Env>,
+  opts?: FeedOptions,
+): Promise<FeedData> {
   const { appConfig } = c.var;
   const siteName = appConfig.siteName;
   const siteDescription = appConfig.siteDescription;
@@ -29,6 +48,9 @@ async function buildFeedData(c: Context<Env>): Promise<FeedData> {
   const posts = await c.var.services.posts.list({
     status: "published",
     excludeReplies: true,
+    visibility: opts?.visibility,
+    excludeUnlisted: opts?.excludeUnlisted,
+    format: opts?.format,
     limit: feedLimit,
   });
 
@@ -61,9 +83,23 @@ async function buildFeedData(c: Context<Env>): Promise<FeedData> {
   };
 }
 
-// RSS 2.0 Feed - main feed at /feed
+/**
+ * Parse and validate the `format` query parameter.
+ * Returns a valid Format or undefined if missing/invalid.
+ */
+function parseFormatQuery(c: Context<Env>): Format | undefined {
+  const raw = c.req.query("format");
+  if (raw && (FORMATS as readonly string[]).includes(raw)) {
+    return raw as Format;
+  }
+  return undefined;
+}
+
+// --- Featured feed (curated) ---
+
+// RSS 2.0 — /feed
 rssRoutes.get("/", async (c) => {
-  const feedData = await buildFeedData(c);
+  const feedData = await buildFeedData(c, { visibility: "featured" });
   const xml = defaultRssRenderer(feedData);
 
   return new Response(xml, {
@@ -73,9 +109,37 @@ rssRoutes.get("/", async (c) => {
   });
 });
 
-// Atom Feed
+// Atom — /feed/atom.xml
 rssRoutes.get("/atom.xml", async (c) => {
-  const feedData = await buildFeedData(c);
+  const feedData = await buildFeedData(c, { visibility: "featured" });
+  const xml = defaultAtomRenderer(feedData);
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/atom+xml; charset=utf-8",
+    },
+  });
+});
+
+// --- All posts feed ---
+
+// RSS 2.0 — /feed/all
+rssRoutes.get("/all", async (c) => {
+  const format = parseFormatQuery(c);
+  const feedData = await buildFeedData(c, { excludeUnlisted: true, format });
+  const xml = defaultRssRenderer(feedData);
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/rss+xml; charset=utf-8",
+    },
+  });
+});
+
+// Atom — /feed/all/atom.xml
+rssRoutes.get("/all/atom.xml", async (c) => {
+  const format = parseFormatQuery(c);
+  const feedData = await buildFeedData(c, { excludeUnlisted: true, format });
   const xml = defaultAtomRenderer(feedData);
 
   return new Response(xml, {

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,
     });