@jant/core 0.3.24 → 0.3.26

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

@@ -0,0 +1,141 @@
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../app.js";
+import { createTestDatabase } from "../../../__tests__/helpers/db.js";
+import { createPostService } from "../../../services/post.js";
+import { createSettingsService } from "../../../services/settings.js";
+import { createMediaService } from "../../../services/media.js";
+import { rssRoutes } from "../rss.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+function createFeedTestApp(envOverrides: Partial<Bindings> = {}) {
+  const { db } = createTestDatabase();
+
+  const services = {
+    posts: createPostService(db as never),
+    settings: createSettingsService(db as never),
+    media: createMediaService(db as never),
+  };
+
+  const app = new Hono<Env>();
+
+  app.use("*", async (c, next) => {
+    c.env = {
+      SITE_URL: "http://localhost:9019",
+      ...envOverrides,
+    } as Bindings;
+
+    c.set("services", services as AppVariables["services"]);
+    c.set("config", {});
+    await next();
+  });
+
+  app.route("/feed", rssRoutes);
+
+  return { app, services };
+}
+
+describe("RSS Feed Routes", () => {
+  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
+      for (let i = 0; i < 3; i++) {
+        await services.posts.create({
+          format: "note",
+          title: `Post ${i}`,
+          body: `Body ${i}`,
+          status: "published",
+        });
+      }
+
+      const res = await app.request("/feed");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      // All 3 posts should appear (under default limit of 50)
+      expect(xml).toContain("Post 0");
+      expect(xml).toContain("Post 1");
+      expect(xml).toContain("Post 2");
+    });
+
+    it("respects RSS_FEED_LIMIT to limit the number of posts", async () => {
+      const { app, services } = createFeedTestApp({
+        RSS_FEED_LIMIT: "2",
+      });
+
+      // Create 5 posts
+      for (let i = 0; i < 5; i++) {
+        await services.posts.create({
+          format: "note",
+          title: `Post ${i}`,
+          body: `Body ${i}`,
+          status: "published",
+        });
+      }
+
+      const res = await app.request("/feed");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      // Posts are ordered by publishedAt DESC, so the latest 2 should appear
+      // With same timestamp they fall back to id DESC, so Post 4 and Post 3
+      expect(xml).toContain("Post 4");
+      expect(xml).toContain("Post 3");
+      expect(xml).not.toContain("Post 2");
+      expect(xml).not.toContain("Post 1");
+      expect(xml).not.toContain("Post 0");
+    });
+
+    it("falls back to 50 for invalid RSS_FEED_LIMIT", async () => {
+      const { app, services } = createFeedTestApp({
+        RSS_FEED_LIMIT: "not-a-number",
+      });
+
+      // Create 2 posts
+      for (let i = 0; i < 2; i++) {
+        await services.posts.create({
+          format: "note",
+          title: `Post ${i}`,
+          body: `Body ${i}`,
+          status: "published",
+        });
+      }
+
+      const res = await app.request("/feed");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      // Both posts should appear (fallback to 50)
+      expect(xml).toContain("Post 0");
+      expect(xml).toContain("Post 1");
+    });
+
+    it("also applies to atom feed", async () => {
+      const { app, services } = createFeedTestApp({
+        RSS_FEED_LIMIT: "1",
+      });
+
+      for (let i = 0; i < 3; i++) {
+        await services.posts.create({
+          format: "note",
+          title: `Post ${i}`,
+          body: `Body ${i}`,
+          status: "published",
+        });
+      }
+
+      const res = await app.request("/feed/atom.xml");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      // Only the latest post should appear
+      expect(xml).toContain("Post 2");
+      expect(xml).not.toContain("Post 1");
+      expect(xml).not.toContain("Post 0");
+    });
+  });
+});

package/src/routes/feed/rss.ts

