@jant/core 0.6.16 → 0.7.1

package/src/__tests__/export-collection-order.test.ts

@@ -0,0 +1,276 @@
+/**
+ * A collection on an exported site lists its Threads in Jant's order.
+ *
+ * The theme's `collection-members` partial restates the order Jant's
+ * collection page and feed read from the database: pins in this collection
+ * first, then `newest`, `oldest`, or `rating_desc`, which read the whole
+ * Thread (its activity, its earliest published post, its highest rating),
+ * not only the root. This builds the export with the real Hugo binary and
+ * compares every page and feed with what Jant's services return.
+ *
+ * Skips when `hugo` is not on PATH, like the other Hugo build tests.
+ */
+
+import { rm } from "node:fs/promises";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createTestDatabase, DEFAULT_TEST_SITE_ID } from "./helpers/db.js";
+import { makeSiteConfig } from "./helpers/export-fixtures.js";
+import {
+  buildHugoSite,
+  hugoAvailable,
+  readFeedSlugs,
+  readThreadSlugs,
+} from "./helpers/hugo-site.js";
+import { createCollectionService } from "../services/collection.js";
+import { createExportService } from "../services/export.js";
+import { createMediaService } from "../services/media.js";
+import { createPathService } from "../services/path.js";
+import { createPostService } from "../services/post.js";
+import {
+  resolveCollectionSortOrder,
+  supportsCollectionRatingSort,
+} from "../lib/collection-sort.js";
+import type { Database } from "../db/index.js";
+import type { CreatePost } from "../types/operations.js";
+import type { CollectionSortOrder } from "../types.js";
+
+const SITE_URL = "https://example.com";
+const at = (iso: string) => Math.floor(Date.parse(iso) / 1000);
+
+/** One collection per order, over the same Threads, plus the rating fallback. */
+const COLLECTIONS: { slug: string; sortOrder: CollectionSortOrder }[] = [
+  { slug: "by-newest", sortOrder: "newest" },
+  { slug: "by-oldest", sortOrder: "oldest" },
+  { slug: "by-rating", sortOrder: "rating_desc" },
+  // One rated Thread: too few to rank, so the page falls back to newest.
+  { slug: "few-rated", sortOrder: "rating_desc" },
+];
+
+describe.skipIf(!hugoAvailable)("collection order on an exported site", () => {
+  let siteDir: string;
+  const expected = new Map<string, string[]>();
+  const built = new Map<string, string[]>();
+  const expectedFeed = new Map<string, string[]>();
+  const builtFeed = new Map<string, string[]>();
+
+  beforeAll(async () => {
+    const { db: testDb } = createTestDatabase();
+    const db = testDb as unknown as Database;
+    const siteId = DEFAULT_TEST_SITE_ID;
+    const paths = createPathService(db, siteId);
+    const posts = createPostService(db, { slugIdLength: 5 }, siteId);
+    const collections = createCollectionService(db, siteId, paths);
+    const media = createMediaService(db, siteId);
+
+    const collectionIds = new Map<string, string>();
+    for (const { slug, sortOrder } of COLLECTIONS) {
+      const created = await collections.create({
+        slug,
+        title: slug,
+        sortOrder,
+      });
+      collectionIds.set(slug, created.id);
+    }
+    const inCollections = (slugs: string[], pinnedAt: number | null = null) =>
+      slugs.map((slug) => ({
+        collectionId: collectionIds.get(slug) as string,
+        pinnedAt,
+      }));
+    const ordered = ["by-newest", "by-oldest", "by-rating"];
+
+    const slugById = new Map<string, string>();
+    async function post(slug: string, data: Omit<CreatePost, "slug">) {
+      const created = await posts.create({
+        slug,
+        bodyMarkdown: `Body of ${slug}.`,
+        status: "published",
+        ...data,
+        createdAt: data.createdAt ?? data.publishedAt,
+      });
+      slugById.set(created.id, slug);
+      return created;
+    }
+    const reply = (
+      root: { id: string },
+      slug: string,
+      data: Omit<CreatePost, "slug" | "replyToId" | "format"> = {},
+    ) => post(slug, { format: "note", replyToId: root.id, ...data });
+
+    // A reply moves the Thread's activity to June.
+    const replied = await post("a-replied", {
+      format: "note",
+      publishedAt: at("2025-01-01T00:00:00Z"),
+      collectionEntries: inCollections([...ordered, "few-rated"]),
+    });
+    await reply(replied, "a-reply", {
+      publishedAt: at("2025-06-01T00:00:00Z"),
+    });
+
+    // Pinned in every ordered collection, rated on the root.
+    await post("b-pinned-rated", {
+      format: "note",
+      publishedAt: at("2025-02-01T00:00:00Z"),
+      rating: 3,
+      collectionEntries: [
+        ...inCollections(ordered, at("2025-07-01T00:00:00Z")),
+        ...inCollections(["few-rated"]),
+      ],
+    });
+
+    // Rated only on a reply: the Thread's rating is its highest.
+    const replyRated = await post("c-reply-rated", {
+      format: "note",
+      publishedAt: at("2025-03-01T00:00:00Z"),
+      collectionEntries: inCollections(ordered),
+    });
+    await reply(replyRated, "c-rated-reply", {
+      publishedAt: at("2025-03-02T00:00:00Z"),
+      rating: 5,
+    });
+
+    // Two Threads published in the same second: the ID decides.
+    await post("d-tied", {
+      format: "note",
+      publishedAt: at("2025-04-01T12:00:00Z"),
+      rating: 4,
+      collectionEntries: inCollections(ordered),
+    });
+    await post("e-tied", {
+      format: "note",
+      publishedAt: at("2025-04-01T12:00:00Z"),
+      collectionEntries: inCollections([...ordered, "few-rated"]),
+    });
+
+    // A reply dated before every other post: `oldest` reads the Thread's
+    // earliest published post, so this Thread comes first though its root
+    // is one of the later ones.
+    const early = await post("f-early-reply", {
+      format: "note",
+      publishedAt: at("2025-03-15T00:00:00Z"),
+      collectionEntries: inCollections(ordered),
+    });
+    await reply(early, "f-reply-before-root", {
+      publishedAt: at("2024-11-01T00:00:00Z"),
+    });
+
+    // Pinned more recently than b, with a quiet reply that doesn't move the
+    // Thread's activity.
+    const quiet = await post("g-pinned-quiet", {
+      format: "note",
+      publishedAt: at("2025-05-01T00:00:00Z"),
+      collectionEntries: inCollections(ordered, at("2025-08-01T00:00:00Z")),
+    });
+    await reply(quiet, "g-quiet-reply", {
+      publishedAt: at("2025-09-01T00:00:00Z"),
+      quietReply: true,
+    });
+
+    // Neither is on the page.
+    await post("h-private", {
+      format: "note",
+      visibility: "private",
+      publishedAt: at("2025-01-15T00:00:00Z"),
+      collectionEntries: inCollections(ordered),
+    });
+    await post("i-draft", {
+      format: "note",
+      status: "draft",
+      collectionEntries: inCollections(ordered),
+    });
+
+    const reader = { status: "published" as const, excludePrivate: true };
+    for (const { slug, sortOrder } of COLLECTIONS) {
+      const ids = [collectionIds.get(slug) as string];
+      // What the page shows, as the collection page route decides it.
+      const rated = await posts.countCollectionThreadRootsUpToForCollections(
+        ids,
+        { ...reader, hasRating: true },
+        2,
+      );
+      const pageOrder = resolveCollectionSortOrder(
+        undefined,
+        sortOrder,
+        supportsCollectionRatingSort(rated),
+      );
+      const rootIds = await posts.listCollectionThreadRootIdsForCollections(
+        ids,
+        { ...reader, sortOrder: pageOrder },
+      );
+      expected.set(
+        slug,
+        rootIds.map((id) => slugById.get(id) as string),
+      );
+      // What the feed carries, as the collection feed route asks for it.
+      const entries = await posts.listCollectionFeedEntriesForCollections(ids, {
+        ...reader,
+        ignoreCollectionPinnedSort: true,
+        limit: 50,
+      });
+      expectedFeed.set(
+        slug,
+        entries.map((entry) => slugById.get(entry.post.id) as string),
+      );
+    }
+
+    // A small page size, so the pages are read across pagination.
+    siteDir = await buildHugoSite(
+      await createExportService(
+        { posts, paths, collections, media },
+        makeSiteConfig({ siteUrl: SITE_URL, pageSize: 3 }),
+        { storage: null, bundleMedia: false },
+      ).generateHugoFiles(),
+    );
+    for (const { slug } of COLLECTIONS) {
+      built.set(slug, await readThreadSlugs(siteDir, slug));
+      builtFeed.set(slug, await readFeedSlugs(siteDir, slug, SITE_URL));
+    }
+  }, 60_000);
+
+  afterAll(async () => {
+    if (siteDir) await rm(siteDir, { recursive: true, force: true });
+  });
+
+  it.each(COLLECTIONS.map(({ slug }) => slug))(
+    "%s lists its Threads in Jant's order",
+    (slug) => {
+      expect(built.get(slug)).toEqual(expected.get(slug));
+    },
+  );
+
+  it.each(COLLECTIONS.map(({ slug }) => slug))(
+    "%s feed carries Jant's feed order",
+    (slug) => {
+      expect(builtFeed.get(slug)).toEqual(expectedFeed.get(slug));
+    },
+  );
+
+  // Equal lists prove nothing if the fixture can't tell the orders apart.
+  it("runs on a fixture where each rule changes the order", () => {
+    // Pins first, most recent first.
+    expect(expected.get("by-newest")?.slice(0, 2)).toEqual([
+      "g-pinned-quiet",
+      "b-pinned-rated",
+    ]);
+    // The reply dated before every other post puts its Thread first.
+    expect(expected.get("by-oldest")?.slice(2, 4)).toEqual([
+      "f-early-reply",
+      "a-replied",
+    ]);
+    // The rating on a reply ranks its Thread above a root rated lower.
+    expect(expected.get("by-rating")?.slice(2, 4)).toEqual([
+      "c-reply-rated",
+      "d-tied",
+    ]);
+    // One rated Thread: the page falls back to newest.
+    expect(expected.get("few-rated")).toEqual([
+      "a-replied",
+      "e-tied",
+      "b-pinned-rated",
+    ]);
+    // The feed ignores pins, and a quiet reply doesn't move its Thread up.
+    expect(expectedFeed.get("by-oldest")?.slice(0, 2)).toEqual([
+      "a-replied",
+      "g-pinned-quiet",
+    ]);
+  });
+});

