@jant/core 0.3.31 → 0.3.33

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

@@ -3,6 +3,7 @@ import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createMediaService } from "../media.js";
 import { createPostService } from "../post.js";
+import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 
 describe("MediaService", () => {
@@ -14,7 +15,7 @@ describe("MediaService", () => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
     mediaService = createMediaService(db);
-    postService = createPostService(db);
+    postService = createPostService(db, createPathRegistryService(db));
   });
 
   const sampleMedia = {
@@ -262,6 +263,51 @@ describe("MediaService", () => {
     });
   });
 
+  describe("validateIds", () => {
+    it("passes for valid IDs", async () => {
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.jpg",
+      });
+      const m2 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/b.jpg",
+      });
+
+      await expect(
+        mediaService.validateIds([m1.id, m2.id]),
+      ).resolves.not.toThrow();
+    });
+
+    it("is a no-op for empty array", async () => {
+      await expect(mediaService.validateIds([])).resolves.not.toThrow();
+    });
+
+    it("throws ValidationError when count exceeds limit", async () => {
+      const ids = Array.from({ length: 21 }, (_, i) => `fake-id-${i}`);
+      await expect(mediaService.validateIds(ids)).rejects.toThrow(
+        "at most 20 media attachments",
+      );
+    });
+
+    it("throws ValidationError when IDs do not exist", async () => {
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.jpg",
+      });
+
+      await expect(
+        mediaService.validateIds([m1.id, "nonexistent-id"]),
+      ).rejects.toThrow("media IDs are invalid");
+    });
+
+    it("throws ValidationError for all nonexistent IDs", async () => {
+      await expect(
+        mediaService.validateIds(["fake-1", "fake-2"]),
+      ).rejects.toThrow("media IDs are invalid");
+    });
+  });
+
   describe("getByStorageKey", () => {
     it("returns media by R2 key", async () => {
       await mediaService.create(sampleMedia);
@@ -424,4 +470,35 @@ describe("MediaService", () => {
       expect(result).toBe(false);
     });
   });
+
+  describe("deleteByIds", () => {
+    it("deletes multiple media records", async () => {
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.jpg",
+      });
+      const m2 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/b.jpg",
+      });
+      const m3 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/c.jpg",
+      });
+
+      await mediaService.deleteByIds([m1.id, m2.id]);
+
+      expect(await mediaService.getById(m1.id)).toBeNull();
+      expect(await mediaService.getById(m2.id)).toBeNull();
+      expect(await mediaService.getById(m3.id)).not.toBeNull();
+    });
+
+    it("handles empty array gracefully", async () => {
+      const m1 = await mediaService.create(sampleMedia);
+
+      await mediaService.deleteByIds([]);
+
+      expect(await mediaService.getById(m1.id)).not.toBeNull();
+    });
+  });
 });

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

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createNavItemService } from "../navigation.js";
 import { createPageService } from "../page.js";
+import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 
 describe("NavItemService", () => {
@@ -13,7 +14,7 @@ describe("NavItemService", () => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
     navItemService = createNavItemService(db);
-    pageService = createPageService(db);
+    pageService = createPageService(db, createPathRegistryService(db));
   });
 
   describe("create", () => {

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

@@ -1,18 +1,25 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createPageService } from "../page.js";
+import { createPostService } from "../post.js";
 import { createNavItemService } from "../navigation.js";
+import { createPathRegistryService } from "../path-registry.js";
+import { ValidationError, ConflictError } from "../../lib/errors.js";
 import type { Database } from "../../db/index.js";
 
 describe("PageService", () => {
   let db: Database;
   let pageService: ReturnType<typeof createPageService>;
+  let postService: ReturnType<typeof createPostService>;
   let navItemService: ReturnType<typeof createNavItemService>;
+  let pathRegistry: ReturnType<typeof createPathRegistryService>;
 
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    pageService = createPageService(db);
+    pathRegistry = createPathRegistryService(db);
+    pageService = createPageService(db, pathRegistry);
+    postService = createPostService(db, pathRegistry);
     navItemService = createNavItemService(db);
   });
 
@@ -218,4 +225,74 @@ describe("PageService", () => {
       expect(contactNav?.label).toBe("Contact");
     });
   });
