@jant/core 0.0.1

package/src/services/post.ts

@@ -0,0 +1,279 @@
+/**
+ * Post Service
+ *
+ * CRUD operations for posts with Thread support
+ */
+
+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";
+
+export interface PostFilters {
+  type?: PostType;
+  visibility?: Visibility | Visibility[];
+  includeDeleted?: boolean;
+  threadId?: number;
+  /** Exclude posts that are replies (have threadId set) */
+  excludeReplies?: boolean;
+  limit?: number;
+  cursor?: number; // post id for cursor pagination
+}
+
+export interface PostService {
+  getById(id: number): Promise<Post | null>;
+  getByPath(path: 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>;
+  /** Get reply counts for multiple posts */
+  getReplyCounts(postIds: number[]): Promise<Map<number, number>>;
+}
+
+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,
+      title: row.title,
+      path: row.path,
+      content: row.content,
+      contentHtml: row.contentHtml,
+      sourceUrl: row.sourceUrl,
+      sourceName: row.sourceName,
+      sourceDomain: row.sourceDomain,
+      replyToId: row.replyToId,
+      threadId: row.threadId,
+      deletedAt: row.deletedAt,
+      publishedAt: row.publishedAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  return {
+    async getById(id) {
+      const result = await db
+        .select()
+        .from(posts)
+        .where(and(eq(posts.id, id), isNull(posts.deletedAt)))
+        .limit(1);
+      return result[0] ? toPost(result[0]) : null;
+    },
+
+    async getByPath(path) {
+      const result = await db
+        .select()
+        .from(posts)
+        .where(and(eq(posts.path, path), isNull(posts.deletedAt)))
+        .limit(1);
+      return result[0] ? toPost(result[0]) : null;
+    },
+
+    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));
+        }
+      }
+
+      // Type filter
+      if (filters.type) {
+        conditions.push(eq(posts.type, filters.type));
+      }
+
+      // 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}`);
+      }
+
+      const query = db
+        .select()
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .orderBy(desc(posts.publishedAt), desc(posts.id))
+        .limit(filters.limit ?? 100);
+
+      const rows = await query;
+      return rows.map(toPost);
+    },
+
+    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;
+
+      // Handle thread relationship
+      let threadId: number | null = null;
+      let visibility = data.visibility ?? "quiet";
+
+      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
+          const root = parent.threadId ? await this.getById(parent.threadId) : parent;
+          if (root) {
+            visibility = root.visibility;
+          }
+        }
+      }
+
+      const result = await db
+        .insert(posts)
+        .values({
+          type: data.type,
+          visibility,
+          title: data.title ?? null,
+          path: data.path ?? null,
+          content: data.content ?? null,
+          contentHtml,
+          sourceUrl: data.sourceUrl ?? null,
+          sourceName: data.sourceName ?? null,
+          sourceDomain,
+          replyToId: data.replyToId ?? null,
+          threadId,
+          publishedAt: data.publishedAt ?? timestamp,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        })
+        .returning();
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+      return toPost(result[0]!);
+    },
+
+    async update(id, data) {
+      const existing = await this.getById(id);
+      if (!existing) return null;
+
+      const timestamp = now();
+      const updates: Partial<typeof posts.$inferInsert> = { updatedAt: timestamp };
+
+      if (data.type !== undefined) updates.type = data.type;
+      if (data.title !== undefined) updates.title = data.title;
+      if (data.path !== undefined) updates.path = data.path;
+      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.content !== undefined) {
+        updates.content = data.content;
+        updates.contentHtml = data.content ? renderMarkdown(data.content) : 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);
+        }
+      }
+
+      const result = await db.update(posts).set(updates).where(eq(posts.id, id)).returning();
+
+      return result[0] ? toPost(result[0]) : null;
+    },
+
+    async delete(id) {
+      const existing = await this.getById(id);
+      if (!existing) return false;
+
+      const timestamp = now();
+
+      // If this is a thread root, soft delete all posts in the thread
+      if (!existing.threadId) {
+        await db
+          .update(posts)
+          .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 })
+          .where(eq(posts.id, id));
+      }
+
+      return true;
+    },
+
+    async getThread(rootId) {
+      const rows = await db
+        .select()
+        .from(posts)
+        .where(
+          and(or(eq(posts.id, rootId), eq(posts.threadId, rootId)), isNull(posts.deletedAt))
+        )
+        .orderBy(posts.createdAt);
+
+      return rows.map(toPost);
+    },
+
+    async updateThreadVisibility(rootId, visibility) {
+      const timestamp = now();
+      await db
+        .update(posts)
+        .set({ visibility, updatedAt: timestamp })
+        .where(eq(posts.threadId, rootId));
+    },
+
+    async getReplyCounts(postIds) {
+      if (postIds.length === 0) return new Map();
+
+      const rows = await db
+        .select({
+          threadId: posts.threadId,
+          count: sql<number>`count(*)`.as("count"),
+        })
+        .from(posts)
+        .where(and(inArray(posts.threadId, postIds), isNull(posts.deletedAt)))
+        .groupBy(posts.threadId);
+
+      const counts = new Map<number, number>();
+      for (const row of rows) {
+        if (row.threadId !== null) {
+          counts.set(row.threadId, row.count);
+        }
+      }
+      return counts;
+    },
+  };
+}

