@jant/core 0.6.11 → 0.6.13

package/src/routes/pages/home.tsx

@@ -3,31 +3,21 @@
  *
  * Timeline feed with per-type card components and thread previews.
  * Uses page-based pagination.
- *
- * The homepage shows whichever built-in feed comes first between
- * Latest and Featured in navigation. The explicit feed routes still work.
  */
 
 import { Hono } from "hono";
 import { msg } from "@lingui/core/macro";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
-import {
-  getHomeDefaultViewFromNavItems,
-  getNavigationData,
-} from "../../lib/navigation.js";
+import { getNavigationData } from "../../lib/navigation.js";
 import { getI18n } from "../../i18n/index.js";
 import { formatPageLabel, parsePageNumber } from "../../lib/pagination.js";
 import { buildPageTitle } from "../../lib/page-title.js";
 import { renderPublicPage } from "../../lib/render.js";
-import {
-  assembleFeaturedTimeline,
-  assembleTimeline,
-} from "../../lib/timeline.js";
+import { assembleTimeline } from "../../lib/timeline.js";
 import { toAbsoluteSiteUrl, toPublicPath } from "../../lib/url.js";
 import { buildWebSiteJsonLd } from "../../lib/structured-data.js";
 import { HomePage } from "../../ui/pages/HomePage.js";
-import { FeaturedPage } from "../../ui/pages/FeaturedPage.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -39,19 +29,10 @@ homeRoutes.get("/", async (c) => {
   const paginatedPageTitle = formatPageLabel(page);
   const isAuthenticated = c.var.isAuthenticated;
 
-  // Fetch nav items once — we need `homeDefaultView` to decide which timeline
-  // to assemble, but `getNavigationData` also consumes them. Passing them
-  // through avoids a duplicate DB query and unlocks the Promise.all below.
-  const navItems = await c.var.services.navItems.list();
-  const homeDefaultView = getHomeDefaultViewFromNavItems(navItems);
-
-  const timelinePromise =
-    homeDefaultView === "featured"
-      ? assembleFeaturedTimeline(c, { page, isAuthenticated })
-      : assembleTimeline(c, { page, isAuthenticated });
+  const timelinePromise = assembleTimeline(c, { page, isAuthenticated });
 
   const [navData, timeline] = await Promise.all([
-    getNavigationData(c, { preloadedItems: navItems }),
+    getNavigationData(c),
     timelinePromise,
   ]);
 
@@ -74,34 +55,6 @@ homeRoutes.get("/", async (c) => {
         })
       : undefined;
 