package/src/__tests__/export-feed-ids.test.ts

@@ -0,0 +1,184 @@
+/**
+ * An exported site's feeds keep the entry IDs Jant's feeds served.
+ *
+ * A feed reader recognises an entry it has already shown by its `<id>` alone.
+ * The Hugo page a post moves to has a different URL — a trailing slash
+ * always, and the slug where Jant used a custom path — so a feed that took
+ * `<id>` from the page URL would show every post again to every subscriber
+ * after a site moves to its export. This serves Jant's feed and builds the
+ * export with the real Hugo binary from the same database, and compares the
+ * IDs.
+ *
+ * Skips when `hugo` is not on PATH, like the other Hugo build tests.
+ */
+
+import { readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Hono } from "hono";
+import { afterAll, describe, expect, it } from "vitest";
+import { createTestDatabase, DEFAULT_TEST_SITE_ID } from "./helpers/db.js";
+import { makeSiteConfig } from "./helpers/export-fixtures.js";
+import { buildHugoSite, hugoAvailable } from "./helpers/hugo-site.js";
+import { resolveConfig } from "../lib/resolve-config.js";
+import { latestRoutes } from "../routes/pages/latest.js";
+import { createCollectionService } from "../services/collection.js";
+import { createExportService } from "../services/export.js";
+import { createMediaService } from "../services/media.js";
+import { createPathService } from "../services/path.js";
+import { createPostService } from "../services/post.js";
+import { createSettingsService } from "../services/settings.js";
+import type { Database } from "../db/index.js";
+import type { Bindings } from "../types.js";
+import type { AppVariables } from "../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+const ORIGIN = "https://example.com";
+const CUSTOM_PATH = "/blog/links/2024-06-09-4";
+const CUSTOM_SLUG = "blog-links-2024-06-09-4";
+const at = (iso: string) => Math.floor(Date.parse(iso) / 1000);
+
+interface Entry {
+  id: string;
+  alternate: string;
+}
+
+/** Each entry's `<id>` and `<link rel="alternate">`, in document order. */
+function readEntries(xml: string): Entry[] {
+  return [...xml.matchAll(/<entry>([\s\S]*?)<\/entry>/g)].map(([, body]) => ({
+    id: body?.match(/<id>([^<]*)<\/id>/)?.[1] ?? "",
+    alternate:
+      body?.match(/<link href="([^"]*)" rel="alternate"\/>/)?.[1] ?? "",
+  }));
+}
+
+const ids = (entries: Entry[]) => entries.map((entry) => entry.id).sort();
+
+describe.skipIf(!hugoAvailable)("feed entry IDs on an exported site", () => {
+  const siteDirs: string[] = [];
+
+  afterAll(async () => {
+    for (const dir of siteDirs) await rm(dir, { recursive: true, force: true });
+  });
+
+  it.each([
+    { where: "at the domain root", prefix: "" },
+    { where: "under a site path prefix", prefix: "/journal" },
+  ])(
+    "match what Jant's feed served, $where",
+    async ({ prefix }) => {
+      const { db: testDb } = createTestDatabase();
+      const db = testDb as unknown as Database;
+      const siteId = DEFAULT_TEST_SITE_ID;
+      const paths = createPathService(db, siteId);
+      const posts = createPostService(db, { slugIdLength: 5 }, siteId, paths);
+      const collections = createCollectionService(db, siteId, paths);
+      const media = createMediaService(db, siteId);
+      const settings = createSettingsService(db, siteId);
+
+      // Served at its random slug, which is what an untitled note gets.
+      const plain = await posts.create({
+        format: "note",
+        bodyMarkdown: "A plain note.",
+        status: "published",
+        publishedAt: at("2024-06-01T00:00:00Z"),
+      });
+      // Served at a custom path, which its entry is named by. Its slug is
+      // where the Hugo page goes.
+      const custom = await posts.create({
+        format: "link",
+        slug: CUSTOM_SLUG,
+        title: "A link",
+        url: "https://other.example/article",
+        status: "published",
+        publishedAt: at("2024-06-09T00:00:00Z"),
+      });
+      await paths.create({
+        path: CUSTOM_PATH,
+        kind: "alias",
+        postId: custom.id,
+      });
+
+      const env = {
+        SITE_ORIGIN: ORIGIN,
+        SITE_PATH_PREFIX: prefix,
+        RSS_PUBLISH_DELAY_SECONDS: 0,
+      } as Bindings;
+      const appConfig = resolveConfig(env, await settings.getAll());
+      const app = new Hono<Env>();
+      app.use("*", async (c, next) => {
+        c.env = env;
+        c.set("services", {
+          posts,
+          paths,
+          media,
+          settings,
+        } as unknown as AppVariables["services"]);
+        c.set("appConfig", appConfig);
+        c.set("i18n", {
+          _(value: string | { message?: string }) {
+            return typeof value === "string" ? value : (value.message ?? "");
+          },
+        } as AppVariables["i18n"]);
+        await next();
+      });
+      app.route("/latest", latestRoutes);
+      const served = readEntries(
+        await (await app.request("/latest/feed")).text(),
+      );
+
+      const siteDir = await buildHugoSite(
+        await createExportService(
+          { posts, paths, collections, media },
+          makeSiteConfig({
+            siteUrl: appConfig.siteUrl,
+            sitePathPrefix: appConfig.sitePathPrefix,
+          }),
+          { storage: null, bundleMedia: false },
+        ).generateHugoFiles(),
+      );
+      siteDirs.push(siteDir);
+      const readFeed = async (path: string) =>
+        readEntries(await readFile(join(siteDir, "public", path), "utf8"));
+      const exportedLatest = await readFeed("index.xml");
+      const exportedArchive = await readFeed("archive/index.xml");
+
+      // What Jant serves: the random slug, and the custom path in place of
+      // the slug, neither with a trailing slash.
+      const base = `${ORIGIN}${prefix}`;
+      expect(ids(served)).toEqual(
+        [`${base}/${plain.slug}`, `${base}${CUSTOM_PATH}`].sort(),
+      );
+
+      expect(ids(exportedLatest)).toEqual(ids(served));
+      expect(ids(exportedArchive)).toEqual(ids(served));
+
+      // The entry still links to the page the post now lives on, not to the
+      // alias page that redirects there.
+      const exportedCustom = exportedLatest.find(
+        (entry) => entry.id === `${base}${CUSTOM_PATH}`,
+      );
+      expect(exportedCustom?.alternate).toBe("https://other.example/article");
+      const exportedFeed = await readFile(
+        join(siteDir, "public", "index.xml"),
+        "utf8",
+      );
+      expect(exportedFeed).toContain(
+        `<link href="${base}/${CUSTOM_SLUG}/" rel="related"/>`,
+      );
+      expect(
+        exportedLatest.find((entry) => entry.id === `${base}/${plain.slug}`)
+          ?.alternate,
+      ).toBe(`${base}/${plain.slug}/`);
+      // The ID still resolves: the custom path is an alias page that sends
+      // its visitor on to the post.
+      expect(
+        await readFile(
+          join(siteDir, "public", CUSTOM_PATH, "index.html"),
+          "utf8",
+        ),
+      ).toContain(`${base}/${CUSTOM_SLUG}/`);
+    },
+    60_000,
+  );
+});