@jant/core 0.3.35 → 0.3.37

package/src/services/__tests__/custom-url.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createCustomUrlService } from "../custom-url.js";
+import { createPostService } from "../post.js";
+import type { Database } from "../../db/index.js";
+
+describe("CustomUrlService", () => {
+  let db: Database;
+  let customUrlService: ReturnType<typeof createCustomUrlService>;
+  let postService: ReturnType<typeof createPostService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    customUrlService = createCustomUrlService(db);
+    postService = createPostService(db, { slugIdLength: 5 });
+  });
+
+  describe("create", () => {
+    it("creates a redirect custom URL", async () => {
+      const url = await customUrlService.create({
+        path: "old-page",
+        targetType: "redirect",
+        toPath: "/new-page",
+        redirectType: 301,
+      });
+
+      expect(url.path).toBe("old-page");
+      expect(url.targetType).toBe("redirect");
+      expect(url.toPath).toBe("/new-page");
+      expect(url.redirectType).toBe(301);
+      expect(typeof url.id).toBe("string");
+      expect(typeof url.createdAt).toBe("number");
+    });
+
+    it("creates a post custom URL", async () => {
+      const post = await postService.create({ format: "note" });
+
+      const url = await customUrlService.create({
+        path: "blog/my-post",
+        targetType: "post",
+        targetId: post.id,
+      });
+
+      expect(url.path).toBe("blog/my-post");
+      expect(url.targetType).toBe("post");
+      expect(url.targetId).toBe(post.id);
+    });
+
+    it("rejects reserved paths", async () => {
+      await expect(
+        customUrlService.create({
+          path: "dash",
+          targetType: "redirect",
+          toPath: "/somewhere",
+        }),
+      ).rejects.toThrow("reserved");
+    });
+
+    it("rejects duplicate paths", async () => {
+      await customUrlService.create({
+        path: "my-path",
+        targetType: "redirect",
+        toPath: "/target",
+      });
+
+      await expect(
+        customUrlService.create({
+          path: "my-path",
+          targetType: "redirect",
+          toPath: "/other-target",
+        }),
+      ).rejects.toThrow("already in use");
+    });
+
+    it("rejects paths that conflict with post slugs", async () => {
+      const post = await postService.create({
+        format: "note",
+        slug: "my-slug",
+      });
+
+      await expect(
+        customUrlService.create({
+          path: post.slug,
+          targetType: "redirect",
+          toPath: "/somewhere",
+        }),
+      ).rejects.toThrow("conflicts with an existing post slug");
+    });
+  });
+
+  describe("getByPath", () => {
+    it("returns custom URL by path", async () => {
+      await customUrlService.create({
+        path: "test-path",
+        targetType: "redirect",
+        toPath: "/target",
+        redirectType: 302,
+      });
+
+      const result = await customUrlService.getByPath("test-path");
+      expect(result).not.toBeNull();
+      expect(result?.path).toBe("test-path");
+      expect(result?.redirectType).toBe(302);
+    });
+
+    it("returns null for non-existent path", async () => {
+      const result = await customUrlService.getByPath("nonexistent");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("getByTarget", () => {
+    it("returns custom URL by target", async () => {
+      const post = await postService.create({ format: "note" });
+      await customUrlService.create({
+        path: "custom-path",
+        targetType: "post",
+        targetId: post.id,
+      });
+
+      const result = await customUrlService.getByTarget("post", post.id);
+      expect(result).not.toBeNull();
+      expect(result?.path).toBe("custom-path");
+      expect(result?.targetId).toBe(post.id);
+    });
+
+    it("returns null when no match", async () => {
+      const result = await customUrlService.getByTarget(
+        "post",
+        "nonexistent-id",
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("delete", () => {
+    it("deletes a custom URL", async () => {
+      const url = await customUrlService.create({
+        path: "to-delete",
+        targetType: "redirect",
+        toPath: "/target",
+      });
+
+      const deleted = await customUrlService.delete(url.id);
+      expect(deleted).toBe(true);
+
+      const result = await customUrlService.getByPath("to-delete");
+      expect(result).toBeNull();
+    });
+
+    it("returns false for non-existent ID", async () => {
+      const deleted = await customUrlService.delete("nonexistent-id");
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe("list", () => {
+    it("returns all custom URLs", async () => {
+      await customUrlService.create({
+        path: "path-1",
+        targetType: "redirect",
+        toPath: "/a",
+      });
+      await customUrlService.create({
+        path: "path-2",
+        targetType: "redirect",
+        toPath: "/b",
+      });
+
+      const all = await customUrlService.list();
+      expect(all).toHaveLength(2);
+    });
+
+    it("returns empty array when none exist", async () => {
+      const all = await customUrlService.list();
+      expect(all).toEqual([]);
+    });
+  });
+
+  describe("isPathAvailable", () => {
+    it("returns true for available path", async () => {
+      const available = await customUrlService.isPathAvailable("free-path");
+      expect(available).toBe(true);
+    });
+
+    it("returns false for reserved path", async () => {
+      const available = await customUrlService.isPathAvailable("api");
+      expect(available).toBe(false);
+    });
+
+    it("returns false for existing custom URL path", async () => {
+      await customUrlService.create({
+        path: "taken-path",
+        targetType: "redirect",
+        toPath: "/target",
+      });
+
+      const available = await customUrlService.isPathAvailable("taken-path");
+      expect(available).toBe(false);
+    });
+
+    it("returns false for existing post slug", async () => {
+      const post = await postService.create({
+        format: "note",
+        slug: "post-slug",
+      });
+
+      const available = await customUrlService.isPathAvailable(post.slug);
+      expect(available).toBe(false);
+    });
+  });
+});

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

@@ -3,7 +3,6 @@ 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", () => {
@@ -15,7 +14,7 @@ describe("MediaService", () => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
     mediaService = createMediaService(db);
-    postService = createPostService(db, createPathRegistryService(db));
+    postService = createPostService(db, { slugIdLength: 5 });
   });
 
   const sampleMedia = {
@@ -45,8 +44,19 @@ describe("MediaService", () => {
       expect(media.height).toBe(1080);
       expect(media.postId).toBeNull();
       expect(media.alt).toBeNull();
-      expect(media.position).toBe(0);
+      expect(media.position).toBe("a0");
       expect(media.blurhash).toBeNull();
+      expect(media.posterKey).toBeNull();
+    });
+
+    it("creates media with posterKey", async () => {
+      const media = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/2025/01/video.mp4",
+        posterKey: "media/2025/01/video-poster.webp",
+      });
+
+      expect(media.posterKey).toBe("media/2025/01/video-poster.webp");
     });
 
     it("creates media with optional alt text", async () => {
@@ -75,14 +85,34 @@ describe("MediaService", () => {
     it("creates media with position and blurhash", async () => {
       const media = await mediaService.create({
         ...sampleMedia,
-        position: 3,
+        position: "a3",
         blurhash: "LKO2?U%2Tw=w]~RBVZRi};RPxuwH",
       });
 
-      expect(media.position).toBe(3);
+      expect(media.position).toBe("a3");
       expect(media.blurhash).toBe("LKO2?U%2Tw=w]~RBVZRi};RPxuwH");
     });
 
+    it("appends position when creating media already attached to a post", async () => {
+      const post = await postService.create({
+        format: "note",
+        bodyMarkdown: "test",
+      });
+
+      const media1 = await mediaService.create({
+        ...sampleMedia,
+        postId: post.id,
+      });
+      const media2 = await mediaService.create({
+        ...sampleMedia,
+        postId: post.id,
+        storageKey: "media/2025/01/second.jpg",
+      });
+
+      expect(media1.position).toBe("a0");
+      expect(media2.position).toBe("a1");
+    });
+
     it("generates UUIDv7 IDs", async () => {
       const media1 = await mediaService.create(sampleMedia);
       const media2 = await mediaService.create({
@@ -117,6 +147,46 @@ describe("MediaService", () => {
         /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
       );
     });
+
+    it("rejects non-positive sizes at the database layer", async () => {
+      await expect(
+        mediaService.create({
+          ...sampleMedia,
+          storageKey: "media/2025/01/invalid-size.jpg",
+          size: 0,
+        }),
+      ).rejects.toThrow();
+    });
+
+    it("rejects blank positions at the database layer", async () => {
+      await expect(
+        mediaService.create({
+          ...sampleMedia,
+          storageKey: "media/2025/01/invalid-position.jpg",
+          position: "   ",
+        }),
+      ).rejects.toThrow();
+    });
+
+    it("rejects non-positive dimensions at the database layer", async () => {
+      await expect(
+        mediaService.create({
+          ...sampleMedia,
+          storageKey: "media/2025/01/invalid-dimensions.jpg",
+          width: 0,
+        }),
+      ).rejects.toThrow();
+    });
+
+    it("rejects negative extracted text length at the database layer", async () => {
+      await expect(
+        mediaService.create({
+          ...sampleMedia,
+          storageKey: "media/2025/01/invalid-chars.jpg",
+          chars: -1,
+        }),
+      ).rejects.toThrow();
+    });
   });
 
   describe("getById", () => {
@@ -168,7 +238,7 @@ describe("MediaService", () => {
     it("returns media ordered by position", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const m1 = await mediaService.create({
@@ -185,15 +255,15 @@ describe("MediaService", () => {
       const results = await mediaService.getByPostId(post.id);
       expect(results).toHaveLength(2);
       expect(results[0]!.id).toBe(m2.id);
-      expect(results[0]!.position).toBe(0);
+      expect(results[0]!.position).toBe("a0");
       expect(results[1]!.id).toBe(m1.id);
-      expect(results[1]!.position).toBe(1);
+      expect(results[1]!.position).toBe("a1");
     });
 
     it("returns empty array for post with no media", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const results = await mediaService.getByPostId(post.id);
@@ -205,11 +275,11 @@ describe("MediaService", () => {
     it("returns Map grouped by postId", async () => {
       const post1 = await postService.create({
         format: "note",
-        body: "post 1",
+        bodyMarkdown: "post 1",
       });
       const post2 = await postService.create({
         format: "note",
-        body: "post 2",
+        bodyMarkdown: "post 2",
       });
 
       const m1 = await mediaService.create({
@@ -242,7 +312,7 @@ describe("MediaService", () => {
     it("returns ordered by position within each post", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const m1 = await mediaService.create({
@@ -314,15 +384,37 @@ describe("MediaService", () => {
 
       const found = await mediaService.getByStorageKey(
         "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
+        "r2",
       );
       expect(found).not.toBeNull();
       expect(found?.originalName).toBe("photo.jpg");
     });
 
     it("returns null for non-existent R2 key", async () => {
-      const found = await mediaService.getByStorageKey("nonexistent");
+      const found = await mediaService.getByStorageKey("nonexistent", "r2");
       expect(found).toBeNull();
     });
+
+    it("allows the same storage key on different providers", async () => {
+      await mediaService.create(sampleMedia);
+      await mediaService.create({
+        ...sampleMedia,
+        id: "0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e10",
+        provider: "s3",
+      });
+
+      const r2Media = await mediaService.getByStorageKey(
+        sampleMedia.storageKey,
+        "r2",
+      );
+      const s3Media = await mediaService.getByStorageKey(
+        sampleMedia.storageKey,
+        "s3",
+      );
+
+      expect(r2Media?.provider).toBe("r2");
+      expect(s3Media?.provider).toBe("s3");
+    });
   });
 
   describe("list", () => {
@@ -356,7 +448,7 @@ describe("MediaService", () => {
     it("sets postId and position for each media", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const m1 = await mediaService.create({
@@ -373,15 +465,15 @@ describe("MediaService", () => {
       const attached = await mediaService.getByPostId(post.id);
       expect(attached).toHaveLength(2);
       expect(attached[0]!.id).toBe(m1.id);
-      expect(attached[0]!.position).toBe(0);
+      expect(attached[0]!.position).toBe("a0");
       expect(attached[1]!.id).toBe(m2.id);
-      expect(attached[1]!.position).toBe(1);
+      expect(attached[1]!.position).toBe("a1");
     });
 
     it("replaces existing attachments", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const m1 = await mediaService.create({
@@ -403,18 +495,18 @@ describe("MediaService", () => {
       const attached = await mediaService.getByPostId(post.id);
       expect(attached).toHaveLength(1);
       expect(attached[0]!.id).toBe(m3.id);
-      expect(attached[0]!.position).toBe(0);
+      expect(attached[0]!.position).toBe("a0");
 
       // Verify old media is detached
       const old1 = await mediaService.getById(m1.id);
       expect(old1!.postId).toBeNull();
-      expect(old1!.position).toBe(0);
+      expect(old1!.position).toBe("a0");
     });
 
     it("handles empty array by clearing all attachments", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const m1 = await mediaService.create({
@@ -434,7 +526,7 @@ describe("MediaService", () => {
     it("clears postId and resets position", async () => {
       const post = await postService.create({
         format: "note",
-        body: "test",
+        bodyMarkdown: "test",
       });
 
       const m1 = await mediaService.create({
@@ -450,7 +542,7 @@ describe("MediaService", () => {
 
       const detached = await mediaService.getById(m1.id);
       expect(detached!.postId).toBeNull();
-      expect(detached!.position).toBe(0);
+      expect(detached!.position).toBe("a0");
     });
   });
 
@@ -469,6 +561,27 @@ describe("MediaService", () => {
       const result = await mediaService.delete("nonexistent");
       expect(result).toBe(false);
     });
+
+    it("deletes poster from storage when posterKey exists", async () => {
+      const media = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/2025/01/vid.mp4",
+        posterKey: "media/2025/01/vid-poster.webp",
+      });
+
+      const deletedKeys: string[] = [];
+      const mockStorage = {
+        delete: async (key: string) => {
+          deletedKeys.push(key);
+        },
+        put: async () => {},
+        get: async () => null,
+      };
+
+      await mediaService.delete(media.id, mockStorage as never);
+      expect(deletedKeys).toContain("media/2025/01/vid.mp4");
+      expect(deletedKeys).toContain("media/2025/01/vid-poster.webp");
+    });
   });
 
   describe("deleteByIds", () => {
@@ -500,5 +613,32 @@ describe("MediaService", () => {
 
       expect(await mediaService.getById(m1.id)).not.toBeNull();
     });
+
+    it("deletes poster keys from storage", async () => {
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.mp4",
+        posterKey: "media/a-poster.webp",
+      });
+      const m2 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/b.jpg",
+      });
+
+      const deletedKeys: string[] = [];
+      const mockStorage = {
+        delete: async (key: string) => {
+          deletedKeys.push(key);
+        },
+        put: async () => {},
+        get: async () => null,
+      };
+
+      await mediaService.deleteByIds([m1.id, m2.id], mockStorage as never);
+      expect(deletedKeys).toContain("media/a.mp4");
+      expect(deletedKeys).toContain("media/a-poster.webp");
+      expect(deletedKeys).toContain("media/b.jpg");
+      expect(deletedKeys).toHaveLength(3);
+    });
   });
 });