@jant/core 0.6.16 → 0.7.0

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

@@ -0,0 +1,200 @@
+/**
+ * What the archive tells crawlers about each of its URLs.
+ *
+ * The filter space has no ceiling — `media` alone is a comma-joined subset of
+ * kinds, multiplied by every other dimension — and the page sits in no cache,
+ * so each facet a crawler walks costs a Worker invocation and seven D1
+ * queries. None of those URLs is a page the site publishes. The ones that are
+ * — the bare path, a stored archive path, and the same page rendered
+ * differently — consolidate onto one canonical instead.
+ */
+
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { archiveRoutes } from "../archive.js";
+import { pageRoutes } from "../page.js";
+
+const SITE_URL = "http://localhost:3000";
+
+function setupApp() {
+  const { app, services } = createTestApp({ authenticated: false });
+  app.route("/archive", archiveRoutes);
+  return { app, services };
+}
+
+function setupPageApp() {
+  const testApp = createTestApp({ authenticated: false });
+  const { app } = testApp;
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+  app.route("/", pageRoutes);
+  return testApp;
+}
+
+function readCanonical(html: string): string | null {
+  return html.match(/<link rel="canonical" href="([^"]+)"/)?.[1] ?? null;
+}
+
+function readRobotsMeta(html: string): string | null {
+  return html.match(/<meta name="robots" content="([^"]+)"/)?.[1] ?? null;
+}
+
+/**
+ * The `<link rel="alternate" hreflang>` set only. The language switcher in the
+ * nav also carries `hreflang`, on ordinary `<a>` links — that is navigation
+ * chrome, not the annotation search engines read.
+ */
+function readAlternates(html: string): string[] {
+  return [
+    ...html.matchAll(
+      /<link rel="alternate" hreflang="([^"]+)" href="([^"]+)"/g,
+    ),
+  ].map((m) => `${m[1]} ${m[2]}`);
+}
+
+async function seed(services: {
+  posts: { create: (input: Record<string, unknown>) => Promise<unknown> };
+}) {
+  await services.posts.create({
+    format: "note",
+    bodyMarkdown: "a note in the archive",
+    status: "published",
+  });
+}
+
+describe("archive indexing", () => {
+  it("publishes the bare archive with a self-canonical", async () => {
+    const { app, services } = setupApp();
+    await seed(services);
+
+    const res = await app.request("/archive");
+    const html = await res.text();
+
+    expect(readRobotsMeta(html)).toBeNull();
+    expect(res.headers.get("X-Robots-Tag")).toBeNull();
+    expect(readCanonical(html)).toBe(`${SITE_URL}/archive`);
+  });
+
+  // `layout` changes the markup, not the posts or their order, so the two
+  // renderings are one page with one canonical.
+  it("consolidates layout and tracking params onto the bare path", async () => {
+    const { app, services } = setupApp();
+    await seed(services);
+
+    for (const query of ["?layout=grid", "?utm_source=nl"]) {
+      const html = await (await app.request(`/archive${query}`)).text();
+      expect(readRobotsMeta(html)).toBeNull();
+      expect(readCanonical(html)).toBe(`${SITE_URL}/archive`);
+    }
+  });
+
+  // Pagination is genuinely different content, not a different rendering of
+  // the same content, so the canonical keeps it.
+  it("keeps the page number in the canonical", async () => {
+    const { app, services } = setupApp();
+    await seed(services);
+
+    const html = await (await app.request("/archive?page=2")).text();
+    expect(readCanonical(html)).toBe(`${SITE_URL}/archive?page=2`);
+  });
+
+  it("keeps a reader's facet out of the index while leaving its links crawlable", async () => {
+    const { app, services } = setupApp();
+    await seed(services);
+
+    const res = await app.request("/archive?format=note");
+    const html = await res.text();
+
+    expect(readRobotsMeta(html)).toBe("noindex, follow");
+    expect(res.headers.get("X-Robots-Tag")).toBe("noindex, follow");
+    expect(readCanonical(html)).toBeNull();
+  });
+
+  // `sort` is a filter, not a presentation toggle: the year filter follows the
+  // sort axis, and under pagination a different order is a different page one.
+  it("treats sort as a facet rather than a rendering", async () => {
+    const { app, services } = setupApp();
+    await seed(services);
+
+    const html = await (await app.request("/archive?sort=updated")).text();
+    expect(readRobotsMeta(html)).toBe("noindex, follow");
+    expect(readCanonical(html)).toBeNull();
+  });
+
+  // A site that asked not to be indexed at all has made the stricter
+  // statement, and a page policy may only narrow further. `follow` would
+  // otherwise reopen the site's links on exactly the URLs it never wanted
+  // crawled.
+  it("lets a site-wide noindex override the facet policy", async () => {
+    const { app, services } = createTestApp({
+      authenticated: false,
+      demoMode: true,
+    });
+    app.route("/archive", archiveRoutes);
+    await seed(services);
+
+    const facet = await (await app.request("/archive?format=note")).text();
+    expect(readRobotsMeta(facet)).toBe("noindex, nofollow");
+
+    const bare = await (await app.request("/archive")).text();
+    expect(readRobotsMeta(bare)).toBe("noindex, nofollow");
+  });
+
+  // Every member of an hreflang set has to be a canonical URL. Left alone, the
+  // self-referential alternate would carry the very params the canonical
+  // strips, giving one page two identities.
+  it("builds the hreflang set from the canonical, not the raw URL", async () => {
+    const { app, services } = setupApp();
+    await services.settings.set("SITE_LANGUAGE", "zh-Hans");
+    await services.settings.set("ADDITIONAL_LANGUAGES", "en");
+    await services.settings.set("MULTILINGUAL_ENABLED", "true");
+    await seed(services);
+
+    const html = await (await app.request("/archive?utm_source=nl")).text();
+
+    expect(readCanonical(html)).toBe(`${SITE_URL}/archive`);
+    expect(readAlternates(html)).toEqual([
+      `zh-Hans ${SITE_URL}/archive`,
+      `en ${SITE_URL}/en/archive`,
+      `x-default ${SITE_URL}/archive`,
+    ]);
+  });
+
+  // A facet has no canonical, so there is no set to build.
+  it("emits no hreflang set on a facet", async () => {
+    const { app, services } = setupApp();
+    await services.settings.set("SITE_LANGUAGE", "zh-Hans");
+    await services.settings.set("ADDITIONAL_LANGUAGES", "en");
+    await services.settings.set("MULTILINGUAL_ENABLED", "true");
+    await seed(services);
+
+    const facet = await (await app.request("/archive?format=note")).text();
+    expect(readAlternates(facet)).toEqual([]);
+
+    const bare = await (await app.request("/archive")).text();
+    expect(readAlternates(bare)).toContain(`en ${SITE_URL}/en/archive`);
+  });
+
+  // The author declared this path, so it is a page even though its stored
+  // query is a filter. Same seam the auth guard uses.
+  it("publishes a stored archive path despite its filter", async () => {
+    const { app, services } = setupPageApp();
+    await seed(services);
+    await services.paths.create({
+      path: "/every-note",
+      kind: "archive",
+      archiveQuery: "format=note&sort=updated",
+    });
+
+    const res = await app.request("/every-note");
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(readRobotsMeta(html)).toBeNull();
+    expect(res.headers.get("X-Robots-Tag")).toBeNull();
+    expect(readCanonical(html)).toBe(`${SITE_URL}/every-note`);
+  });
+});

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

