@jant/core 0.3.26 → 0.3.28

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

@@ -29,7 +29,6 @@ describe("CollectionService", () => {
       expect(collection.description).toBeNull();
       expect(collection.icon).toBeNull();
       expect(collection.sortOrder).toBe("newest");
-      expect(collection.showDivider).toBe(0);
     });
 
     it("creates a collection with all fields", async () => {
@@ -40,7 +39,6 @@ describe("CollectionService", () => {
         icon: "laptop",
         sortOrder: "oldest",
         position: 5,
-        showDivider: true,
       });
 
       expect(collection.slug).toBe("tech");
@@ -49,7 +47,6 @@ describe("CollectionService", () => {
       expect(collection.icon).toBe("laptop");
       expect(collection.sortOrder).toBe("oldest");
       expect(collection.position).toBe(5);
-      expect(collection.showDivider).toBe(1);
     });
 
     it("sets timestamps", async () => {
@@ -214,7 +211,7 @@ describe("CollectionService", () => {
       expect(updated?.icon).toBeNull();
     });
 
-    it("updates icon, sortOrder, position, and showDivider", async () => {
+    it("updates icon, sortOrder, and position", async () => {
       const collection = await collectionService.create({
         slug: "test",
         title: "Test",
@@ -224,13 +221,11 @@ describe("CollectionService", () => {
         icon: "rocket",
         sortOrder: "rating_desc",
         position: 10,
-        showDivider: true,
       });
 
       expect(updated?.icon).toBe("rocket");
       expect(updated?.sortOrder).toBe("rating_desc");
       expect(updated?.position).toBe(10);
-      expect(updated?.showDivider).toBe(1);
     });
 
     it("updates updatedAt timestamp", async () => {
@@ -266,7 +261,7 @@ describe("CollectionService", () => {
       expect(found).toBeNull();
     });
 
-    it("clears collectionId on related posts", async () => {
+    it("removes junction table entries on cascade", async () => {
       const collection = await collectionService.create({
         slug: "test",
         title: "Test",
@@ -274,15 +269,23 @@ describe("CollectionService", () => {
       const post = await postService.create({
         format: "note",
         body: "test post",
-        collectionId: collection.id,
       });
 
+      await collectionService.addPost(collection.id, post.id);
+
+      // Verify association exists
+      const before = await collectionService.getCollectionsByPostId(post.id);
+      expect(before).toHaveLength(1);
+
       await collectionService.delete(collection.id);
 
-      // Post itself should still exist but with null collectionId
+      // Post should still exist
       const found = await postService.getById(post.id);
       expect(found).not.toBeNull();
-      expect(found?.collectionId).toBeNull();
+
+      // Association should be gone (cascade delete)
+      const after = await collectionService.getCollectionsByPostId(post.id);
+      expect(after).toHaveLength(0);
     });
 
     it("returns false for non-existent collection", async () => {
@@ -358,21 +361,13 @@ describe("CollectionService", () => {
         title: "Col 2",
       });
 
-      await postService.create({
-        format: "note",
-        body: "post 1",
-        collectionId: col1.id,
-      });
-      await postService.create({
-        format: "note",
-        body: "post 2",
-        collectionId: col1.id,
-      });
-      await postService.create({
-        format: "note",
-        body: "post 3",
-        collectionId: col2.id,
-      });
+      const p1 = await postService.create({ format: "note", body: "post 1" });
+      const p2 = await postService.create({ format: "note", body: "post 2" });
+      const p3 = await postService.create({ format: "note", body: "post 3" });
+
+      await collectionService.addPost(col1.id, p1.id);
+      await collectionService.addPost(col1.id, p2.id);
+      await collectionService.addPost(col2.id, p3.id);
 
       const counts = await collectionService.getPostCounts();
       expect(counts.get(col1.id)).toBe(2);
@@ -385,15 +380,13 @@ describe("CollectionService", () => {
         title: "Col",
       });
 
-      await postService.create({
+      const p1 = await postService.create({
         format: "note",
         body: "with collection",
-        collectionId: col.id,
-      });
-      await postService.create({
-        format: "note",
-        body: "no collection",
       });
+      await postService.create({ format: "note", body: "no collection" });
+
+      await collectionService.addPost(col.id, p1.id);
 
       const counts = await collectionService.getPostCounts();
       expect(counts.get(col.id)).toBe(1);
@@ -409,14 +402,15 @@ describe("CollectionService", () => {
       const post = await postService.create({
         format: "note",
         body: "will be deleted",
-        collectionId: col.id,
       });
-      await postService.create({
+      const post2 = await postService.create({
         format: "note",
         body: "still alive",
-        collectionId: col.id,
       });
 
+      await collectionService.addPost(col.id, post.id);
+      await collectionService.addPost(col.id, post2.id);
+
       // Soft-delete one post
       await postService.delete(post.id);
 
@@ -424,4 +418,300 @@ describe("CollectionService", () => {
       expect(counts.get(col.id)).toBe(1);
     });
   });
+
+  describe("addPost / removePost", () => {
+    it("adds a post to a collection", async () => {
+      const col = await collectionService.create({
+        slug: "test",
+        title: "Test",
+      });
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      await collectionService.addPost(col.id, post.id);
+
+      const collections = await collectionService.getCollectionsByPostId(
+        post.id,
+      );
+      expect(collections).toHaveLength(1);
+      expect(collections[0]?.id).toBe(col.id);
+    });
+
+    it("does not duplicate on re-add", async () => {
+      const col = await collectionService.create({
+        slug: "test",
+        title: "Test",
+      });
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      await collectionService.addPost(col.id, post.id);
+      await collectionService.addPost(col.id, post.id); // duplicate
+
+      const postIds = await collectionService.getPostIds(col.id);
+      expect(postIds).toHaveLength(1);
+    });
+
+    it("removes a post from a collection", async () => {
+      const col = await collectionService.create({
+        slug: "test",
+        title: "Test",
+      });
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      await collectionService.addPost(col.id, post.id);
+      await collectionService.removePost(col.id, post.id);
+
+      const collections = await collectionService.getCollectionsByPostId(
+        post.id,
+      );
+      expect(collections).toHaveLength(0);
+    });
+  });
+
+  describe("getCollectionsByPostId", () => {
+    it("returns all collections a post belongs to", async () => {
+      const col1 = await collectionService.create({
+        slug: "col1",
+        title: "Col 1",
+        position: 0,
+      });
+      const col2 = await collectionService.create({
+        slug: "col2",
+        title: "Col 2",
+        position: 1,
+      });
+
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      await collectionService.addPost(col1.id, post.id);
+      await collectionService.addPost(col2.id, post.id);
+
+      const collections = await collectionService.getCollectionsByPostId(
+        post.id,
+      );
+      expect(collections).toHaveLength(2);
+      expect(collections[0]?.slug).toBe("col1");
+      expect(collections[1]?.slug).toBe("col2");
+    });
+
+    it("returns empty array for post with no collections", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      const collections = await collectionService.getCollectionsByPostId(
+        post.id,
+      );
+      expect(collections).toHaveLength(0);
+    });
+  });
+
+  describe("getPostIds", () => {
+    it("returns all post IDs in a collection", async () => {
+      const col = await collectionService.create({
+        slug: "test",
+        title: "Test",
+      });
+      const p1 = await postService.create({ format: "note", body: "one" });
+      const p2 = await postService.create({ format: "note", body: "two" });
+
+      await collectionService.addPost(col.id, p1.id);
+      await collectionService.addPost(col.id, p2.id);
+
+      const ids = await collectionService.getPostIds(col.id);
+      expect(ids).toHaveLength(2);
+      expect(ids).toContain(p1.id);
+      expect(ids).toContain(p2.id);
+    });
+  });
+
+  describe("createDivider", () => {
+    it("creates a divider with auto-assigned position", async () => {
+      const divider = await collectionService.createDivider();
+
+      expect(divider.id).toBe(1);
+      expect(divider.position).toBe(0);
+      expect(divider.createdAt).toBeGreaterThan(0);
+      expect(divider.updatedAt).toBeGreaterThan(0);
+    });
+
+    it("assigns position after existing collections", async () => {
+      await collectionService.create({ slug: "a", title: "A" }); // position 0
+      await collectionService.create({ slug: "b", title: "B" }); // position 1
+
+      const divider = await collectionService.createDivider();
+      expect(divider.position).toBe(2);
+    });
+
+    it("assigns position after existing dividers", async () => {
+      const d1 = await collectionService.createDivider(); // position 0
+      const d2 = await collectionService.createDivider(); // position 1
+
+      expect(d1.position).toBe(0);
+      expect(d2.position).toBe(1);
+    });
+
+    it("considers both collections and dividers for position", async () => {
+      await collectionService.create({ slug: "a", title: "A" }); // position 0
+      await collectionService.createDivider(); // position 1
+      await collectionService.create({ slug: "b", title: "B" }); // position 2
+
+      const divider = await collectionService.createDivider();
+      expect(divider.position).toBe(3);
+    });
+  });
+
+  describe("deleteDivider", () => {
+    it("deletes a divider by ID", async () => {
+      const divider = await collectionService.createDivider();
+
+      const result = await collectionService.deleteDivider(divider.id);
+      expect(result).toBe(true);
+
+      const list = await collectionService.listDividers();
+      expect(list).toHaveLength(0);
+    });
+
+    it("returns false for non-existent divider", async () => {
+      const result = await collectionService.deleteDivider(9999);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("listDividers", () => {
+    it("returns empty array when no dividers exist", async () => {
+      const list = await collectionService.listDividers();
+      expect(list).toEqual([]);
+    });
+
+    it("returns dividers ordered by position", async () => {
+      const d1 = await collectionService.createDivider();
+      const d2 = await collectionService.createDivider();
+
+      const list = await collectionService.listDividers();
+      expect(list).toHaveLength(2);
+      expect(list[0]?.id).toBe(d1.id);
+      expect(list[1]?.id).toBe(d2.id);
+    });
+  });
+
+  describe("reorderAll", () => {
+    it("handles mixed prefixed IDs correctly", async () => {
+      const a = await collectionService.create({ slug: "a", title: "A" });
+      const b = await collectionService.create({ slug: "b", title: "B" });
+      const d1 = await collectionService.createDivider();
+
+      // Reorder: divider first, then B, then A
+      await collectionService.reorderAll([
+        `d-${d1.id}`,
+        `c-${b.id}`,
+        `c-${a.id}`,
+      ]);
+
+      const dividers = await collectionService.listDividers();
+      expect(dividers[0]?.position).toBe(0);
+
+      const colB = await collectionService.getById(b.id);
+      const colA = await collectionService.getById(a.id);
+      expect(colB?.position).toBe(1);
+      expect(colA?.position).toBe(2);
+    });
+
+    it("handles empty array", async () => {
+      await collectionService.reorderAll([]);
+      // Should not throw
+      const list = await collectionService.list();
+      expect(list).toEqual([]);
+    });
+
+    it("reflects new order in combined list", async () => {
+      const a = await collectionService.create({ slug: "a", title: "A" });
+      const d1 = await collectionService.createDivider();
+      const b = await collectionService.create({ slug: "b", title: "B" });
+
+      // Put divider between B and A
+      await collectionService.reorderAll([
+        `c-${b.id}`,
+        `d-${d1.id}`,
+        `c-${a.id}`,
+      ]);
+
+      const cols = await collectionService.list();
+      const divs = await collectionService.listDividers();
+
+      // B at position 0, divider at 1, A at 2
+      expect(cols.find((c) => c.id === b.id)?.position).toBe(0);
+      expect(divs[0]?.position).toBe(1);
+      expect(cols.find((c) => c.id === a.id)?.position).toBe(2);
+    });
+  });
+
+  describe("syncPostCollections", () => {
+    it("replaces all collection memberships for a post", async () => {
+      const col1 = await collectionService.create({
+        slug: "col1",
+        title: "Col 1",
+      });
+      const col2 = await collectionService.create({
+        slug: "col2",
+        title: "Col 2",
+      });
+      const col3 = await collectionService.create({
+        slug: "col3",
+        title: "Col 3",
+      });
+
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      // Initially in col1 and col2
+      await collectionService.addPost(col1.id, post.id);
+      await collectionService.addPost(col2.id, post.id);
+
+      // Sync to col2 and col3
+      await collectionService.syncPostCollections(post.id, [col2.id, col3.id]);
+
+      const collections = await collectionService.getCollectionsByPostId(
+        post.id,
+      );
+      const ids = collections.map((c) => c.id);
+      expect(ids).toHaveLength(2);
+      expect(ids).toContain(col2.id);
+      expect(ids).toContain(col3.id);
+      expect(ids).not.toContain(col1.id);
+    });
+
+    it("removes all collections when empty array provided", async () => {
+      const col = await collectionService.create({
+        slug: "test",
+        title: "Test",
+      });
+      const post = await postService.create({
+        format: "note",
+        body: "test",
+      });
+
+      await collectionService.addPost(col.id, post.id);
+      await collectionService.syncPostCollections(post.id, []);
+
+      const collections = await collectionService.getCollectionsByPostId(
+        post.id,
+      );
+      expect(collections).toHaveLength(0);
+    });
+  });
 });

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

@@ -301,7 +301,7 @@ describe("MediaService", () => {
         });
       }
 
-      const list = await mediaService.list(2);
+      const list = await mediaService.list({ limit: 2 });
       expect(list).toHaveLength(2);
     });
   });

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

@@ -92,7 +92,9 @@ describe("PageService", () => {
         type: "page",
         label: "Second",
         url: "/second",
-        pageId: pages.find((p) => p.slug === "second")!.id,
+        pageId: (
+          pages.find((p) => p.slug === "second") as (typeof pages)[number]
+        ).id,
       });
 
       const notInNav = await pageService.listNotInNav();
@@ -103,4 +105,117 @@ describe("PageService", () => {
       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");
+    });
+  });
 });

package/src/services/auth.ts

@@ -0,0 +1,88 @@
+/**
+ * Auth Service
+ *
+ * Handles authentication-related business logic:
+ * password reset token validation, password updates, and session management.
+ */
+
+import { eq, and } from "drizzle-orm";
+import { hashPassword } from "better-auth/crypto";
+import type { Database } from "../db/index.js";
+import { user, account, session } from "../db/schema.js";
+import type { SettingsService } from "./settings.js";
+import { SETTINGS_KEYS } from "../lib/constants.js";
+import { ValidationError, NotFoundError } from "../lib/errors.js";
+
+export interface AuthService {
+  /**
+   * Validate a password reset token against the stored value.
+   *
+   * @param token - The reset token from the URL
+   * @returns true if the token is valid and not expired
+   */
+  validateResetToken(token: string): Promise<boolean>;
+
+  /**
+   * Reset the admin user's password.
+   *
+   * Validates the token, hashes the new password, updates the account,
+   * clears all sessions, and removes the reset token.
+   *
+   * @param token - The reset token (re-validated to prevent TOCTOU)
+   * @param newPassword - The new plaintext password
+   * @throws {ValidationError} if token is invalid or expired
+   * @throws {NotFoundError} if no user account exists
+   */
+  resetPassword(token: string, newPassword: string): Promise<void>;
+}
+
+export function createAuthService(
+  db: Database,
+  settings: SettingsService,
+): AuthService {
+  async function validateResetToken(token: string): Promise<boolean> {
+    const stored = await settings.get(SETTINGS_KEYS.PASSWORD_RESET_TOKEN);
+    if (!stored) return false;
+
+    const separatorIndex = stored.lastIndexOf(":");
+    const storedToken = stored.substring(0, separatorIndex);
+    const expiry = parseInt(stored.substring(separatorIndex + 1), 10);
+    const now = Math.floor(Date.now() / 1000);
+
+    return token === storedToken && now <= expiry;
+  }
+
+  return {
+    validateResetToken,
+
+    async resetPassword(token, newPassword) {
+      const isValid = await validateResetToken(token);
+      if (!isValid) {
+        throw new ValidationError("Invalid or expired reset token");
+      }
+
+      const hashedPw = await hashPassword(newPassword);
+
+      // Get admin user (single-author system)
+      const userResult = await db.select({ id: user.id }).from(user).limit(1);
+      if (!userResult[0]) {
+        throw new NotFoundError("User account");
+      }
+      const userId = userResult[0].id;
+
+      // Update password
+      await db
+        .update(account)
+        .set({ password: hashedPw })
+        .where(
+          and(eq(account.userId, userId), eq(account.providerId, "credential")),
+        );
+
+      // Clear all sessions
+      await db.delete(session).where(eq(session.userId, userId));
+
+      // Remove the reset token
+      await settings.remove(SETTINGS_KEYS.PASSWORD_RESET_TOKEN);
+    },
+  };
+}