@jant/core 0.3.35 → 0.3.37

package/src/services/__tests__/path-registry.test.ts

@@ -1,165 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { createTestDatabase } from "../../__tests__/helpers/db.js";
-import { createPathRegistryService } from "../path-registry.js";
-import { ValidationError, ConflictError } from "../../lib/errors.js";
-import type { Database } from "../../db/index.js";
-
-describe("PathRegistryService", () => {
-  let db: Database;
-  let pathRegistry: ReturnType<typeof createPathRegistryService>;
-
-  beforeEach(() => {
-    const testDb = createTestDatabase();
-    db = testDb.db as unknown as Database;
-    pathRegistry = createPathRegistryService(db);
-  });
-
-  describe("claim", () => {
-    it("claims a path successfully", async () => {
-      const entry = await pathRegistry.claim("about", "page", 1);
-
-      expect(entry.path).toBe("about");
-      expect(entry.ownerType).toBe("page");
-      expect(entry.ownerId).toBe(1);
-      expect(entry.createdAt).toBeGreaterThan(0);
-    });
-
-    it("normalizes the path before claiming", async () => {
-      const entry = await pathRegistry.claim("  /About/  ", "page", 1);
-      expect(entry.path).toBe("about");
-    });
-
-    it("rejects reserved paths", async () => {
-      await expect(pathRegistry.claim("dash", "page", 1)).rejects.toThrow(
-        ValidationError,
-      );
-      await expect(pathRegistry.claim("api", "page", 1)).rejects.toThrow(
-        ValidationError,
-      );
-      await expect(pathRegistry.claim("search", "page", 1)).rejects.toThrow(
-        ValidationError,
-      );
-    });
-
-    it("rejects reserved paths regardless of casing", async () => {
-      await expect(pathRegistry.claim("DASH", "page", 1)).rejects.toThrow(
-        ValidationError,
-      );
-    });
-
-    it("throws ConflictError when path is already claimed by another entity", async () => {
-      await pathRegistry.claim("about", "page", 1);
-
-      await expect(pathRegistry.claim("about", "post", 2)).rejects.toThrow(
-        ConflictError,
-      );
-    });
-
-    it("is idempotent for the same owner", async () => {
-      const first = await pathRegistry.claim("about", "page", 1);
-      const second = await pathRegistry.claim("about", "page", 1);
-
-      expect(second.path).toBe(first.path);
-      expect(second.ownerType).toBe(first.ownerType);
-      expect(second.ownerId).toBe(first.ownerId);
-    });
-
-    it("allows multi-level paths", async () => {
-      const entry = await pathRegistry.claim("2024/01/my-post", "post", 1);
-      expect(entry.path).toBe("2024/01/my-post");
-    });
-  });
-
-  describe("release", () => {
-    it("releases a claimed path", async () => {
-      await pathRegistry.claim("about", "page", 1);
-      await pathRegistry.release("about");
-
-      const entry = await pathRegistry.getByPath("about");
-      expect(entry).toBeNull();
-    });
-
-    it("normalizes the path before releasing", async () => {
-      await pathRegistry.claim("about", "page", 1);
-      await pathRegistry.release("  /About/  ");
-
-      const entry = await pathRegistry.getByPath("about");
-      expect(entry).toBeNull();
-    });
-
-    it("is a no-op for unclaimed paths", async () => {
-      // Should not throw
-      await pathRegistry.release("nonexistent");
-    });
-  });
-
-  describe("releaseByOwner", () => {
-    it("releases all paths for a specific owner", async () => {
-      await pathRegistry.claim("about", "page", 1);
-      await pathRegistry.claim("contact", "page", 1);
-      await pathRegistry.claim("blog", "page", 2);
-
-      await pathRegistry.releaseByOwner("page", 1);
-
-      expect(await pathRegistry.getByPath("about")).toBeNull();
-      expect(await pathRegistry.getByPath("contact")).toBeNull();
-      // Different owner's path should remain
-      expect(await pathRegistry.getByPath("blog")).not.toBeNull();
-    });
-
-    it("does not affect other owner types", async () => {
-      await pathRegistry.claim("about", "page", 1);
-      await pathRegistry.claim("my-post", "post", 1);
-
-      await pathRegistry.releaseByOwner("page", 1);
-
-      expect(await pathRegistry.getByPath("about")).toBeNull();
-      expect(await pathRegistry.getByPath("my-post")).not.toBeNull();
-    });
-  });
-
-  describe("getByPath", () => {
-    it("returns entry for claimed path", async () => {
-      await pathRegistry.claim("about", "page", 1);
-
-      const entry = await pathRegistry.getByPath("about");
-      expect(entry).not.toBeNull();
-      expect(entry?.ownerType).toBe("page");
-      expect(entry?.ownerId).toBe(1);
-    });
-
-    it("normalizes the lookup path", async () => {
-      await pathRegistry.claim("about", "page", 1);
-
-      const entry = await pathRegistry.getByPath("  /About/  ");
-      expect(entry).not.toBeNull();
-    });
-
-    it("returns null for unclaimed path", async () => {
-      const entry = await pathRegistry.getByPath("nonexistent");
-      expect(entry).toBeNull();
-    });
-  });
-
-  describe("isAvailable", () => {
-    it("returns true for unclaimed, non-reserved paths", async () => {
-      expect(await pathRegistry.isAvailable("about")).toBe(true);
-    });
-
-    it("returns false for reserved paths", async () => {
-      expect(await pathRegistry.isAvailable("dash")).toBe(false);
-      expect(await pathRegistry.isAvailable("api")).toBe(false);
-    });
-
-    it("returns false for claimed paths", async () => {
-      await pathRegistry.claim("about", "page", 1);
-      expect(await pathRegistry.isAvailable("about")).toBe(false);
-    });
-
-    it("returns true after a path is released", async () => {
-      await pathRegistry.claim("about", "page", 1);
-      await pathRegistry.release("about");
-      expect(await pathRegistry.isAvailable("about")).toBe(true);
-    });
-  });
-});

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

