@jant/core 0.3.33 → 0.3.35

package/dist/index.js

@@ -2586,7 +2586,7 @@ const SYSTEM_NAV_KEYS = {
     },
     collections: {
         defaultLabel: "Collections",
-        url: "/collections"
+        url: "/c"
     },
     archive: {
         defaultLabel: "Archive",
@@ -5152,7 +5152,7 @@ const I18nProvider = ({ c, children })=>{
 }
 
 const IS_VITE_DEV = typeof __JANT_DEV__ !== "undefined" && __JANT_DEV__ === true;
-const CORE_VERSION = "0.3.33";
+const CORE_VERSION = "0.3.35";
 
 const BaseLayout = ({ title, description, lang, c, toast, faviconUrl, faviconVersion, noindex, isAuthenticated = false, children })=>{
     // Read lang from Hono context if available, otherwise use prop or default
@@ -6223,7 +6223,7 @@ setupRoutes.post("/setup", async (c)=>{
         await c.var.services.navItems.create({
             type: "link",
             label: "Collections",
-            url: "/collections"
+            url: "/c"
         });
         // Seed default navigation items
         await c.var.services.navItems.create({
@@ -14925,7 +14925,11 @@ composeRoutes.post("/", async (c)=>{
 const rssRoutes = new Hono();
 /**
  * Build FeedData from the Hono context.
- */ async function buildFeedData(c) {
+ *
+ * @param c - Hono context
+ * @param opts - Filter options for the feed
+ * @returns Feed data ready for rendering
+ */ async function buildFeedData(c, opts) {
     const { appConfig } = c.var;
     const siteName = appConfig.siteName;
     const siteDescription = appConfig.siteDescription;
@@ -14935,6 +14939,8 @@ const rssRoutes = new Hono();
     const posts = await c.var.services.posts.list({
         status: "published",
         excludeReplies: true,
+        featured: opts?.featured,
+        format: opts?.format,
         limit: feedLimit
     });
     // Batch load media for enclosures
@@ -14955,9 +14961,22 @@ const rssRoutes = new Hono();
         posts: postViews
     };
 }
-// 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) {
+    const raw = c.req.query("format");
+    if (raw && FORMATS.includes(raw)) {
+        return raw;
+    }
+    return undefined;
+}
+// --- Featured feed (curated) ---
+// RSS 2.0 — /feed
 rssRoutes.get("/", async (c)=>{
-    const feedData = await buildFeedData(c);
+    const feedData = await buildFeedData(c, {
+        featured: true
+    });
     const xml = defaultRssRenderer(feedData);
     return new Response(xml, {
         headers: {
@@ -14965,9 +14984,38 @@ 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, {
+        featured: true
+    });
+    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, {
+        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, {
+        format
+    });
     const xml = defaultAtomRenderer(feedData);
     return new Response(xml, {
         headers: {
@@ -15575,7 +15623,7 @@ const errorHandler = (err, c)=>{
     app.route("/archive", archiveRoutes);
     app.route("/featured", featuredRoutes);
     app.route("/latest", latestRoutes);
-    app.route("/collections", collectionsPageRoutes);
+    app.route("/c", collectionsPageRoutes);
     app.route("/c", collectionRoutes);
     app.route("/p", postRoutes);
     app.route("/", homeRoutes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {

package/src/app.tsx

@@ -266,7 +266,7 @@ export function createApp(): App {
   app.route("/archive", archiveRoutes);
   app.route("/featured", featuredRoutes);
   app.route("/latest", latestRoutes);
-  app.route("/collections", collectionsPageRoutes);
+  app.route("/c", collectionsPageRoutes);
   app.route("/c", collectionRoutes);
   app.route("/p", postRoutes);
   app.route("/", homeRoutes);

package/src/routes/auth/__tests__/setup.test.ts

@@ -23,7 +23,7 @@ async function runSetupSeed(services: {
   await services.navItems.create({
     type: "link",
     label: "Collections",
-    url: "/collections",
+    url: "/c",
   });
   await services.navItems.create({
     type: "link",

package/src/routes/auth/setup.tsx

@@ -198,7 +198,7 @@ setupRoutes.post("/setup", async (c) => {
     await c.var.services.navItems.create({
       type: "link",
       label: "Collections",
-      url: "/collections",
+      url: "/c",
     });
     // Seed default navigation items
     await c.var.services.navItems.create({

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

@@ -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",
+        featured: true,
+      });
+
+      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",
+        featured: true,
+      });
+
+      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",
+        featured: true,
+      });
+      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",
+        featured: true,
+      });
+
+      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",
+          featured: true,
         });
       }
 
@@ -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",
+          featured: true,
         });
       }
 

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,22 @@ type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const rssRoutes = new Hono<Env>();
 
+interface FeedOptions {
+  featured?: 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 +47,8 @@ async function buildFeedData(c: Context<Env>): Promise<FeedData> {
   const posts = await c.var.services.posts.list({
     status: "published",
     excludeReplies: true,
+    featured: opts?.featured,
+    format: opts?.format,
     limit: feedLimit,
   });
 
@@ -61,9 +81,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, { featured: true });
   const xml = defaultRssRenderer(feedData);
 
   return new Response(xml, {
@@ -73,9 +107,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, { featured: true });
+  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, { 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, { format });
   const xml = defaultAtomRenderer(feedData);
 
   return new Response(xml, {

package/src/types/constants.ts

@@ -22,7 +22,7 @@ export type NavItemType = (typeof NAV_ITEM_TYPES)[number];
 export const SYSTEM_NAV_KEYS = {
   rss: { defaultLabel: "RSS", url: "/feed" },
   dashboard: { defaultLabel: "Dashboard", url: "/dash" },
-  collections: { defaultLabel: "Collections", url: "/collections" },
+  collections: { defaultLabel: "Collections", url: "/c" },
   archive: { defaultLabel: "Archive", url: "/archive" },
 } as const;
 export type SystemNavKey = keyof typeof SYSTEM_NAV_KEYS;