package/src/services/redirect.ts

@@ -0,0 +1,74 @@
+/**
+ * Redirect Service
+ *
+ * URL redirect management for path changes
+ */
+
+import { eq } from "drizzle-orm";
+import type { Database } from "../db/index.js";
+import { redirects } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import { normalizePath } from "../lib/url.js";
+import type { Redirect } from "../types.js";
+
+export interface RedirectService {
+  getByPath(fromPath: string): Promise<Redirect | null>;
+  create(fromPath: string, toPath: string, type?: 301 | 302): Promise<Redirect>;
+  delete(id: number): Promise<boolean>;
+  list(): Promise<Redirect[]>;
+}
+
+export function createRedirectService(db: Database): RedirectService {
+  function toRedirect(row: typeof redirects.$inferSelect): Redirect {
+    return {
+      id: row.id,
+      fromPath: row.fromPath,
+      toPath: row.toPath,
+      type: row.type as 301 | 302,
+      createdAt: row.createdAt,
+    };
+  }
+
+  return {
+    async getByPath(fromPath) {
+      const normalized = normalizePath(fromPath);
+      const result = await db
+        .select()
+        .from(redirects)
+        .where(eq(redirects.fromPath, normalized))
+        .limit(1);
+      return result[0] ? toRedirect(result[0]) : null;
+    },
+
+    async create(fromPath, toPath, type = 301) {
+      const timestamp = now();
+      const normalizedFrom = normalizePath(fromPath);
+
+      // Delete existing redirect from this path if any
+      await db.delete(redirects).where(eq(redirects.fromPath, normalizedFrom));
+
+      const result = await db
+        .insert(redirects)
+        .values({
+          fromPath: normalizedFrom,
+          toPath,
+          type,
+          createdAt: timestamp,
+        })
+        .returning();
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+      return toRedirect(result[0]!);
+    },
+
+    async delete(id) {
+      const result = await db.delete(redirects).where(eq(redirects.id, id)).returning();
+      return result.length > 0;
+    },
+
+    async list() {
+      const rows = await db.select().from(redirects);
+      return rows.map(toRedirect);
+    },
+  };
+}

package/src/services/search.ts

