@jant/core 0.6.14 → 0.6.16

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

@@ -0,0 +1,176 @@
+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("Edit draft");
+    expect(html).toContain(`/preview/${draft.slug}?edit=1`);
+    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).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");
+  });
+});

package/src/routes/pages/archive.tsx

@@ -21,16 +21,22 @@ import type {
 import type { AppVariables } from "../../types/app-context.js";
 import type {
   ArchiveFilters,
+  ArchiveSort,
   ArchiveView,
   ArchiveVisibility,
 } from "../../types/props.js";
 import { FORMATS, MEDIA_KINDS } from "../../types.js";
 import { ArchivePage } from "../../ui/pages/ArchivePage.js";
 import { defaultFeedRenderer } from "../../lib/feed.js";
+import {
+  getFeedEntryUpdatedAt,
+  getRssPublishedBefore,
+  RSS_FEED_CACHE_CONTROL,
+} from "../../lib/feed-policy.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { buildPageTitle } from "../../lib/page-title.js";
 import { renderPublicPage } from "../../lib/render.js";
-import { formatYearMonth, toISOString } from "../../lib/time.js";
+import { formatYearMonth } from "../../lib/time.js";
 import { toAbsoluteSiteUrl, toPublicPath } from "../../lib/url.js";
 import {
   createMediaContext,
@@ -61,6 +67,7 @@ interface ParsedArchiveParams {
   visibility?: ArchiveVisibility;
   visibilityAll: boolean;
   view?: ArchiveView;
+  sort: ArchiveSort;
   currentPage: number;
 }
 
@@ -139,6 +146,11 @@ function parseArchiveParams(
       ? viewParam
       : undefined;
 
+  // sort selects the time axis for ordering, month grouping, and the year
+  // filter alike — they must stay on the same column or the month headers
+  // stop agreeing with the order inside them.
+  const sort: ArchiveSort = q("sort") === "updated" ? "updated" : "published";
+
   // Page always comes from the actual request URL (pagination links use ?page=N)
   const pageParam = c.req.query("page");
   const currentPage = Math.max(1, parseInt(pageParam || "1", 10) || 1);
@@ -154,6 +166,7 @@ function parseArchiveParams(
     visibility,
     visibilityAll,
     view,
+    sort,
     currentPage,
   };
 }
@@ -182,12 +195,15 @@ function buildArchivePostFilters(
       : (params.visibility ?? undefined)
     : undefined;
 
-  let publishedAfter: number | undefined;
-  let publishedBefore: number | undefined;
-  if (params.validYear) {
-    publishedAfter = Date.UTC(params.validYear, 0, 1) / 1000;
-    publishedBefore = Date.UTC(params.validYear + 1, 0, 1) / 1000;
-  }
+  // The year filter follows the active axis, so every month bucket shown
+  // under `year=N` really belongs to that year.
+  const yearRange = params.validYear
+    ? {
+        after: Date.UTC(params.validYear, 0, 1) / 1000,
+        before: Date.UTC(params.validYear + 1, 0, 1) / 1000,
+      }
+    : undefined;
+  const sortsByActivity = params.sort === "updated";
 
   return {
     format: params.format,
@@ -201,18 +217,28 @@ function buildArchivePostFilters(
         ? { visibility: effectiveVisibility }
         : {}),
     collectionId,
-    publishedAfter,
-    publishedBefore,
+    ...(yearRange
+      ? sortsByActivity
+        ? { axisAfter: yearRange.after, axisBefore: yearRange.before }
+        : { publishedAfter: yearRange.after, publishedBefore: yearRange.before }
+      : {}),
     mediaKinds: params.mediaKinds,
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
     hasReplies: params.hasReplies,
+    // "thread_updated", not "activity": the archive is the canonical all-posts
+    // view, and the quiet-reply switch only promises not to move a Thread on
+    // Latest. Here the honest answer is when the Thread last changed.
+    sortBy: sortsByActivity ? "thread_updated" : "published",
+    ignorePinnedSort: true,
   };
 }
 
 /**
  * Build a query string from parsed archive params (for feed self-URL and
- * archive page feed link). Omits page-only params (view, page).
+ * archive page feed link). Omits view and page — those shape the rendered
+ * page, not the result set — but carries `sort`, so the feed button on an
+ * updated-sorted page hands back the matching feed.
  */
 function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
   const qs = new URLSearchParams();
@@ -230,6 +256,7 @@ function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
   if (params.hasReplies !== undefined) {
     qs.set("replies", params.hasReplies ? "any" : "none");
   }
+  if (params.sort === "updated") qs.set("sort", "updated");
   const str = qs.toString();
   return str ? `?${str}` : "";
 }
@@ -331,6 +358,7 @@ export async function renderArchivePage(
       services.posts.getDistinctYears({
         status: "published",
         excludeReplies: true,
+        sortBy: filters.sortBy,
       }),
       services.collections.list(),
     ]);
