@jant/core 0.3.7 → 0.3.9

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

@@ -18,11 +18,11 @@ describe("MediaService", () => {
   });
 
   const sampleMedia = {
-    filename: "image-abc123.jpg",
+    filename: "0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
     originalName: "photo.jpg",
     mimeType: "image/jpeg",
     size: 102400,
-    r2Key: "media/image-abc123.jpg",
+    storageKey: "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
     width: 1920,
     height: 1080,
   };
@@ -32,11 +32,14 @@ describe("MediaService", () => {
       const media = await mediaService.create(sampleMedia);
 
       expect(media.id).toBeTruthy(); // UUIDv7
-      expect(media.filename).toBe("image-abc123.jpg");
+      expect(media.filename).toBe("0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg");
       expect(media.originalName).toBe("photo.jpg");
       expect(media.mimeType).toBe("image/jpeg");
       expect(media.size).toBe(102400);
-      expect(media.r2Key).toBe("media/image-abc123.jpg");
+      expect(media.storageKey).toBe(
+        "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
+      );
+      expect(media.provider).toBe("r2");
       expect(media.width).toBe(1920);
       expect(media.height).toBe(1080);
       expect(media.postId).toBeNull();
@@ -54,6 +57,20 @@ describe("MediaService", () => {
       expect(media.alt).toBe("A beautiful sunset");
     });
 
+    it("defaults provider to 'r2'", async () => {
+      const media = await mediaService.create(sampleMedia);
+      expect(media.provider).toBe("r2");
+    });
+
+    it("accepts provider 's3'", async () => {
+      const media = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/2025/01/s3-upload.jpg",
+        provider: "s3",
+      });
+      expect(media.provider).toBe("s3");
+    });
+
     it("creates media with position and blurhash", async () => {
       const media = await mediaService.create({
         ...sampleMedia,
@@ -69,13 +86,36 @@ describe("MediaService", () => {
       const media1 = await mediaService.create(sampleMedia);
       const media2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/other.jpg",
+        storageKey: "media/2025/01/other.jpg",
       });
 
       expect(media1.id).not.toBe(media2.id);
       // UUIDv7 should be sortable — later ID is lexicographically greater
       expect(media2.id > media1.id).toBe(true);
     });
+
+    it("uses provided id when given", async () => {
+      const customId = "0192a9f1-a2b7-7c3d-8e4f-custom000001";
+      const media = await mediaService.create({
+        ...sampleMedia,
+        id: customId,
+      });
+
+      expect(media.id).toBe(customId);
+    });
+
+    it("auto-generates id when not provided", async () => {
+      const media = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/2025/01/auto.jpg",
+      });
+
+      expect(media.id).toBeTruthy();
+      // UUIDv7 format: 8-4-4-4-12 hex chars
+      expect(media.id).toMatch(
+        /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+      );
+    });
   });
 
   describe("getById", () => {
@@ -84,7 +124,7 @@ describe("MediaService", () => {
 
       const found = await mediaService.getById(created.id);
       expect(found).not.toBeNull();
-      expect(found?.filename).toBe("image-abc123.jpg");
+      expect(found?.filename).toBe("0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg");
     });
 
     it("returns null for non-existent ID", async () => {
@@ -97,11 +137,11 @@ describe("MediaService", () => {
     it("returns media for valid IDs", async () => {
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
       const m2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/b.jpg",
+        storageKey: "media/b.jpg",
       });
 
       const results = await mediaService.getByIds([m1.id, m2.id]);
@@ -132,11 +172,11 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
       const m2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/b.jpg",
+        storageKey: "media/b.jpg",
       });
 
       await mediaService.attachToPost(post.id, [m2.id, m1.id]);
@@ -173,15 +213,15 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
       const m2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/b.jpg",
+        storageKey: "media/b.jpg",
       });
       const m3 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/c.jpg",
+        storageKey: "media/c.jpg",
       });
 
       await mediaService.attachToPost(post1.id, [m1.id, m2.id]);
@@ -206,11 +246,11 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
       const m2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/b.jpg",
+        storageKey: "media/b.jpg",
       });
 
       await mediaService.attachToPost(post.id, [m2.id, m1.id]);
@@ -222,17 +262,19 @@ describe("MediaService", () => {
     });
   });
 