@@ -0,0 +1,117 @@
+/**
+ * Search Service
+ *
+ * Full-text search using FTS5
+ */
+
+import type { Post, Visibility } from "../types.js";
+
+export interface SearchResult {
+  post: Post;
+  /** FTS5 rank score (lower is better) */
+  rank: number;
+  /** Highlighted snippet from content */
+  snippet?: string;
+}
+
+export interface SearchOptions {
+  /** Limit number of results */
+  limit?: number;
+  /** Offset for pagination */
+  offset?: number;
+  /** Filter by visibility */
+  visibility?: Visibility[];
+}
+
+export interface SearchService {
+  search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}
+
+interface RawSearchRow {
+  id: number;
+  type: string;
+  visibility: string;
+  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;
+  reply_to_id: number | null;
+  thread_id: number | null;
+  deleted_at: number | null;
+  published_at: number;
+  created_at: number;
+  updated_at: number;
+  rank: number;
+  snippet: string;
+}
+
+export function createSearchService(d1: D1Database): SearchService {
+  return {
+    async search(query, options = {}) {
+      const limit = options.limit ?? 20;
+      const offset = options.offset ?? 0;
+      const visibility = options.visibility ?? ["featured", "quiet"];
+
+      // Escape and prepare the query for FTS5
+      // FTS5 uses * for prefix matching
+      const ftsQuery = query
+        .trim()
+        .split(/\s+/)
+        .filter((term) => term.length > 0)
+        .map((term) => `"${term.replace(/"/g, '""')}"*`)
+        .join(" ");
+
+      if (!ftsQuery) {
+        return [];
+      }
+
+      // Build visibility placeholders
+      const visibilityPlaceholders = visibility.map(() => "?").join(", ");
+
+      // Query FTS5 table and join with posts using raw D1 query
+      const stmt = d1.prepare(`
+        SELECT
+          posts.*,
+          posts_fts.rank AS rank,
+          snippet(posts_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
+        FROM posts_fts
+        JOIN posts ON posts.id = posts_fts.rowid
+        WHERE posts_fts MATCH ?
+          AND posts.deleted_at IS NULL
+          AND posts.visibility IN (${visibilityPlaceholders})
+        ORDER BY posts_fts.rank
+        LIMIT ? OFFSET ?
+      `);
+
+      const { results } = await stmt
+        .bind(ftsQuery, ...visibility, limit, offset)
+        .all<RawSearchRow>();
+
+      return (results || []).map((row) => ({
+        post: {
+          id: row.id,
+          type: row.type as Post["type"],
+          visibility: row.visibility as Post["visibility"],
+          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,
+          replyToId: row.reply_to_id,
+          threadId: row.thread_id,
+          deletedAt: row.deleted_at,
+          publishedAt: row.published_at,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at,
+        },
+        rank: row.rank,
+        snippet: row.snippet,
+      }));
+    },
+  };
+}

package/src/services/settings.ts

@@ -0,0 +1,76 @@
+/**
+ * Settings Service
+ *
+ * Key-value store for site configuration
+ */
+
+import { eq } from "drizzle-orm";
+import type { Database } from "../db/index.js";
+import { settings } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import { SETTINGS_KEYS, ONBOARDING_STATUS, type SettingsKey } from "../lib/constants.js";
+
+export interface SettingsService {
+  get(key: SettingsKey): Promise<string | null>;
+  getAll(): Promise<Record<string, string>>;
+  set(key: SettingsKey, value: string): Promise<void>;
+  setMany(entries: Partial<Record<SettingsKey, string>>): Promise<void>;
+  isOnboardingComplete(): Promise<boolean>;
+  completeOnboarding(): Promise<void>;
+}
+
+export function createSettingsService(db: Database): SettingsService {
+  return {
+    async get(key) {
+      const result = await db.select().from(settings).where(eq(settings.key, key)).limit(1);
+      return result[0]?.value ?? null;
+    },
+
+    async getAll() {
+      const rows = await db.select().from(settings);
+      const result: Record<string, string> = {};
+      for (const row of rows) {
+        result[row.key] = row.value;
+      }
+      return result;
+    },
+
+    async set(key, value) {
+      const timestamp = now();
+      await db
+        .insert(settings)
+        .values({ key, value, updatedAt: timestamp })
+        .onConflictDoUpdate({
+          target: settings.key,
+          set: { value, updatedAt: timestamp },
+        });
+    },
+
+    async setMany(entries) {
+      const timestamp = now();
+      const keys = Object.keys(entries) as SettingsKey[];
+
+      for (const key of keys) {
+        const value = entries[key];
+        if (value !== undefined) {
+          await db
+            .insert(settings)
+            .values({ key, value, updatedAt: timestamp })
+            .onConflictDoUpdate({
+              target: settings.key,
+              set: { value, updatedAt: timestamp },
+            });
+        }
+      }
+    },
+
+    async isOnboardingComplete() {
+      const status = await this.get(SETTINGS_KEYS.ONBOARDING_STATUS);
+      return status === ONBOARDING_STATUS.COMPLETED;
+    },
+
+    async completeOnboarding() {
+      await this.set(SETTINGS_KEYS.ONBOARDING_STATUS, ONBOARDING_STATUS.COMPLETED);
+    },
+  };
+}

