@jant/core 0.3.32 → 0.3.34

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

@@ -95,6 +95,159 @@ describe("SettingsService", () => {
     });
   });
 
+  describe("updateGeneral", () => {
+    const defaults = {
+      siteName: "",
+      siteDescription: "",
+      siteFooter: "",
+      siteLanguage: "en",
+      homeDefaultView: "latest",
+      headerNavMaxVisible: "3",
+      timeZone: "UTC",
+    };
+
+    it("sets non-empty values", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, siteName: "My Blog", siteDescription: "A blog" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("SITE_NAME")).toBe("My Blog");
+      expect(await settingsService.get("SITE_DESCRIPTION")).toBe("A blog");
+    });
+
+    it("removes empty values", async () => {
+      await settingsService.set("SITE_NAME", "Old Name");
+      await settingsService.updateGeneral(
+        { ...defaults, siteName: "" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("SITE_NAME")).toBeNull();
+    });
+
+    it("trims whitespace from values", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, siteName: "  Trimmed  " },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("SITE_NAME")).toBe("Trimmed");
+    });
+
+    it("removes HOME_DEFAULT_VIEW when set to default", async () => {
+      await settingsService.set("HOME_DEFAULT_VIEW", "featured");
+      await settingsService.updateGeneral(
+        { ...defaults, homeDefaultView: "latest" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("HOME_DEFAULT_VIEW")).toBeNull();
+    });
+
+    it("stores HOME_DEFAULT_VIEW when set to featured", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, homeDefaultView: "featured" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("HOME_DEFAULT_VIEW")).toBe("featured");
+    });
+
+    it("removes HEADER_NAV_MAX_VISIBLE when set to default (3)", async () => {
+      await settingsService.set("HEADER_NAV_MAX_VISIBLE", "5");
+      await settingsService.updateGeneral(
+        { ...defaults, headerNavMaxVisible: "3" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("HEADER_NAV_MAX_VISIBLE")).toBeNull();
+    });
+
+    it("stores HEADER_NAV_MAX_VISIBLE when non-default", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, headerNavMaxVisible: "5" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("HEADER_NAV_MAX_VISIBLE")).toBe("5");
+    });
+
+    it("removes TIME_ZONE when set to UTC", async () => {
+      await settingsService.set("TIME_ZONE", "America/New_York");
+      await settingsService.updateGeneral(
+        { ...defaults, timeZone: "UTC" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("TIME_ZONE")).toBeNull();
+    });
+
+    it("stores TIME_ZONE when non-default", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, timeZone: "America/New_York" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("TIME_ZONE")).toBe("America/New_York");
+    });
+
+    it("detects language change", async () => {
+      const result = await settingsService.updateGeneral(
+        { ...defaults, siteLanguage: "sv" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(result.languageChanged).toBe(true);
+    });
+
+    it("returns no language change when same", async () => {
+      const result = await settingsService.updateGeneral(defaults, {
+        oldLanguage: "en",
+        fallbackSiteName: "Jant",
+      });
+
+      expect(result.languageChanged).toBe(false);
+    });
+
+    it("returns display name from siteName when non-empty", async () => {
+      const result = await settingsService.updateGeneral(
+        { ...defaults, siteName: "My Blog" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(result.displayName).toBe("My Blog");
+    });
+
+    it("returns fallback display name when siteName is empty", async () => {
+      const result = await settingsService.updateGeneral(defaults, {
+        oldLanguage: "en",
+        fallbackSiteName: "Jant",
+      });
+
+      expect(result.displayName).toBe("Jant");
+    });
+
+    it("stores footer when non-empty", async () => {
+      await settingsService.updateGeneral(
+        { ...defaults, siteFooter: "© 2026" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("SITE_FOOTER")).toBe("© 2026");
+    });
+
+    it("removes footer when empty", async () => {
+      await settingsService.set("SITE_FOOTER", "Old footer");
+      await settingsService.updateGeneral(
+        { ...defaults, siteFooter: "" },
+        { oldLanguage: "en", fallbackSiteName: "Jant" },
+      );
+
+      expect(await settingsService.get("SITE_FOOTER")).toBeNull();
+    });
+  });
+
   describe("onboarding", () => {
     it("returns false when onboarding is not complete", async () => {
       const result = await settingsService.isOnboardingComplete();

package/src/services/index.ts

@@ -17,6 +17,10 @@ import {
 import { createSearchService, type SearchService } from "./search.js";
 import { createNavItemService, type NavItemService } from "./navigation.js";
 import { createAuthService, type AuthService } from "./auth.js";
+import {
+  createPathRegistryService,
+  type PathRegistryService,
+} from "./path-registry.js";
 
 export interface Services {
   settings: SettingsService;
@@ -28,15 +32,18 @@ export interface Services {
   search: SearchService;
   navItems: NavItemService;
   auth: AuthService;
+  pathRegistry: PathRegistryService;
 }
 
 export function createServices(db: Database, d1: D1Database): Services {
   const settings = createSettingsService(db);
+  const pathRegistry = createPathRegistryService(db);
   return {
     settings,
-    posts: createPostService(db),
-    pages: createPageService(db),
-    redirects: createRedirectService(db),
+    pathRegistry,
+    posts: createPostService(db, pathRegistry),
+    pages: createPageService(db, pathRegistry),
+    redirects: createRedirectService(db, pathRegistry),
     media: createMediaService(db),
     collections: createCollectionService(db),
     search: createSearchService(d1),
@@ -46,7 +53,7 @@ export function createServices(db: Database, d1: D1Database): Services {
 }
 
 export type { SettingsService } from "./settings.js";
-export type { PostService, PostFilters } from "./post.js";
+export type { PostService, PostFilters, PostDeleteDeps } from "./post.js";
 export type { PageService, PageFilters } from "./page.js";
 export type { RedirectService } from "./redirect.js";
 export type { MediaService, MediaFilters } from "./media.js";
@@ -54,3 +61,4 @@ export type { CollectionService } from "./collection.js";
 export type { SearchService, SearchResult, SearchOptions } from "./search.js";
 export type { NavItemService } from "./navigation.js";
 export type { AuthService } from "./auth.js";
+export type { PathRegistryService, OwnerType } from "./path-registry.js";

package/src/services/media.ts

@@ -9,7 +9,10 @@ import { uuidv7 } from "uuidv7";
 import type { Database } from "../db/index.js";
 import { media } from "../db/schema.js";
 import { now } from "../lib/time.js";
+import type { StorageDriver } from "../lib/storage.js";
 import type { Media } from "../types.js";
+import { MAX_MEDIA_ATTACHMENTS } from "../types.js";
+import { ValidationError } from "../lib/errors.js";
 
 export interface MediaFilters {
   limit?: number;
@@ -24,7 +27,29 @@ export interface MediaService {
   getByPostIds(postIds: number[]): Promise<Map<number, Media[]>>;
   list(filters?: MediaFilters): Promise<Media[]>;
   create(data: CreateMediaData): Promise<Media>;
-  delete(id: string): Promise<boolean>;
+  /**
+   * Validate media IDs: checks count limit and verifies all IDs exist in the database.
+   * No-op when the array is empty.
+   *
+   * @param ids - Media IDs to validate
+   * @throws {ValidationError} When count exceeds MAX_MEDIA_ATTACHMENTS or any ID is missing
+   */
+  validateIds(ids: string[]): Promise<void>;
+  /**
+   * Delete a media record and its storage file.
+   *
+   * @param id - Media record ID
+   * @param storage - Optional storage driver; when provided the file is deleted from storage
+   * @returns true if the record existed and was deleted
+   */
+  delete(id: string, storage?: StorageDriver | null): Promise<boolean>;
+  /**
+   * Delete multiple media records and their storage files.
+   *
+   * @param ids - Media record IDs
+   * @param storage - Optional storage driver; when provided the files are deleted from storage
+   */
+  deleteByIds(ids: string[], storage?: StorageDriver | null): Promise<void>;
   getByStorageKey(storageKey: string): Promise<Media | null>;
   attachToPost(postId: number, mediaIds: string[]): Promise<void>;
   detachFromPost(postId: number): Promise<void>;
@@ -142,6 +167,21 @@ export function createMediaService(db: Database): MediaService {
       return rows.map(toMedia);
     },
 
+    async validateIds(ids) {
+      if (ids.length === 0) return;
+
+      if (ids.length > MAX_MEDIA_ATTACHMENTS) {
+        throw new ValidationError(
+          `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} media attachments`,
+        );
+      }
+
+      const existing = await this.getByIds(ids);
+      if (existing.length !== ids.length) {
+        throw new ValidationError("One or more media IDs are invalid");
+      }
+    },
+
     async create(data) {
       const id = data.id ?? uuidv7();
       const timestamp = now();
@@ -207,9 +247,37 @@ export function createMediaService(db: Database): MediaService {
       await db.update(media).set({ alt }).where(eq(media.id, id));
     },
 
-    async delete(id) {
-      const result = await db.delete(media).where(eq(media.id, id)).returning();
-      return result.length > 0;
+    async delete(id, storage) {
+      const record = await this.getById(id);
+      if (!record) return false;
+
+      if (storage) {
+        await storage.delete(record.storageKey).catch((err) => {
+          // eslint-disable-next-line no-console -- Error logging is intentional
+          console.error("Storage delete error:", err);
+        });
+      }
+
+      await db.delete(media).where(eq(media.id, id));
+      return true;
+    },
+
+    async deleteByIds(ids, storage) {
+      if (ids.length === 0) return;
+
+      if (storage) {
+        const records = await this.getByIds(ids);
+        await Promise.all(
+          records.map((r) =>
+            storage.delete(r.storageKey).catch((err) => {
+              // eslint-disable-next-line no-console -- Error logging is intentional
+              console.error("Storage delete error:", err);
+            }),
+          ),
+        );
+      }
+
+      await db.delete(media).where(inArray(media.id, ids));
     },
   };
 }

package/src/services/page.ts

@@ -10,6 +10,8 @@ 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";
+import type { PathRegistryService } from "./path-registry.js";
+import { ConflictError } from "../lib/errors.js";
 
 export interface PageFilters {
   status?: Status;
@@ -25,7 +27,16 @@ export interface PageService {
   delete(id: number): Promise<boolean>;
 }
 
-export function createPageService(db: Database): PageService {
+/** 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 createPageService(
+  db: Database,
+  pathRegistry: PathRegistryService,
+): PageService {
   function toPage(row: typeof pages.$inferSelect): Page {
     return {
       id: row.id,
@@ -83,31 +94,60 @@ export function createPageService(db: Database): PageService {
     },
 
     async create(data) {
-      const timestamp = now();
+      // Validate and reserve path before DB insert — throws friendly
+      // ConflictError/ValidationError instead of a raw UNIQUE constraint error.
+      // Uses placeholder owner ID; corrected to real ID after insert.
+      await pathRegistry.claim(data.slug, "page", 0);
 
+      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();
+      let page: Page;
+      try {
+        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
+        page = toPage(result[0]!);
+      } catch (err) {
+        await pathRegistry.release(data.slug);
+        // Surface DB unique constraint failures as a friendly error
+        if (isUniqueConstraintError(err)) {
+          throw new ConflictError(`Slug "${data.slug}" is already in use`);
+        }
+        throw err;
+      }
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-      return toPage(result[0]!);
+      // Update registry with actual page ID
+      await pathRegistry.release(data.slug);
+      await pathRegistry.claim(data.slug, "page", page.id);
+
+      return page;
     },
 
     async update(id, data) {
       const existing = await this.getById(id);
       if (!existing) return null;
 
+      const slugChanging =
+        data.slug !== undefined && data.slug !== existing.slug;
+
+      // If slug is changing, claim the new path first (validates before modifying)
+      if (slugChanging) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guarded by slugChanging check
+        await pathRegistry.claim(data.slug!, "page", id);
+      }
+
       const timestamp = now();
       const updates: Partial<typeof pages.$inferInsert> = {
         updatedAt: timestamp,
@@ -123,7 +163,7 @@ export function createPageService(db: Database): PageService {
       }
 
       // If slug changed, update related nav_items
-      if (data.slug !== undefined && data.slug !== existing.slug) {
+      if (slugChanging) {
         await db
           .update(navItems)
           .set({ url: `/${data.slug}`, updatedAt: timestamp })
@@ -144,10 +184,17 @@ export function createPageService(db: Database): PageService {
         .where(eq(pages.id, id))
         .returning();
 
+      // Release old slug from registry after successful update
+      if (slugChanging) {
+        await pathRegistry.release(existing.slug);
+      }
+
       return result[0] ? toPage(result[0]) : null;
     },
 
     async delete(id) {
+      // Release path registry entries for this page
+      await pathRegistry.releaseByOwner("page", 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/path-registry.ts

@@ -0,0 +1,160 @@
+/**
+ * Path Registry Service
+ *
+ * Central registry for URL path ownership. Every entity (page, post, redirect)
+ * that claims a URL path registers it here. The table's PRIMARY KEY on path
+ * provides DB-level uniqueness. Reserved system paths are rejected at the
+ * service layer.
+ */
+
+import { eq, and } from "drizzle-orm";
+import type { Database } from "../db/index.js";
+import { pathRegistry } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import { normalizePath } from "../lib/url.js";
+import { isReservedPath } from "../lib/constants.js";
+import { ValidationError, ConflictError } from "../lib/errors.js";
+
+export type OwnerType = "page" | "post" | "redirect";
+
+export interface PathRegistryEntry {
+  path: string;
+  ownerType: OwnerType;
+  ownerId: number;
+  createdAt: number;
+}
+
+export interface PathRegistryService {
+  /**
+   * Claim a path for an entity. Rejects reserved paths and conflicts.
+   * Idempotent: re-claiming the same path for the same owner is a no-op.
+   *
+   * @param path - The URL path to claim
+   * @param ownerType - The type of entity claiming the path
+   * @param ownerId - The ID of the entity claiming the path
+   * @returns The registry entry
+   */
+  claim(
+    path: string,
+    ownerType: OwnerType,
+    ownerId: number,
+  ): Promise<PathRegistryEntry>;
+
+  /**
+   * Release a claimed path.
+   *
+   * @param path - The URL path to release
+   */
+  release(path: string): Promise<void>;
+
+  /**
+   * Release all paths owned by a specific entity.
+   *
+   * @param ownerType - The type of entity
+   * @param ownerId - The ID of the entity
+   */
+  releaseByOwner(ownerType: OwnerType, ownerId: number): Promise<void>;
+
+  /**
+   * Look up a path in the registry.
+   *
+   * @param path - The URL path to look up
+   * @returns The registry entry, or null if not claimed
+   */
+  getByPath(path: string): Promise<PathRegistryEntry | null>;
+
+  /**
+   * Check if a path is available (not reserved and not claimed).
+   *
+   * @param path - The URL path to check
+   * @returns true if the path is available
+   */
+  isAvailable(path: string): Promise<boolean>;
+}
+
+export function createPathRegistryService(db: Database): PathRegistryService {
+  function toEntry(row: typeof pathRegistry.$inferSelect): PathRegistryEntry {
+    return {
+      path: row.path,
+      ownerType: row.ownerType as OwnerType,
+      ownerId: row.ownerId,
+      createdAt: row.createdAt,
+    };
+  }
+
+  return {
+    async claim(path, ownerType, ownerId) {
+      const normalized = normalizePath(path);
+
+      if (isReservedPath(normalized)) {
+        throw new ValidationError(
+          `Path "${normalized}" is reserved and cannot be used`,
+        );
+      }
+
+      // Check existing claim
+      const existing = await db
+        .select()
+        .from(pathRegistry)
+        .where(eq(pathRegistry.path, normalized))
+        .limit(1);
+
+      if (existing[0]) {
+        const entry = toEntry(existing[0]);
+        // Idempotent: same owner re-claiming is a no-op
+        if (entry.ownerType === ownerType && entry.ownerId === ownerId) {
+          return entry;
+        }
+        throw new ConflictError(`Path "${normalized}" is already in use`);
+      }
+
+      const timestamp = now();
+      await db.insert(pathRegistry).values({
+        path: normalized,
+        ownerType,
+        ownerId,
+        createdAt: timestamp,
+      });
+
+      return { path: normalized, ownerType, ownerId, createdAt: timestamp };
+    },
+
+    async release(path) {
+      const normalized = normalizePath(path);
+      await db.delete(pathRegistry).where(eq(pathRegistry.path, normalized));
+    },
+
+    async releaseByOwner(ownerType, ownerId) {
+      await db
+        .delete(pathRegistry)
+        .where(
+          and(
+            eq(pathRegistry.ownerType, ownerType),
+            eq(pathRegistry.ownerId, ownerId),
+          ),
+        );
+    },
+
+    async getByPath(path) {
+      const normalized = normalizePath(path);
+      const result = await db
+        .select()
+        .from(pathRegistry)
+        .where(eq(pathRegistry.path, normalized))
+        .limit(1);
+      return result[0] ? toEntry(result[0]) : null;
+    },
+
+    async isAvailable(path) {
+      const normalized = normalizePath(path);
+      if (isReservedPath(normalized)) return false;
+
+      const existing = await db
+        .select()
+        .from(pathRegistry)
+        .where(eq(pathRegistry.path, normalized))
+        .limit(1);
+      return existing.length === 0;
+    },
+  };
+}