@@ -1,159 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { createTestDatabase } from "../../__tests__/helpers/db.js";
-import { createRedirectService } from "../redirect.js";
-import { createPageService } from "../page.js";
-import { createPostService } from "../post.js";
-import { createPathRegistryService } from "../path-registry.js";
-import { ConflictError } from "../../lib/errors.js";
-import type { Database } from "../../db/index.js";
-
-describe("RedirectService", () => {
-  let db: Database;
-  let redirectService: ReturnType<typeof createRedirectService>;
-  let pageService: ReturnType<typeof createPageService>;
-  let postService: ReturnType<typeof createPostService>;
-  let pathRegistry: ReturnType<typeof createPathRegistryService>;
-
-  beforeEach(() => {
-    const testDb = createTestDatabase();
-    db = testDb.db as unknown as Database;
-    pathRegistry = createPathRegistryService(db);
-    redirectService = createRedirectService(db, pathRegistry);
-    pageService = createPageService(db, pathRegistry);
-    postService = createPostService(db, pathRegistry);
-  });
-
-  describe("create", () => {
-    it("creates a 301 redirect by default", async () => {
-      const redirect = await redirectService.create("/old-path", "/new-path");
-
-      expect(redirect.fromPath).toBe("old-path"); // normalizePath removes leading slash
-      expect(redirect.toPath).toBe("/new-path");
-      expect(redirect.type).toBe(301);
-      expect(redirect.id).toBe(1);
-    });
-
-    it("creates a 302 redirect", async () => {
-      const redirect = await redirectService.create(
-        "/temp",
-        "/destination",
-        302,
-      );
-
-      expect(redirect.type).toBe(302);
-    });
-
-    it("normalizes from path", async () => {
-      const redirect = await redirectService.create(
-        "  /OLD-PATH/  ",
-        "/new-path",
-      );
-
-      expect(redirect.fromPath).toBe("old-path");
-    });
-
-    it("replaces existing redirect for same from path", async () => {
-      await redirectService.create("/old", "/first");
-      const second = await redirectService.create("/old", "/second");
-
-      expect(second.toPath).toBe("/second");
-
-      const list = await redirectService.list();
-      expect(list).toHaveLength(1);
-    });
-  });
-
-  describe("getByPath", () => {
-    it("finds redirect by from path", async () => {
-      await redirectService.create("/old-page", "/new-page");
-
-      const found = await redirectService.getByPath("/old-page");
-      expect(found).not.toBeNull();
-      expect(found?.toPath).toBe("/new-page");
-    });
-
-    it("normalizes the lookup path", async () => {
-      await redirectService.create("/old-page", "/new-page");
-
-      const found = await redirectService.getByPath("  /OLD-PAGE/  ");
-      expect(found).not.toBeNull();
-    });
-
-    it("returns null for non-existent path", async () => {
-      const found = await redirectService.getByPath("/nonexistent");
-      expect(found).toBeNull();
-    });
-  });
-
-  describe("delete", () => {
-    it("deletes a redirect by ID", async () => {
-      const redirect = await redirectService.create("/old", "/new");
-      const result = await redirectService.delete(redirect.id);
-
-      expect(result).toBe(true);
-
-      const found = await redirectService.getByPath("/old");
-      expect(found).toBeNull();
-    });
-
-    it("returns false for non-existent ID", async () => {
-      const result = await redirectService.delete(9999);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("list", () => {
-    it("returns empty array when no redirects exist", async () => {
-      const redirects = await redirectService.list();
-      expect(redirects).toEqual([]);
-    });
-
-    it("returns all redirects", async () => {
-      await redirectService.create("/old-a", "/new-a");
-      await redirectService.create("/old-b", "/new-b");
-      await redirectService.create("/old-c", "/new-c");
-
-      const redirects = await redirectService.list();
-      expect(redirects).toHaveLength(3);
-    });
-  });
-
-  describe("path registry integration", () => {
-    it("rejects redirect that conflicts with a page", async () => {
-      await pageService.create({ slug: "about", title: "About" });
-
-      await expect(
-        redirectService.create("/about", "/new-about"),
-      ).rejects.toThrow(ConflictError);
-    });
-
-    it("rejects redirect that conflicts with a post path", async () => {
-      await postService.create({
-        format: "note",
-        body: "test",
-        path: "my-post",
-      });
-
-      await expect(
-        redirectService.create("/my-post", "/elsewhere"),
-      ).rejects.toThrow(ConflictError);
-    });
-
-    it("allows upsert for existing redirect (same type)", async () => {
-      await redirectService.create("/old", "/first");
-      const second = await redirectService.create("/old", "/second");
-
-      expect(second.toPath).toBe("/second");
-
-      const list = await redirectService.list();
-      expect(list).toHaveLength(1);
-    });
-
-    it("releases path on delete", async () => {
-      const redirect = await redirectService.create("/old", "/new");
-      await redirectService.delete(redirect.id);
-
-      expect(await pathRegistry.isAvailable("old")).toBe(true);
-    });
-  });
-});

package/src/services/page.ts

@@ -1,203 +0,0 @@
-/**
- * Page Service
- *
- * CRUD operations for standalone pages (about, now, etc.)
- */
-
-import { eq, desc, sql, and } 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";
-import type { PathRegistryService } from "./path-registry.js";
-import { ConflictError } from "../lib/errors.js";
-
-export interface PageFilters {
-  status?: Status;
-}
-
-export interface PageService {
-  getById(id: number): Promise<Page | null>;
-  getBySlug(slug: string): Promise<Page | null>;
-  list(filters?: PageFilters): Promise<Page[]>;
-  listNotInNav(): Promise<Page[]>;
-  create(data: CreatePage): Promise<Page>;
-  update(id: number, data: UpdatePage): Promise<Page | null>;
-  delete(id: number): Promise<boolean>;
-}
-
-/** 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,
-      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(filters?: PageFilters) {
-      const conditions = [];
-      if (filters?.status) {
-        conditions.push(eq(pages.status, filters.status));
-      }
-      const rows = await db
-        .select()
-        .from(pages)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(desc(pages.createdAt));
-      return rows.map(toPage);
-    },
-
-    async listNotInNav() {
-      const rows = await db
-        .select()
-        .from(pages)
-        .where(
-          sql`${pages.id} NOT IN (SELECT ${navItems.pageId} FROM ${navItems} WHERE ${navItems.pageId} IS NOT NULL)`,
-        )
-        .orderBy(desc(pages.createdAt));
-      return rows.map(toPage);
-    },
-
-    async create(data) {
-      // 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;
-
-      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;
-      }
-
-      // 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,
-      };
-
-      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 (slugChanging) {
-        await db
-          .update(navItems)
-          .set({ url: `/${data.slug}`, updatedAt: timestamp })
-          .where(eq(navItems.pageId, id));
-      }
-
-      // If title changed, update related nav_items label
-      if (data.title !== undefined && data.title !== existing.title) {
-        await db
-          .update(navItems)
-          .set({ label: data.title ?? existing.slug, updatedAt: timestamp })
-          .where(eq(navItems.pageId, id));
-      }
-
-      const result = await db
-        .update(pages)
-        .set(updates)
-        .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

@@ -1,160 +0,0 @@
-/**
- * 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;
-    },
-  };
-}