+
+  describe("path registry integration", () => {
+    it("rejects reserved slug on create", async () => {
+      await expect(
+        pageService.create({ slug: "dash", title: "Dashboard" }),
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it("rejects slug that conflicts with a post path", async () => {
+      await postService.create({
+        format: "note",
+        body: "test",
+        path: "about",
+      });
+
+      await expect(
+        pageService.create({ slug: "about", title: "About" }),
+      ).rejects.toThrow(ConflictError);
+    });
+
+    it("rejects reserved slug on update", async () => {
+      const page = await pageService.create({
+        slug: "about",
+        title: "About",
+      });
+
+      await expect(
+        pageService.update(page.id, { slug: "api" }),
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it("rejects slug update that conflicts with another entity", async () => {
+      const page = await pageService.create({
+        slug: "about",
+        title: "About",
+      });
+      await postService.create({
+        format: "note",
+        body: "test",
+        path: "contact",
+      });
+
+      await expect(
+        pageService.update(page.id, { slug: "contact" }),
+      ).rejects.toThrow(ConflictError);
+    });
+
+    it("releases path on delete", async () => {
+      const page = await pageService.create({
+        slug: "about",
+        title: "About",
+      });
+
+      await pageService.delete(page.id);
+
+      expect(await pathRegistry.isAvailable("about")).toBe(true);
+    });
+
+    it("releases old slug and claims new slug on update", async () => {
+      const page = await pageService.create({
+        slug: "about",
+        title: "About",
+      });
+
+      await pageService.update(page.id, { slug: "about-us" });
+
+      expect(await pathRegistry.isAvailable("about")).toBe(true);
+      expect(await pathRegistry.isAvailable("about-us")).toBe(false);
+    });
+  });
 });

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

@@ -0,0 +1,165 @@
+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__/post-timeline.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createPostService } from "../post.js";
+import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 
 describe("PostService - Timeline features", () => {
@@ -10,7 +11,7 @@ describe("PostService - Timeline features", () => {
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    postService = createPostService(db);
+    postService = createPostService(db, createPathRegistryService(db));
   });
 
   describe("format filter", () => {

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

@@ -1,16 +1,23 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createPostService } from "../post.js";
+import { createPageService } from "../page.js";
+import { createPathRegistryService } from "../path-registry.js";
+import { ValidationError, ConflictError } from "../../lib/errors.js";
 import type { Database } from "../../db/index.js";
 
 describe("PostService", () => {
   let db: Database;
   let postService: ReturnType<typeof createPostService>;
+  let pageService: ReturnType<typeof createPageService>;
+  let pathRegistry: ReturnType<typeof createPathRegistryService>;
 
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    postService = createPostService(db);
+    pathRegistry = createPathRegistryService(db);
+    postService = createPostService(db, pathRegistry);
+    pageService = createPageService(db, pathRegistry);
   });
 
   describe("create", () => {
@@ -868,4 +875,99 @@ describe("PostService", () => {
       expect(counts.get(root.id)).toBe(1);
     });
   });
+
+  describe("path registry integration", () => {
+    it("claims path on create", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+        path: "my-post",
+      });
+
+      const entry = await pathRegistry.getByPath("my-post");
+      expect(entry).not.toBeNull();
+      expect(entry?.ownerType).toBe("post");
+      expect(entry?.ownerId).toBe(post.id);
+    });
+
+    it("does not claim when no path provided", async () => {
+      await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      // No path registry entries should exist
+      expect(await pathRegistry.isAvailable("test")).toBe(true);
+    });
+
+    it("rejects path that conflicts with a page slug", async () => {
+      await pageService.create({ slug: "about", title: "About" });
+
+      await expect(
+        postService.create({ format: "note", body: "test", path: "about" }),
+      ).rejects.toThrow(ConflictError);
+    });
+
+    it("rejects reserved path on create", async () => {
+      await expect(
+        postService.create({ format: "note", body: "test", path: "dash" }),
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it("releases old path and claims new on update", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+        path: "old-path",
+      });
+
+      await postService.update(post.id, { path: "new-path" });
+
+      expect(await pathRegistry.isAvailable("old-path")).toBe(true);
+      expect(await pathRegistry.isAvailable("new-path")).toBe(false);
+    });
+
+    it("releases path when cleared to null on update", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+        path: "my-path",
+      });
+
+      await postService.update(post.id, { path: null });
+
+      expect(await pathRegistry.isAvailable("my-path")).toBe(true);
+    });
+
+    it("releases path on soft-delete", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+        path: "my-path",
+      });
+
+      await postService.delete(post.id);
+
+      expect(await pathRegistry.isAvailable("my-path")).toBe(true);
+    });
+
+    it("releases paths for all thread posts on root delete", async () => {
+      const root = await postService.create({
+        format: "note",
+        body: "root",
+        path: "thread-root",
+      });
+      await postService.create({
+        format: "note",
+        body: "reply",
+        path: "thread-reply",
+        replyToId: root.id,
+      });
+
+      await postService.delete(root.id);
+
+      expect(await pathRegistry.isAvailable("thread-root")).toBe(true);
+      expect(await pathRegistry.isAvailable("thread-reply")).toBe(true);
+    });
+  });
 });

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

@@ -1,16 +1,26 @@
 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;
-    redirectService = createRedirectService(db);
+    pathRegistry = createPathRegistryService(db);
+    redirectService = createRedirectService(db, pathRegistry);
+    pageService = createPageService(db, pathRegistry);
+    postService = createPostService(db, pathRegistry);
   });
 
   describe("create", () => {
@@ -99,12 +109,51 @@ describe("RedirectService", () => {
     });
 
     it("returns all redirects", async () => {
-      await redirectService.create("/a", "/b");
-      await redirectService.create("/c", "/d");
-      await redirectService.create("/e", "/f");
+      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/__tests__/search.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createSearchService } from "../search.js";
 import { createPostService } from "../post.js";
+import { createPathRegistryService } from "../path-registry.js";
 import type { Database } from "../../db/index.js";
 import type BetterSqlite3 from "better-sqlite3";
 
@@ -33,7 +34,7 @@ describe("SearchService", () => {
     const testDb = createTestDatabase({ fts: true });
     db = testDb.db as unknown as Database;
     sqlite = testDb.sqlite;
-    postService = createPostService(db);
+    postService = createPostService(db, createPathRegistryService(db));
   });
 
   it("returns empty results for empty query", async () => {