package/src/theme/components/ActionButtons.tsx

@@ -0,0 +1,98 @@
+/**
+ * Action Buttons Component
+ *
+ * Provides consistent Edit/View/Delete button group for list and detail pages
+ */
+
+import type { FC } from "hono/jsx";
+import { useLingui } from "../../i18n/index.js";
+
+export interface ActionButtonsProps {
+  /**
+   * URL for the edit action
+   */
+  editHref?: string;
+
+  /**
+   * URL for the view action (opens in new tab)
+   */
+  viewHref?: string;
+
+  /**
+   * Delete button form action
+   */
+  deleteAction?: string;
+
+  /**
+   * Delete confirmation message
+   */
+  deleteConfirm?: string;
+
+  /**
+   * Button size variant
+   * @default "sm"
+   */
+  size?: "sm" | "md";
+
+  /**
+   * Custom edit button label (overrides default translation)
+   */
+  editLabel?: string;
+
+  /**
+   * Custom view button label (overrides default translation)
+   */
+  viewLabel?: string;
+
+  /**
+   * Custom delete button label (overrides default translation)
+   */
+  deleteLabel?: string;
+}
+
+export const ActionButtons: FC<ActionButtonsProps> = ({
+  editHref,
+  viewHref,
+  deleteAction,
+  deleteConfirm,
+  size = "sm",
+  editLabel,
+  viewLabel,
+  deleteLabel,
+}) => {
+  const { t } = useLingui();
+
+  const editClass = size === "sm" ? "btn-sm-outline" : "btn-outline";
+  const viewClass = size === "sm" ? "btn-sm-ghost" : "btn-ghost";
+  const deleteClass = size === "sm" ? "btn-sm-ghost text-destructive" : "btn-ghost text-destructive";
+
+  const defaultEditLabel = t({ message: "Edit", comment: "@context: Button to edit item" });
+  const defaultViewLabel = t({ message: "View", comment: "@context: Button to view item on public site" });
+  const defaultDeleteLabel = t({ message: "Delete", comment: "@context: Button to delete item" });
+
+  return (
+    <>
+      {editHref && (
+        <a href={editHref} class={editClass}>
+          {editLabel || defaultEditLabel}
+        </a>
+      )}
+      {viewHref && (
+        <a href={viewHref} class={viewClass} target="_blank">
+          {viewLabel || defaultViewLabel}
+        </a>
+      )}
+      {deleteAction && (
+        <form method="post" action={deleteAction} style="display: inline">
+          <button
+            type="submit"
+            class={deleteClass}
+            onclick={deleteConfirm ? `return confirm('${deleteConfirm}')` : undefined}
+          >
+            {deleteLabel || defaultDeleteLabel}
+          </button>
+        </form>
+      )}
+    </>
+  );
+};

package/src/theme/components/CrudPageHeader.tsx

@@ -0,0 +1,48 @@
+/**
+ * CRUD Page Header Component
+ *
+ * Provides consistent header layout for dashboard CRUD list pages
+ * with title and primary action button
+ */
+
+import type { FC, PropsWithChildren } from "hono/jsx";
+
+export interface CrudPageHeaderProps extends PropsWithChildren {
+  /**
+   * Page title to display
+   */
+  title: string;
+
+  /**
+   * Primary action button text (e.g., "New Post")
+   */
+  ctaLabel?: string;
+
+  /**
+   * Primary action button href
+   */
+  ctaHref?: string;
+
+  // children is already defined in PropsWithChildren
+  // Optional children to render in place of default CTA button (useful for custom actions like upload buttons)
+}
+
+export const CrudPageHeader: FC<CrudPageHeaderProps> = ({
+  title,
+  ctaLabel,
+  ctaHref,
+  children,
+}) => {
+  return (
+    <div class="flex items-center justify-between mb-6">
+      <h1 class="text-2xl font-semibold">{title}</h1>
+      {children || (
+        ctaLabel && ctaHref && (
+          <a href={ctaHref} class="btn">
+            {ctaLabel}
+          </a>
+        )
+      )}
+    </div>
+  );
+};