-  describe("getByR2Key", () => {
+  describe("getByStorageKey", () => {
     it("returns media by R2 key", async () => {
       await mediaService.create(sampleMedia);
 
-      const found = await mediaService.getByR2Key("media/image-abc123.jpg");
+      const found = await mediaService.getByStorageKey(
+        "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
+      );
       expect(found).not.toBeNull();
       expect(found?.originalName).toBe("photo.jpg");
     });
 
     it("returns null for non-existent R2 key", async () => {
-      const found = await mediaService.getByR2Key("nonexistent");
+      const found = await mediaService.getByStorageKey("nonexistent");
       expect(found).toBeNull();
     });
   });
@@ -244,8 +286,8 @@ describe("MediaService", () => {
     });
 
     it("returns media ordered by createdAt desc", async () => {
-      await mediaService.create({ ...sampleMedia, r2Key: "a.jpg" });
-      await mediaService.create({ ...sampleMedia, r2Key: "b.jpg" });
+      await mediaService.create({ ...sampleMedia, storageKey: "a.jpg" });
+      await mediaService.create({ ...sampleMedia, storageKey: "b.jpg" });
 
       const list = await mediaService.list();
       expect(list).toHaveLength(2);
@@ -253,7 +295,10 @@ describe("MediaService", () => {
 
     it("respects limit parameter", async () => {
       for (let i = 0; i < 5; i++) {
-        await mediaService.create({ ...sampleMedia, r2Key: `img${i}.jpg` });
+        await mediaService.create({
+          ...sampleMedia,
+          storageKey: `img${i}.jpg`,
+        });
       }
 
       const list = await mediaService.list(2);
@@ -270,11 +315,11 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
       const m2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/b.jpg",
+        storageKey: "media/b.jpg",
       });
 
       await mediaService.attachToPost(post.id, [m1.id, m2.id]);
@@ -295,15 +340,15 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
       const m2 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/b.jpg",
+        storageKey: "media/b.jpg",
       });
       const m3 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/c.jpg",
+        storageKey: "media/c.jpg",
       });
 
       await mediaService.attachToPost(post.id, [m1.id, m2.id]);
@@ -328,7 +373,7 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
 
       await mediaService.attachToPost(post.id, [m1.id]);
@@ -348,7 +393,7 @@ describe("MediaService", () => {
 
       const m1 = await mediaService.create({
         ...sampleMedia,
-        r2Key: "media/a.jpg",
+        storageKey: "media/a.jpg",
       });
 
       await mediaService.attachToPost(post.id, [m1.id]);

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

@@ -0,0 +1,213 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createNavigationLinkService } from "../navigation.js";
+import type { Database } from "../../db/index.js";
+
+describe("NavigationLinkService", () => {
+  let db: Database;
+  let navigationService: ReturnType<typeof createNavigationLinkService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    navigationService = createNavigationLinkService(db);
+  });
+
+  describe("create", () => {
+    it("creates a navigation link with auto-assigned position", async () => {
+      const link = await navigationService.create({
+        label: "Home",
+        url: "/",
+      });
+
+      expect(link.label).toBe("Home");
+      expect(link.url).toBe("/");
+      expect(link.position).toBe(0);
+      expect(link.id).toBe(1);
+    });
+
+    it("auto-increments position for subsequent links", async () => {
+      await navigationService.create({ label: "Home", url: "/" });
+      const second = await navigationService.create({
+        label: "Archive",
+        url: "/archive",
+      });
+
+      expect(second.position).toBe(1);
+    });
+
+    it("uses provided position when specified", async () => {
+      const link = await navigationService.create({
+        label: "Home",
+        url: "/",
+        position: 5,
+      });
+
+      expect(link.position).toBe(5);
+    });
+  });
+
+  describe("getById", () => {
+    it("returns a link by ID", async () => {
+      const created = await navigationService.create({
+        label: "Home",
+        url: "/",
+      });
+
+      const found = await navigationService.getById(created.id);
+      expect(found).not.toBeNull();
+      expect(found?.label).toBe("Home");
+    });
+
+    it("returns null for non-existent ID", async () => {
+      const found = await navigationService.getById(9999);
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("list", () => {
+    it("returns empty array when no links exist", async () => {
+      const links = await navigationService.list();
+      expect(links).toEqual([]);
+    });
+
+    it("returns links ordered by position", async () => {
+      await navigationService.create({
+        label: "C",
+        url: "/c",
+        position: 2,
+      });
+      await navigationService.create({
+        label: "A",
+        url: "/a",
+        position: 0,
+      });
+      await navigationService.create({
+        label: "B",
+        url: "/b",
+        position: 1,
+      });
+
+      const links = await navigationService.list();
+      expect(links).toHaveLength(3);
+      expect(links[0]?.label).toBe("A");
+      expect(links[1]?.label).toBe("B");
+      expect(links[2]?.label).toBe("C");
+    });
+  });
+
+  describe("update", () => {
+    it("updates a link's label", async () => {
+      const created = await navigationService.create({
+        label: "Home",
+        url: "/",
+      });
+
+      const updated = await navigationService.update(created.id, {
+        label: "Main Page",
+      });
+
+      expect(updated?.label).toBe("Main Page");
+      expect(updated?.url).toBe("/");
+    });
+
+    it("updates a link's url", async () => {
+      const created = await navigationService.create({
+        label: "Blog",
+        url: "/blog",
+      });
+
+      const updated = await navigationService.update(created.id, {
+        url: "/posts",
+      });
+
+      expect(updated?.url).toBe("/posts");
+      expect(updated?.label).toBe("Blog");
+    });
+
+    it("returns null for non-existent ID", async () => {
+      const result = await navigationService.update(9999, { label: "Nope" });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("delete", () => {
+    it("deletes a link by ID", async () => {
+      const link = await navigationService.create({
+        label: "Home",
+        url: "/",
+      });
+      const result = await navigationService.delete(link.id);
+
+      expect(result).toBe(true);
+
+      const found = await navigationService.getById(link.id);
+      expect(found).toBeNull();
+    });
+
+    it("returns false for non-existent ID", async () => {
+      const result = await navigationService.delete(9999);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("reorder", () => {
+    it("updates positions to match array order", async () => {
+      const a = await navigationService.create({
+        label: "A",
+        url: "/a",
+      });
+      const b = await navigationService.create({
+        label: "B",
+        url: "/b",
+      });
+      const c = await navigationService.create({
+        label: "C",
+        url: "/c",
+      });
+
+      // Reverse the order
+      await navigationService.reorder([c.id, b.id, a.id]);
+
+      const links = await navigationService.list();
+      expect(links[0]?.label).toBe("C");
+      expect(links[0]?.position).toBe(0);
+      expect(links[1]?.label).toBe("B");
+      expect(links[1]?.position).toBe(1);
+      expect(links[2]?.label).toBe("A");
+      expect(links[2]?.position).toBe(2);
+    });
+  });
+
+  describe("ensureDefaults", () => {
+    it("creates default links when table is empty", async () => {
+      const links = await navigationService.ensureDefaults();
+
+      expect(links).toHaveLength(3);
+      expect(links[0]?.label).toBe("Home");
+      expect(links[0]?.url).toBe("/");
+      expect(links[1]?.label).toBe("Archive");
+      expect(links[1]?.url).toBe("/archive");
+      expect(links[2]?.label).toBe("RSS");
+      expect(links[2]?.url).toBe("/feed");
+    });
+
+    it("returns existing links without creating new ones", async () => {
+      await navigationService.create({ label: "Custom", url: "/custom" });
+
+      const links = await navigationService.ensureDefaults();
+
+      expect(links).toHaveLength(1);
+      expect(links[0]?.label).toBe("Custom");
+    });
+
+    it("is idempotent - calling twice returns same result", async () => {
+      const first = await navigationService.ensureDefaults();
+      const second = await navigationService.ensureDefaults();
+
+      expect(first).toHaveLength(3);
+      expect(second).toHaveLength(3);
+      expect(first[0]?.id).toBe(second[0]?.id);
+    });
+  });
+});

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

@@ -0,0 +1,220 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createPostService } from "../post.js";
+import type { Database } from "../../db/index.js";
+
+describe("PostService - Timeline features", () => {
+  let db: Database;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    postService = createPostService(db);
+  });
+
+  describe("excludeTypes filter", () => {
+    it("excludes posts of specified types", async () => {
+      await postService.create({ type: "note", content: "a note" });
+      await postService.create({ type: "page", content: "a page" });
+      await postService.create({
+        type: "article",
+        content: "an article",
+        title: "Article",
+      });
+
+      const posts = await postService.list({ excludeTypes: ["page"] });
+      expect(posts).toHaveLength(2);
+      expect(posts.every((p) => p.type !== "page")).toBe(true);
+    });
+
+    it("excludes multiple types", async () => {
+      await postService.create({ type: "note", content: "a note" });
+      await postService.create({ type: "page", content: "a page" });
+      await postService.create({
+        type: "article",
+        content: "an article",
+        title: "Article",
+      });
+      await postService.create({
+        type: "link",
+        content: "a link",
+        sourceUrl: "https://example.com",
+      });
+
+      const posts = await postService.list({
+        excludeTypes: ["page", "link"],
+      });
+      expect(posts).toHaveLength(2);
+      expect(posts.every((p) => p.type !== "page" && p.type !== "link")).toBe(
+        true,
+      );
+    });
+
+    it("returns all posts when excludeTypes is empty", async () => {
+      await postService.create({ type: "note", content: "a note" });
+      await postService.create({ type: "page", content: "a page" });
+
+      const posts = await postService.list({ excludeTypes: [] });
+      expect(posts).toHaveLength(2);
+    });
+
+    it("works combined with other filters", async () => {
+      await postService.create({
+        type: "note",
+        content: "featured note",
+        visibility: "featured",
+      });
+      await postService.create({
+        type: "page",
+        content: "featured page",
+        visibility: "featured",
+      });
+      await postService.create({
+        type: "note",
+        content: "draft note",
+        visibility: "draft",
+      });
+
+      const posts = await postService.list({
+        excludeTypes: ["page"],
+        visibility: "featured",
+      });
+      expect(posts).toHaveLength(1);
+      expect(posts[0]?.type).toBe("note");
+      expect(posts[0]?.visibility).toBe("featured");
+    });
+  });
+
+  describe("getThreadPreviews", () => {
+    it("returns empty map for empty input", async () => {
+      const previews = await postService.getThreadPreviews([]);
+      expect(previews.size).toBe(0);
+    });
+
+    it("returns preview replies for a thread root", async () => {
+      const root = await postService.create({
+        type: "note",
+        content: "root",
+      });
+      await postService.create({
+        type: "note",
+        content: "reply 1",
+        replyToId: root.id,
+      });
+      await postService.create({
+        type: "note",
+        content: "reply 2",
+        replyToId: root.id,
+      });
+
+      const previews = await postService.getThreadPreviews([root.id]);
+      const replies = previews.get(root.id);
+      expect(replies).toBeDefined();
+      expect(replies).toHaveLength(2);
+      expect(replies?.[0]?.content).toBe("reply 1");
+      expect(replies?.[1]?.content).toBe("reply 2");
+    });
+
+    it("limits preview replies to previewCount", async () => {
+      const root = await postService.create({
+        type: "note",
+        content: "root",
+      });
+      for (let i = 0; i < 5; i++) {
+        await postService.create({
+          type: "note",
+          content: `reply ${i}`,
+          replyToId: root.id,
+        });
+      }
+
+      const previews = await postService.getThreadPreviews([root.id], 2);
+      const replies = previews.get(root.id);
+      expect(replies).toHaveLength(2);
+      expect(replies?.[0]?.content).toBe("reply 0");
+      expect(replies?.[1]?.content).toBe("reply 1");
+    });
+
+    it("defaults to 3 preview replies", async () => {
+      const root = await postService.create({
+        type: "note",
+        content: "root",
+      });
+      for (let i = 0; i < 5; i++) {
+        await postService.create({
+          type: "note",
+          content: `reply ${i}`,
+          replyToId: root.id,
+        });
+      }
+
+      const previews = await postService.getThreadPreviews([root.id]);
+      const replies = previews.get(root.id);
+      expect(replies).toHaveLength(3);
+    });
+
+    it("handles multiple thread roots", async () => {
+      const root1 = await postService.create({
+        type: "note",
+        content: "root 1",
+      });
+      const root2 = await postService.create({
+        type: "note",
+        content: "root 2",
+      });
+      await postService.create({
+        type: "note",
+        content: "reply to root 1",
+        replyToId: root1.id,
+      });
+      await postService.create({
+        type: "note",
+        content: "reply to root 2",
+        replyToId: root2.id,
+      });
+
+      const previews = await postService.getThreadPreviews([
+        root1.id,
+        root2.id,
+      ]);
+      expect(previews.size).toBe(2);
+      expect(previews.get(root1.id)).toHaveLength(1);
+      expect(previews.get(root2.id)).toHaveLength(1);
+    });
+
+    it("excludes deleted replies", async () => {
+      const root = await postService.create({
+        type: "note",
+        content: "root",
+      });
+      const reply1 = await postService.create({
+        type: "note",
+        content: "reply 1",
+        replyToId: root.id,
+      });
+      await postService.create({
+        type: "note",
+        content: "reply 2",
+        replyToId: root.id,
+      });
+
+      await postService.delete(reply1.id);
+
+      const previews = await postService.getThreadPreviews([root.id]);
+      const replies = previews.get(root.id);
+      expect(replies).toHaveLength(1);
+      expect(replies?.[0]?.content).toBe("reply 2");
+    });
+
+    it("returns empty for roots with no replies", async () => {
+      const root = await postService.create({
+        type: "note",
+        content: "root with no replies",
+      });
+
+      const previews = await postService.getThreadPreviews([root.id]);
+      expect(previews.get(root.id)).toBeUndefined();
+    });
+  });
+});