@jant/core 0.3.34 → 0.3.36

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

@@ -22,28 +22,51 @@ describe("PostService", () => {
 
   describe("create", () => {
     it("creates a note post with required fields", async () => {
+      const body = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: "Hello world" }],
+          },
+        ],
+      });
       const post = await postService.create({
         format: "note",
-        body: "Hello world",
+        body,
       });
 
       expect(post.id).toBe(1);
       expect(post.format).toBe("note");
-      expect(post.body).toBe("Hello world");
+      expect(post.body).toBe(body);
       expect(post.status).toBe("published"); // default
-      expect(post.featured).toBe(0);
+      expect(post.visibility).toBe("listed");
       expect(post.pinned).toBe(0);
       expect(post.bodyHtml).toContain("<p>Hello world</p>");
       expect(post.deletedAt).toBeNull();
     });
 
     it("creates a post with all fields", async () => {
+      const body = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "heading",
+            attrs: { level: 1 },
+            content: [{ type: "text", text: "Introduction" }],
+          },
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: "Some content." }],
+          },
+        ],
+      });
       const post = await postService.create({
         format: "link",
         title: "My Link",
-        body: "# Introduction\n\nSome content.",
+        body,
         status: "published",
-        featured: true,
+        visibility: "featured",
         pinned: true,
         path: "my-link",
         url: "https://example.com/source",
@@ -54,7 +77,7 @@ describe("PostService", () => {
       expect(post.format).toBe("link");
       expect(post.title).toBe("My Link");
       expect(post.status).toBe("published");
-      expect(post.featured).toBe(1);
+      expect(post.visibility).toBe("featured");
       expect(post.pinned).toBe(1);
       expect(post.path).toBe("my-link");
       expect(post.url).toBe("https://example.com/source");
@@ -63,10 +86,27 @@ describe("PostService", () => {
       expect(post.bodyHtml).toContain("<h1>");
     });
 
-    it("renders markdown body to HTML", async () => {
+    it("renders Tiptap JSON body to HTML", async () => {
+      const body = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "This is " },
+              {
+                type: "text",
+                marks: [{ type: "bold" }],
+                text: "bold",
+              },
+              { type: "text", text: " text" },
+            ],
+          },
+        ],
+      });
       const post = await postService.create({
         format: "note",
-        body: "This is **bold** text",
+        body,
       });
 
       expect(post.bodyHtml).toContain("<strong>bold</strong>");
@@ -267,26 +307,60 @@ describe("PostService", () => {
       expect(published[0]?.status).toBe("published");
     });
 
-    it("filters by featured", async () => {
+    it("filters by visibility", async () => {
       await postService.create({
         format: "note",
         body: "featured post",
-        featured: true,
+        visibility: "featured",
       });
       await postService.create({
         format: "note",
         body: "normal post",
       });
+      await postService.create({
+        format: "note",
+        body: "unlisted post",
+        visibility: "unlisted",
+      });
 
-      const featured = await postService.list({ featured: true });
+      const featured = await postService.list({ visibility: "featured" });
       expect(featured).toHaveLength(1);
-      expect(featured[0]?.featured).toBe(1);
+      expect(featured[0]?.visibility).toBe("featured");
       expect(featured[0]?.body).toBe("featured post");
 
-      const notFeatured = await postService.list({ featured: false });
-      expect(notFeatured).toHaveLength(1);
-      expect(notFeatured[0]?.featured).toBe(0);
-      expect(notFeatured[0]?.body).toBe("normal post");
+      const listed = await postService.list({ visibility: "listed" });
+      expect(listed).toHaveLength(1);
+      expect(listed[0]?.visibility).toBe("listed");
+      expect(listed[0]?.body).toBe("normal post");
+
+      const unlisted = await postService.list({ visibility: "unlisted" });
+      expect(unlisted).toHaveLength(1);
+      expect(unlisted[0]?.visibility).toBe("unlisted");
+      expect(unlisted[0]?.body).toBe("unlisted post");
+    });
+
+    it("excludes unlisted posts when requested", async () => {
+      await postService.create({
+        format: "note",
+        body: "listed post",
+      });
+      await postService.create({
+        format: "note",
+        body: "unlisted post",
+        visibility: "unlisted",
+      });
+      await postService.create({
+        format: "note",
+        body: "featured post",
+        visibility: "featured",
+      });
+
+      const posts = await postService.list({ excludeUnlisted: true });
+      expect(posts).toHaveLength(2);
+      expect(posts.map((p) => p.body).sort()).toEqual([
+        "featured post",
+        "listed post",
+      ]);
     });
 
     it("filters by pinned", async () => {
@@ -426,15 +500,15 @@ describe("PostService", () => {
       expect(count).toBe(1);
     });
 
-    it("filters by featured", async () => {
+    it("filters by visibility", async () => {
       await postService.create({
         format: "note",
         body: "featured",
-        featured: true,
+        visibility: "featured",
       });
       await postService.create({ format: "note", body: "normal" });
 
-      const count = await postService.count({ featured: true });
+      const count = await postService.count({ visibility: "featured" });
       expect(count).toBe(1);
     });
 
@@ -470,15 +544,32 @@ describe("PostService", () => {
     it("updates post body", async () => {
       const post = await postService.create({
         format: "note",
-        body: "original",
+        body: JSON.stringify({
+          type: "doc",
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "original" }],
+            },
+          ],
+        }),
+      });
+
+      const updatedBody = JSON.stringify({
+        type: "doc",
+        content: [
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: "updated content" }],
+          },
+        ],
       });
-
       const updated = await postService.update(post.id, {
-        body: "updated content",
+        body: updatedBody,
       });
 
       expect(updated).not.toBeNull();
-      expect(updated?.body).toBe("updated content");
+      expect(updated?.body).toBe(updatedBody);
       expect(updated?.bodyHtml).toContain("updated content");
     });
 
@@ -547,19 +638,19 @@ describe("PostService", () => {
       expect(updated?.updatedAt).toBeGreaterThanOrEqual(originalUpdatedAt);
     });
 
-    it("updates featured flag", async () => {
+    it("updates visibility", async () => {
       const post = await postService.create({
         format: "note",
         body: "test",
       });
 
-      expect(post.featured).toBe(0);
+      expect(post.visibility).toBe("listed");
 
       const updated = await postService.update(post.id, {
-        featured: true,
+        visibility: "featured",
       });
 
-      expect(updated?.featured).toBe(1);
+      expect(updated?.visibility).toBe("featured");
     });
 
     it("updates pinned flag", async () => {
@@ -723,11 +814,11 @@ describe("PostService", () => {
       expect(reply.status).toBe("draft");
     });
 
-    it("inherits featured from root post", async () => {
+    it("inherits visibility from root post", async () => {
       const root = await postService.create({
         format: "note",
         body: "root",
-        featured: true,
+        visibility: "featured",
       });
       const reply = await postService.create({
         format: "note",
@@ -735,7 +826,7 @@ describe("PostService", () => {
         replyToId: root.id,
       });
 
-      expect(reply.featured).toBe(1);
+      expect(reply.visibility).toBe("featured");
     });
 
     it("getThread returns all posts in a thread", async () => {
@@ -797,7 +888,7 @@ describe("PostService", () => {
       }
     });
 
-    it("cascades featured changes from root to thread", async () => {
+    it("cascades visibility changes from root to thread", async () => {
       const root = await postService.create({
         format: "note",
         body: "root",
@@ -808,11 +899,11 @@ describe("PostService", () => {
         replyToId: root.id,
       });
 
-      await postService.update(root.id, { featured: true });
+      await postService.update(root.id, { visibility: "featured" });
 
       const thread = await postService.getThread(root.id);
       for (const post of thread) {
-        expect(post.featured).toBe(1);
+        expect(post.visibility).toBe("featured");
       }
     });
   });

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

@@ -102,7 +102,7 @@ describe("SettingsService", () => {
       siteFooter: "",
       siteLanguage: "en",
       homeDefaultView: "latest",
-      headerNavMaxVisible: "3",
+      headerNavMaxVisible: "2",
       timeZone: "UTC",
     };
 
@@ -154,10 +154,10 @@ describe("SettingsService", () => {
       expect(await settingsService.get("HOME_DEFAULT_VIEW")).toBe("featured");
     });
 
-    it("removes HEADER_NAV_MAX_VISIBLE when set to default (3)", async () => {
+    it("removes HEADER_NAV_MAX_VISIBLE when set to default (2)", async () => {
       await settingsService.set("HEADER_NAV_MAX_VISIBLE", "5");
       await settingsService.updateGeneral(
-        { ...defaults, headerNavMaxVisible: "3" },
+        { ...defaults, headerNavMaxVisible: "2" },
         { oldLanguage: "en", fallbackSiteName: "Jant" },
       );
 

package/src/services/page.ts

@@ -27,10 +27,23 @@ export interface PageService {
   delete(id: number): Promise<boolean>;
 }
 
-/** Check if an error is a SQLite UNIQUE constraint violation (D1 or better-sqlite3) */
+/** Check if an error (or any of its causes) is a SQLite UNIQUE constraint violation */
 function isUniqueConstraintError(err: unknown): boolean {
-  const msg = String(err);
-  return msg.includes("UNIQUE constraint") || msg.includes("SQLITE_CONSTRAINT");
+  let current: unknown = err;
+  while (current) {
+    const msg = String(current);
+    if (
+      msg.includes("UNIQUE constraint") ||
+      msg.includes("SQLITE_CONSTRAINT")
+    ) {
+      return true;
+    }
+    current =
+      current instanceof Error && current.cause !== current
+        ? current.cause
+        : undefined;
+  }
+  return false;
 }
 
 export function createPageService(

package/src/services/post.ts

@@ -3,7 +3,7 @@
  *
  * CRUD operations for posts with Thread support.
  * Posts have format (note/link/quote), status (draft/published),
- * featured flag, and pinned flag.
+ * visibility (listed/featured/unlisted), and pinned flag.
  */
 
 import { eq, and, isNull, desc, or, inArray, sql } from "drizzle-orm";
@@ -11,10 +11,18 @@ import type { BatchItem } from "drizzle-orm/batch";
 import type { Database } from "../db/index.js";
 import { posts, postCollections } from "../db/schema.js";
 import { now } from "../lib/time.js";
-import { render as renderMarkdown } from "../lib/markdown.js";
+import { renderTiptapJson } from "../lib/tiptap-render.js";
+import { extractSummary } from "../lib/summary.js";
 import type { StorageDriver } from "../lib/storage.js";
 import type { MediaService } from "./media.js";
-import type { Format, Status, Post, CreatePost, UpdatePost } from "../types.js";
+import type {
+  Format,
+  Status,
+  Visibility,
+  Post,
+  CreatePost,
+  UpdatePost,
+} from "../types.js";
 import type { PathRegistryService } from "./path-registry.js";
 import { ConflictError } from "../lib/errors.js";
 
@@ -27,11 +35,13 @@ export interface PostDeleteDeps {
 export interface PostFilters {
   format?: Format;
   status?: Status;
-  featured?: boolean;
+  visibility?: Visibility;
   pinned?: boolean;
   collectionId?: number;
   /** Exclude posts that are replies (have threadId set) */
   excludeReplies?: boolean;
+  /** Exclude unlisted posts from results */
+  excludeUnlisted?: boolean;
   includeDeleted?: boolean;
   threadId?: number;
   limit?: number;
@@ -39,14 +49,24 @@ export interface PostFilters {
   offset?: number; // offset for page-based pagination
 }
 
+/** Config for automatic summary extraction */
+export interface SummaryConfig {
+  maxParagraphs: number;
+  maxChars: number;
+}
+
 export interface PostService {
   getById(id: number): Promise<Post | null>;
   getByPath(path: string): Promise<Post | null>;
   list(filters?: PostFilters): Promise<Post[]>;
   /** Count posts matching filters (ignores cursor, offset, limit) */
   count(filters?: PostFilters): Promise<number>;
-  create(data: CreatePost): Promise<Post>;
-  update(id: number, data: UpdatePost): Promise<Post | null>;
+  create(data: CreatePost, summaryConfig?: SummaryConfig): Promise<Post>;
+  update(
+    id: number,
+    data: UpdatePost,
+    summaryConfig?: SummaryConfig,
+  ): Promise<Post | null>;
   /**
    * Soft-delete a post and clean up its media (storage files + DB records).
    * Thread roots cascade to all replies.
@@ -56,10 +76,10 @@ export interface PostService {
    */
   delete(id: number, deps?: PostDeleteDeps): Promise<boolean>;
   getThread(rootId: number): Promise<Post[]>;
-  updateThreadStatusAndFeatured(
+  updateThreadStatusAndVisibility(
     rootId: number,
     status: Status,
-    featured: boolean,
+    visibility: Visibility,
   ): Promise<void>;
   /** Get reply counts for multiple posts */
   getReplyCounts(postIds: number[]): Promise<Map<number, number>>;
@@ -70,10 +90,23 @@ export interface PostService {
   ): Promise<Map<number, Post[]>>;
 }
 
-/** Check if an error is a SQLite UNIQUE constraint violation (D1 or better-sqlite3) */
+/** Check if an error (or any of its causes) is a SQLite UNIQUE constraint violation */
 function isUniqueConstraintError(err: unknown): boolean {
-  const msg = String(err);
-  return msg.includes("UNIQUE constraint") || msg.includes("SQLITE_CONSTRAINT");
+  let current: unknown = err;
+  while (current) {
+    const msg = String(current);
+    if (
+      msg.includes("UNIQUE constraint") ||
+      msg.includes("SQLITE_CONSTRAINT")
+    ) {
+      return true;
+    }
+    current =
+      current instanceof Error && current.cause !== current
+        ? current.cause
+        : undefined;
+  }
+  return false;
 }
 
 export function createPostService(
@@ -87,8 +120,11 @@ export function createPostService(
     if (filters.status) {
       conditions.push(eq(posts.status, filters.status));
     }
-    if (filters.featured !== undefined) {
-      conditions.push(eq(posts.featured, filters.featured ? 1 : 0));
+    if (filters.visibility !== undefined) {
+      conditions.push(eq(posts.visibility, filters.visibility));
+    }
+    if (filters.excludeUnlisted) {
+      conditions.push(sql`${posts.visibility} != 'unlisted'`);
     }
     if (filters.pinned !== undefined) {
       conditions.push(eq(posts.pinned, filters.pinned ? 1 : 0));
@@ -120,7 +156,7 @@ export function createPostService(
       id: row.id,
       format: row.format as Format,
       status: row.status as Status,
-      featured: row.featured,
+      visibility: row.visibility as Visibility,
       pinned: row.pinned,
       path: row.path,
       title: row.title,
@@ -128,6 +164,7 @@ export function createPostService(
       body: row.body,
       bodyHtml: row.bodyHtml,
       quoteText: row.quoteText,
+      summary: row.summary,
       rating: row.rating,
       replyToId: row.replyToId,
       threadId: row.threadId,
@@ -190,27 +227,37 @@ export function createPostService(
       return result[0]?.count ?? 0;
     },
 
-    async create(data) {
+    async create(data, summaryConfig) {
       const timestamp = now();
 
-      const bodyHtml = data.body ? renderMarkdown(data.body) : null;
+      const bodyHtml = data.body ? renderTiptapJson(data.body) : null;
+
+      // Generate summary for titled notes with body content
+      let summary: string | null = null;
+      if (data.format === "note" && data.title && data.body && summaryConfig) {
+        summary = extractSummary(
+          data.body,
+          summaryConfig.maxParagraphs,
+          summaryConfig.maxChars,
+        );
+      }
 
       // Handle thread relationship
       let threadId: number | null = null;
       let status: Status = data.status ?? "published";
-      let featured = data.featured ?? false;
+      let visibility: Visibility = data.visibility ?? "listed";
 
       if (data.replyToId) {
         const parent = await this.getById(data.replyToId);
         if (parent) {
           threadId = parent.threadId ?? parent.id;
-          // Inherit status and featured from root
+          // Inherit status and visibility from root
           const root = parent.threadId
             ? await this.getById(parent.threadId)
             : parent;
           if (root) {
             status = root.status as Status;
-            featured = root.featured === 1;
+            visibility = root.visibility as Visibility;
           }
         }
       }
@@ -229,7 +276,7 @@ export function createPostService(
           .values({
             format: data.format,
             status,
-            featured: featured ? 1 : 0,
+            visibility,
             pinned: data.pinned ? 1 : 0,
             path: data.path ?? null,
             title: data.title ?? null,
@@ -237,6 +284,7 @@ export function createPostService(
             body: data.body ?? null,
             bodyHtml,
             quoteText: data.quoteText ?? null,
+            summary,
             rating: data.rating ?? null,
             replyToId: data.replyToId ?? null,
             threadId,
@@ -275,7 +323,7 @@ export function createPostService(
       return post;
     },
 
-    async update(id, data) {
+    async update(id, data, summaryConfig) {
       const existing = await this.getById(id);
       if (!existing) return null;
 
@@ -310,22 +358,38 @@ export function createPostService(
 
       if (data.body !== undefined) {
         updates.body = data.body;
-        updates.bodyHtml = data.body ? renderMarkdown(data.body) : null;
+        updates.bodyHtml = data.body ? renderTiptapJson(data.body) : null;
+      }
+
+      // Recompute summary when body, title, or format change
+      if (summaryConfig) {
+        const format = data.format ?? (existing.format as Format);
+        const title = data.title !== undefined ? data.title : existing.title;
+        const body = data.body !== undefined ? data.body : existing.body;
+        if (format === "note" && title && body) {
+          updates.summary = extractSummary(
+            body,
+            summaryConfig.maxParagraphs,
+            summaryConfig.maxChars,
+          );
+        } else {
+          updates.summary = null;
+        }
       }
 
-      // Handle status/featured change - cascade to thread if this is root
+      // Handle status/visibility change - cascade to thread if this is root
       const statusChanged =
         data.status !== undefined && data.status !== existing.status;
-      const featuredChanged =
-        data.featured !== undefined &&
-        (data.featured ? 1 : 0) !== existing.featured;
+      const visibilityChanged =
+        data.visibility !== undefined &&
+        data.visibility !== existing.visibility;
 
       if (statusChanged) updates.status = data.status;
-      if (featuredChanged) updates.featured = data.featured ? 1 : 0;
+      if (visibilityChanged) updates.visibility = data.visibility;
 
       // Build all write queries for atomic execution via D1 batch
       const needsCascade =
-        (statusChanged || featuredChanged) && !existing.threadId;
+        (statusChanged || visibilityChanged) && !existing.threadId;
       const needsCollectionSync = data.collectionIds !== undefined;
       const hasExtraWrites = needsCascade || needsCollectionSync;
 
@@ -348,13 +412,8 @@ export function createPostService(
             .update(posts)
             .set({
               status: data.status ?? (existing.status as Status),
-              featured: (
-                data.featured !== undefined
-                  ? data.featured
-                  : existing.featured === 1
-              )
-                ? 1
-                : 0,
+              visibility:
+                data.visibility ?? (existing.visibility as Visibility),
               updatedAt: timestamp,
             })
             .where(eq(posts.threadId, id)),
@@ -467,11 +526,11 @@ export function createPostService(
       return rows.map(toPost);
     },
 
-    async updateThreadStatusAndFeatured(rootId, status, featured) {
+    async updateThreadStatusAndVisibility(rootId, status, visibility) {
       const timestamp = now();
       await db
         .update(posts)
-        .set({ status, featured: featured ? 1 : 0, updatedAt: timestamp })
+        .set({ status, visibility, updatedAt: timestamp })
         .where(eq(posts.threadId, rootId));
     },
 

package/src/services/search.ts

@@ -27,7 +27,7 @@ interface RawSearchRow {
   id: number;
   format: string;
   status: string;
-  featured: number;
+  visibility: string;
   pinned: number;
   path: string | null;
   title: string | null;
@@ -35,6 +35,7 @@ interface RawSearchRow {
   body: string | null;
   body_html: string | null;
   quote_text: string | null;
+  summary: string | null;
   rating: number | null;
   collection_id: number | null;
   reply_to_id: number | null;
@@ -97,7 +98,7 @@ export function createSearchService(d1: D1Database): SearchService {
           id: row.id,
           format: row.format as Post["format"],
           status: row.status as Post["status"],
-          featured: row.featured,
+          visibility: row.visibility as Post["visibility"],
           pinned: row.pinned,
           path: row.path,
           title: row.title,
@@ -105,6 +106,7 @@ export function createSearchService(d1: D1Database): SearchService {
           body: row.body,
           bodyHtml: row.body_html,
           quoteText: row.quote_text,
+          summary: row.summary,
           rating: row.rating,
           replyToId: row.reply_to_id,
           threadId: row.thread_id,

package/src/services/settings.ts

@@ -44,6 +44,7 @@ export interface AvatarUploadDeps {
   media: MediaService;
   storage: StorageDriver;
   storageProvider: string;
+  maxFileSizeMB: number;
 }
 
 export interface SettingsService {
@@ -194,7 +195,7 @@ export function createSettingsService(db: Database): SettingsService {
       // Header nav max visible: only update if provided (may be managed separately)
       if (data.headerNavMaxVisible !== undefined) {
         const navMax = parseInt(String(data.headerNavMaxVisible), 10);
-        if (!isNaN(navMax) && navMax !== 3) {
+        if (!isNaN(navMax) && navMax !== 2) {
           await this.set("HEADER_NAV_MAX_VISIBLE", String(navMax));
         } else {
           await this.remove("HEADER_NAV_MAX_VISIBLE");
@@ -215,7 +216,10 @@ export function createSettingsService(db: Database): SettingsService {
     },
 
     async uploadAvatar(data, deps) {
-      const uploadError = validateUploadFile(data.file as unknown as File);
+      const uploadError = validateUploadFile(data.file as unknown as File, {
+        imagesOnly: true,
+        maxFileSizeMB: deps.maxFileSizeMB,
+      });
       if (uploadError) {
         throw new ValidationError(uploadError);
       }