@jant/core 0.3.23 → 0.3.25

package/src/{routes/api → lib}/__tests__/timeline.test.ts

@@ -1,19 +1,19 @@
 /**
- * Timeline API Tests
+ * Timeline Data Assembly Tests
  *
  * Tests the timeline data assembly logic via the service layer.
  * The actual route handler renders JSX components which require the Lingui SWC
  * plugin (not available in vitest). We test the underlying service operations
- * that power the timeline API instead.
+ * that power the timeline instead.
  */
 
 import { describe, it, expect, beforeEach } from "vitest";
-import { createTestDatabase } from "../../../__tests__/helpers/db.js";
-import { createPostService } from "../../../services/post.js";
-import { createMediaService } from "../../../services/media.js";
-import { buildMediaMap } from "../../../lib/media-helpers.js";
-import type { Database } from "../../../db/index.js";
-import type { PostWithMedia } from "../../../types.js";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createPostService } from "../../services/post.js";
+import { createMediaService } from "../../services/media.js";
+import { buildMediaMap } from "../media-helpers.js";
+import type { Database } from "../../db/index.js";
+import type { PostWithMedia } from "../../types.js";
 
 describe("Timeline data assembly", () => {
   let db: Database;
@@ -29,15 +29,13 @@ describe("Timeline data assembly", () => {
 
   it("assembles timeline items with media attachments", async () => {
     const post = await postService.create({
-      type: "note",
-      content: "Hello",
-      visibility: "featured",
+      format: "note",
+      body: "Hello",
     });
 
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 21,
     });
 
@@ -60,25 +58,23 @@ describe("Timeline data assembly", () => {
 
   it("identifies thread roots and builds thread previews", async () => {
     const root = await postService.create({
-      type: "note",
-      content: "Thread root",
-      visibility: "featured",
+      format: "note",
+      body: "Thread root",
     });
     await postService.create({
-      type: "note",
-      content: "Reply 1",
+      format: "note",
+      body: "Reply 1",
       replyToId: root.id,
     });
     await postService.create({
-      type: "note",
-      content: "Reply 2",
+      format: "note",
+      body: "Reply 2",
       replyToId: root.id,
     });
 
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 21,
     });
 
@@ -96,7 +92,7 @@ describe("Timeline data assembly", () => {
     const threadPreviews = await postService.getThreadPreviews(threadRootIds);
     const replies = threadPreviews.get(root.id);
     expect(replies).toHaveLength(2);
-    expect(replies?.[0]?.content).toBe("Reply 1");
+    expect(replies?.[0]?.body).toBe("Reply 1");
 
     // Assemble items
     const rawMediaMap = await mediaService.getByPostIds(postIds);
@@ -133,50 +129,25 @@ describe("Timeline data assembly", () => {
     expect(items[0]?.threadPreview?.totalReplyCount).toBe(2);
   });
 
-  it("excludes pages from timeline", async () => {
-    await postService.create({
-      type: "note",
-      content: "A note",
-      visibility: "quiet",
-    });
-    await postService.create({
-      type: "page",
-      content: "A page",
-      visibility: "quiet",
-    });
-
-    const posts = await postService.list({
-      visibility: ["featured", "quiet"],
-      excludeReplies: true,
-      excludeTypes: ["page"],
-      limit: 21,
-    });
-
-    expect(posts).toHaveLength(1);
-    expect(posts[0]?.type).toBe("note");
-  });
-
   it("excludes replies from top-level list", async () => {
     const root = await postService.create({
-      type: "note",
-      content: "Root",
-      visibility: "quiet",
+      format: "note",
+      body: "Root",
     });
     await postService.create({
-      type: "note",
-      content: "Reply",
+      format: "note",
+      body: "Reply",
       replyToId: root.id,
     });
 
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 21,
     });
 
     expect(posts).toHaveLength(1);
-    expect(posts[0]?.content).toBe("Root");
+    expect(posts[0]?.body).toBe("Root");
   });
 
   it("supports cursor pagination for load more", async () => {
@@ -184,9 +155,8 @@ describe("Timeline data assembly", () => {
     for (let i = 0; i < 5; i++) {
       posts.push(
         await postService.create({
-          type: "note",
-          content: `Post ${i}`,
-          visibility: "quiet",
+          format: "note",
+          body: `Post ${i}`,
           publishedAt: 1000 + i,
         }),
       );
@@ -194,9 +164,8 @@ describe("Timeline data assembly", () => {
 
     // First page
     const page1 = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 3,
     });
     expect(page1).toHaveLength(3);
@@ -205,9 +174,8 @@ describe("Timeline data assembly", () => {
     const lastPost = page1[page1.length - 1];
     expect(lastPost).toBeDefined();
     const page2 = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 3,
       cursor: lastPost?.id,
     });
@@ -215,28 +183,66 @@ describe("Timeline data assembly", () => {
     expect(page2.every((p) => p.id < (lastPost?.id ?? 0))).toBe(true);
   });
 
-  it("correctly determines hasMore flag", async () => {
-    for (let i = 0; i < 3; i++) {
+  it("supports offset-based pagination for page navigation", async () => {
+    for (let i = 0; i < 5; i++) {
       await postService.create({
-        type: "note",
-        content: `Post ${i}`,
-        visibility: "quiet",
+        format: "note",
+        body: `Post ${i}`,
+        publishedAt: 1000 + i,
       });
     }
 
-    // Request limit + 1 to check for more
     const pageSize = 2;
-    const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+
+    // Page 1
+    const page1 = await postService.list({
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
-      limit: pageSize + 1,
+      limit: pageSize,
+      offset: 0,
     });
+    expect(page1).toHaveLength(2);
+    expect(page1[0]?.body).toBe("Post 4");
+    expect(page1[1]?.body).toBe("Post 3");
 
-    const hasMore = posts.length > pageSize;
-    expect(hasMore).toBe(true);
+    // Page 2
+    const page2 = await postService.list({
+      status: "published",
+      excludeReplies: true,
+      limit: pageSize,
+      offset: 2,
+    });
+    expect(page2).toHaveLength(2);
+    expect(page2[0]?.body).toBe("Post 2");
+    expect(page2[1]?.body).toBe("Post 1");
+
+    // Page 3 (partial)
+    const page3 = await postService.list({
+      status: "published",
+      excludeReplies: true,
+      limit: pageSize,
+      offset: 4,
+    });
+    expect(page3).toHaveLength(1);
+    expect(page3[0]?.body).toBe("Post 0");
+  });
+
+  it("computes total pages from count", async () => {
+    for (let i = 0; i < 5; i++) {
+      await postService.create({
+        format: "note",
+        body: `Post ${i}`,
+      });
+    }
+
+    const pageSize = 2;
+    const totalCount = await postService.count({
+      status: "published",
+      excludeReplies: true,
+    });
 
-    const displayPosts = posts.slice(0, pageSize);
-    expect(displayPosts).toHaveLength(2);
+    expect(totalCount).toBe(5);
+    const totalPages = Math.ceil(totalCount / pageSize);
+    expect(totalPages).toBe(3);
   });
 });

package/src/lib/__tests__/view.test.ts

@@ -7,8 +7,8 @@ import {
   toPostView,
   toPostViews,
   toMediaView,
-  toNavLinkView,
-  toNavLinkViews,
+  toNavItemView,
+  toNavItemViews,
   toSearchResultView,
   toArchiveGroups,
 } from "../view.js";
@@ -16,7 +16,7 @@ import type { MediaContext } from "../view.js";
 import type {
   PostWithMedia,
   Media,
-  NavigationLink,
+  NavItem,
   SearchResult,
   Post,
 } from "../../types.js";
@@ -30,15 +30,18 @@ const CTX_WITH_URLS: MediaContext = {
 function makePost(overrides: Partial<Post> = {}): Post {
   return {
     id: 1,
-    type: "note",
-    visibility: "featured",
-    title: null,
+    format: "note",
+    status: "published",
+    featured: 0,
+    pinned: 0,
     path: null,
-    content: "Hello world",
-    contentHtml: "<p>Hello world</p>",
-    sourceUrl: null,
-    sourceName: null,
-    sourceDomain: null,
+    title: null,
+    url: null,
+    body: "Hello world",
+    bodyHtml: "<p>Hello world</p>",
+    quoteText: null,
+    rating: null,
+    collectionId: null,
     replyToId: null,
     threadId: null,
     deletedAt: null,
@@ -78,11 +81,13 @@ function makeMedia(overrides: Partial<Media> = {}): Media {
   };
 }
 
-function makeNavLink(overrides: Partial<NavigationLink> = {}): NavigationLink {
+function makeNavItem(overrides: Partial<NavItem> = {}): NavItem {
   return {
     id: 1,
+    type: "link",
     label: "Home",
     url: "/",
+    pageId: null,
     position: 0,
     createdAt: 1706745600,
     updatedAt: 1706745600,
@@ -95,13 +100,25 @@ function makeNavLink(overrides: Partial<NavigationLink> = {}): NavigationLink {
 // =============================================================================
 
 describe("toPostView", () => {
-  it("generates permalink from post id", () => {
-    const post = makePostWithMedia({ id: 123 });
+  it("generates permalink from post id when no path", () => {
+    const post = makePostWithMedia({ id: 123, path: null });
     const view = toPostView(post, EMPTY_CTX);
     expect(view.permalink).toMatch(/^\/p\/.+$/);
     expect(view.permalink.length).toBeGreaterThan(3);
   });
 
+  it("generates permalink from path when path is set", () => {
+    const post = makePostWithMedia({ id: 123, path: "my-post" });
+    const view = toPostView(post, EMPTY_CTX);
+    expect(view.permalink).toBe("/my-post");
+  });
+
+  it("generates permalink from multi-level path", () => {
+    const post = makePostWithMedia({ id: 123, path: "2024/01/my-post" });
+    const view = toPostView(post, EMPTY_CTX);
+    expect(view.permalink).toBe("/2024/01/my-post");
+  });
+
   it("formats dates correctly", () => {
     const post = makePostWithMedia({ publishedAt: 1706745600 });
     const view = toPostView(post, EMPTY_CTX);
@@ -109,52 +126,156 @@ describe("toPostView", () => {
     expect(view.publishedAtFormatted).toBe("Feb 1, 2024");
   });
 
-  it("generates excerpt from content", () => {
-    const shortContent = "Short text";
-    const longContent = "A".repeat(200);
+  it("generates excerpt from body", () => {
+    const shortBody = "Short text";
+    const longBody = "A".repeat(200);
 
     const shortView = toPostView(
-      makePostWithMedia({ content: shortContent }),
+      makePostWithMedia({ body: shortBody }),
       EMPTY_CTX,
     );
     expect(shortView.excerpt).toBe("Short text");
 
     const longView = toPostView(
-      makePostWithMedia({ content: longContent }),
+      makePostWithMedia({ body: longBody }),
       EMPTY_CTX,
     );
     expect(longView.excerpt).toBe("A".repeat(160) + "...");
   });
 
-  it("handles null content gracefully", () => {
-    const view = toPostView(makePostWithMedia({ content: null }), EMPTY_CTX);
+  it("computes summaryHtml for posts with title and bodyHtml", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        title: "My Article",
+        body: "Short article body",
+        bodyHtml: "<p>Short article body</p>",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBe("<p>Short article body</p>");
+    expect(view.summaryHasMore).toBe(false);
+  });
+
+  it("truncates summaryHtml for long articles", () => {
+    const p1 = `<p>${"A".repeat(300)}</p>`;
+    const p2 = `<p>${"B".repeat(300)}</p>`;
+    const view = toPostView(
+      makePostWithMedia({
+        title: "Long Article",
+        body: "A".repeat(300) + "B".repeat(300),
+        bodyHtml: p1 + p2,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBe(p1);
+    expect(view.summaryHasMore).toBe(true);
+  });
+
+  it("does not compute summaryHtml for posts without title", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        title: null,
+        bodyHtml: "<p>Just a note</p>",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBeUndefined();
+    expect(view.summaryHasMore).toBeUndefined();
+  });
+
+  it("does not compute summaryHtml for posts without bodyHtml", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        title: "Title Only",
+        bodyHtml: null,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBeUndefined();
+    expect(view.summaryHasMore).toBeUndefined();
+  });
+
+  it("handles null body gracefully", () => {
+    const view = toPostView(
+      makePostWithMedia({ body: null, bodyHtml: null }),
+      EMPTY_CTX,
+    );
     expect(view.excerpt).toBeUndefined();
-    expect(view.content).toBeUndefined();
+    expect(view.bodyHtml).toBeUndefined();
+    expect(view.body).toBeUndefined();
   });
 
   it("converts null fields to undefined", () => {
     const view = toPostView(makePostWithMedia(), EMPTY_CTX);
     expect(view.title).toBeUndefined();
     expect(view.path).toBeUndefined();
-    expect(view.sourceUrl).toBeUndefined();
-    expect(view.sourceName).toBeUndefined();
-    expect(view.sourceDomain).toBeUndefined();
+    expect(view.url).toBeUndefined();
+    expect(view.quoteText).toBeUndefined();
+    expect(view.rating).toBeUndefined();
+    expect(view.collectionId).toBeUndefined();
     expect(view.replyToId).toBeUndefined();
     expect(view.threadRootId).toBeUndefined();
   });
 
-  it("preserves non-null source fields", () => {
+  it("preserves non-null url field", () => {
     const view = toPostView(
       makePostWithMedia({
-        sourceUrl: "https://example.com",
-        sourceName: "Example",
-        sourceDomain: "example.com",
+        url: "https://example.com",
       }),
       EMPTY_CTX,
     );
-    expect(view.sourceUrl).toBe("https://example.com");
-    expect(view.sourceName).toBe("Example");
-    expect(view.sourceDomain).toBe("example.com");
+    expect(view.url).toBe("https://example.com");
+  });
+
+  it("preserves non-null quoteText field", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        format: "quote",
+        quoteText: "Something wise",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.quoteText).toBe("Something wise");
+  });
+
+  it("maps format, status, featured, and pinned correctly", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        format: "link",
+        status: "draft",
+        featured: 1,
+        pinned: 1,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.format).toBe("link");
+    expect(view.status).toBe("draft");
+    expect(view.featured).toBe(true);
+    expect(view.pinned).toBe(true);
+  });
+
+  it("converts featured=0 and pinned=0 to false", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        featured: 0,
+        pinned: 0,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.featured).toBe(false);
+    expect(view.pinned).toBe(false);
+  });
+
+  it("preserves rating and collectionId when set", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        rating: 5,
+        collectionId: 42,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.rating).toBe(5);
+    expect(view.collectionId).toBe(42);
   });
 
   it("converts media attachments to MediaView", () => {
@@ -249,40 +370,40 @@ describe("toMediaView", () => {
 });
 
 // =============================================================================
-// toNavLinkView
+// toNavItemView
 // =============================================================================
 
-describe("toNavLinkView", () => {
+describe("toNavItemView", () => {
   it("marks home link active on exact / match", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/" }), "/");
+    const view = toNavItemView(makeNavItem({ url: "/" }), "/");
     expect(view.isActive).toBe(true);
     expect(view.isExternal).toBe(false);
   });
 
   it("marks home link inactive on other paths", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/" }), "/archive");
+    const view = toNavItemView(makeNavItem({ url: "/" }), "/archive");
     expect(view.isActive).toBe(false);
   });
 
   it("matches prefix for non-root links", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/archive" }), "/archive");
+    const view = toNavItemView(makeNavItem({ url: "/archive" }), "/archive");
     expect(view.isActive).toBe(true);
 
-    const viewSub = toNavLinkView(
-      makeNavLink({ url: "/archive" }),
+    const viewSub = toNavItemView(
+      makeNavItem({ url: "/archive" }),
       "/archive/2024",
     );
     expect(viewSub.isActive).toBe(true);
   });
 
   it("does not false-match similar prefixes", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/arch" }), "/archive");
+    const view = toNavItemView(makeNavItem({ url: "/arch" }), "/archive");
     expect(view.isActive).toBe(false);
   });
 
   it("marks external links as external and never active", () => {
-    const view = toNavLinkView(
-      makeNavLink({ url: "https://example.com" }),
+    const view = toNavItemView(
+      makeNavItem({ url: "https://example.com" }),
       "/",
     );
     expect(view.isExternal).toBe(true);
@@ -290,20 +411,31 @@ describe("toNavLinkView", () => {
   });
 
   it("handles http:// links", () => {
-    const view = toNavLinkView(makeNavLink({ url: "http://example.com" }), "/");
+    const view = toNavItemView(makeNavItem({ url: "http://example.com" }), "/");
     expect(view.isExternal).toBe(true);
     expect(view.isActive).toBe(false);
   });
+
+  it("includes type and pageId in view", () => {
+    const view = toNavItemView(makeNavItem({ type: "page", pageId: 5 }), "/");
+    expect(view.type).toBe("page");
+    expect(view.pageId).toBe(5);
+  });
+
+  it("converts null pageId to undefined", () => {
+    const view = toNavItemView(makeNavItem({ pageId: null }), "/");
+    expect(view.pageId).toBeUndefined();
+  });
 });
 
-describe("toNavLinkViews", () => {
-  it("converts multiple links", () => {
-    const links = [
-      makeNavLink({ id: 1, url: "/" }),
-      makeNavLink({ id: 2, url: "/archive" }),
-      makeNavLink({ id: 3, url: "https://github.com" }),
+describe("toNavItemViews", () => {
+  it("converts multiple items", () => {
+    const items = [
+      makeNavItem({ id: 1, url: "/" }),
+      makeNavItem({ id: 2, url: "/archive" }),
+      makeNavItem({ id: 3, url: "https://github.com" }),
     ];
-    const views = toNavLinkViews(links, "/archive");
+    const views = toNavItemViews(items, "/archive");
     expect(views).toHaveLength(3);
     expect(views[0]).toHaveProperty("isActive", false);
     expect(views[1]).toHaveProperty("isActive", true);
@@ -329,6 +461,28 @@ describe("toSearchResultView", () => {
     expect(view.rank).toBe(1.5);
     expect(view.snippet).toBe("...matching <b>text</b>...");
   });
+
+  it("uses new post fields in search result view", () => {
+    const result: SearchResult = {
+      post: makePost({
+        id: 10,
+        format: "link",
+        status: "published",
+        featured: 1,
+        pinned: 0,
+        url: "https://example.com",
+        path: "my-link",
+      }),
+      rank: 0.8,
+    };
+    const view = toSearchResultView(result, EMPTY_CTX);
+    expect(view.post.format).toBe("link");
+    expect(view.post.status).toBe("published");
+    expect(view.post.featured).toBe(true);
+    expect(view.post.pinned).toBe(false);
+    expect(view.post.url).toBe("https://example.com");
+    expect(view.post.permalink).toBe("/my-link");
+  });
 });
 
 // =============================================================================

package/src/lib/constants.ts

@@ -7,6 +7,7 @@
  */
 export const RESERVED_PATHS = [
   "featured",
+  "collections",
   "signin",
   "signout",
   "setup",
@@ -15,10 +16,6 @@ export const RESERVED_PATHS = [
   "feed",
   "search",
   "archive",
-  "notes",
-  "articles",
-  "links",
-  "quotes",
   "media",
   "pages",
   "reset",
@@ -53,6 +50,7 @@ export const SETTINGS_KEYS = {
   SITE_DESCRIPTION: "SITE_DESCRIPTION",
   SITE_LANGUAGE: "SITE_LANGUAGE",
   THEME: "THEME",
+  CUSTOM_CSS: "CUSTOM_CSS",
   PASSWORD_RESET_TOKEN: "PASSWORD_RESET_TOKEN",
 } as const;