@jant/core 0.6.16 → 0.7.0

package/src/services/__tests__/navigation.test.ts

@@ -81,6 +81,8 @@ function insertTestPost(
     format?: "note" | "link" | "quote";
     status?: "draft" | "published";
     visibility?: "public" | "latest_hidden" | "private";
+    language?: string | null;
+    translationGroupId?: string | null;
   },
 ) {
   const ts = now();
@@ -88,9 +90,10 @@ function insertTestPost(
     .prepare(
       `INSERT INTO post (
         id, site_id, format, status, visibility, title, thread_id,
+        language, translation_group_id,
         published_at, last_activity_at, created_at, updated_at
       )
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     )
     .run(
       input.id,
@@ -100,6 +103,8 @@ function insertTestPost(
       input.visibility ?? "latest_hidden",
       input.title,
       input.id,
+      input.language ?? null,
+      input.translationGroupId ?? null,
       ts,
       ts,
       ts,
@@ -252,7 +257,9 @@ describe("NavItemService", () => {
       expect(item).toMatchObject({
         type: "page",
         postId: TEST_POST_ID,
-        label: "About me",
+        // Nothing stored: the item follows the page's title from here on.
+        label: "",
+        targetTitle: "About me",
         url: "/about-me",
         placement: "header",
       });
@@ -280,7 +287,7 @@ describe("NavItemService", () => {
       ).rejects.toThrow("Page must be a published, non-private titled note");
     });
 
-    it("truncates a page's default navigation label", async () => {
+    it("truncates a page's custom navigation label", async () => {
       insertTestPost(sqlite, {
         id: TEST_POST_ID,
         slug: "long-title",
@@ -290,9 +297,146 @@ describe("NavItemService", () => {
       const item = await navItemService.create({
         type: "page",
         postId: TEST_POST_ID,
+        label: "B".repeat(150),
+      });
+
+      expect(item.label).toBe("B".repeat(100));
+    });
+
+    it("leaves a page item's label empty so it follows the page title", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about-me",
+        title: "About me",
+      });
+      const item = await navItemService.create({
+        type: "page",
+        postId: TEST_POST_ID,
+      });
+
+      sqlite
+        .prepare(`UPDATE post SET title = ? WHERE id = ?`)
+        .run("Colophon", TEST_POST_ID);
+
+      const [reread] = await navItemService.list();
+      expect(reread).toMatchObject({
+        id: item.id,
+        label: "",
+        targetTitle: "Colophon",
+      });
+    });
+  });
+
+  describe("list in a language view", () => {
+    const TRANSLATION_GROUP = "tgr_test0000000000000000000001";
+
+    function addAboutPageNav() {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "关于",
+        language: "zh-Hans",
+        translationGroupId: TRANSLATION_GROUP,
+      });
+      return navItemService.create({ type: "page", postId: TEST_POST_ID });
+    }
+
+    it("points a page item at the version written in the view's language", async () => {
+      const item = await addAboutPageNav();
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "about-en",
+        title: "About",
+        language: "en",
+        translationGroupId: TRANSLATION_GROUP,
+      });
+
+      const [resolved] = await navItemService.list({ language: "en" });
+
+      expect(resolved).toMatchObject({
+        id: item.id,
+        // The address and the title move together: a link that lands on
+        // English content is labelled in English.
+        url: "/about-en",
+        targetTitle: "About",
+        // Still the configured target — only the destination follows the view.
+        postId: TEST_POST_ID,
+      });
+    });
+
+    it("leaves the item alone when that language has no version", async () => {
+      const item = await addAboutPageNav();
+
+      const [resolved] = await navItemService.list({ language: "ja" });
+
+      expect(resolved).toMatchObject({
+        id: item.id,
+        url: "/about",
+        targetTitle: "关于",
+      });
+    });
+
+    it("ignores a translation that is not publicly readable", async () => {
+      await addAboutPageNav();
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "about-en",
+        title: "About",
+        status: "draft",
+        language: "en",
+        translationGroupId: TRANSLATION_GROUP,
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_3,
+        slug: "about-ja",
+        title: "About (ja)",
+        visibility: "private",
+        language: "ja",
+        translationGroupId: TRANSLATION_GROUP,
+      });
+
+      const [draftView] = await navItemService.list({ language: "en" });
+      const [privateView] = await navItemService.list({ language: "ja" });
+
+      expect(draftView?.url).toBe("/about");
+      expect(privateView?.url).toBe("/about");
+    });
+
+    it("keeps a label the author typed, whatever the view", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "关于",
+        language: "zh-Hans",
+        translationGroupId: TRANSLATION_GROUP,
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "about-en",
+        title: "About",
+        language: "en",
+        translationGroupId: TRANSLATION_GROUP,
+      });
+      await navItemService.create({
+        type: "page",
+        postId: TEST_POST_ID,
+        label: "自我介绍",
+      });
+
+      const [resolved] = await navItemService.list({ language: "en" });
+
+      expect(resolved).toMatchObject({
+        label: "自我介绍",
+        url: "/about-en",
       });
+    });
+
+    it("does not follow translations without a language", async () => {
+      const item = await addAboutPageNav();
+
+      const [resolved] = await navItemService.list();
 
-      expect(item.label).toBe("A".repeat(100));
+      expect(resolved).toMatchObject({ id: item.id, url: "/about" });
     });
   });
 
@@ -302,15 +446,15 @@ describe("NavItemService", () => {
 
       expect(created.map((item) => item.systemKey)).toEqual([
         "featured",
-        "collections",
         "archive",
-        "rss",
+        "collections",
+        "subscribe",
         "settings",
       ]);
       expect(created.map((item) => item.placement)).toEqual([
         "header",
         "header",
-        "header",
+        "more",
         "more",
         "more",
       ]);
@@ -333,9 +477,9 @@ describe("NavItemService", () => {
 
       expect(created.map((item) => item.systemKey)).toEqual([
         "featured",
-        "collections",
         "archive",
-        "rss",
+        "collections",
+        "subscribe",
         "settings",
       ]);
       expect(items.find((item) => item.id === latest.id)).toEqual(
@@ -367,7 +511,7 @@ describe("NavItemService", () => {
       expect(created.map((item) => item.systemKey)).toEqual([
         "featured",
         "collections",
-        "rss",
+        "subscribe",
         "settings",
       ]);
       expect(items.slice(0, 2).map((item) => item.id)).toEqual([
@@ -513,6 +657,65 @@ describe("NavItemService", () => {
     });
   });
 
+  describe("resolveNavTarget", () => {
+    it("resolves a page address to the item it can become", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About this site",
+        visibility: "latest_hidden",
+      });
+
+      expect(await navItemService.resolveNavTarget("/about")).toEqual({
+        status: "page",
+        page: {
+          id: TEST_POST_ID,
+          title: "About this site",
+          slug: "about",
+          updatedAt: expect.any(Number),
+        },
+      });
+    });
+
+    it("reports an address navigation can only hold as a link", async () => {
+      // A custom archive URL is a real page with no post behind it, so no page
+      // item can track it.
+      insertTestPath(sqlite, {
+        id: "pth_archive000000000000000000",
+        path: "reading-2025",
+        kind: "archive",
+        archiveQuery: "year=2025",
+      });
+
+      expect(await navItemService.resolveNavTarget("/reading-2025")).toEqual({
+        status: "link_only",
+      });
+    });
+
+    it("resolves an alias to the post's canonical slug", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About this site",
+      });
+      insertTestPath(sqlite, {
+        id: "pth_alias0000000000000000000000",
+        path: "about-us",
+        kind: "alias",
+        postId: TEST_POST_ID,
+      });
+
+      // The menu should show where the page lives, not the old address the
+      // author happened to have in their history.
+      expect(await navItemService.resolveNavTarget("/about-us")).toEqual(
+        expect.objectContaining({
+          status: "page",
+          page: expect.objectContaining({ slug: "about" }),
+        }),
+      );
+    });
+  });
+
   describe("listSuggestedLinks", () => {
     it("suggests a published /about page as a page nav item", async () => {
       insertTestPost(sqlite, {

package/src/services/__tests__/path.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Path resolution.
+ *
+ * `resolve` answers a request — a redirect there has to stay a redirect, so
+ * the router can emit it. `resolveTarget` answers a person holding an address,
+ * where the only useful answer is the thing at the end of the hops.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { sql } from "drizzle-orm";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
+import { createPathService } from "../path.js";
+import { createPostService } from "../post.js";
+import type { Database } from "../../db/index.js";
+
+describe("PathService.resolveTarget", () => {
+  let db: Database;
+  let paths: ReturnType<typeof createPathService>;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    paths = createPathService(db, DEFAULT_TEST_SITE_ID);
+    postService = createPostService(
+      db,
+      { slugIdLength: 5 },
+      DEFAULT_TEST_SITE_ID,
+      paths,
+    );
+  });
+
+  async function createPost(slug: string) {
+    return postService.create({
+      format: "note",
+      title: slug,
+      slug,
+      body: JSON.stringify({
+        type: "doc",
+        content: [{ type: "paragraph" }],
+      }),
+    });
+  }
+
+  it("resolves a plain slug to its post", async () => {
+    const post = await createPost("hello");
+
+    expect(await paths.resolveTarget("hello")).toEqual(
+      expect.objectContaining({ targetType: "post", postId: post.id }),
+    );
+  });
+
+  it("follows a redirect to the post it points at", async () => {
+    const post = await createPost("new-name");
+    await paths.create({
+      path: "old-name",
+      kind: "redirect",
+      redirectToPath: "new-name",
+      redirectType: 301,
+    });
+
+    expect(await paths.resolve("old-name")).toEqual(
+      expect.objectContaining({ targetType: "redirect" }),
+    );
+    expect(await paths.resolveTarget("old-name")).toEqual(
+      expect.objectContaining({ targetType: "post", postId: post.id }),
+    );
+  });
+
+  it("follows a chain of redirects", async () => {
+    const post = await createPost("third");
+    await paths.create({
+      path: "first",
+      kind: "redirect",
+      redirectToPath: "second",
+      redirectType: 301,
+    });
+    await paths.create({
+      path: "second",
+      kind: "redirect",
+      redirectToPath: "third",
+      redirectType: 301,
+    });
+
+    expect(await paths.resolveTarget("first")).toEqual(
+      expect.objectContaining({ targetType: "post", postId: post.id }),
+    );
+  });
+
+  it("gives up on a redirect loop rather than spinning", async () => {
+    await paths.create({
+      path: "ping",
+      kind: "redirect",
+      redirectToPath: "pong",
+      redirectType: 302,
+    });
+    await paths.create({
+      path: "pong",
+      kind: "redirect",
+      redirectToPath: "ping",
+      redirectType: 302,
+    });
+
+    expect(await paths.resolveTarget("ping")).toBeNull();
+  });
+
+  it("returns null for an address nothing is registered at", async () => {
+    expect(await paths.resolveTarget("nothing-here")).toBeNull();
+  });
+});
+
+/**
+ * `aliases[0]` becomes a Post's permalink, and therefore its Atom `<id>` and
+ * its sitemap `<loc>`. Feed readers and the Discover crawler both key entries
+ * on that id, so which alias comes first is an identity decision, not a
+ * presentation one — it must come from the query, never from the storage
+ * engine's row order.
+ */
+describe("PathService.getPostAliases", () => {
+  let db: Database;
+  let paths: ReturnType<typeof createPathService>;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    paths = createPathService(db, DEFAULT_TEST_SITE_ID);
+    postService = createPostService(
+      db,
+      { slugIdLength: 5 },
+      DEFAULT_TEST_SITE_ID,
+      paths,
+    );
+  });
+
+  async function createAlias(postId: string, path: string, createdAt: number) {
+    const record = await paths.create({ path, kind: "alias", postId });
+    await db.run(
+      sql`UPDATE path_registry SET created_at = ${createdAt} WHERE id = ${record.id}`,
+    );
+    return record;
+  }
+
+  it("returns aliases oldest first, whatever order they were inserted in", async () => {
+    const post = await postService.create({
+      format: "note",
+      title: "Aliased",
+      slug: "aliased",
+      body: JSON.stringify({ type: "doc", content: [{ type: "paragraph" }] }),
+    });
+
+    // Inserted newest-first, so insertion order is the opposite of the answer.
+    await createAlias(post.id, "second-address", 2_000);
+    await createAlias(post.id, "first-address", 1_000);
+
+    const aliases = await paths.getPostAliases([post.id]);
+
+    expect(aliases.get(post.id)).toEqual(["/first-address", "/second-address"]);
+  });
+
+  it("keeps a second custom URL from taking over the permalink", async () => {
+    const post = await postService.create({
+      format: "note",
+      title: "Renamed",
+      slug: "renamed",
+      body: JSON.stringify({ type: "doc", content: [{ type: "paragraph" }] }),
+    });
+
+    await createAlias(post.id, "original", 1_000);
+    const before = await paths.getPostAliases([post.id]);
+    await createAlias(post.id, "added-later", 2_000);
+    const after = await paths.getPostAliases([post.id]);
+
+    expect(before.get(post.id)?.[0]).toBe("/original");
+    expect(after.get(post.id)?.[0]).toBe("/original");
+  });
+});