@jant/core 0.3.38 → 0.3.39

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

@@ -1,9 +1,46 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion -- Test assertions use ! for readability */
-import { describe, it, expect, beforeEach } from "vitest";
-import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
 import { createMediaService } from "../media.js";
 import { createPostService } from "../post.js";
 import type { Database } from "../../db/index.js";
+import { MediaQuotaExceededError } from "../../lib/errors.js";
+
+function createMockStorage() {
+  const files = new Map<string, { body: Uint8Array; contentType?: string }>();
+
+  return {
+    files,
+    async put(
+      key: string,
+      body: Uint8Array | ReadableStream,
+      opts?: { contentType?: string },
+    ) {
+      const bytes =
+        body instanceof Uint8Array
+          ? body
+          : new Uint8Array(await new Response(body).arrayBuffer());
+      files.set(key, {
+        body: bytes,
+        contentType: opts?.contentType,
+      });
+    },
+    async get(key: string) {
+      const file = files.get(key);
+      if (!file) return null;
+      return {
+        body: new Response(file.body).body as ReadableStream,
+        contentType: file.contentType,
+      };
+    },
+    async delete(key: string) {
+      files.delete(key);
+    },
+  };
+}
 
 describe("MediaService", () => {
   let db: Database;
@@ -13,8 +50,12 @@ describe("MediaService", () => {
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    mediaService = createMediaService(db);
-    postService = createPostService(db, { slugIdLength: 5 });
+    mediaService = createMediaService(db, DEFAULT_TEST_SITE_ID);
+    postService = createPostService(
+      db,
+      { slugIdLength: 5 },
+      DEFAULT_TEST_SITE_ID,
+    );
   });
 
   const sampleMedia = {
@@ -22,22 +63,87 @@ describe("MediaService", () => {
     originalName: "photo.jpg",
     mimeType: "image/jpeg",
     size: 102400,
-    storageKey: "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
+    storageKey: "media/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
     width: 1920,
     height: 1080,
   };
 
+  describe("assertCanWriteBytes", () => {
+    it("is a no-op when hosted quota enforcement is disabled", async () => {
+      await expect(
+        mediaService.assertCanWriteBytes(1024),
+      ).resolves.toBeUndefined();
+    });
+
+    it("delegates hosted quota checks to the control plane when enabled", async () => {
+      const checkMediaWriteQuota = vi.fn(async () => ({
+        allowed: true,
+        limitBytes: 50_000,
+        remainingBytes: 40_000,
+        usedBytes: 10_000,
+      }));
+      const hostedQuotaService = createMediaService(
+        db,
+        DEFAULT_TEST_SITE_ID,
+        undefined,
+        undefined,
+        {
+          enforceHostedQuota: true,
+          hostedControlPlane: {
+            checkMediaWriteQuota,
+            async syncSiteMetadata() {},
+          },
+        },
+      );
+
+      await expect(
+        hostedQuotaService.assertCanWriteBytes(2048),
+      ).resolves.toBeUndefined();
+      expect(checkMediaWriteQuota).toHaveBeenCalledWith({
+        additionalBytes: 2048,
+        coreSiteId: DEFAULT_TEST_SITE_ID,
+      });
+    });
+
+    it("throws when a hosted upload would exceed the shared quota", async () => {
+      const hostedQuotaService = createMediaService(
+        db,
+        DEFAULT_TEST_SITE_ID,
+        undefined,
+        undefined,
+        {
+          enforceHostedQuota: true,
+          hostedControlPlane: {
+            async checkMediaWriteQuota() {
+              return {
+                allowed: false,
+                limitBytes: 50_000,
+                remainingBytes: 0,
+                usedBytes: 50_000,
+              };
+            },
+            async syncSiteMetadata() {},
+          },
+        },
+      );
+
+      await expect(
+        hostedQuotaService.assertCanWriteBytes(2048),
+      ).rejects.toBeInstanceOf(MediaQuotaExceededError);
+    });
+  });
+
   describe("create", () => {
     it("creates a media record with all fields", async () => {
       const media = await mediaService.create(sampleMedia);
 
-      expect(media.id).toBeTruthy(); // UUIDv7
+      expect(media.id).toBeTruthy(); // TypeID
       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.storageKey).toBe(
-        "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
+        "media/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
       );
       expect(media.provider).toBe("r2");
       expect(media.width).toBe(1920);
@@ -52,11 +158,11 @@ describe("MediaService", () => {
     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",
+        storageKey: "media/video.mp4",
+        posterKey: "media/video.poster.webp",
       });
 
-      expect(media.posterKey).toBe("media/2025/01/video-poster.webp");
+      expect(media.posterKey).toBe("media/video.poster.webp");
     });
 
     it("creates media with optional alt text", async () => {
@@ -76,12 +182,34 @@ describe("MediaService", () => {
     it("accepts provider 's3'", async () => {
       const media = await mediaService.create({
         ...sampleMedia,
-        storageKey: "media/2025/01/s3-upload.jpg",
+        storageKey: "media/s3-upload.jpg",
         provider: "s3",
       });
       expect(media.provider).toBe("s3");
     });
 
+    it("rejects unsupported storage providers", async () => {
+      await expect(
+        mediaService.create({
+          ...sampleMedia,
+          storageKey: "media/bad-provider.jpg",
+          provider: "gcs" as never,
+        }),
+      ).rejects.toThrow("Storage provider must be r2, s3, or local.");
+    });
+
+    it("rejects unsupported media kinds", async () => {
+      await expect(
+        mediaService.create({
+          ...sampleMedia,
+          storageKey: "media/bad-kind.jpg",
+          mediaKind: "binary" as never,
+        }),
+      ).rejects.toThrow(
+        "Media kind must be image, video, audio, text, or document.",
+      );
+    });
+
     it("creates media with position and blurhash", async () => {
       const media = await mediaService.create({
         ...sampleMedia,
@@ -106,27 +234,27 @@ describe("MediaService", () => {
       const media2 = await mediaService.create({
         ...sampleMedia,
         postId: post.id,
-        storageKey: "media/2025/01/second.jpg",
+        storageKey: "media/second.jpg",
       });
 
       expect(media1.position).toBe("a0");
       expect(media2.position).toBe("a1");
     });
 
-    it("generates UUIDv7 IDs", async () => {
+    it("generates sortable TypeIDs", async () => {
       const media1 = await mediaService.create(sampleMedia);
       const media2 = await mediaService.create({
         ...sampleMedia,
-        storageKey: "media/2025/01/other.jpg",
+        storageKey: "media/other.jpg",
       });
 
       expect(media1.id).not.toBe(media2.id);
-      // UUIDv7 should be sortable — later ID is lexicographically greater
+      // TypeIDs remain lexicographically sortable because they preserve time ordering.
       expect(media2.id > media1.id).toBe(true);
     });
 
     it("uses provided id when given", async () => {
-      const customId = "0192a9f1-a2b7-7c3d-8e4f-custom000001";
+      const customId = "med_01jpyxdk1m7w4v8s2r5c9b3qfh";
       const media = await mediaService.create({
         ...sampleMedia,
         id: customId,
@@ -138,21 +266,18 @@ describe("MediaService", () => {
     it("auto-generates id when not provided", async () => {
       const media = await mediaService.create({
         ...sampleMedia,
-        storageKey: "media/2025/01/auto.jpg",
+        storageKey: "media/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}$/,
-      );
+      expect(media.id).toMatch(/^med_[a-z0-9]{26}$/);
     });
 
     it("rejects non-positive sizes at the database layer", async () => {
       await expect(
         mediaService.create({
           ...sampleMedia,
-          storageKey: "media/2025/01/invalid-size.jpg",
+          storageKey: "media/invalid-size.jpg",
           size: 0,
         }),
       ).rejects.toThrow();
@@ -162,7 +287,7 @@ describe("MediaService", () => {
       await expect(
         mediaService.create({
           ...sampleMedia,
-          storageKey: "media/2025/01/invalid-position.jpg",
+          storageKey: "media/invalid-position.jpg",
           position: "   ",
         }),
       ).rejects.toThrow();
@@ -172,7 +297,7 @@ describe("MediaService", () => {
       await expect(
         mediaService.create({
           ...sampleMedia,
-          storageKey: "media/2025/01/invalid-dimensions.jpg",
+          storageKey: "media/invalid-dimensions.jpg",
           width: 0,
         }),
       ).rejects.toThrow();
@@ -182,13 +307,79 @@ describe("MediaService", () => {
       await expect(
         mediaService.create({
           ...sampleMedia,
-          storageKey: "media/2025/01/invalid-chars.jpg",
+          storageKey: "media/invalid-chars.jpg",
           chars: -1,
         }),
       ).rejects.toThrow();
     });
   });
 
+  describe("createTextAttachment", () => {
+    it("stores markdown text attachments as TipTap-backed text media", async () => {
+      const storage = createMockStorage();
+
+      const media = await mediaService.createTextAttachment(
+        {
+          contentFormat: "markdown",
+          content: "# Heading\n\nBody text",
+        },
+        {
+          storage,
+          storageDriver: "local",
+          maxFileSizeMB: 1,
+        },
+      );
+
+      expect(media.mimeType).toBe("text/x-tiptap+json");
+      expect(media.provider).toBe("local");
+      expect(media.summary).toBe("Heading Body text");
+      expect(media.chars).toBe(17);
+      expect(storage.files.get(media.storageKey)?.contentType).toBe(
+        "text/x-tiptap+json",
+      );
+    });
+  });
+
+  describe("getTextAttachmentContent", () => {
+    it("returns markdown content for TipTap-backed text attachments", async () => {
+      const storage = createMockStorage();
+      const media = await mediaService.createTextAttachment(
+        {
+          contentFormat: "markdown",
+          content: "# Heading\n\nBody text",
+        },
+        {
+          storage,
+          storageDriver: "local",
+          maxFileSizeMB: 1,
+        },
+      );
+
+      const content = await mediaService.getTextAttachmentContent(
+        media.id,
+        storage,
+      );
+
+      expect(content).toEqual({
+        id: media.id,
+        type: "text",
+        contentFormat: "markdown",
+        content: "# Heading\n\nBody text",
+        summary: "Heading Body text",
+        chars: 17,
+      });
+    });
+
+    it("returns null for non-text attachments", async () => {
+      const media = await mediaService.create(sampleMedia);
+      const storage = createMockStorage();
+
+      await expect(
+        mediaService.getTextAttachmentContent(media.id, storage),
+      ).resolves.toBeNull();
+    });
+  });
+
   describe("getById", () => {
     it("returns media by ID", async () => {
       const created = await mediaService.create(sampleMedia);
@@ -356,7 +547,7 @@ describe("MediaService", () => {
     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",
+        "at most 20 attachments",
       );
     });
 
@@ -368,13 +559,13 @@ describe("MediaService", () => {
 
       await expect(
         mediaService.validateIds([m1.id, "nonexistent-id"]),
-      ).rejects.toThrow("media IDs are invalid");
+      ).rejects.toThrow("invalid media IDs");
     });
 
     it("throws ValidationError for all nonexistent IDs", async () => {
       await expect(
         mediaService.validateIds(["fake-1", "fake-2"]),
-      ).rejects.toThrow("media IDs are invalid");
+      ).rejects.toThrow("invalid media IDs");
     });
   });
 
@@ -383,7 +574,7 @@ describe("MediaService", () => {
       await mediaService.create(sampleMedia);
 
       const found = await mediaService.getByStorageKey(
-        "media/2025/01/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
+        "media/0192a9f1-a2b7-7c3d-8e4f-5a6b7c8d9e0f.jpg",
         "r2",
       );
       expect(found).not.toBeNull();
@@ -520,6 +711,38 @@ describe("MediaService", () => {
       const attached = await mediaService.getByPostId(post.id);
       expect(attached).toHaveLength(0);
     });
+
+    it("does not call transaction() when reordering attachments on sqlite-family backends", async () => {
+      const post = await postService.create({
+        format: "note",
+        bodyMarkdown: "test",
+      });
+
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/sqlite-a.jpg",
+      });
+      const m2 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/sqlite-b.jpg",
+      });
+
+      const dbWithoutTransaction = db as Database & {
+        transaction: () => Promise<never>;
+      };
+      const originalTransaction = dbWithoutTransaction.transaction.bind(db);
+      dbWithoutTransaction.transaction = async () => {
+        throw new Error("sqlite attachToPost() should not call transaction()");
+      };
+
+      try {
+        await expect(
+          mediaService.attachToPost(post.id, [m1.id, m2.id]),
+        ).resolves.toBeUndefined();
+      } finally {
+        dbWithoutTransaction.transaction = originalTransaction;
+      }
+    });
   });
 
   describe("detachFromPost", () => {
@@ -565,8 +788,8 @@ describe("MediaService", () => {
     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",
+        storageKey: "media/vid.mp4",
+        posterKey: "media/vid.poster.webp",
       });
 
       const deletedKeys: string[] = [];
@@ -579,8 +802,8 @@ describe("MediaService", () => {
       };
 
       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");
+      expect(deletedKeys).toContain("media/vid.mp4");
+      expect(deletedKeys).toContain("media/vid.poster.webp");
     });
   });
 

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

@@ -1,5 +1,8 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
 import { createNavItemService } from "../navigation.js";
 import type { Database } from "../../db/index.js";
 
@@ -10,7 +13,7 @@ describe("NavItemService", () => {
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    navItemService = createNavItemService(db);
+    navItemService = createNavItemService(db, DEFAULT_TEST_SITE_ID);
   });
 
   describe("create", () => {
@@ -84,6 +87,73 @@ describe("NavItemService", () => {
       expect(item.updatedAt).toBeGreaterThan(0);
       expect(item.createdAt).toBe(item.updatedAt);
     });
+
+    it("derives built-in system label and url from systemKey", async () => {
+      const item = await navItemService.create({
+        type: "system",
+        systemKey: "settings",
+      });
+
+      expect(item.type).toBe("system");
+      expect(item.systemKey).toBe("settings");
+      expect(item.label).toBe("Settings");
+      expect(item.url).toBe("/settings");
+    });
+
+    it("rejects duplicate built-in system items", async () => {
+      await navItemService.create({
+        type: "system",
+        systemKey: "archive",
+      });
+
+      await expect(
+        navItemService.create({
+          type: "system",
+          systemKey: "archive",
+        }),
+      ).rejects.toThrow("Built-in navigation item already exists");
+    });
+  });
+
+  describe("ensureSystemDefaults", () => {
+    it("creates the four default system items once", async () => {
+      const created = await navItemService.ensureSystemDefaults();
+
+      expect(created).toHaveLength(4);
+      expect(created.map((item) => item.systemKey)).toEqual([
+        "collections",
+        "archive",
+        "rss",
+        "settings",
+      ]);
+    });
+
+    it("creates only missing default system items", async () => {
+      await navItemService.create({
+        type: "system",
+        systemKey: "archive",
+      });
+
+      const created = await navItemService.ensureSystemDefaults();
+      const items = await navItemService.list();
+
+      expect(created.map((item) => item.systemKey)).toEqual([
+        "collections",
+        "rss",
+        "settings",
+      ]);
+      expect(items.filter((item) => item.type === "system")).toHaveLength(4);
+    });
+
+    it("is idempotent when defaults already exist", async () => {
+      await navItemService.ensureSystemDefaults();
+
+      const created = await navItemService.ensureSystemDefaults();
+      const items = await navItemService.list();
+
+      expect(created).toEqual([]);
+      expect(items.filter((item) => item.type === "system")).toHaveLength(4);
+    });
   });
 
   describe("getById", () => {
@@ -149,14 +219,14 @@ describe("NavItemService", () => {
       });
       await navItemService.create({
         type: "system",
-        label: "Settings",
-        url: "/settings",
+        systemKey: "settings",
       });
 
       const items = await navItemService.list();
       expect(items).toHaveLength(2);
       expect(items[0]?.type).toBe("link");
       expect(items[1]?.type).toBe("system");
+      expect(items[1]?.systemKey).toBe("settings");
     });
   });
 
@@ -213,6 +283,21 @@ describe("NavItemService", () => {
       );
       expect(result).toBeNull();
     });
+
+    it("rejects label changes for built-in system items", async () => {
+      const created = await navItemService.create({
+        type: "system",
+        systemKey: "archive",
+      });
+
+      await expect(
+        navItemService.update(created.id, {
+          label: "Everything",
+        }),
+      ).rejects.toThrow(
+        "Built-in navigation labels and URLs are managed automatically",
+      );
+    });
   });
 
   describe("delete", () => {