@@ -30,6 +30,12 @@ function setupApp(rssPublishDelaySeconds = 0) {
   return { app, services };
 }
 
+function setupAuthedApp() {
+  const { app, services } = createTestApp({ authenticated: true });
+  app.route("/archive", archiveRoutes);
+  return { app, services };
+}
+
 afterEach(() => {
   vi.restoreAllMocks();
 });
@@ -60,6 +66,31 @@ describe("archive feed filter params", () => {
     expect(xml).not.toContain("Recent Archive Post");
   });
 
+  it("carries the number of entries ?limit= asks for", async () => {
+    const { app, services } = setupApp();
+    await services.posts.create({
+      format: "note",
+      title: "Older Archive Post",
+      bodyMarkdown: "Older",
+      status: "published",
+      publishedAt: 1_000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Newer Archive Post",
+      bodyMarkdown: "Newer",
+      status: "published",
+      publishedAt: 2_000,
+    });
+
+    const xml = await fetchFeed(app, "?limit=1");
+
+    expect(xml).toContain("Newer Archive Post");
+    expect(xml).not.toContain("Older Archive Post");
+    // Not a filter, so the feed's own address does not carry it.
+    expect(xml).not.toContain("limit=1");
+  });
+
   it("filters by title with the new param and the legacy fallback", async () => {
     const { app, services } = setupApp();
     await services.posts.create({
@@ -298,6 +329,20 @@ describe("archive page legacy param redirect", () => {
     expect(res.headers.get("location")).toBe("/archive?visibility=hidden");
   });
 
+  // `visibility=all` filtered nothing, exactly like an absent parameter — a
+  // second spelling of "nothing selected" that only the parser knew about.
+  it("drops the visibility=all chip state, which selected nothing", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?visibility=all");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive");
+
+    const withOthers = await app.request("/archive?format=note&visibility=all");
+    expect(withOthers.status).toBe(308);
+    expect(withOthers.headers.get("location")).toBe("/archive?format=note");
+  });
+
   it("drops a legacy param without overriding an explicit new one", async () => {
     const { app } = setupApp();
 
@@ -305,6 +350,39 @@ describe("archive page legacy param redirect", () => {
     expect(res.status).toBe(308);
     expect(res.headers.get("location")).toBe("/archive?title=any");
   });
+
+  // `view` was renamed to `layout` so `view` can name the saved-selection
+  // concept. Shared links and bookmarks predate the rename.
+  it("redirects the legacy view param to layout", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?view=grid");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive?layout=grid");
+  });
+
+  it("keeps layout when a URL carries both spellings", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?layout=list&view=grid");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive?layout=list");
+  });
+
+  it("drops a view value it cannot render", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?view=carousel");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive");
+  });
+
+  it("leaves a canonical layout param alone", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?layout=grid");
+    expect(res.status).toBe(200);
+  });
 });
 
 describe("archive page ordering", () => {
@@ -354,7 +432,7 @@ describe("archive page ordering", () => {
       publishedAt: Date.UTC(2026, 0, 1) / 1000,
     });
 
-    const res = await app.request("/archive?view=list");
+    const res = await app.request("/archive?layout=list");
     expect(res.status).toBe(200);
     const html = await res.text();
 
@@ -408,16 +486,20 @@ describe("archive page sort=updated", () => {
     );
   });
 
+  // Month headers are a grid affordance, so the bucketing axis is asserted
+  // through the grid layout rather than the site default.
   it("buckets months on the same axis it sorts by", async () => {
     const { app, services } = setupApp();
     await seedDivergingThreads(services);
 
-    const byPublished = await (await app.request("/archive")).text();
+    const byPublished = await (
+      await app.request("/archive?layout=grid")
+    ).text();
     expect(byPublished).toContain("March 2019");
     expect(byPublished).not.toContain("August 2026");
 
     const byActivity = await (
-      await app.request("/archive?sort=updated")
+      await app.request("/archive?layout=grid&sort=updated")
     ).text();
     expect(byActivity).toContain("August 2026");
     expect(byActivity).not.toContain("March 2019");
@@ -454,13 +536,46 @@ describe("archive page sort=updated", () => {
     await seedDivergingThreads(services);
 
     const byPublished = await (await app.request("/archive")).text();
-    expect(byPublished).toContain("<title>Archive - ");
+    expect(byPublished).toContain("<title>All posts - ");
     expect(byPublished).not.toContain("Recently updated");
 
     const byActivity = await (
       await app.request("/archive?sort=updated")
     ).text();
-    expect(byActivity).toContain("<title>Archive - Recently updated - ");
+    expect(byActivity).toContain("<title>All posts - Recently updated - ");
+  });
+
+  it("says how much a filter removed, and stays quiet when none did", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    // Two thread roots; asking for threads with replies leaves one of them.
+    const filtered = await (await app.request("/archive?replies=any")).text();
+    expect(filtered).toContain("of 2");
+
+    // Nothing filtered, so there is no baseline worth comparing against.
+    const unfiltered = await (await app.request("/archive")).text();
+    expect(unfiltered).not.toContain("of 2");
+  });
+
+  it("names the active filter in the document title", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const byFormat = await (await app.request("/archive?format=note")).text();
+    expect(byFormat).toContain("<title>Notes - ");
+
+    // Title presence absorbs the format it refines, as the filter chip does.
+    const untitled = await (
+      await app.request("/archive?format=note&title=none")
+    ).text();
+    expect(untitled).toContain("<title>Untitled - ");
+
+    // A tab truncates from the right, so the description stops at two parts.
+    const capped = await (
+      await app.request("/archive?format=note&year=2019&replies=any")
+    ).text();
+    expect(capped).toContain("<title>Notes, 2019 - ");
   });
 
   it("ignores an unknown sort value", async () => {
@@ -499,7 +614,9 @@ describe("archive page sort=updated", () => {
       publishedAt: Date.UTC(2025, 0, 1) / 1000,
     });
 
-    const html = await (await app.request("/archive?sort=updated")).text();
+    const html = await (
+      await app.request("/archive?layout=grid&sort=updated")
+    ).text();
     expect(html.indexOf("Quietly extended thread")).toBeLessThan(
       html.indexOf("Untouched newer thread"),
     );
@@ -514,3 +631,250 @@ describe("archive page sort=updated", () => {
     expect(roots[0]?.title).toBe("Untouched newer thread");
   });
 });
+
+/**
+ * `visibility` is the one archive dimension whose values are not all reachable
+ * by every reader. The rule: `private` is never silently dropped. On the page
+ * the reader's own URL is rewritten so the address bar keeps describing what
+ * rendered; a stored archive path 404s instead (see custom-archive-url.test.ts,
+ * which has no URL to rewrite).
+ */
+describe("archive visibility without a session", () => {
+  async function seedVisibilities(services: {
+    posts: {
+      create: (input: Record<string, unknown>) => Promise<unknown>;
+    };
+  }) {
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "body on the stream",
+      status: "published",
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "body off the stream",
+      status: "published",
+      visibility: "latest_hidden",
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "body kept back",
+      status: "published",
+      visibility: "private",
+    });
+  }
+
+  it("filters by Hidden-from-Latest for a signed-out reader", async () => {
+    const { app, services } = setupApp();
+    await seedVisibilities(services);
+
+    const res = await app.request("/archive?visibility=hidden");
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(html).toContain("body off the stream");
+    expect(html).not.toContain("body on the stream");
+    expect(html).not.toContain("body kept back");
+  });
+
+  it("strips private from a signed-out reader's URL, keeping the rest", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?visibility=private&format=note");
+    expect(res.status).toBe(302);
+    expect(res.headers.get("location")).toBe("/archive?format=note");
+  });
+
+  // 302, not 308: the URL moved for this reader at this moment, and has to
+  // keep working once the author signs in.
+  it("uses a temporary redirect, and a permanent one for legacy spellings", async () => {
+    const { app } = setupApp();
+
+    const both = await app.request("/archive?visibility=private&hasTitle=1");
+    expect(both.status).toBe(302);
+    expect(both.headers.get("location")).toBe("/archive?title=any");
+
+    const legacyOnly = await app.request("/archive?hasTitle=1");
+    expect(legacyOnly.status).toBe(308);
+  });
+
+  // The redirect must answer from the param and the session alone. Firing only
+  // when private posts exist would tell any visitor whether this site keeps any.
+  it("redirects identically when the site holds no private posts", async () => {
+    const { app, services } = setupApp();
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "the only post here",
+      status: "published",
+    });
+
+    const res = await app.request("/archive?visibility=private");
+    expect(res.status).toBe(302);
+    expect(res.headers.get("location")).toBe("/archive");
+  });
+
+  it("leaves the author's own private filter alone", async () => {
+    const { app, services } = setupAuthedApp();
+    await seedVisibilities(services);
+
+    const res = await app.request("/archive?visibility=private");
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(html).toContain("body kept back");
+    expect(html).not.toContain("body on the stream");
+  });
+
+  // A feed carries no session, so it cannot serve this selection. The page
+  // withholds the link rather than promising a feed that answers 404.
+  it("offers no feed link while the private filter is active", async () => {
+    const { app, services } = setupAuthedApp();
+    await seedVisibilities(services);
+
+    const filtered = await app.request("/archive?visibility=private");
+    expect(await filtered.text()).not.toContain("/archive/feed");
+
+    const plain = await app.request("/archive");
+    expect(await plain.text()).toContain("/archive/feed");
+  });
+
+  it("carries the visibility selection into the feed", async () => {
+    const { app, services } = setupApp();
+    await seedVisibilities(services);
+
+    const xml = await fetchFeed(app, "?visibility=hidden");
+    expect(xml).toContain("body off the stream");
+    expect(xml).not.toContain("body on the stream");
+  });
+
+  it("404s the feed for a selection it cannot serve", async () => {
+    const { app, services } = setupApp();
+    await seedVisibilities(services);
+
+    const res = await app.request("/archive/feed?visibility=private");
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("archive collection selection", () => {
+  async function seedOneCollectedPost(services: {
+    posts: {
+      create: (input: Record<string, unknown>) => Promise<{ id: string }>;
+    };
+    collections: {
+      create: (input: Record<string, unknown>) => Promise<{ id: string }>;
+      addThread: (collectionId: string, threadId: string) => Promise<unknown>;
+    };
+  }) {
+    const collection = await services.collections.create({
+      slug: "recipes",
+      title: "Recipes",
+    });
+    const collected = await services.posts.create({
+      format: "note",
+      title: "Collected Post",
+      bodyMarkdown: "in the collection",
+      status: "published",
+    });
+    await services.collections.addThread(collection.id, collected.id);
+    await services.posts.create({
+      format: "note",
+      title: "Loose Post",
+      bodyMarkdown: "in no collection",
+      status: "published",
+    });
+  }
+
+  it("filters the page by a collection that exists", async () => {
+    const { app, services } = setupApp();
+    await seedOneCollectedPost(services);
+
+    const res = await app.request("/archive?collection=recipes");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("Collected Post");
+    expect(html).not.toContain("Loose Post");
+  });
+
+  // Rendering the whole archive here would answer a question nobody asked,
+  // under the name the reader typed — the failure `visibility=private` was
+  // fixed for. `/collections/{slug}` answers the same question with a 404.
+  it("404s the page for a collection that does not exist", async () => {
+    const { app, services } = setupApp();
+    await seedOneCollectedPost(services);
+
+    const res = await app.request("/archive?collection=nope");
+    expect(res.status).toBe(404);
+  });
+
+  it("404s the feed for a collection that does not exist", async () => {
+    const { app, services } = setupApp();
+    await seedOneCollectedPost(services);
+
+    expect((await app.request("/archive/feed?collection=recipes")).status).toBe(
+      200,
+    );
+    expect((await app.request("/archive/feed?collection=nope")).status).toBe(
+      404,
+    );
+  });
+
+  // The page read a single slug while `/api/public/archive` read a list, so one
+  // spelling meant two things depending on which surface you asked. Both now
+  // read the same vocabulary.
+  it("selects the union of several collections", async () => {
+    const { app, services } = setupApp();
+    const recipes = await services.collections.create({
+      slug: "recipes",
+      title: "Recipes",
+    });
+    const travel = await services.collections.create({
+      slug: "travel",
+      title: "Travel",
+    });
+    const inRecipes = await services.posts.create({
+      format: "note",
+      title: "Recipe Post",
+      bodyMarkdown: "in recipes",
+      status: "published",
+    });
+    const inTravel = await services.posts.create({
+      format: "note",
+      title: "Travel Post",
+      bodyMarkdown: "in travel",
+      status: "published",
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Loose Post",
+      bodyMarkdown: "in no collection",
+      status: "published",
+    });
+    await services.collections.addThread(recipes.id, inRecipes.id);
+    await services.collections.addThread(travel.id, inTravel.id);
+
+    const res = await app.request("/archive?collection=recipes,travel");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("Recipe Post");
+    expect(html).toContain("Travel Post");
+    expect(html).not.toContain("Loose Post");
+
+    // Hono decodes a query value as form-urlencoded, so the `+` that separates
+    // slugs in `/collections/{a+b}` arrives here as a space. It is read anyway;
+    // a comma is what gets written back.
+    const plusSpelling = await app.request(
+      "/archive?collection=recipes+travel",
+    );
+    expect(plusSpelling.status).toBe(200);
+    expect(await plusSpelling.text()).toContain("Travel Post");
+  });
+
+  it("404s when only one of several collections is missing", async () => {
+    const { app, services } = setupApp();
+    await seedOneCollectedPost(services);
+
+    const res = await app.request("/archive?collection=recipes,nope");
+    expect(res.status).toBe(404);
+  });
+});

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

@@ -166,6 +166,22 @@ describe("Collection Routing", () => {
     expect(xml).toContain("Film log");
   });
 
+  it("leads the collection feed title with the site name", async () => {
+    // A reader's sidebar sorts by feed title, so every Jant feed leads with
+    // the site name — otherwise one site's feeds scatter across the alphabet.
+    const { app, services } = createCollectionRoutingTestApp();
+    await services.settings.set("SITE_NAME", "Jant");
+    await createCollectionWithPost(services, {
+      slug: "reading",
+      title: "Reading",
+      postTitle: "Book log",
+    });
+
+    const xml = await (await app.request("/reading/feed")).text();
+
+    expect(xml).toContain("<title>Jant - Reading</title>");
+  });
+
   it("applies the RSS publication delay to Collection feeds", async () => {
     const currentTime = 2_000_000;
     vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);