@jant/core 0.6.15 → 0.7.0

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);

package/src/routes/pages/__tests__/collections-feed-links.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Collection feeds in the directory.
+ *
+ * `/subscribe` lists only the site-wide feeds, so this is the one place a
+ * reader is handed a collection's feed. If these icons go, collection feeds
+ * become undiscoverable outside the collection's own page.
+ */
+
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { i18nMiddleware } from "../../../i18n/index.js";
+import { collectionsPageRoutes } from "../collections.js";
+
+function createDirectoryTestApp() {
+  const testApp = createTestApp();
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+  app.use("*", i18nMiddleware());
+  app.route("/collections", collectionsPageRoutes);
+
+  return testApp;
+}
+
+/** Every feed address the directory offers, in document order. */
+function feedHrefs(html: string): string[] {
+  return [...html.matchAll(/<a href="([^"]*)" class="feed-link"/g)].map(
+    (match) => match[1] as string,
+  );
+}
+
+async function seedCollection(
+  services: ReturnType<typeof createTestApp>["services"],
+  slug: string,
+) {
+  const collection = await services.collections.create({
+    slug,
+    title: slug,
+  });
+  const post = await services.posts.create({
+    format: "note",
+    bodyMarkdown: `A post in ${slug}`,
+    status: "published",
+  });
+  await services.collections.addThread(collection.id, post.id);
+}
+
+describe("collections directory feed links", () => {
+  it("offers each collection's feed beside it", async () => {
+    const { app, services } = createDirectoryTestApp();
+    await seedCollection(services, "reading");
+    await seedCollection(services, "cooking");
+
+    const html = await (await app.request("/collections")).text();
+
+    expect(feedHrefs(html).sort()).toEqual(["/cooking/feed", "/reading/feed"]);
+  });
+
+  it("offers nothing when feeds are switched off site-wide", async () => {
+    const { app, services } = createDirectoryTestApp();
+    await seedCollection(services, "reading");
+    await services.settings.set("RSS_FEEDS_ENABLED", "false");
+
+    const html = await (await app.request("/collections")).text();
+
+    expect(feedHrefs(html)).toEqual([]);
+  });
+});

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