@@ -25,10 +25,12 @@ async function buildFeedData(c: Context<Env>): Promise<FeedData> {
   const siteUrl = c.env.SITE_URL;
   const siteLanguage = await getSiteLanguage(c);
 
+  const feedLimit = parseInt(c.env.RSS_FEED_LIMIT ?? "50", 10) || 50;
+
   const posts = await c.var.services.posts.list({
     status: "published",
     excludeReplies: true,
-    limit: 50,
+    limit: feedLimit,
   });
 
   // Batch load media for enclosures
@@ -64,7 +66,7 @@ async function buildFeedData(c: Context<Env>): Promise<FeedData> {
 rssRoutes.get("/", async (c) => {
   const feedData = await buildFeedData(c);
 
-  const renderer = c.var.config.theme?.feed?.rss ?? defaultRssRenderer;
+  const renderer = c.var.config.feed?.rss ?? defaultRssRenderer;
   const xml = renderer(feedData);
 
   return new Response(xml, {
@@ -78,7 +80,7 @@ rssRoutes.get("/", async (c) => {
 rssRoutes.get("/atom.xml", async (c) => {
   const feedData = await buildFeedData(c);
 
-  const renderer = c.var.config.theme?.feed?.atom ?? defaultAtomRenderer;
+  const renderer = c.var.config.feed?.atom ?? defaultAtomRenderer;
   const xml = renderer(feedData);
 
   return new Response(xml, {

package/src/routes/feed/sitemap.ts

@@ -35,7 +35,7 @@ sitemapRoutes.get("/sitemap.xml", async (c) => {
   const postViews = toPostViewsFromPosts(posts, mediaCtx);
   const pageViews = publishedPages.map(toPageView);
 
-  const renderer = c.var.config.theme?.feed?.sitemap ?? defaultSitemapRenderer;
+  const renderer = c.var.config.feed?.sitemap ?? defaultSitemapRenderer;
   const xml = renderer({ siteUrl, posts: postViews, pages: pageViews });
 
   return new Response(xml, {
@@ -46,11 +46,13 @@ sitemapRoutes.get("/sitemap.xml", async (c) => {
 });
 
 // robots.txt
-sitemapRoutes.get("/robots.txt", (c) => {
+sitemapRoutes.get("/robots.txt", async (c) => {
   const siteUrl = c.env.SITE_URL;
+  const noindex = (await c.var.services.settings.get("NOINDEX")) === "true";
 
+  const directive = noindex ? "Disallow: /" : "Allow: /";
   const robots = `User-agent: *
-Allow: /
+${directive}
 
 Sitemap: ${siteUrl}/sitemap.xml
 `;

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

@@ -0,0 +1,94 @@
+/**
+ * Tests for the collections listing page data logic.
+ *
+ * Note: Route handler tests that import JSX components with @lingui/react/macro
+ * cannot run in vitest (requires SWC plugin). These tests verify the service
+ * layer operations that the collections route orchestrates.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../../__tests__/helpers/db.js";
+import { createCollectionService } from "../../../services/collection.js";
+import { createPostService } from "../../../services/post.js";
+import type { Database } from "../../../db/index.js";
+
+describe("Collections Listing Page - Data Logic", () => {
+  let db: Database;
+  let collectionService: ReturnType<typeof createCollectionService>;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    collectionService = createCollectionService(db);
+    postService = createPostService(db);
+  });
+
+  it("returns collections with post counts", async () => {
+    const recipes = await collectionService.create({
+      slug: "recipes",
+      title: "Recipes",
+    });
+    await collectionService.create({
+      slug: "travel",
+      title: "Travel",
+    });
+
+    // Add posts to recipes collection
+    await postService.create({
+      format: "note",
+      body: "Recipe 1",
+      collectionId: recipes.id,
+    });
+    await postService.create({
+      format: "note",
+      body: "Recipe 2",
+      collectionId: recipes.id,
+    });
+
+    // Simulate route handler logic
+    const [allCollections, postCounts] = await Promise.all([
+      collectionService.list(),
+      collectionService.getPostCounts(),
+    ]);
+
+    const collections = allCollections.map((col) => ({
+      ...col,
+      postCount: postCounts.get(col.id) ?? 0,
+    }));
+
+    expect(collections).toHaveLength(2);
+    const recipesResult = collections.find((c) => c.slug === "recipes");
+    const travelResult = collections.find((c) => c.slug === "travel");
+    expect(recipesResult?.postCount).toBe(2);
+    expect(travelResult?.postCount).toBe(0);
+  });
+
+  it("returns empty list when no collections exist", async () => {
+    const allCollections = await collectionService.list();
+    expect(allCollections).toHaveLength(0);
+  });
+
+  it("does not count soft-deleted posts", async () => {
+    const col = await collectionService.create({
+      slug: "test",
+      title: "Test",
+    });
+
+    const post = await postService.create({
+      format: "note",
+      body: "Will be deleted",
+      collectionId: col.id,
+    });
+    await postService.create({
+      format: "note",
+      body: "Will remain",
+      collectionId: col.id,
+    });
+
+    await postService.delete(post.id);
+
+    const postCounts = await collectionService.getPostCounts();
+    expect(postCounts.get(col.id)).toBe(1);
+  });
+});

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

@@ -0,0 +1,94 @@
+/**
+ * Tests for the featured page data logic.
+ *
+ * Note: Route handler tests that import JSX components with @lingui/react/macro
+ * cannot run in vitest (requires SWC plugin). These tests verify the service
+ * layer operations that the featured route orchestrates.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../../__tests__/helpers/db.js";
+import { createPostService } from "../../../services/post.js";
+import type { Database } from "../../../db/index.js";
+
+describe("Featured Page - Data Logic", () => {
+  let db: Database;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    postService = createPostService(db);
+  });
+
+  it("returns only featured published posts", async () => {
+    await postService.create({
+      format: "note",
+      body: "Featured post",
+      featured: true,
+      status: "published",
+    });
+    await postService.create({
+      format: "note",
+      body: "Normal post",
+      featured: false,
+      status: "published",
+    });
+    await postService.create({
+      format: "note",
+      body: "Draft featured",
+      featured: true,
+      status: "draft",
+    });
+
+    const posts = await postService.list({
+      featured: true,
+      status: "published",
+      excludeReplies: true,
+    });
+
+    expect(posts).toHaveLength(1);
+    expect(posts[0]?.body).toBe("Featured post");
+  });
+
+  it("returns empty list when no featured posts exist", async () => {
+    await postService.create({
+      format: "note",
+      body: "Normal post",
+      status: "published",
+    });
+
+    const posts = await postService.list({
+      featured: true,
+      status: "published",
+      excludeReplies: true,
+    });
+
+    expect(posts).toHaveLength(0);
+  });
+
+  it("excludes replies from featured posts", async () => {
+    const root = await postService.create({
+      format: "note",
+      body: "Featured root",
+      featured: true,
+      status: "published",
+    });
+
+    // Reply inherits featured from root
+    await postService.create({
+      format: "note",
+      body: "Reply to featured",
+      replyToId: root.id,
+    });
+
+    const posts = await postService.list({
+      featured: true,
+      status: "published",
+      excludeReplies: true,
+    });
+
+    expect(posts).toHaveLength(1);
+    expect(posts[0]?.body).toBe("Featured root");
+  });
+});

package/src/routes/pages/archive.tsx

@@ -8,7 +8,7 @@ import { Hono } from "hono";
 import type { Bindings, Format } from "../../types.js";
 import type { AppVariables } from "../../app.js";
 import { FORMATS } from "../../types.js";
-import { ArchivePage as DefaultArchivePage } from "../../themes/threads/pages/ArchivePage.js";
+import { ArchivePage } from "../../ui/pages/ArchivePage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { createMediaContext, toArchiveGroups } from "../../lib/view.js";
@@ -69,20 +69,16 @@ archiveRoutes.get("/", async (c) => {
   const mediaCtx = createMediaContext(c);
   const groups = toArchiveGroups(grouped, mediaCtx);
 
-  const components = c.var.config.theme?.components;
-  const Page = components?.ArchivePage ?? DefaultArchivePage;
-
   return renderPublicPage(c, {
     title: `Archive - ${navData.siteName}`,
     navData,
     content: (
-      <Page
+      <ArchivePage
         groups={groups}
         hasMore={hasMore}
         nextCursor={nextCursor}
         format={format}
         featured={featured}
-        theme={components}
       />
     ),
   });

package/src/routes/pages/collection.tsx

@@ -5,7 +5,7 @@
 import { Hono } from "hono";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../app.js";
-import { CollectionPage as DefaultCollectionPage } from "../../themes/threads/pages/CollectionPage.js";
+import { CollectionPage } from "../../ui/pages/CollectionPage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { createMediaContext, toPostViewsFromPosts } from "../../lib/view.js";
@@ -33,19 +33,15 @@ collectionRoutes.get("/:slug", async (c) => {
   const mediaCtx = createMediaContext(c);
   const postViews = toPostViewsFromPosts(posts, mediaCtx);
 
-  const components = c.var.config.theme?.components;
-  const Page = components?.CollectionPage ?? DefaultCollectionPage;
-
   return renderPublicPage(c, {
     title: `${collection.title} - ${navData.siteName}`,
     description: collection.description ?? undefined,
     navData,
     content: (
-      <Page
+      <CollectionPage
         collection={collection}
         posts={postViews}
         hasMore={false}
-        theme={components}
       />
     ),
   });

package/src/routes/pages/collections.tsx

@@ -0,0 +1,36 @@
+/**
+ * Collections Listing Page Route
+ *
+ * Lists all collections with their post counts.
+ */
+
+import { Hono } from "hono";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { getNavigationData } from "../../lib/navigation.js";
+import { renderPublicPage } from "../../lib/render.js";
+import { CollectionsPage } from "../../ui/pages/CollectionsPage.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const collectionsPageRoutes = new Hono<Env>();
+
+collectionsPageRoutes.get("/", async (c) => {
+  const [allCollections, postCounts] = await Promise.all([
+    c.var.services.collections.list(),
+    c.var.services.collections.getPostCounts(),
+  ]);
+
+  const collections = allCollections.map((col) => ({
+    ...col,
+    postCount: postCounts.get(col.id) ?? 0,
+  }));
+
+  const navData = await getNavigationData(c);
+
+  return renderPublicPage(c, {
+    title: `Collections - ${navData.siteName}`,
+    navData,
+    content: <CollectionsPage collections={collections} />,
+  });
+});

package/src/routes/pages/featured.tsx

@@ -0,0 +1,44 @@
+/**
+ * Featured Page Route
+ *
+ * Shows featured posts as a timeline feed.
+ */
+
+import { Hono } from "hono";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { getNavigationData } from "../../lib/navigation.js";
+import { renderPublicPage } from "../../lib/render.js";
+import { createMediaContext, toPostViewsFromPosts } from "../../lib/view.js";
+import { FeaturedPage } from "../../ui/pages/FeaturedPage.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const featuredRoutes = new Hono<Env>();
+
+featuredRoutes.get("/", async (c) => {
+  const navData = await getNavigationData(c);
+
+  // When homepage already shows featured, redirect to avoid duplicate content
+  if (navData.homeDefaultView === "featured") {
+    return c.redirect("/", 302);
+  }
+
+  const posts = await c.var.services.posts.list({
+    featured: true,
+    status: "published",
+    excludeReplies: true,
+  });
+
+  const mediaCtx = createMediaContext(c);
+  const postViews = toPostViewsFromPosts(posts, mediaCtx);
+
+  // Convert to timeline items (simple — no thread previews)
+  const items = postViews.map((post) => ({ post }));
+
+  return renderPublicPage(c, {
+    title: `Featured - ${navData.siteName}`,
+    navData,
+    content: <FeaturedPage items={items} />,
+  });
+});

package/src/routes/pages/home.tsx

@@ -2,7 +2,10 @@
  * Home Page Route
  *
  * Timeline feed with per-type card components and thread previews.
- * Handles both full-page rendering and load-more SSE responses.
+ * Uses page-based pagination.
+ *
+ * When HOME_DEFAULT_VIEW is "featured", the homepage shows featured posts
+ * instead of latest. The /latest route always shows latest posts explicitly.
  */
 
 import { Hono } from "hono";
@@ -11,64 +14,42 @@ import type { AppVariables } from "../../app.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { assembleTimeline } from "../../lib/timeline.js";
-import { sse } from "../../lib/sse.js";
 import { createMediaContext, toPostViewsFromPosts } from "../../lib/view.js";
-import { HomePage as DefaultHomePage } from "../../themes/threads/pages/HomePage.js";
+import { HomePage } from "../../ui/pages/HomePage.js";
+import { FeaturedPage } from "../../ui/pages/FeaturedPage.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const homeRoutes = new Hono<Env>();
 
 homeRoutes.get("/", async (c) => {
-  const cursorParam = c.req.query("cursor");
-  const cursor = cursorParam ? parseInt(cursorParam, 10) : undefined;
-  const lastDate = c.req.query("lastDate");
-
-  const { items, hasMore, nextCursor } = await assembleTimeline(c, {
-    cursor: cursor && !isNaN(cursor) ? cursor : undefined,
-  });
-
-  // SSE load-more response
-  if (cursor && !isNaN(cursor)) {
-    if (items.length === 0) {
-      return sse(c, async (stream) => {
-        stream.remove("#load-more-container");
-      });
-    }
-
-    const themeConfig = c.var.config.theme;
-    const renderMore = themeConfig?.timelineMore;
-    if (!renderMore) {
-      // Should never happen — default theme always provides timelineMore
-      return sse(c, async (stream) => {
-        stream.remove("#load-more-container");
-      });
-    }
+  const navData = await getNavigationData(c);
 
-    const patches = renderMore({
-      items,
-      lastDate: lastDate ?? undefined,
-      hasMore,
-      nextCursor,
-      theme: themeConfig?.components,
+  if (navData.homeDefaultView === "featured") {
+    // Show featured posts on homepage
+    const posts = await c.var.services.posts.list({
+      featured: true,
+      status: "published",
+      excludeReplies: true,
     });
+    const mediaCtx = createMediaContext(c);
+    const postViews = toPostViewsFromPosts(posts, mediaCtx);
+    const items = postViews.map((post) => ({ post }));
 
-    return sse(c, async (stream) => {
-      for (const patch of patches) {
-        if (patch.mode === "remove") {
-          stream.remove(patch.selector);
-        } else {
-          stream.patchElements(patch.content, {
-            mode: patch.mode,
-            selector: patch.selector,
-          });
-        }
-      }
+    return renderPublicPage(c, {
+      title: navData.siteName,
+      navData,
+      content: <FeaturedPage items={items} />,
     });
   }
 
-  // Full page render
-  const navData = await getNavigationData(c);
+  // Default: show latest posts
+  const pageParam = c.req.query("page");
+  const page = pageParam ? Math.max(1, parseInt(pageParam, 10) || 1) : 1;
+
+  const { items, currentPage, totalPages } = await assembleTimeline(c, {
+    page,
+  });
 
   // Fetch pinned posts
   const pinnedPosts = await c.var.services.posts.list({
@@ -79,19 +60,15 @@ homeRoutes.get("/", async (c) => {
   const mediaCtx = createMediaContext(c);
   const pinnedItems = toPostViewsFromPosts(pinnedPosts, mediaCtx);
 
-  const components = c.var.config.theme?.components;
-  const Page = components?.HomePage ?? DefaultHomePage;
-
   return renderPublicPage(c, {
     title: navData.siteName,
     navData,
     content: (
-      <Page
+      <HomePage
         items={items}
         pinnedItems={pinnedItems}
-        hasMore={hasMore}
-        nextCursor={nextCursor}
-        theme={components}
+        currentPage={currentPage}
+        totalPages={totalPages}
       />
     ),
   });