@jant/core 0.3.36 → 0.3.37

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

@@ -1,298 +0,0 @@
-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;
-    pathRegistry = createPathRegistryService(db);
-    pageService = createPageService(db, pathRegistry);
-    postService = createPostService(db, pathRegistry);
-    navItemService = createNavItemService(db);
-  });
-
-  describe("listNotInNav", () => {
-    it("returns all pages when none are in navigation", async () => {
-      await pageService.create({ slug: "about", title: "About" });
-      await pageService.create({ slug: "contact", title: "Contact" });
-
-      const pages = await pageService.listNotInNav();
-      expect(pages).toHaveLength(2);
-    });
-
-    it("excludes pages that have a nav item", async () => {
-      const aboutPage = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-      await pageService.create({ slug: "contact", title: "Contact" });
-
-      // Add "About" to navigation
-      await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: aboutPage.id,
-      });
-
-      const pages = await pageService.listNotInNav();
-      expect(pages).toHaveLength(1);
-      expect(pages[0]?.slug).toBe("contact");
-    });
-
-    it("returns empty array when all pages are in navigation", async () => {
-      const aboutPage = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-
-      await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: aboutPage.id,
-      });
-
-      const pages = await pageService.listNotInNav();
-      expect(pages).toHaveLength(0);
-    });
-
-    it("returns empty array when no pages exist", async () => {
-      const pages = await pageService.listNotInNav();
-      expect(pages).toHaveLength(0);
-    });
-
-    it("is not affected by link-type nav items (no pageId)", async () => {
-      await pageService.create({ slug: "about", title: "About" });
-
-      // Link-type nav items have no pageId
-      await navItemService.create({
-        type: "link",
-        label: "External",
-        url: "https://example.com",
-      });
-
-      const pages = await pageService.listNotInNav();
-      expect(pages).toHaveLength(1);
-    });
-
-    it("returns multiple pages correctly", async () => {
-      await pageService.create({ slug: "first", title: "First" });
-      await pageService.create({ slug: "second", title: "Second" });
-      await pageService.create({ slug: "third", title: "Third" });
-
-      // Add one to nav
-      const pages = await pageService.list();
-      await navItemService.create({
-        type: "page",
-        label: "Second",
-        url: "/second",
-        pageId: (
-          pages.find((p) => p.slug === "second") as (typeof pages)[number]
-        ).id,
-      });
-
-      const notInNav = await pageService.listNotInNav();
-      expect(notInNav).toHaveLength(2);
-      const slugs = notInNav.map((p) => p.slug);
-      expect(slugs).toContain("first");
-      expect(slugs).toContain("third");
-      expect(slugs).not.toContain("second");
-    });
-  });
-
-  describe("update nav item sync", () => {
-    it("syncs nav item label when page title changes", async () => {
-      const page = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-      await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: page.id,
-      });
-
-      await pageService.update(page.id, { title: "About Us" });
-
-      const navs = await navItemService.list();
-      expect(navs).toHaveLength(1);
-      expect(navs[0]?.label).toBe("About Us");
-    });
-
-    it("syncs nav item url when page slug changes", async () => {
-      const page = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-      await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: page.id,
-      });
-
-      await pageService.update(page.id, { slug: "about-us" });
-
-      const navs = await navItemService.list();
-      expect(navs).toHaveLength(1);
-      expect(navs[0]?.url).toBe("/about-us");
-    });
-
-    it("syncs both label and url when title and slug change together", async () => {
-      const page = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-      await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: page.id,
-      });
-
-      await pageService.update(page.id, {
-        title: "About Our Company",
-        slug: "about-our-company",
-      });
-
-      const navs = await navItemService.list();
-      expect(navs).toHaveLength(1);
-      expect(navs[0]?.label).toBe("About Our Company");
-      expect(navs[0]?.url).toBe("/about-our-company");
-    });
-
-    it("does not change nav item label when title is unchanged", async () => {
-      const page = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-      await navItemService.create({
-        type: "page",
-        label: "Custom Label",
-        url: "/about",
-        pageId: page.id,
-      });
-
-      // Update body only, not title
-      await pageService.update(page.id, { body: "New content" });
-
-      const navs = await navItemService.list();
-      expect(navs[0]?.label).toBe("Custom Label");
-    });
-
-    it("does not affect nav items for other pages", async () => {
-      const page1 = await pageService.create({
-        slug: "about",
-        title: "About",
-      });
-      const page2 = await pageService.create({
-        slug: "contact",
-        title: "Contact",
-      });
-      await navItemService.create({
-        type: "page",
-        label: "About",
-        url: "/about",
-        pageId: page1.id,
-      });
-      await navItemService.create({
-        type: "page",
-        label: "Contact",
-        url: "/contact",
-        pageId: page2.id,
-      });
-
-      await pageService.update(page1.id, { title: "About Us" });
-
-      const navs = await navItemService.list();
-      const aboutNav = navs.find((n) => n.pageId === page1.id);
-      const contactNav = navs.find((n) => n.pageId === page2.id);
-      expect(aboutNav?.label).toBe("About Us");
-      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

@@ -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);
-    });
-  });
-});