@jant/core 0.3.32 → 0.3.34

package/src/services/post.ts

@@ -12,7 +12,17 @@ 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 type { StorageDriver } from "../lib/storage.js";
+import type { MediaService } from "./media.js";
 import type { Format, Status, Post, CreatePost, UpdatePost } from "../types.js";
+import type { PathRegistryService } from "./path-registry.js";
+import { ConflictError } from "../lib/errors.js";
+
+/** Dependencies for operations that coordinate with other services */
+export interface PostDeleteDeps {
+  media: MediaService;
+  storage?: StorageDriver | null;
+}
 
 export interface PostFilters {
   format?: Format;
@@ -37,7 +47,14 @@ export interface PostService {
   count(filters?: PostFilters): Promise<number>;
   create(data: CreatePost): Promise<Post>;
   update(id: number, data: UpdatePost): Promise<Post | null>;
-  delete(id: number): Promise<boolean>;
+  /**
+   * Soft-delete a post and clean up its media (storage files + DB records).
+   * Thread roots cascade to all replies.
+   *
+   * @param id - Post ID
+   * @param deps - Media service and optional storage driver for file cleanup
+   */
+  delete(id: number, deps?: PostDeleteDeps): Promise<boolean>;
   getThread(rootId: number): Promise<Post[]>;
   updateThreadStatusAndFeatured(
     rootId: number,
@@ -53,7 +70,16 @@ export interface PostService {
   ): Promise<Map<number, Post[]>>;
 }
 
-export function createPostService(db: Database): PostService {
+/** Check if an error is a SQLite UNIQUE constraint violation (D1 or better-sqlite3) */
+function isUniqueConstraintError(err: unknown): boolean {
+  const msg = String(err);
+  return msg.includes("UNIQUE constraint") || msg.includes("SQLITE_CONSTRAINT");
+}
+
+export function createPostService(
+  db: Database,
+  pathRegistry: PathRegistryService,
+): PostService {
   /** Build WHERE conditions from filters (shared by list and count) */
   function buildFilterConditions(filters: PostFilters) {
     const conditions = [];
@@ -189,31 +215,53 @@ export function createPostService(db: Database): PostService {
         }
       }
 
-      const result = await db
-        .insert(posts)
-        .values({
-          format: data.format,
-          status,
-          featured: featured ? 1 : 0,
-          pinned: data.pinned ? 1 : 0,
-          path: data.path ?? null,
-          title: data.title ?? null,
-          url: data.url ?? null,
-          body: data.body ?? null,
-          bodyHtml,
-          quoteText: data.quoteText ?? null,
-          rating: data.rating ?? null,
-          replyToId: data.replyToId ?? null,
-          threadId,
-          publishedAt: data.publishedAt ?? timestamp,
-          createdAt: timestamp,
-          updatedAt: timestamp,
-        })
-        .returning();
+      // Validate path availability before DB insert — throws friendly
+      // ConflictError/ValidationError instead of a raw UNIQUE constraint error.
+      // Uses placeholder owner ID; corrected to real ID after insert.
+      if (data.path) {
+        await pathRegistry.claim(data.path, "post", 0);
+      }
+
+      let result;
+      try {
+        result = await db
+          .insert(posts)
+          .values({
+            format: data.format,
+            status,
+            featured: featured ? 1 : 0,
+            pinned: data.pinned ? 1 : 0,
+            path: data.path ?? null,
+            title: data.title ?? null,
+            url: data.url ?? null,
+            body: data.body ?? null,
+            bodyHtml,
+            quoteText: data.quoteText ?? null,
+            rating: data.rating ?? null,
+            replyToId: data.replyToId ?? null,
+            threadId,
+            publishedAt: data.publishedAt ?? timestamp,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+          })
+          .returning();
+      } catch (err) {
+        if (data.path) await pathRegistry.release(data.path);
+        if (isUniqueConstraintError(err)) {
+          throw new ConflictError(`Path "${data.path}" is already in use`);
+        }
+        throw err;
+      }
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
       const post = toPost(result[0]!);
 
+      // Update registry with actual post ID
+      if (post.path) {
+        await pathRegistry.release(post.path);
+        await pathRegistry.claim(post.path, "post", post.id);
+      }
+
       // Sync collection memberships if provided
       if (data.collectionIds && data.collectionIds.length > 0) {
         await db.insert(postCollections).values(
@@ -231,6 +279,20 @@ export function createPostService(db: Database): PostService {
       const existing = await this.getById(id);
       if (!existing) return null;
 
+      // Handle path changes in the registry before modifying the post
+      const pathChanging =
+        data.path !== undefined && data.path !== existing.path;
+      if (pathChanging) {
+        // Claim new path (if non-null) before releasing old
+        if (data.path) {
+          await pathRegistry.claim(data.path, "post", id);
+        }
+        // Release old path (if it existed)
+        if (existing.path) {
+          await pathRegistry.release(existing.path);
+        }
+      }
+
       const timestamp = now();
       const updates: Partial<typeof posts.$inferInsert> = {
         updatedAt: timestamp,
@@ -335,10 +397,43 @@ export function createPostService(db: Database): PostService {
       return updateResult?.[0] ? toPost(updateResult[0]) : null;
     },
 
-    async delete(id) {
+    async delete(id, deps) {
       const existing = await this.getById(id);
       if (!existing) return false;
 
+      // Clean up media for all affected posts
+      if (deps?.media) {
+        let postIds: number[];
+        if (!existing.threadId) {
+          const thread = await this.getThread(id);
+          postIds = thread.map((p) => p.id);
+        } else {
+          postIds = [id];
+        }
+
+        const mediaMap = await deps.media.getByPostIds(postIds);
+        const allMedia = [...mediaMap.values()].flat();
+        if (allMedia.length > 0) {
+          await deps.media.deleteByIds(
+            allMedia.map((m) => m.id),
+            deps.storage,
+          );
+        }
+      }
+
+      // Release paths from registry
+      if (!existing.threadId) {
+        // Thread root: release paths for all posts in thread
+        const thread = await this.getThread(id);
+        for (const post of thread) {
+          if (post.path) {
+            await pathRegistry.release(post.path);
+          }
+        }
+      } else if (existing.path) {
+        await pathRegistry.release(existing.path);
+      }
+
       const timestamp = now();
 
       // If this is a thread root, soft delete all posts in the thread

package/src/services/redirect.ts

@@ -10,6 +10,8 @@ import { redirects } from "../db/schema.js";
 import { now } from "../lib/time.js";
 import { normalizePath } from "../lib/url.js";
 import type { Redirect } from "../types.js";
+import type { PathRegistryService } from "./path-registry.js";
+import { ConflictError } from "../lib/errors.js";
 
 export interface RedirectService {
   getByPath(fromPath: string): Promise<Redirect | null>;
@@ -18,7 +20,10 @@ export interface RedirectService {
   list(): Promise<Redirect[]>;
 }
 
-export function createRedirectService(db: Database): RedirectService {
+export function createRedirectService(
+  db: Database,
+  pathRegistry: PathRegistryService,
+): RedirectService {
   function toRedirect(row: typeof redirects.$inferSelect): Redirect {
     return {
       id: row.id,
@@ -44,7 +49,16 @@ export function createRedirectService(db: Database): RedirectService {
       const timestamp = now();
       const normalizedFrom = normalizePath(fromPath);
 
-      // Delete existing redirect from this path if any
+      // Check if path is claimed by a non-redirect entity
+      const existingClaim = await pathRegistry.getByPath(normalizedFrom);
+      if (existingClaim && existingClaim.ownerType !== "redirect") {
+        throw new ConflictError(`Path "${normalizedFrom}" is already in use`);
+      }
+
+      // Delete existing redirect from this path if any (upsert behavior)
+      if (existingClaim?.ownerType === "redirect") {
+        await pathRegistry.release(normalizedFrom);
+      }
       await db.delete(redirects).where(eq(redirects.fromPath, normalizedFrom));
 
       const result = await db
@@ -58,10 +72,16 @@ export function createRedirectService(db: Database): RedirectService {
         .returning();
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-      return toRedirect(result[0]!);
+      const redirect = toRedirect(result[0]!);
+
+      await pathRegistry.claim(normalizedFrom, "redirect", redirect.id);
+
+      return redirect;
     },
 
     async delete(id) {
+      // Release path registry entries for this redirect
+      await pathRegistry.releaseByOwner("redirect", id);
       const result = await db
         .delete(redirects)
         .where(eq(redirects.id, id))

package/src/services/settings.ts

@@ -13,6 +13,38 @@ import {
   ONBOARDING_STATUS,
   type SettingsKey,
 } from "../lib/constants.js";
+import type { StorageDriver } from "../lib/storage.js";
+import type { MediaService } from "./media.js";
+import { validateUploadFile, generateStorageKey } from "../lib/upload.js";
+import { arrayBufferToBase64 } from "../lib/favicon.js";
+import { ValidationError } from "../lib/errors.js";
+
+export interface GeneralSettingsData {
+  siteName: string;
+  siteDescription: string;
+  siteFooter: string;
+  siteLanguage: string;
+  homeDefaultView?: string;
+  headerNavMaxVisible?: string;
+  timeZone: string;
+}
+
+export interface GeneralSettingsResult {
+  languageChanged: boolean;
+  displayName: string;
+}
+
+export interface AvatarUploadData {
+  file: { stream(): ReadableStream; name: string; type: string; size: number };
+  faviconIco?: ArrayBuffer;
+  appleTouchIcon?: ArrayBuffer;
+}
+
+export interface AvatarUploadDeps {
+  media: MediaService;
+  storage: StorageDriver;
+  storageProvider: string;
+}
 
 export interface SettingsService {
   get(key: SettingsKey): Promise<string | null>;
@@ -22,6 +54,34 @@ export interface SettingsService {
   remove(key: SettingsKey): Promise<void>;
   isOnboardingComplete(): Promise<boolean>;
   completeOnboarding(): Promise<void>;
+  /**
+   * Update general site settings with trim/set/remove logic.
+   * Empty strings are removed. Default values are removed to keep the DB clean.
+   *
+   * @param data - Form data from the settings page
+   * @param opts - Old language (for change detection) and fallback site name
+   * @returns Whether the language changed and the display name for the site
+   */
+  updateGeneral(
+    data: GeneralSettingsData,
+    opts: { oldLanguage: string; fallbackSiteName: string },
+  ): Promise<GeneralSettingsResult>;
+  /**
+   * Upload an avatar image: validates file, stores in storage, creates media record,
+   * updates settings (SITE_AVATAR, SITE_FAVICON_ICO, SITE_FAVICON_APPLE_TOUCH, SITE_FAVICON_VERSION).
+   *
+   * @param data - Avatar file and optional favicon variants
+   * @param deps - Media service and storage driver dependencies
+   * @throws {ValidationError} When file validation fails
+   */
+  uploadAvatar(data: AvatarUploadData, deps: AvatarUploadDeps): Promise<void>;
+  /**
+   * Remove avatar and all favicon-related settings.
+   * Deletes the apple-touch-icon from storage if it exists.
+   *
+   * @param storage - Optional storage driver for deleting the apple-touch-icon file
+   */
+  removeAvatar(storage?: StorageDriver | null): Promise<void>;
 }
 
 export function createSettingsService(db: Database): SettingsService {
@@ -96,5 +156,126 @@ export function createSettingsService(db: Database): SettingsService {
         ONBOARDING_STATUS.COMPLETED,
       );
     },
+
+    async updateGeneral(data, opts) {
+      // Site name: set if non-empty, remove otherwise
+      if (data.siteName.trim()) {
+        await this.set("SITE_NAME", data.siteName.trim());
+      } else {
+        await this.remove("SITE_NAME");
+      }
+
+      // Site description: set if non-empty, remove otherwise
+      if (data.siteDescription.trim()) {
+        await this.set("SITE_DESCRIPTION", data.siteDescription.trim());
+      } else {
+        await this.remove("SITE_DESCRIPTION");
+      }
+
+      // Footer: set if non-empty, remove otherwise
+      if (data.siteFooter?.trim()) {
+        await this.set("SITE_FOOTER", data.siteFooter.trim());
+      } else {
+        await this.remove("SITE_FOOTER");
+      }
+
+      // Language is always stored
+      await this.set("SITE_LANGUAGE", data.siteLanguage);
+
+      // Homepage default view: only update if provided (may be managed separately)
+      if (data.homeDefaultView !== undefined) {
+        if (data.homeDefaultView === "featured") {
+          await this.set("HOME_DEFAULT_VIEW", data.homeDefaultView);
+        } else {
+          await this.remove("HOME_DEFAULT_VIEW");
+        }
+      }
+
+      // 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) {
+          await this.set("HEADER_NAV_MAX_VISIBLE", String(navMax));
+        } else {
+          await this.remove("HEADER_NAV_MAX_VISIBLE");
+        }
+      }
+
+      // Timezone: only store non-default (default is UTC)
+      if (data.timeZone && data.timeZone !== "UTC") {
+        await this.set("TIME_ZONE", data.timeZone);
+      } else {
+        await this.remove("TIME_ZONE");
+      }
+
+      return {
+        languageChanged: opts.oldLanguage !== data.siteLanguage,
+        displayName: data.siteName.trim() || opts.fallbackSiteName,
+      };
+    },
+
+    async uploadAvatar(data, deps) {
+      const uploadError = validateUploadFile(data.file as unknown as File);
+      if (uploadError) {
+        throw new ValidationError(uploadError);
+      }
+
+      const { id, filename, storageKey } = generateStorageKey(data.file.name);
+
+      await deps.storage.put(storageKey, data.file.stream(), {
+        contentType: data.file.type,
+      });
+
+      await deps.media.create({
+        id,
+        filename,
+        originalName: data.file.name,
+        mimeType: data.file.type,
+        size: data.file.size,
+        storageKey,
+        provider: deps.storageProvider,
+      });
+
+      await this.set("SITE_AVATAR", storageKey);
+
+      // Store favicon ICO as base64 in settings (tiny file, accessed every page load)
+      if (data.faviconIco) {
+        const b64 = arrayBufferToBase64(data.faviconIco);
+        await this.set("SITE_FAVICON_ICO", b64);
+      }
+
+      // Store apple-touch-icon in storage (180x180 PNG, not tiny enough for base64)
+      if (data.appleTouchIcon) {
+        const appleTouchKey = "favicon/apple-touch-icon.png";
+        await deps.storage.put(
+          appleTouchKey,
+          new Uint8Array(data.appleTouchIcon),
+          { contentType: "image/png" },
+        );
+        await this.set("SITE_FAVICON_APPLE_TOUCH", appleTouchKey);
+      }
+
+      // Set favicon version for cache-busting
+      const ts = new Date();
+      const version =
+        String(ts.getUTCFullYear()) +
+        String(ts.getUTCMonth() + 1).padStart(2, "0") +
+        String(ts.getUTCDate()).padStart(2, "0") +
+        String(ts.getUTCHours()).padStart(2, "0") +
+        String(ts.getUTCMinutes()).padStart(2, "0");
+      await this.set("SITE_FAVICON_VERSION", version);
+    },
+
+    async removeAvatar(storage) {
+      const appleTouchKey = await this.get("SITE_FAVICON_APPLE_TOUCH");
+      if (storage && appleTouchKey) {
+        await storage.delete(appleTouchKey);
+      }
+
+      await this.remove("SITE_AVATAR");
+      await this.remove("SITE_FAVICON_ICO");
+      await this.remove("SITE_FAVICON_APPLE_TOUCH");
+      await this.remove("SITE_FAVICON_VERSION");
+    },
   };
 }

package/src/styles/components.css

@@ -5,6 +5,15 @@
  * AFTER Tailwind is initialized in the user's CSS entry.
  */
 
+/* Icon stroke width — CSS property overrides SVG presentational attributes */
+svg[stroke-width] {
+  stroke-width: var(--icon-stroke);
+}
+
+svg[stroke-width].icon-fine {
+  stroke-width: var(--icon-stroke-fine);
+}
+
 /* Custom utilities */
 @layer utilities {
   .container {
@@ -93,6 +102,132 @@
   }
 }
 
+/* Dashboard header */
+@layer components {
+  .dash-header {
+    padding: 20px 0 0;
+  }
+
+  @media (min-width: 700px) {
+    .dash-header {
+      padding: 24px 0 0;
+    }
+  }
+
+  .dash-header-inner {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    padding-bottom: 12px;
+  }
+
+  .dash-header-left {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .dash-header-nav {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    flex: 1;
+  }
+
+  .dash-header-logo {
+    font-size: 1.125rem;
+    font-weight: 800;
+    line-height: 1;
+    color: var(--color-foreground);
+  }
+
+  .dash-header-site-link {
+    @apply flex items-center justify-center;
+    color: var(--color-muted-foreground);
+    transition: color 0.15s;
+
+    &:hover {
+      color: var(--color-foreground);
+    }
+  }
+
+  .dash-header-link {
+    position: relative;
+    font-size: 0.875rem;
+    padding: 6px 10px;
+    border-radius: var(--radius);
+    color: var(--color-muted-foreground);
+    transition:
+      color 0.15s,
+      background-color 0.15s;
+
+    &:hover {
+      color: var(--color-foreground);
+      background-color: var(--color-accent);
+    }
+  }
+
+  .dash-header-link-active {
+    color: var(--color-foreground);
+    font-weight: 600;
+    background-color: var(--color-accent);
+  }
+
+  .dash-header-menu-btn {
+    @apply flex items-center justify-center;
+    width: 32px;
+    height: 32px;
+    border-radius: 999px;
+    border: none;
+    background: transparent;
+    color: var(--color-muted-foreground);
+    cursor: pointer;
+    transition:
+      color 0.15s,
+      background-color 0.15s;
+
+    &:hover {
+      color: var(--color-foreground);
+      background-color: var(--color-accent);
+    }
+  }
+
+  .dash-header-menu-btn + [data-popover] {
+    min-width: 170px;
+  }
+}
+
+/* Sub-navigation — underline style for secondary tabs (Settings, Appearance) */
+@layer components {
+  .dash-subnav {
+    @apply flex gap-4 mb-6;
+
+    > a {
+      position: relative;
+      font-size: 0.8125rem;
+      padding-bottom: 8px;
+      color: var(--color-muted-foreground);
+      transition: color 0.15s;
+
+      &:hover {
+        color: var(--color-foreground);
+      }
+
+      &.active {
+        color: var(--color-foreground);
+        font-weight: 500;
+
+        &::after {
+          content: "";
+          @apply absolute inset-x-0 bottom-0 h-0.5 rounded-full;
+          background-color: var(--color-foreground);
+        }
+      }
+    }
+  }
+}
+
 /* Skeleton screen sizing — used in SSR fallbacks while Lit hydrates */
 @layer components {
   .skel-label {

package/src/styles/tokens.css

@@ -17,7 +17,7 @@
   --leading: 1.5;
 
   /* Layout */
-  --site-width: 640px;
+  --site-width: 600px;
   --site-padding: 1.5rem;
   --content-gap: 1rem;
   --space-xl: 2rem;
@@ -38,6 +38,10 @@
   --avatar-radius: 50%;
   --media-radius: 0.5rem;
 
+  /* Icons */
+  --icon-stroke: 2;
+  --icon-stroke-fine: 1.5;
+
   /* Derived color tokens (from BaseCoat variables) */
   --site-column-outline: var(--border);
   --site-threadline: var(--border);
@@ -46,6 +50,7 @@
   --site-nav-hover-bg: var(--accent);
   --site-text-primary: var(--foreground);
   --site-text-secondary: var(--muted-foreground);
+  --site-text-placeholder: oklch(from var(--muted-foreground) l c h / 0.5);
   --site-media-outline: var(--border);
   --site-divider: var(--border);
 }