-  if (homeDefaultView === "featured") {
-    const featuredTitle = i18n._(
-      msg({
-        message: "Featured",
-        comment: "@context: Browser page title for the featured feed",
-      }),
-    );
-
-    return renderPublicPage(c, {
-      title:
-        page > 1
-          ? buildPageTitle(featuredTitle, paginatedPageTitle, navData.siteName)
-          : navData.siteName,
-      jsonLd: websiteJsonLd,
-      navData,
-      showHomeBranding:
-        c.var.appConfig.showJantBrandingOnHome && currentPage === 1,
-      content: (
-        <FeaturedPage
-          items={items}
-          currentPage={currentPage}
-          totalPages={totalPages}
-          baseUrl={toPublicPath("/", navData.sitePathPrefix)}
-        />
-      ),
-    });
-  }
-
   const latestTitle = i18n._(
     msg({
       message: "Latest",

package/src/routes/pages/latest.tsx

@@ -1,71 +1,22 @@
 /**
  * Latest Page Route
  *
- * Explicit /latest URL that always shows the latest posts timeline.
- * When Latest is the homepage default, this redirects to / to avoid
- * duplicate content. When Featured comes first, this serves as the
- * explicit latest view.
+ * The homepage is the canonical latest timeline, so /latest redirects to /.
  */
 
 import { Hono } from "hono";
-import { msg } from "@lingui/core/macro";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
-import { getI18n } from "../../i18n/index.js";
-import { getNavigationData } from "../../lib/navigation.js";
-import { formatPageLabel, parsePageNumber } from "../../lib/pagination.js";
-import { buildPageTitle } from "../../lib/page-title.js";
-import { renderPublicPage } from "../../lib/render.js";
-import { assembleTimeline } from "../../lib/timeline.js";
 import { toPublicPath } from "../../lib/url.js";
 import { defaultFeedRenderer } from "../../lib/feed.js";
 import { buildFeedData, parseFormatQuery, renderFeed } from "../feed/feed.js";
-import { HomePage } from "../../ui/pages/HomePage.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const latestRoutes = new Hono<Env>();
 
 latestRoutes.get("/", async (c) => {
-  const navData = await getNavigationData(c);
-  const i18n = getI18n(c);
-
-  // When homepage already shows latest, redirect to avoid duplicate content
-  if (navData.homeDefaultView !== "featured") {
-    return c.redirect(toPublicPath("/", navData.sitePathPrefix), 302);
-  }
-
-  const page = parsePageNumber(c.req.query("page"));
-  const latestTitle = i18n._(
-    msg({
-      message: "Latest",
-      comment: "@context: Browser page title for the latest feed",
-    }),
-  );
-  const paginatedPageTitle = formatPageLabel(page);
-
-  const { items, currentPage, totalPages } = await assembleTimeline(c, {
-    page,
-    isAuthenticated: navData.isAuthenticated,
-  });
-
-  return renderPublicPage(c, {
-    title:
-      page > 1
-        ? buildPageTitle(latestTitle, paginatedPageTitle, navData.siteName)
-        : buildPageTitle(latestTitle, navData.siteName),
-    navData,
-    content: (
-      <HomePage
-        items={items}
-        baseUrl={toPublicPath("/latest", navData.sitePathPrefix)}
-        currentPage={currentPage}
-        totalPages={totalPages}
-        isAuthenticated={navData.isAuthenticated}
-        signinUrl={`${toPublicPath("/signin", navData.sitePathPrefix)}?redirect=${encodeURIComponent(toPublicPath("/latest", navData.sitePathPrefix))}`}
-      />
-    ),
-  });
+  return c.redirect(toPublicPath("/", c.var.appConfig.sitePathPrefix), 302);
 });
 
 // Atom — /latest/feed (canonical latest feed; accepts ?format=note|link|quote)

package/src/routes/pages/page.tsx

@@ -23,6 +23,7 @@ import {
   toPublicHref,
   toPublicPath,
 } from "../../lib/url.js";
+import { ABOUT_PAGE_SLUG } from "../../services/about-page.js";
 import { isTextAttachment } from "../../services/media.js";
 import type { Post } from "../../types.js";
 import { renderArchivePage } from "./archive.js";
@@ -186,12 +187,30 @@ async function renderPostWithTextPreview(
   });
 }
 
-async function renderPost(c: Context<Env>, post: Post) {
+function canRenderDraftAboutEditor(
+  c: Context<Env>,
+  fullPath: string,
+  post: Post,
+): boolean {
+  return (
+    post.status === "draft" &&
+    fullPath === ABOUT_PAGE_SLUG &&
+    c.req.query("edit") === "1" &&
+    c.var.isAuthenticated
+  );
+}
+
+async function renderPost(
+  c: Context<Env>,
+  post: Post,
+  options: { allowDraft?: boolean } = {},
+) {
   // Start navData fetch immediately — it's independent of thread/media queries
   const navDataPromise = getNavigationData(c);
   const display = await assemblePostPageDisplay(c, post, {
     // Private-post access is validated before renderPost() is called.
     isAuthenticated: true,
+    allowDraft: options.allowDraft,
   });
   if (!display) {
     return c.notFound();
@@ -208,15 +227,25 @@ async function renderPost(c: Context<Env>, post: Post) {
   return renderPublicPage(c, {
     title: buildPageTitle(meta.title, navData.siteName),
     description: meta.description,
-    canonicalHref,
-    socialImageUrl: display.socialImage?.url,
-    socialImageAlt: display.socialImage?.alt,
-    socialImageWidth: display.socialImage?.width,
-    socialImageHeight: display.socialImage?.height,
-    ogType: "article",
-    articlePublishedTime: display.articlePublishedTime,
-    articleModifiedTime: display.articleModifiedTime,
-    jsonLd: buildPostJsonLd(c, display, meta, canonicalHref, navData.siteName),
+    ...(post.status === "published"
+      ? {
+          canonicalHref,
+          socialImageUrl: display.socialImage?.url,
+          socialImageAlt: display.socialImage?.alt,
+          socialImageWidth: display.socialImage?.width,
+          socialImageHeight: display.socialImage?.height,
+          ogType: "article" as const,
+          articlePublishedTime: display.articlePublishedTime,
+          articleModifiedTime: display.articleModifiedTime,
+          jsonLd: buildPostJsonLd(
+            c,
+            display,
+            meta,
+            canonicalHref,
+            navData.siteName,
+          ),
+        }
+      : {}),
     navData,
     content: (
       <PostPage post={display.postView} threadPosts={display.threadPostViews} />
@@ -350,7 +379,10 @@ pageRoutes.get("/*", async (c) => {
 
   if (resolved.postId) {
     const post = await c.var.services.posts.getById(resolved.postId);
-    if (!post || post.status === "draft") return c.notFound();
+    if (!post) return c.notFound();
+
+    const allowDraft = canRenderDraftAboutEditor(c, fullPath, post);
+    if (post.status === "draft" && !allowDraft) return c.notFound();
 
     if (post.visibility === "private") {
       const navData = await getNavigationData(c);
@@ -368,7 +400,7 @@ pageRoutes.get("/*", async (c) => {
       }
     }
 
-    return renderPost(c, post);
+    return renderPost(c, post, { allowDraft });
   }
 
   if (resolved.collectionId) {

package/src/services/__tests__/about-page.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
+import type { Database } from "../../db/index.js";
+import { createAboutPageService } from "../about-page.js";
+import { createCollectionService } from "../collection.js";
+import { createPathService } from "../path.js";
+import { createPostService } from "../post.js";
+
+const ABOUT_BODY = JSON.stringify({
+  type: "doc",
+  content: [
+    {
+      type: "paragraph",
+      content: [{ type: "text", text: "About this site." }],
+    },
+  ],
+});
+
+describe("AboutPageService", () => {
+  let aboutPage: ReturnType<typeof createAboutPageService>;
+  let posts: ReturnType<typeof createPostService>;
+  let collections: ReturnType<typeof createCollectionService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    const db = testDb.db as unknown as Database;
+    const paths = createPathService(db, DEFAULT_TEST_SITE_ID);
+    posts = createPostService(
+      db,
+      { slugIdLength: 5 },
+      DEFAULT_TEST_SITE_ID,
+      paths,
+    );
+    collections = createCollectionService(db, DEFAULT_TEST_SITE_ID, paths);
+    aboutPage = createAboutPageService({
+      paths,
+      posts,
+      collections,
+    });
+  });
+
+  it("reports a missing About page when /about is unused", async () => {
+    await expect(aboutPage.getStatus()).resolves.toMatchObject({
+      state: "missing",
+      path: "/about",
+    });
+  });
+
+  it("recognizes a post at /about as the About page", async () => {
+    const post = await posts.create({
+      format: "note",
+      title: "About",
+      slug: "about",
+      visibility: "latest_hidden",
+      body: ABOUT_BODY,
+    });
+
+    await expect(aboutPage.getStatus()).resolves.toMatchObject({
+      state: "ready",
+      post: {
+        id: post.id,
+        title: "About",
+        visibility: "latest_hidden",
+      },
+    });
+  });
+
+  it("creates a hidden About page when /about is unused", async () => {
+    const post = await aboutPage.ensurePage();
+    expect(post).toMatchObject({
+      title: "About",
+      status: "published",
+      visibility: "latest_hidden",
+    });
+
+    await expect(aboutPage.getStatus()).resolves.toMatchObject({
+      state: "ready",
+      post: {
+        id: post.id,
+        title: "About",
+        status: "published",
+        visibility: "latest_hidden",
+      },
+    });
+  });
+
+  it("reports a conflict when a collection owns /about", async () => {
+    const collection = await collections.create({
+      title: "About",
+      slug: "about",
+    });
+
+    await expect(aboutPage.getStatus()).resolves.toMatchObject({
+      state: "conflict",
+      conflict: {
+        targetType: "collection",
+        id: collection.id,
+        title: "About",
+      },
+    });
+  });
+
+  it("rejects About creation when another item owns /about", async () => {
+    await collections.create({
+      title: "About",
+      slug: "about",
+    });
+
+    await expect(aboutPage.ensurePage()).rejects.toThrow(
+      "/about is already used.",
+    );
+  });
+});

package/src/services/__tests__/github-app-installations.test.ts

@@ -14,7 +14,9 @@ import {
 const SECOND_SITE_ID = "sit_second00000000000000000000000";
 const SECOND_SITE_KEY = "second";
 
-function insertSecondSite(sqlite: ReturnType<typeof createTestDatabase>["sqlite"]) {
+function insertSecondSite(
+  sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
+) {
   const timestamp = Math.floor(Date.now() / 1000);
   sqlite
     .prepare(
@@ -48,9 +50,9 @@ describe("GitHubAppInstallationsService", () => {
   });
 
   it("returns empty list for an unknown site", async () => {
-    expect(await service.listInstallationsForSite(DEFAULT_TEST_SITE_ID)).toEqual(
-      [],
-    );
+    expect(
+      await service.listInstallationsForSite(DEFAULT_TEST_SITE_ID),
+    ).toEqual([]);
   });
 
   it("returns empty list of sites for an unknown installation", async () => {
@@ -78,9 +80,8 @@ describe("GitHubAppInstallationsService", () => {
       DEFAULT_TEST_SITE_ID,
       makeAccount({ login: "old-name" }),
     );
-    const initial = await service.listInstallationsForSite(
-      DEFAULT_TEST_SITE_ID,
-    );
+    const initial =
+      await service.listInstallationsForSite(DEFAULT_TEST_SITE_ID);
     const addedAt = initial[0]!.addedAt;
 
     await service.upsertInstallation(
@@ -88,9 +89,8 @@ describe("GitHubAppInstallationsService", () => {
       DEFAULT_TEST_SITE_ID,
       makeAccount({ login: "renamed-org", avatarUrl: "https://x.png" }),
     );
-    const updated = await service.listInstallationsForSite(
-      DEFAULT_TEST_SITE_ID,
-    );
+    const updated =
+      await service.listInstallationsForSite(DEFAULT_TEST_SITE_ID);
     expect(updated).toHaveLength(1);
     expect(updated[0]!.addedAt).toBe(addedAt);
     expect(updated[0]!.account.login).toBe("renamed-org");

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

@@ -9,11 +9,50 @@ import { now } from "../../lib/time.js";
 
 const TEST_COLLECTION_ID = "col_test00000000000000000000001";
 const TEST_COLLECTION_ID_2 = "col_test00000000000000000000002";
+const TEST_POST_ID = "pst_test00000000000000000000001";
+const TEST_POST_ID_2 = "pst_test00000000000000000000002";
+
+function insertTestPath(
+  sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
+  input: {
+    id: string;
+    path: string;
+    kind: "slug" | "alias" | "redirect" | "archive";
+    postId?: string | null;
+    collectionId?: string | null;
+    redirectToPath?: string | null;
+    redirectType?: 301 | 302 | null;
+    archiveQuery?: string | null;
+  },
+) {
+  const ts = now();
+  sqlite
+    .prepare(
+      `INSERT INTO path_registry (
+        id, site_id, path, kind, post_id, collection_id, redirect_to_path,
+        redirect_type, archive_query, created_at, updated_at
+      )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      input.id,
+      DEFAULT_TEST_SITE_ID,
+      input.path,
+      input.kind,
+      input.postId ?? null,
+      input.collectionId ?? null,
+      input.redirectToPath ?? null,
+      input.redirectType ?? null,
+      input.archiveQuery ?? null,
+      ts,
+      ts,
+    );
+}
 
 function insertTestCollection(
   sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
   id: string,
-  _slug: string,
+  slug: string,
   title: string,
 ) {
   const ts = now();
@@ -23,6 +62,51 @@ function insertTestCollection(
        VALUES (?, ?, ?, 'newest', ?, ?)`,
     )
     .run(id, DEFAULT_TEST_SITE_ID, title, ts, ts);
+  insertTestPath(sqlite, {
+    id: `pth_col_${id.slice(4)}`,
+    path: slug,
+    kind: "slug",
+    collectionId: id,
+  });
+}
+
+function insertTestPost(
+  sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
+  input: {
+    id: string;
+    slug: string;
+    title: string | null;
+    status?: "draft" | "published";
+    visibility?: "public" | "latest_hidden" | "private";
+  },
+) {
+  const ts = now();
+  sqlite
+    .prepare(
+      `INSERT INTO post (
+        id, site_id, format, status, visibility, title, thread_id,
+        published_at, last_activity_at, created_at, updated_at
+      )
+       VALUES (?, ?, 'note', ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      input.id,
+      DEFAULT_TEST_SITE_ID,
+      input.status ?? "published",
+      input.visibility ?? "latest_hidden",
+      input.title,
+      input.id,
+      ts,
+      ts,
+      ts,
+      ts,
+    );
+  insertTestPath(sqlite, {
+    id: `pth_pst_${input.id.slice(4)}`,
+    path: input.slug,
+    kind: "slug",
+    postId: input.id,
+  });
 }
 
 describe("NavItemService", () => {
@@ -277,6 +361,152 @@ describe("NavItemService", () => {
     });
   });
 
+  describe("listSuggestedLinks", () => {
+    it("suggests a published /about page as a normal link", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About me",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([
+        {
+          key: "about",
+          label: "About me",
+          url: "/about",
+          targetType: "page",
+          navItemType: "link",
+        },
+      ]);
+    });
+
+    it("suggests a canonical /now collection as a collection nav item", async () => {
+      insertTestCollection(sqlite, TEST_COLLECTION_ID, "now", "Now");
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([
+        {
+          key: "now",
+          label: "Now",
+          url: "/now",
+          targetType: "collection",
+          navItemType: "collection",
+          collectionId: TEST_COLLECTION_ID,
+        },
+      ]);
+    });
+
+    it("suggests a /now collection alias as a normal link to preserve the path", async () => {
+      insertTestCollection(sqlite, TEST_COLLECTION_ID, "updates", "Updates");
+      insertTestPath(sqlite, {
+        id: "pth_now_alias",
+        path: "now",
+        kind: "alias",
+        collectionId: TEST_COLLECTION_ID,
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([
+        {
+          key: "now",
+          label: "Updates",
+          url: "/now",
+          targetType: "collection",
+          navItemType: "link",
+        },
+      ]);
+    });
+
+    it("hides suggestions already represented by path or collection id", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+      });
+      insertTestCollection(sqlite, TEST_COLLECTION_ID, "now", "Now");
+
+      await navItemService.create({
+        type: "link",
+        label: "About",
+        url: "/about/",
+      });
+      await navItemService.create({
+        type: "collection",
+        collectionId: TEST_COLLECTION_ID,
+        label: "Now",
+        url: "/now",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([]);
+    });
+
+    it("hides suggestions already represented by a same-site absolute URL", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+      });
+
+      await navItemService.create({
+        type: "link",
+        label: "About",
+        url: "https://preview-test.owenyoung.com/about",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks({
+        siteOrigin: "https://preview-test.owenyoung.com",
+      });
+
+      expect(suggestions).toEqual([]);
+    });
+
+    it("hides suggestions already represented by a public path prefix", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+      });
+
+      await navItemService.create({
+        type: "link",
+        label: "About",
+        url: "https://example.com/blog/about",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks({
+        siteOrigin: "https://example.com",
+        sitePathPrefix: "/blog",
+      });
+
+      expect(suggestions).toEqual([]);
+    });
+
+    it("does not suggest draft or private posts", async () => {
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID,
+        slug: "about",
+        title: "About",
+        status: "draft",
+      });
+      insertTestPost(sqlite, {
+        id: TEST_POST_ID_2,
+        slug: "now",
+        title: "Now",
+        visibility: "private",
+      });
+
+      const suggestions = await navItemService.listSuggestedLinks();
+
+      expect(suggestions).toEqual([]);
+    });
+  });
+
   describe("update", () => {
     it("updates a nav item's label", async () => {
       const created = await navItemService.create({