@@ -358,8 +386,12 @@ export async function renderArchivePage(
 
     const grouped = new Map<string, PostWithMedia[]>();
     for (const post of posts) {
-      const publishedAt = post.publishedAt ?? post.updatedAt;
-      const key = formatYearMonth(publishedAt, appConfig.timeZone);
+      // Bucket on the same axis the query sorted by, so groups stay ordered.
+      const groupedAt =
+        params.sort === "updated"
+          ? post.threadUpdatedAt
+          : (post.publishedAt ?? post.updatedAt);
+      const key = formatYearMonth(groupedAt, appConfig.timeZone);
       if (!grouped.has(key)) {
         grouped.set(key, []);
       }
@@ -431,6 +463,7 @@ export async function renderArchivePage(
     hasReplies: params.hasReplies,
     visibility: effectiveVisibility,
     view: params.view,
+    sort: params.sort === "updated" ? "updated" : undefined,
   };
 
   const feedQuery = buildArchiveFeedQuery(params);
@@ -441,7 +474,12 @@ export async function renderArchivePage(
   }));
 
   return renderPublicPage(c, {
-    title: buildPageTitle("Archive", navData.siteName),
+    // Distinguishes a bookmarked or shared ?sort=updated view in the tab bar.
+    title: buildPageTitle(
+      "Archive",
+      params.sort === "updated" ? "Recently updated" : undefined,
+      navData.siteName,
+    ),
     navData,
     content: (
       <ArchivePage
@@ -456,7 +494,9 @@ export async function renderArchivePage(
         isAuthenticated={navData.isAuthenticated}
         sitePathPrefix={navData.sitePathPrefix}
         timeZone={appConfig.timeZone}
-        feedHref={`/archive/feed${feedQuery}`}
+        feedHref={
+          appConfig.rssFeedsEnabled ? `/archive/feed${feedQuery}` : undefined
+        }
       />
     ),
   });
@@ -615,10 +655,27 @@ async function buildArchiveFeedData(
   const collection = params.collectionSlug
     ? await services.collections.getBySlug(params.collectionSlug)
     : undefined;
+  const rssPublishedBefore = getRssPublishedBefore(
+    appConfig.rssPublishDelaySeconds,
+  );
+  const yearPublishedBefore = params.validYear
+    ? Date.UTC(params.validYear + 1, 0, 1) / 1000
+    : undefined;
 
   // Feed mirrors the unauthenticated archive page: published + non-private,
   // including Hidden-from-Latest. /archive is the canonical "all posts" view,
   // so its feed must match.
+  //
+  // Ordered by publication by default, like the page it belongs to. Ordering
+  // by activity would make the feed's contents shift under a fixed
+  // `rssFeedLimit` — a new reply pulls an old Thread back into the window and
+  // pushes something else out — and it buys nothing in return, because readers
+  // key entries by id and will not re-surface one that merely moved.
+  // /latest/feed is the activity feed; this one is the chronological record.
+  //
+  // `?sort=updated` opts into the same axis the page uses, for a subscriber
+  // who wants that trade-off deliberately.
+  const sortsByActivity = params.sort === "updated";
   const filters: PostFilters = {
     format: params.format,
     status: "published",
@@ -630,13 +687,22 @@ async function buildArchiveFeedData(
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
     hasReplies: params.hasReplies,
+    sortBy: sortsByActivity ? "thread_updated" : "published",
     ignorePinnedSort: true,
+    // The year filter follows the active axis; the RSS delay always stays on
+    // publication, so a just-published post is never announced early.
     ...(params.validYear
-      ? {
-          publishedAfter: Date.UTC(params.validYear, 0, 1) / 1000,
-          publishedBefore: Date.UTC(params.validYear + 1, 0, 1) / 1000,
-        }
+      ? sortsByActivity
+        ? {
+            axisAfter: Date.UTC(params.validYear, 0, 1) / 1000,
+            axisBefore: yearPublishedBefore,
+          }
+        : { publishedAfter: Date.UTC(params.validYear, 0, 1) / 1000 }
       : {}),
+    publishedBefore:
+      yearPublishedBefore === undefined || sortsByActivity
+        ? rssPublishedBefore
+        : Math.min(yearPublishedBefore, rssPublishedBefore),
     limit: appConfig.rssFeedLimit,
   };
 
@@ -648,7 +714,9 @@ async function buildArchiveFeedData(
   // Batch load media, aliases, and thread replies
   const postIds = posts.map((p) => p.id);
   const [threadMap, rawMediaMap, aliasesMap] = await Promise.all([
-    services.posts.getPublishedThreads(rootIds),
+    services.posts.getPublishedThreads(rootIds, {
+      publishedBefore: rssPublishedBefore,
+    }),
     services.media.getByPostIds(postIds),
     services.paths.getPostAliases(postIds),
   ]);
@@ -702,9 +770,9 @@ async function buildArchiveFeedData(
     aliasMap,
   ).map((postView, index) => {
     const post = posts[index] as (typeof posts)[number];
+    const thread = threadMap.get(post.id);
 
     // Build thread replies
-    const thread = threadMap.get(post.id);
     const replies =
       thread && thread.length > 1
         ? toPostViews(
@@ -720,7 +788,7 @@ async function buildArchiveFeedData(
 
     return {
       ...postView,
-      feedUpdatedAt: toISOString(post.lastActivityAt),
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread),
       threadReplies: replies,
     };
   });
@@ -748,7 +816,7 @@ archiveRoutes.get("/feed", async (c) => {
   return new Response(defaultFeedRenderer(feedData), {
     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/collection.tsx

@@ -19,9 +19,13 @@ import {
 } from "../../lib/collection-sort.js";
 import { assembleCollectionTimeline } from "../../lib/timeline.js";
 import { defaultFeedRenderer } from "../../lib/feed.js";
+import {
+  getFeedEntryUpdatedAt,
+  getRssPublishedBefore,
+  RSS_FEED_CACHE_CONTROL,
+} from "../../lib/feed-policy.js";
 import { toPlainText as markdownToPlainText } from "../../lib/markdown.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
-import { toISOString } from "../../lib/time.js";
 import { createMediaContext, toPostViews } from "../../lib/view.js";
 import { toAbsoluteSiteUrl, toPublicPath } from "../../lib/url.js";
 import {
@@ -147,16 +151,17 @@ export async function renderCollectionPage(
   );
   const isAggregate = selection.collections.length > 1;
 
-  const ratedPostCount = await c.var.services.posts.countUpTo(
-    {
+  const ratedThreadCount =
+    await c.var.services.posts.countCollectionThreadRootsUpToForCollections(
       collectionIds,
-      status: "published",
-      excludePrivate: !navData.isAuthenticated,
-      hasRating: true,
-    },
-    2,
-  );
-  const showRatingSort = supportsCollectionRatingSort(ratedPostCount);
+      {
+        status: "published",
+        excludePrivate: !navData.isAuthenticated,
+        hasRating: true,
+      },
+      2,
+    );
+  const showRatingSort = supportsCollectionRatingSort(ratedThreadCount);
   const requestedDefaultSort = isAggregate
     ? "newest"
     : primaryCollection.sortOrder;
@@ -219,7 +224,17 @@ export async function renderCollectionPage(
         defaultSort={defaultSort}
         showRatingSort={showRatingSort}
         isAuthenticated={navData.isAuthenticated}
+        isInNavigation={navData.links.some(
+          (item) =>
+            item.type === "collection" &&
+            item.collectionId === primaryCollection.id,
+        )}
         sitePathPrefix={navData.sitePathPrefix}
+        feedHref={
+          c.var.appConfig.rssFeedsEnabled
+            ? `${canonicalPagePath}/feed`
+            : undefined
+        }
       />
     ),
   });
@@ -254,6 +269,9 @@ export async function renderCollectionFeed(
   const siteUrl = appConfig.siteUrl;
   const siteLanguage = appConfig.siteLanguage;
   const feedLimit = appConfig.rssFeedLimit;
+  const publishedBefore = getRssPublishedBefore(
+    appConfig.rssPublishDelaySeconds,
+  );
   const primaryCollection = selection.collections[0];
   if (!primaryCollection) return null;
 
@@ -264,6 +282,7 @@ export async function renderCollectionFeed(
         status: "published",
         excludePrivate: true,
         ignoreCollectionPinnedSort: true,
+        publishedBefore,
         limit: feedLimit,
       },
     );
@@ -274,7 +293,7 @@ export async function renderCollectionFeed(
 
   const postIds = posts.map((post) => post.id);
   const [threadMap, rawMediaMap, aliasesMap] = await Promise.all([
-    c.var.services.posts.getPublishedThreads(rootIds),
+    c.var.services.posts.getPublishedThreads(rootIds, { publishedBefore }),
     c.var.services.media.getByPostIds(postIds),
     c.var.services.paths.getPostAliases(postIds),
   ]);
@@ -345,15 +364,9 @@ export async function renderCollectionFeed(
           )
         : undefined;
 
-    // feedUpdatedAt = max(lastActivityAt, collectedAt)
-    const lastActivity = toISOString(post.lastActivityAt);
-    const collectedIso = collectedAt ? toISOString(collectedAt) : null;
-    const feedUpdatedAt =
-      collectedIso && collectedIso > lastActivity ? collectedIso : lastActivity;
-
     return {
       ...postView,
-      feedUpdatedAt,
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread, [collectedAt]),
       threadReplies: replies,
     };
   });
@@ -382,7 +395,7 @@ export async function renderCollectionFeed(
   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/collections.tsx

@@ -1,7 +1,7 @@
 /**
  * Collections Listing Page Route
  *
- * Lists all collections with their post counts.
+ * Lists all collections with their Thread counts.
  */
 
 import { Hono } from "hono";
@@ -70,6 +70,11 @@ collectionsPageRoutes.get("/", async (c) => {
       <CollectionsPage
         items={directoryData.items}
         isAuthenticated={navData.isAuthenticated ?? false}
+        navigationCollectionIds={navData.links.flatMap((item) =>
+          item.type === "collection" && item.collectionId
+            ? [item.collectionId]
+            : [],
+        )}
         sitePathPrefix={navData.sitePathPrefix}
         siteOrigin={c.var.appConfig.siteOrigin}
       />