@@ -52,7 +52,9 @@ describe("Collections Listing Page - Data Logic", () => {
     await collectionService.addThread(recipes.id, p1.id);
     await collectionService.addThread(recipes.id, p2.id);
 
-    const directory = await collectionService.listDirectoryData();
+    const directory = await collectionService.listDirectoryData({
+      isAuthenticated: false,
+    });
 
     expect(directory.collections).toHaveLength(2);
     const recipesResult = directory.collections.find(
@@ -66,7 +68,9 @@ describe("Collections Listing Page - Data Logic", () => {
   });
 
   it("returns empty list when no collections exist", async () => {
-    const directory = await collectionService.listDirectoryData();
+    const directory = await collectionService.listDirectoryData({
+      isAuthenticated: false,
+    });
     expect(directory.collections).toHaveLength(0);
     expect(directory.items).toHaveLength(0);
   });
@@ -91,7 +95,9 @@ describe("Collections Listing Page - Data Logic", () => {
 
     await postService.delete(post.id);
 
-    const directory = await collectionService.listDirectoryData();
+    const directory = await collectionService.listDirectoryData({
+      isAuthenticated: false,
+    });
     expect(directory.collections[0]?.threadCount).toBe(1);
     expect(directory.collections[0]?.recentActivityAt).toBe(
       post2.lastActivityAt,

package/src/routes/pages/__tests__/custom-archive-url.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Coverage for archive queries stored in the path registry.
+ *
+ * A custom URL of kind `archive` hands `renderArchivePage` a query the author
+ * wrote, not one the reader assembled. That distinction decides what a
+ * signed-out reader gets when the query names a set only the author can see:
+ * the /archive route rewrites such a URL, but here the path *is* the name, so
+ * there is nothing to rewrite. Rendering the query with the clause quietly
+ * dropped would serve a different set under a name the author chose for
+ * another one.
+ */
+
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { pageRoutes } from "../page.js";
+
+function createPageTestApp(authenticated = false) {
+  const testApp = createTestApp({ authenticated });
+  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;
+}
+
+async function seed(services: {
+  posts: { create: (input: Record<string, unknown>) => Promise<unknown> };
+  customUrls: {
+    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 kept back",
+    status: "published",
+    visibility: "private",
+  });
+  await services.paths.create({
+    path: "/private-notes",
+    kind: "archive",
+    archiveQuery: "visibility=private",
+  });
+  await services.paths.create({
+    path: "/every-note",
+    kind: "archive",
+    archiveQuery: "format=note",
+  });
+}
+
+describe("custom archive URLs", () => {
+  it("renders a stored query the reader is allowed to see", async () => {
+    const { app, services } = createPageTestApp();
+    await seed(services);
+
+    const res = await app.request("/every-note");
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(html).toContain("body on the stream");
+    expect(html).not.toContain("body kept back");
+  });
+
+  it("404s a stored query naming a set only the author can see", async () => {
+    const { app, services } = createPageTestApp();
+    await seed(services);
+
+    const res = await app.request("/private-notes");
+    expect(res.status).toBe(404);
+  });
+
+  // The bug this covers: the clause used to evaporate for signed-out readers,
+  // so /private-notes served the whole public archive under that name.
+  it("never widens a stored private query into the public archive", async () => {
+    const { app, services } = createPageTestApp();
+    await seed(services);
+
+    const res = await app.request("/private-notes");
+    expect(await res.text()).not.toContain("body on the stream");
+  });
+
+  it("renders the same stored query for the author", async () => {
+    const { app, services } = createPageTestApp(true);
+    await seed(services);
+
+    const res = await app.request("/private-notes");
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(html).toContain("body kept back");
+    expect(html).not.toContain("body on the stream");
+  });
+
+  // Same rule, reached through a stored query: a collection that was deleted
+  // after the path was saved leaves the path naming nothing, and the honest
+  // answer is that it no longer resolves — not the whole archive.
+  it("404s a stored query naming a collection that is gone", async () => {
+    const { app, services } = createPageTestApp();
+    await seed(services);
+    await services.paths.create({
+      path: "/gone",
+      kind: "archive",
+      archiveQuery: "collection=deleted-collection",
+    });
+
+    const res = await app.request("/gone");
+    expect(res.status).toBe(404);
+  });
+});

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

@@ -39,12 +39,16 @@ describe("Featured Page - Data Logic", () => {
       bodyMarkdown: "Normal post",
       status: "published",
     });
-    await postService.create({
+    // Featuring an unpublished post is refused outright, so the only way a
+    // draft carries the flag is by being unpublished after the fact — the
+    // case this filter still has to catch.
+    const unpublished = await postService.create({
       format: "note",
       bodyMarkdown: "Draft featured",
       featured: true,
-      status: "draft",
+      status: "published",
     });
+    await postService.update(unpublished.id, { status: "draft" });
 
     const posts = await postService.list({
       featured: true,

package/src/routes/pages/__tests__/feed-autodiscovery.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Feed autodiscovery in `<head>`.
+ *
+ * A page that publishes its own feed must advertise it, so a reader's
+ * extension subscribing from `/reading` gets the Reading collection — not
+ * only the site-wide feeds every page carries.
+ */
+
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { i18nMiddleware } from "../../../i18n/index.js";
+import { archiveRoutes } from "../archive.js";
+import { collectionRoutes } from "../collection.js";
+import { collectionsPageRoutes } from "../collections.js";
+import { languageRoutes } from "../language.js";
+import { pageRoutes } from "../page.js";
+
+function createFeedLinkTestApp() {
+  const testApp = createTestApp();
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+  app.use("*", i18nMiddleware());
+
+  app.route("/archive", archiveRoutes);
+  app.route("/collections", collectionsPageRoutes);
+  app.route("/collections", collectionRoutes);
+  app.route("/:lang", languageRoutes);
+  app.route("/", pageRoutes);
+
+  return testApp;
+}
+
+/** Every `<link rel="alternate" type="application/atom+xml">` in document order. */
+function feedLinks(html: string): { title?: string; href: string }[] {
+  const matches = html.matchAll(
+    /<link rel="alternate" type="application\/atom\+xml"(?: title="([^"]*)")? href="([^"]*)"\/?>/g,
+  );
+  return [...matches].map((match) => ({
+    title: match[1],
+    href: match[2] as string,
+  }));
+}
+
+async function createCollectionWithPost(
+  services: ReturnType<typeof createTestApp>["services"],
+  {
+    slug,
+    title,
+    postTitle,
+  }: { slug: string; title: string; postTitle: string },
+) {
+  const collection = await services.collections.create({ slug, title });
+  const post = await services.posts.create({
+    format: "note",
+    title: postTitle,
+    bodyMarkdown: postTitle,
+    status: "published",
+  });
+  await services.collections.addThread(collection.id, post.id);
+  return collection;
+}
+
+describe("feed autodiscovery links", () => {
+  it("advertises a collection's own feed ahead of the site feeds", async () => {
+    const { app, services } = createFeedLinkTestApp();
+    await createCollectionWithPost(services, {
+      slug: "reading",
+      title: "Reading",
+      postTitle: "Book log",
+    });
+
+    const html = await (await app.request("/reading")).text();
+
+    expect(feedLinks(html)[0]).toEqual({
+      title: "Reading",
+      href: "/reading/feed",
+    });
+    expect(html).toContain('href="/feed"');
+  });
+
+  it("advertises the combined feed on an aggregate collection page", async () => {
+    const { app, services } = createFeedLinkTestApp();
+    await createCollectionWithPost(services, {
+      slug: "reading",
+      title: "Reading",
+      postTitle: "Book log",
+    });
+    await createCollectionWithPost(services, {
+      slug: "movies",
+      title: "Movies",
+      postTitle: "Film log",
+    });
+
+    const html = await (
+      await app.request("/collections/reading+movies")
+    ).text();
+
+    expect(feedLinks(html)[0]?.href).toBe("/collections/reading+movies/feed");
+  });
+
+  it("advertises the archive feed, carrying the active filters", async () => {
+    const { app } = createFeedLinkTestApp();
+
+    const plain = await (await app.request("/archive")).text();
+    expect(feedLinks(plain)[0]).toEqual({
+      title: "Archive",
+      href: "/archive/feed",
+    });
+
+    const filtered = await (await app.request("/archive?format=note")).text();
+    expect(feedLinks(filtered)[0]).toEqual({
+      title: "Archive: Notes",
+      href: "/archive/feed?format=note",
+    });
+  });
+
+  it("points at the language view's feed inside a language view", async () => {
+    const { app, services } = createFeedLinkTestApp();
+    await services.settings.set("SITE_LANGUAGE", "zh-Hans");
+    await services.settings.set("ADDITIONAL_LANGUAGES", "en");
+    await services.settings.set("MULTILINGUAL_ENABLED", "true");
+
+    const html = await (await app.request("/en/archive")).text();
+
+    expect(feedLinks(html)[0]?.href).toBe("/en/archive/feed");
+  });
+
+  it("drops the page feed link when feed publishing is off", async () => {
+    const { app, services } = createFeedLinkTestApp();
+    await services.settings.set("RSS_FEEDS_ENABLED", "false");
+    await createCollectionWithPost(services, {
+      slug: "reading",
+      title: "Reading",
+      postTitle: "Book log",
+    });
+
+    const collectionHtml = await (await app.request("/reading")).text();
+    const archiveHtml = await (await app.request("/archive")).text();
+
+    expect(feedLinks(collectionHtml)).toHaveLength(0);
+    expect(feedLinks(archiveHtml)).toHaveLength(0);
+  });
+});