@jant/core 0.3.23 → 0.3.24

package/src/services/page.ts

@@ -0,0 +1,124 @@
+/**
+ * Page Service
+ *
+ * CRUD operations for standalone pages (about, now, etc.)
+ */
+
+import { eq, desc } from "drizzle-orm";
+import type { Database } from "../db/index.js";
+import { pages, navItems } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import { render as renderMarkdown } from "../lib/markdown.js";
+import type { Page, Status, CreatePage, UpdatePage } from "../types.js";
+
+export interface PageService {
+  getById(id: number): Promise<Page | null>;
+  getBySlug(slug: string): Promise<Page | null>;
+  list(): Promise<Page[]>;
+  create(data: CreatePage): Promise<Page>;
+  update(id: number, data: UpdatePage): Promise<Page | null>;
+  delete(id: number): Promise<boolean>;
+}
+
+export function createPageService(db: Database): PageService {
+  function toPage(row: typeof pages.$inferSelect): Page {
+    return {
+      id: row.id,
+      slug: row.slug,
+      title: row.title,
+      body: row.body,
+      bodyHtml: row.bodyHtml,
+      status: row.status as Status,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  return {
+    async getById(id) {
+      const result = await db
+        .select()
+        .from(pages)
+        .where(eq(pages.id, id))
+        .limit(1);
+      return result[0] ? toPage(result[0]) : null;
+    },
+
+    async getBySlug(slug) {
+      const result = await db
+        .select()
+        .from(pages)
+        .where(eq(pages.slug, slug))
+        .limit(1);
+      return result[0] ? toPage(result[0]) : null;
+    },
+
+    async list() {
+      const rows = await db.select().from(pages).orderBy(desc(pages.createdAt));
+      return rows.map(toPage);
+    },
+
+    async create(data) {
+      const timestamp = now();
+
+      const bodyHtml = data.body ? renderMarkdown(data.body) : null;
+
+      const result = await db
+        .insert(pages)
+        .values({
+          slug: data.slug,
+          title: data.title ?? null,
+          body: data.body ?? null,
+          bodyHtml,
+          status: data.status ?? "published",
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        })
+        .returning();
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+      return toPage(result[0]!);
+    },
+
+    async update(id, data) {
+      const existing = await this.getById(id);
+      if (!existing) return null;
+
+      const timestamp = now();
+      const updates: Partial<typeof pages.$inferInsert> = {
+        updatedAt: timestamp,
+      };
+
+      if (data.slug !== undefined) updates.slug = data.slug;
+      if (data.title !== undefined) updates.title = data.title;
+      if (data.status !== undefined) updates.status = data.status;
+
+      if (data.body !== undefined) {
+        updates.body = data.body;
+        updates.bodyHtml = data.body ? renderMarkdown(data.body) : null;
+      }
+
+      // If slug changed, update related nav_items
+      if (data.slug !== undefined && data.slug !== existing.slug) {
+        await db
+          .update(navItems)
+          .set({ url: `/${data.slug}`, updatedAt: timestamp })
+          .where(eq(navItems.pageId, id));
+      }
+
+      const result = await db
+        .update(pages)
+        .set(updates)
+        .where(eq(pages.id, id))
+        .returning();
+
+      return result[0] ? toPage(result[0]) : null;
+    },
+
+    async delete(id) {
+      // nav_items with page_id FK have ON DELETE CASCADE, so they auto-delete
+      const result = await db.delete(pages).where(eq(pages.id, id)).returning();
+      return result.length > 0;
+    },
+  };
+}

package/src/services/post.ts

@@ -1,54 +1,45 @@
 /**
- * Post Service
+ * Post Service (v2)
  *
- * CRUD operations for posts with Thread support
+ * CRUD operations for posts with Thread support.
+ * Posts have format (note/link/quote), status (draft/published),
+ * featured flag, and pinned flag.
  */
 
-import {
-  eq,
-  and,
-  isNull,
-  desc,
-  or,
-  inArray,
-  notInArray,
-  sql,
-} from "drizzle-orm";
+import { eq, and, isNull, desc, or, inArray, sql } from "drizzle-orm";
 import type { Database } from "../db/index.js";
 import { posts } from "../db/schema.js";
 import { now } from "../lib/time.js";
-import { extractDomain } from "../lib/url.js";
 import { render as renderMarkdown } from "../lib/markdown.js";
-import type {
-  PostType,
-  Visibility,
-  Post,
-  CreatePost,
-  UpdatePost,
-} from "../types.js";
+import type { Format, Status, Post, CreatePost, UpdatePost } from "../types.js";
 
 export interface PostFilters {
-  type?: PostType;
-  /** Exclude specific post types (e.g. ["page"]) */
-  excludeTypes?: PostType[];
-  visibility?: Visibility | Visibility[];
-  includeDeleted?: boolean;
-  threadId?: number;
+  format?: Format;
+  status?: Status;
+  featured?: boolean;
+  pinned?: boolean;
+  collectionId?: number;
   /** Exclude posts that are replies (have threadId set) */
   excludeReplies?: boolean;
+  includeDeleted?: boolean;
+  threadId?: number;
   limit?: number;
   cursor?: number; // post id for cursor pagination
 }
 
 export interface PostService {
   getById(id: number): Promise<Post | null>;
-  getByPath(path: string): Promise<Post | null>;
+  getBySlug(slug: string): Promise<Post | null>;
   list(filters?: PostFilters): Promise<Post[]>;
   create(data: CreatePost): Promise<Post>;
   update(id: number, data: UpdatePost): Promise<Post | null>;
   delete(id: number): Promise<boolean>;
   getThread(rootId: number): Promise<Post[]>;
-  updateThreadVisibility(rootId: number, visibility: Visibility): Promise<void>;
+  updateThreadStatusAndFeatured(
+    rootId: number,
+    status: Status,
+    featured: boolean,
+  ): Promise<void>;
   /** Get reply counts for multiple posts */
   getReplyCounts(postIds: number[]): Promise<Map<number, number>>;
   /** Get preview replies for multiple thread roots */
@@ -59,19 +50,21 @@ export interface PostService {
 }
 
 export function createPostService(db: Database): PostService {
-  // Helper to map DB row to Post type
   function toPost(row: typeof posts.$inferSelect): Post {
     return {
       id: row.id,
-      type: row.type as PostType,
-      visibility: row.visibility as Visibility,
+      format: row.format as Format,
+      status: row.status as Status,
+      featured: row.featured,
+      pinned: row.pinned,
+      slug: row.slug,
       title: row.title,
-      path: row.path,
-      content: row.content,
-      contentHtml: row.contentHtml,
-      sourceUrl: row.sourceUrl,
-      sourceName: row.sourceName,
-      sourceDomain: row.sourceDomain,
+      url: row.url,
+      body: row.body,
+      bodyHtml: row.bodyHtml,
+      quoteText: row.quoteText,
+      rating: row.rating,
+      collectionId: row.collectionId,
       replyToId: row.replyToId,
       threadId: row.threadId,
       deletedAt: row.deletedAt,
@@ -91,11 +84,11 @@ export function createPostService(db: Database): PostService {
       return result[0] ? toPost(result[0]) : null;
     },
 
-    async getByPath(path) {
+    async getBySlug(slug) {
       const result = await db
         .select()
         .from(posts)
-        .where(and(eq(posts.path, path), isNull(posts.deletedAt)))
+        .where(and(eq(posts.slug, slug), isNull(posts.deletedAt)))
         .limit(1);
       return result[0] ? toPost(result[0]) : null;
     },
@@ -103,41 +96,38 @@ export function createPostService(db: Database): PostService {
     async list(filters = {}) {
       const conditions = [];
 
-      // Visibility filter
-      if (filters.visibility) {
-        if (Array.isArray(filters.visibility)) {
-          conditions.push(inArray(posts.visibility, filters.visibility));
-        } else {
-          conditions.push(eq(posts.visibility, filters.visibility));
-        }
+      if (filters.status) {
+        conditions.push(eq(posts.status, filters.status));
       }
 
-      // Type filter
-      if (filters.type) {
-        conditions.push(eq(posts.type, filters.type));
+      if (filters.featured !== undefined) {
+        conditions.push(eq(posts.featured, filters.featured ? 1 : 0));
       }
 
-      // Exclude types filter
-      if (filters.excludeTypes && filters.excludeTypes.length > 0) {
-        conditions.push(notInArray(posts.type, filters.excludeTypes));
+      if (filters.pinned !== undefined) {
+        conditions.push(eq(posts.pinned, filters.pinned ? 1 : 0));
+      }
+
+      if (filters.format) {
+        conditions.push(eq(posts.format, filters.format));
+      }
+
+      if (filters.collectionId !== undefined) {
+        conditions.push(eq(posts.collectionId, filters.collectionId));
       }
 
-      // Thread filter
       if (filters.threadId) {
         conditions.push(eq(posts.threadId, filters.threadId));
       }
 
-      // Exclude replies (posts that are part of a thread but not the root)
       if (filters.excludeReplies) {
         conditions.push(isNull(posts.threadId));
       }
 
-      // Exclude deleted unless specified
       if (!filters.includeDeleted) {
         conditions.push(isNull(posts.deletedAt));
       }
 
-      // Cursor pagination
       if (filters.cursor) {
         conditions.push(sql`${posts.id} < ${filters.cursor}`);
       }
@@ -156,29 +146,24 @@ export function createPostService(db: Database): PostService {
     async create(data) {
       const timestamp = now();
 
-      // Process content
-      const contentHtml = data.content ? renderMarkdown(data.content) : null;
-
-      // Extract domain from source URL
-      const sourceDomain = data.sourceUrl
-        ? extractDomain(data.sourceUrl)
-        : null;
+      const bodyHtml = data.body ? renderMarkdown(data.body) : null;
 
       // Handle thread relationship
       let threadId: number | null = null;
-      let visibility = data.visibility ?? "quiet";
+      let status: Status = data.status ?? "published";
+      let featured = data.featured ?? false;
 
       if (data.replyToId) {
         const parent = await this.getById(data.replyToId);
         if (parent) {
-          // thread_id = parent's thread_id or parent's id (if parent is root)
           threadId = parent.threadId ?? parent.id;
-          // Inherit visibility from root
+          // Inherit status and featured from root
           const root = parent.threadId
             ? await this.getById(parent.threadId)
             : parent;
           if (root) {
-            visibility = root.visibility;
+            status = root.status as Status;
+            featured = root.featured === 1;
           }
         }
       }
@@ -186,15 +171,18 @@ export function createPostService(db: Database): PostService {
       const result = await db
         .insert(posts)
         .values({
-          type: data.type,
-          visibility,
+          format: data.format,
+          status,
+          featured: featured ? 1 : 0,
+          pinned: data.pinned ? 1 : 0,
+          slug: data.slug ?? null,
           title: data.title ?? null,
-          path: data.path ?? null,
-          content: data.content ?? null,
-          contentHtml,
-          sourceUrl: data.sourceUrl ?? null,
-          sourceName: data.sourceName ?? null,
-          sourceDomain,
+          url: data.url ?? null,
+          body: data.body ?? null,
+          bodyHtml,
+          quoteText: data.quoteText ?? null,
+          rating: data.rating ?? null,
+          collectionId: data.collectionId ?? null,
           replyToId: data.replyToId ?? null,
           threadId,
           publishedAt: data.publishedAt ?? timestamp,
@@ -216,36 +204,40 @@ export function createPostService(db: Database): PostService {
         updatedAt: timestamp,
       };
 
-      if (data.type !== undefined) updates.type = data.type;
+      if (data.format !== undefined) updates.format = data.format;
+      if (data.slug !== undefined) updates.slug = data.slug;
       if (data.title !== undefined) updates.title = data.title;
-      if (data.path !== undefined) updates.path = data.path;
+      if (data.url !== undefined) updates.url = data.url;
+      if (data.quoteText !== undefined) updates.quoteText = data.quoteText;
+      if (data.rating !== undefined) updates.rating = data.rating;
+      if (data.collectionId !== undefined)
+        updates.collectionId = data.collectionId;
       if (data.publishedAt !== undefined)
         updates.publishedAt = data.publishedAt;
-      if (data.sourceUrl !== undefined) {
-        updates.sourceUrl = data.sourceUrl;
-        updates.sourceDomain = data.sourceUrl
-          ? extractDomain(data.sourceUrl)
-          : null;
-      }
-      if (data.sourceName !== undefined) updates.sourceName = data.sourceName;
+      if (data.pinned !== undefined) updates.pinned = data.pinned ? 1 : 0;
 
-      if (data.content !== undefined) {
-        updates.content = data.content;
-        updates.contentHtml = data.content
-          ? renderMarkdown(data.content)
-          : null;
+      if (data.body !== undefined) {
+        updates.body = data.body;
+        updates.bodyHtml = data.body ? renderMarkdown(data.body) : null;
       }
 
-      // Handle visibility change - cascade to thread if this is root
-      if (
-        data.visibility !== undefined &&
-        data.visibility !== existing.visibility
-      ) {
-        updates.visibility = data.visibility;
-        // If this is a root post, cascade visibility to all thread posts
-        if (!existing.threadId) {
-          await this.updateThreadVisibility(id, data.visibility);
-        }
+      // Handle status/featured 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;
+
+      if (statusChanged) updates.status = data.status;
+      if (featuredChanged) updates.featured = data.featured ? 1 : 0;
+
+      // If this is a root post and status/featured changed, cascade to thread
+      if ((statusChanged || featuredChanged) && !existing.threadId) {
+        await this.updateThreadStatusAndFeatured(
+          id,
+          data.status ?? (existing.status as Status),
+          data.featured !== undefined ? data.featured : existing.featured === 1,
+        );
       }
 
       const result = await db
@@ -270,7 +262,6 @@ export function createPostService(db: Database): PostService {
           .set({ deletedAt: timestamp, updatedAt: timestamp })
           .where(or(eq(posts.id, id), eq(posts.threadId, id)));
       } else {
-        // Just delete this single post
         await db
           .update(posts)
           .set({ deletedAt: timestamp, updatedAt: timestamp })
@@ -295,11 +286,11 @@ export function createPostService(db: Database): PostService {
       return rows.map(toPost);
     },
 
-    async updateThreadVisibility(rootId, visibility) {
+    async updateThreadStatusAndFeatured(rootId, status, featured) {
       const timestamp = now();
       await db
         .update(posts)
-        .set({ visibility, updatedAt: timestamp })
+        .set({ status, featured: featured ? 1 : 0, updatedAt: timestamp })
         .where(eq(posts.threadId, rootId));
     },
 
@@ -333,7 +324,6 @@ export function createPostService(db: Database): PostService {
         .where(and(inArray(posts.threadId, rootIds), isNull(posts.deletedAt)))
         .orderBy(posts.threadId, posts.createdAt);
 
-      // Partition by threadId, take first previewCount per thread
       const result = new Map<number, Post[]>();
       for (const row of rows) {
         const post = toPost(row);

package/src/services/search.ts

@@ -1,10 +1,10 @@
 /**
- * Search Service
+ * Search Service (v2)
  *
  * Full-text search using FTS5
  */
 
-import type { Post, Visibility, SearchResult } from "../types.js";
+import type { Post, Status, Format, SearchResult } from "../types.js";
 
 export type { SearchResult };
 
@@ -13,8 +13,10 @@ export interface SearchOptions {
   limit?: number;
   /** Offset for pagination */
   offset?: number;
-  /** Filter by visibility */
-  visibility?: Visibility[];
+  /** Filter by status */
+  status?: Status[];
+  /** Filter by format */
+  format?: Format;
 }
 
 export interface SearchService {
@@ -23,15 +25,18 @@ export interface SearchService {
 
 interface RawSearchRow {
   id: number;
-  type: string;
-  visibility: string;
+  format: string;
+  status: string;
+  featured: number;
+  pinned: number;
+  slug: string | null;
   title: string | null;
-  path: string | null;
-  content: string | null;
-  content_html: string | null;
-  source_url: string | null;
-  source_name: string | null;
-  source_domain: string | null;
+  url: string | null;
+  body: string | null;
+  body_html: string | null;
+  quote_text: string | null;
+  rating: number | null;
+  collection_id: number | null;
   reply_to_id: number | null;
   thread_id: number | null;
   deleted_at: number | null;
@@ -47,10 +52,9 @@ export function createSearchService(d1: D1Database): SearchService {
     async search(query, options = {}) {
       const limit = options.limit ?? 20;
       const offset = options.offset ?? 0;
-      const visibility = options.visibility ?? ["featured", "quiet"];
+      const status = options.status ?? ["published"];
 
       // Escape and prepare the query for FTS5
-      // FTS5 uses * for prefix matching
       const ftsQuery = query
         .trim()
         .split(/\s+/)
@@ -62,10 +66,13 @@ export function createSearchService(d1: D1Database): SearchService {
         return [];
       }
 
-      // Build visibility placeholders
-      const visibilityPlaceholders = visibility.map(() => "?").join(", ");
+      // Build status placeholders
+      const statusPlaceholders = status.map(() => "?").join(", ");
+
+      // Build format filter
+      const formatFilter = options.format ? "AND posts.format = ?" : "";
+      const formatParams = options.format ? [options.format] : [];
 
-      // Query FTS5 table and join with posts using raw D1 query
       const stmt = d1.prepare(`
         SELECT
           posts.*,
@@ -75,27 +82,31 @@ export function createSearchService(d1: D1Database): SearchService {
         JOIN posts ON posts.id = posts_fts.rowid
         WHERE posts_fts MATCH ?
           AND posts.deleted_at IS NULL
-          AND posts.visibility IN (${visibilityPlaceholders})
+          AND posts.status IN (${statusPlaceholders})
+          ${formatFilter}
         ORDER BY posts_fts.rank
         LIMIT ? OFFSET ?
       `);
 
       const { results } = await stmt
-        .bind(ftsQuery, ...visibility, limit, offset)
+        .bind(ftsQuery, ...status, ...formatParams, limit, offset)
         .all<RawSearchRow>();
 
       return (results || []).map((row) => ({
         post: {
           id: row.id,
-          type: row.type as Post["type"],
-          visibility: row.visibility as Post["visibility"],
+          format: row.format as Post["format"],
+          status: row.status as Post["status"],
+          featured: row.featured,
+          pinned: row.pinned,
+          slug: row.slug,
           title: row.title,
-          path: row.path,
-          content: row.content,
-          contentHtml: row.content_html,
-          sourceUrl: row.source_url,
-          sourceName: row.source_name,
-          sourceDomain: row.source_domain,
+          url: row.url,
+          body: row.body,
+          bodyHtml: row.body_html,
+          quoteText: row.quote_text,
+          rating: row.rating,
+          collectionId: row.collection_id,
           replyToId: row.reply_to_id,
           threadId: row.thread_id,
           deletedAt: row.deleted_at,