@jant/core 0.6.14 → 0.6.15

package/src/routes/feed/feed.ts

@@ -27,9 +27,13 @@ import type {
 } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { defaultFeedRenderer } from "../../lib/feed.js";
+import {
+  getFeedEntryUpdatedAt,
+  getRssPublishedBefore,
+  RSS_FEED_CACHE_CONTROL,
+} from "../../lib/feed-policy.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
 import { getI18n } from "../../i18n/index.js";
-import { toISOString } from "../../lib/time.js";
 import { FORMATS } from "../../types/constants.js";
 
 import { createMediaContext, toPostViews } from "../../lib/view.js";
@@ -118,6 +122,7 @@ function collectReplyIds(threadMap: Map<string, Post[]>): string[] {
 async function buildLatestFeedData(
   c: Context<Env>,
   feedLimit: number,
+  publishedBefore: number,
   format?: Format,
 ): Promise<{ posts: Post[]; postViews: FeedPostView[] }> {
   const posts = await c.var.services.posts.list({
@@ -127,6 +132,7 @@ async function buildLatestFeedData(
     excludePrivate: true,
     format,
     ignorePinnedSort: true,
+    publishedBefore,
     limit: feedLimit,
   });
 
@@ -135,7 +141,7 @@ async function buildLatestFeedData(
 
   const mediaCtx = createMediaContext(c.var.appConfig);
   const [threadMap, mediaMap, aliasesMap] = await Promise.all([
-    c.var.services.posts.getPublishedThreads(rootIds),
+    c.var.services.posts.getPublishedThreads(rootIds, { publishedBefore }),
     loadMediaMap(c, postIds, mediaCtx),
     c.var.services.paths.getPostAliases(postIds),
   ]);
@@ -162,9 +168,10 @@ async function buildLatestFeedData(
     aliasMap,
   ).map((postView, index) => {
     const post = posts[index] as (typeof posts)[number];
+    const thread = threadMap.get(post.id);
     return {
       ...postView,
-      feedUpdatedAt: toISOString(post.lastActivityAt),
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread),
       threadReplies: buildThreadReplies(
         post.id,
         threadMap,
@@ -187,10 +194,12 @@ async function buildLatestFeedData(
 async function buildFeaturedFeedData(
   c: Context<Env>,
   feedLimit: number,
+  publishedBefore: number,
 ): Promise<{ posts: Post[]; postViews: FeedPostView[] }> {
   const rootIds = await c.var.services.posts.listFeaturedThreadRootIds({
     status: "published",
     excludePrivate: true,
+    publishedBefore,
     limit: feedLimit,
   });
 
@@ -198,7 +207,9 @@ async function buildFeaturedFeedData(
     return { posts: [], postViews: [] };
   }
 
-  const threadMap = await c.var.services.posts.getPublishedThreads(rootIds);
+  const threadMap = await c.var.services.posts.getPublishedThreads(rootIds, {
+    publishedBefore,
+  });
 
   // Extract root posts in the same order as rootIds
   const posts: Post[] = [];
@@ -241,16 +252,11 @@ async function buildFeaturedFeedData(
     aliasMap,
   ).map((postView, index) => {
     const post = posts[index] as (typeof posts)[number];
-
-    // feedUpdatedAt = max(lastActivityAt, featuredAt)
-    const lastActivity = toISOString(post.lastActivityAt);
-    const featuredIso = post.featuredAt ? toISOString(post.featuredAt) : null;
-    const feedUpdatedAt =
-      featuredIso && featuredIso > lastActivity ? featuredIso : lastActivity;
+    const thread = threadMap.get(post.id);
 
     return {
       ...postView,
-      feedUpdatedAt,
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread),
       threadReplies: buildThreadReplies(post.id, threadMap, mediaMap, mediaCtx),
     };
   });
@@ -280,12 +286,15 @@ export async function buildFeedData(
   const siteUrl = appConfig.siteUrl;
   const siteLanguage = appConfig.siteLanguage;
   const feedLimit = appConfig.rssFeedLimit;
+  const publishedBefore = getRssPublishedBefore(
+    appConfig.rssPublishDelaySeconds,
+  );
   const kind = opts.kind;
 
   const { postViews } =
     kind === "featured"
-      ? await buildFeaturedFeedData(c, feedLimit)
-      : await buildLatestFeedData(c, feedLimit, opts.format);
+      ? await buildFeaturedFeedData(c, feedLimit, publishedBefore)
+      : await buildLatestFeedData(c, feedLimit, publishedBefore, opts.format);
 
   return {
     siteName,
@@ -333,7 +342,7 @@ export function renderFeed(xml: string) {
   return new Response(xml, {
     headers: {
       "Content-Type": "application/atom+xml; charset=utf-8",
-      "Cache-Control": "public, max-age=180",
+      "Cache-Control": RSS_FEED_CACHE_CONTROL,
     },
   });
 }

package/src/routes/pages/__tests__/archive-params.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { createTestApp } from "../../../__tests__/helpers/app.js";
 import { archiveRoutes } from "../archive.js";
 
@@ -21,13 +21,45 @@ async function fetchFeed(
   return res.text();
 }
 
-function setupApp() {
-  const { app, services } = createTestApp({ authenticated: false });
+function setupApp(rssPublishDelaySeconds = 0) {
+  const { app, services } = createTestApp({
+    authenticated: false,
+    rssPublishDelaySeconds,
+  });
   app.route("/archive", archiveRoutes);
   return { app, services };
 }
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 describe("archive feed filter params", () => {
+  it("applies the RSS publication delay", async () => {
+    const currentTime = 2_000_000;
+    vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+    const { app, services } = setupApp(300);
+    await services.posts.create({
+      format: "note",
+      title: "Eligible Archive Post",
+      bodyMarkdown: "Old enough for RSS",
+      status: "published",
+      publishedAt: currentTime - 300,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Recent Archive Post",
+      bodyMarkdown: "Still inside the edit window",
+      status: "published",
+      publishedAt: currentTime,
+    });
+
+    const xml = await fetchFeed(app, "");
+
+    expect(xml).toContain("Eligible Archive Post");
+    expect(xml).not.toContain("Recent Archive Post");
+  });
+
   it("filters by title with the new param and the legacy fallback", async () => {
     const { app, services } = setupApp();
     await services.posts.create({
@@ -133,3 +165,60 @@ describe("archive page legacy param redirect", () => {
     expect(res.headers.get("location")).toBe("/archive?title=any");
   });
 });
+
+describe("archive page ordering", () => {
+  it("orders threads by their root publication time, not recent replies", async () => {
+    const { app, services } = setupApp();
+    const olderThread = await services.posts.create({
+      format: "note",
+      title: "Older active thread",
+      bodyMarkdown: "older root",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "recent reply",
+      replyToId: olderThread.id,
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Newer root thread",
+      bodyMarkdown: "newer root",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+
+    const res = await app.request("/archive");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html.indexOf("Newer root thread")).toBeLessThan(
+      html.indexOf("Older active thread"),
+    );
+  });
+
+  it("keeps newer posts ahead of older pinned posts", async () => {
+    const { app, services } = setupApp();
+    await services.posts.create({
+      format: "note",
+      title: "Older pinned post",
+      bodyMarkdown: "older",
+      pinned: true,
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Newer unpinned post",
+      bodyMarkdown: "newer",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+
+    const res = await app.request("/archive?view=list");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html.indexOf("Newer unpinned post")).toBeLessThan(
+      html.indexOf("Older pinned post"),
+    );
+  });
+});

package/src/routes/pages/__tests__/collection-routing.test.ts

@@ -1,11 +1,11 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { createTestApp } from "../../../__tests__/helpers/app.js";
 import { collectionRoutes } from "../collection.js";
 import { collectionsPageRoutes } from "../collections.js";
 import { pageRoutes } from "../page.js";
 
-function createCollectionRoutingTestApp() {
-  const testApp = createTestApp();
+function createCollectionRoutingTestApp(rssPublishDelaySeconds = 0) {
+  const testApp = createTestApp({ rssPublishDelaySeconds });
   const { app } = testApp;
 
   app.use("*", async (c, next) => {
@@ -21,6 +21,10 @@ function createCollectionRoutingTestApp() {
   return testApp;
 }
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 async function createCollectionWithPost(
   services: ReturnType<typeof createTestApp>["services"],
   {
@@ -42,7 +46,7 @@ async function createCollectionWithPost(
     bodyMarkdown: bodyMarkdown ?? postTitle,
     status: "published",
   });
-  await services.collections.addPost(collection.id, post.id);
+  await services.collections.addThread(collection.id, post.id);
   return { collection, post };
 }
 
@@ -50,11 +54,17 @@ describe("Collection Routing", () => {
   it("renders a single collection at its root path", async () => {
     const { app, services } = createCollectionRoutingTestApp();
 
-    await createCollectionWithPost(services, {
+    const { post } = await createCollectionWithPost(services, {
       slug: "reading",
       title: "Reading",
       postTitle: "Book log",
     });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Thread follow-up",
+      status: "published",
+      replyToId: post.id,
+    });
 
     const res = await app.request("/reading");
 
@@ -64,6 +74,23 @@ describe("Collection Routing", () => {
     const html = await res.text();
     expect(html).toContain("Reading");
     expect(html).toContain("Book log");
+    expect(html).toContain("Thread follow-up");
+  });
+
+  it("hides the collection feed button when feeds are disabled", async () => {
+    const { app, services } = createCollectionRoutingTestApp();
+    await services.settings.set("RSS_FEEDS_ENABLED", "false");
+    await createCollectionWithPost(services, {
+      slug: "reading",
+      title: "Reading",
+      postTitle: "Book log",
+    });
+
+    const response = await app.request("/reading");
+    const html = await response.text();
+
+    expect(response.status).toBe(200);
+    expect(html).not.toContain('class="feed-link"');
   });
 
   it("redirects namespaced single-collection paths to the root canonical URL", async () => {
@@ -139,6 +166,37 @@ describe("Collection Routing", () => {
     expect(xml).toContain("Film log");
   });
 
+  it("applies the RSS publication delay to Collection feeds", async () => {
+    const currentTime = 2_000_000;
+    vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+    const { app, services } = createCollectionRoutingTestApp(300);
+    const collection = await services.collections.create({
+      slug: "reading",
+      title: "Reading",
+    });
+    const eligible = await services.posts.create({
+      format: "note",
+      title: "Eligible Book Log",
+      bodyMarkdown: "Old enough for RSS",
+      status: "published",
+      publishedAt: currentTime - 300,
+    });
+    const recent = await services.posts.create({
+      format: "note",
+      title: "Recent Book Log",
+      bodyMarkdown: "Still inside the edit window",
+      status: "published",
+      publishedAt: currentTime,
+    });
+    await services.collections.addThread(collection.id, eligible.id);
+    await services.collections.addThread(collection.id, recent.id);
+
+    const xml = await (await app.request("/reading/feed")).text();
+
+    expect(xml).toContain("Eligible Book Log");
+    expect(xml).not.toContain("Recent Book Log");
+  });
+
   it("redirects canonical collection pages and feeds to collection aliases", async () => {
     const { app, services } = createCollectionRoutingTestApp();
 

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

@@ -30,7 +30,7 @@ describe("Collections Listing Page - Data Logic", () => {
     );
   });
 
-  it("returns collections with post counts and recent activity", async () => {
+  it("returns collections with Thread counts and recent activity", async () => {
     const recipes = await collectionService.create({
       slug: "recipes",
       title: "Recipes",
@@ -40,7 +40,7 @@ describe("Collections Listing Page - Data Logic", () => {
       title: "Travel",
     });
 
-    // Add posts to recipes collection via junction table
+    // Add Threads to the recipes Collection.
     const p1 = await postService.create({
       format: "note",
       bodyMarkdown: "Recipe 1",
@@ -49,8 +49,8 @@ describe("Collections Listing Page - Data Logic", () => {
       format: "note",
       bodyMarkdown: "Recipe 2",
     });
-    await collectionService.addPost(recipes.id, p1.id);
-    await collectionService.addPost(recipes.id, p2.id);
+    await collectionService.addThread(recipes.id, p1.id);
+    await collectionService.addThread(recipes.id, p2.id);
 
     const directory = await collectionService.listDirectoryData();
 
@@ -59,9 +59,9 @@ describe("Collections Listing Page - Data Logic", () => {
       (c) => c.slug === "recipes",
     );
     const travelResult = directory.collections.find((c) => c.slug === "travel");
-    expect(recipesResult?.postCount).toBe(2);
+    expect(recipesResult?.threadCount).toBe(2);
     expect(recipesResult?.recentActivityAt).toBe(p2.lastActivityAt);
-    expect(travelResult?.postCount).toBe(0);
+    expect(travelResult?.threadCount).toBe(0);
     expect(travelResult?.recentActivityAt).toBeGreaterThan(0);
   });
 
@@ -86,13 +86,13 @@ describe("Collections Listing Page - Data Logic", () => {
       bodyMarkdown: "Will remain",
     });
 
-    await collectionService.addPost(col.id, post.id);
-    await collectionService.addPost(col.id, post2.id);
+    await collectionService.addThread(col.id, post.id);
+    await collectionService.addThread(col.id, post2.id);
 
     await postService.delete(post.id);
 
     const directory = await collectionService.listDirectoryData();
-    expect(directory.collections[0]?.postCount).toBe(1);
+    expect(directory.collections[0]?.threadCount).toBe(1);
     expect(directory.collections[0]?.recentActivityAt).toBe(
       post2.lastActivityAt,
     );

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

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { pageRoutes } from "../page.js";
+
+function createPageTestApp(options: { authenticated?: boolean } = {}) {
+  const testApp = createTestApp(options);
+  testApp.app.route("/", pageRoutes);
+  return testApp;
+}
+
+async function createDraft(
+  services: ReturnType<typeof createTestApp>["services"],
+  title = "A private draft",
+) {
+  return services.posts.create({
+    format: "note",
+    title,
+    bodyMarkdown: `${title} body`,
+    status: "draft",
+  });
+}
+
+describe("draft preview route", () => {
+  it("redirects anonymous visitors to sign in and preserves the preview path", async () => {
+    const { app, services } = createPageTestApp();
+    const draft = await createDraft(services);
+
+    const res = await app.request(`/preview/${draft.slug}`, {
+      redirect: "manual",
+    });
+
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(
+      `/signin?redirect=${encodeURIComponent(`/preview/${draft.slug}`)}`,
+    );
+  });
+
+  it("renders the public post view with explicit private preview signals", async () => {
+    const { app, services } = createPageTestApp({ authenticated: true });
+    const draft = await createDraft(services);
+
+    const res = await app.request(`/preview/${draft.slug}`);
+
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Cache-Control")).toBe("private, no-store");
+    expect(res.headers.get("X-Robots-Tag")).toBe("noindex, nofollow");
+
+    const html = await res.text();
+    expect(html).toContain(`data-post-id="${draft.id}"`);
+    expect(html).toContain("A private draft body");
+    expect(html).toContain("data-preview-status");
+    expect(html).toContain("Draft preview");
+    expect(html).toContain("This post isn’t published.");
+    expect(html).toContain('<meta name="robots" content="noindex, nofollow"');
+    expect(html).not.toContain('rel="canonical"');
+    expect(html).not.toContain("application/ld+json");
+    expect(html).not.toContain("article:published_time");
+    expect(html).not.toContain('id="compose-dialog"');
+  });
+
+  it("renders every draft in a saved thread", async () => {
+    const { app, services } = createPageTestApp({ authenticated: true });
+    const root = await createDraft(services, "Thread root");
+    const reply = await services.posts.create({
+      format: "quote",
+      quoteText: "Unpublished reply quote",
+      status: "draft",
+      replyToId: root.id,
+    });
+
+    const res = await app.request(`/preview/${root.slug}`);
+
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("Thread root body");
+    expect(html).toContain("Unpublished reply quote");
+    expect(html).toContain(`/preview/${reply.slug}`);
+  });
+
+  it("redirects a published post preview to its public permalink", async () => {
+    const { app, services } = createPageTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Already public",
+      status: "published",
+    });
+
+    const res = await app.request(`/preview/${post.slug}`, {
+      redirect: "manual",
+    });
+
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe(`/${post.slug}`);
+  });
+
+  it("returns 404 for the preview root and unknown draft slugs", async () => {
+    const { app } = createPageTestApp({ authenticated: true });
+
+    expect((await app.request("/preview")).status).toBe(404);
+    expect((await app.request("/preview/missing-draft")).status).toBe(404);
+  });
+});
+
+describe("reserved path and redirect precedence", () => {
+  it("ignores a legacy redirect that collides with the preview route", async () => {
+    const { app, services } = createPageTestApp({ authenticated: true });
+    const draft = await createDraft(services);
+    await services.paths.create({
+      path: `preview/${draft.slug}`,
+      kind: "redirect",
+      redirectToPath: "elsewhere",
+      redirectType: 301,
+    });
+
+    const res = await app.request(`/preview/${draft.slug}`, {
+      redirect: "manual",
+    });
+
+    expect(res.status).toBe(200);
+    expect(await res.text()).toContain(`data-post-id="${draft.id}"`);
+  });
+
+  it("makes a legacy canonical preview path inert", async () => {
+    const { app, services } = createPageTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Old preview post",
+      status: "published",
+    });
+    await services.paths.updatePostSlug(post.id, "preview");
+
+    const res = await app.request("/preview", { redirect: "manual" });
+
+    expect(res.status).toBe(404);
+  });
+
+  it("keeps ordinary redirects working and ahead of derived collection feeds", async () => {
+    const { app, services } = createPageTestApp();
+    const collection = await services.collections.create({
+      slug: "reading",
+      title: "Reading",
+    });
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Book log",
+      status: "published",
+    });
+    await services.collections.addThread(collection.id, post.id);
+    await services.paths.create({
+      path: "reading/feed",
+      kind: "redirect",
+      redirectToPath: "archive",
+      redirectType: 302,
+    });
+    await services.paths.create({
+      path: "old-link",
+      kind: "redirect",
+      redirectToPath: "reading",
+      redirectType: 301,
+    });
+
+    const feedRes = await app.request("/reading/feed", {
+      redirect: "manual",
+    });
+    expect(feedRes.status).toBe(302);
+    expect(feedRes.headers.get("Location")).toBe("/archive");
+
+    const ordinaryRes = await app.request("/old-link", {
+      redirect: "manual",
+    });
+    expect(ordinaryRes.status).toBe(301);
+    expect(ordinaryRes.headers.get("Location")).toBe("/reading");
+  });
+});

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { searchRoutes } from "../search.js";
+
+describe("Search Page Routes", () => {
+  it("keeps public HTML search available when anonymous JSON APIs are off", async () => {
+    const { app, services } = createTestApp({
+      authenticated: false,
+      fts: true,
+    });
+    await services.settings.set("PUBLIC_API_ENABLED", "false");
+    app.route("/search", searchRoutes);
+
+    const response = await app.request("/search?q=marker");
+
+    expect(response.status).toBe(200);
+  });
+
+  it("hides visible Thread collection tags on a matching child post", async () => {
+    const { app, services } = createTestApp({ fts: true });
+    app.route("/search", searchRoutes);
+
+    const collection = await services.collections.create({
+      slug: "search-thread",
+      title: "Search Thread Collection",
+    });
+    const root = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Thread root",
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Unique child search marker",
+      replyToId: root.id,
+    });
+    await services.collections.addThread(collection.id, root.id);
+
+    const response = await app.request("/search?q=marker");
+
+    expect(response.status).toBe(200);
+    const html = await response.text();
+    expect(html).toContain("Unique child search");
+    expect(html).toContain("<mark>marker</mark>");
+    expect(html).not.toContain("Search Thread Collection");
+  });
+
+  it("shows Thread collection tags on a matching root post", async () => {
+    const { app, services } = createTestApp({ fts: true });
+    app.route("/search", searchRoutes);
+
+    const collection = await services.collections.create({
+      slug: "search-root",
+      title: "Root Search Collection",
+    });
+    const root = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Unique root search marker",
+    });
+    await services.collections.addThread(collection.id, root.id);
+
+    const response = await app.request("/search?q=marker");
+
+    expect(response.status).toBe(200);
+    const html = await response.text();
+    expect(html).toContain("Unique root search");
+    expect(html).toContain("<mark>marker</mark>");
+    expect(html).toContain("Root Search Collection");
+  });
+});