@jant/core 0.6.7 → 0.6.9

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

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion -- Test assertions use ! for readability */
 import { describe, it, expect, beforeEach, vi } from "vitest";
+import { eq } from "drizzle-orm";
 import {
   createTestDatabase,
   DEFAULT_TEST_SITE_ID,
@@ -7,7 +8,9 @@ import {
 import { createMediaService } from "../media.js";
 import { createPostService } from "../post.js";
 import type { Database } from "../../db/index.js";
+import { storagePurge } from "../../db/schema.js";
 import { MediaQuotaExceededError } from "../../lib/errors.js";
+import { now } from "../../lib/time.js";
 
 interface MockStorageFile {
   body: Uint8Array;
@@ -54,9 +57,21 @@ function createMockStorage() {
     async delete(key: string) {
       files.delete(key);
     },
+    async copy(sourceKey: string, destKey: string) {
+      const file = files.get(sourceKey);
+      if (file) files.set(destKey, { ...file });
+    },
   };
 }
 
+/** Storage mock without server-side copy (e.g. R2 Workers binding). */
+function createNoCopyStorage() {
+  const full = createMockStorage();
+  const { copy: _copy, ...rest } = full;
+  void _copy;
+  return rest;
+}
+
 describe("MediaService", () => {
   let db: Database;
   let mediaService: ReturnType<typeof createMediaService>;
@@ -503,7 +518,7 @@ describe("MediaService", () => {
   });
 
   describe("delete for text attachments", () => {
-    it("removes the single .md storage object", async () => {
+    it("moves the .md object to trash and frees the original key", async () => {
       const storage = createMockStorage();
       const media = await mediaService.createTextAttachment(
         {
@@ -521,13 +536,18 @@ describe("MediaService", () => {
 
       await mediaService.delete(media.id, storage);
 
-      expect(storage.files.size).toBe(0);
+      // Row gone and the original (public) key freed immediately; the bytes
+      // live on under a trash/ key, recoverable until purge.
+      expect(await mediaService.getById(media.id)).toBeNull();
       expect(storage.files.has(media.storageKey)).toBe(false);
+      expect(
+        [...storage.files.keys()].some((k) => k.startsWith("trash/")),
+      ).toBe(true);
     });
   });
 
   describe("deleteByIds for text attachments", () => {
-    it("removes the .md file for every text attachment in the batch", async () => {
+    it("moves every .md object in the batch to trash", async () => {
       const storage = createMockStorage();
       const a = await mediaService.createTextAttachment(
         { contentFormat: "markdown", content: "first" },
@@ -542,7 +562,14 @@ describe("MediaService", () => {
 
       await mediaService.deleteByIds([a.id, b.id], storage);
 
-      expect(storage.files.size).toBe(0);
+      expect(await mediaService.getById(a.id)).toBeNull();
+      expect(await mediaService.getById(b.id)).toBeNull();
+      // Originals freed; two trash copies remain until the purge sweep.
+      expect(storage.files.has(a.storageKey)).toBe(false);
+      expect(storage.files.has(b.storageKey)).toBe(false);
+      expect(
+        [...storage.files.keys()].filter((k) => k.startsWith("trash/")).length,
+      ).toBe(2);
     });
   });
 
@@ -961,6 +988,112 @@ describe("MediaService", () => {
     });
   });
 
+  describe("listOrphanedMediaIds", () => {
+    it("returns unattached media created before the cutoff", async () => {
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.jpg",
+      });
+      const m2 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/b.jpg",
+      });
+
+      const ids = await mediaService.listOrphanedMediaIds({
+        before: now() + 1,
+        limit: 10,
+      });
+
+      expect(ids).toHaveLength(2);
+      expect(ids).toContain(m1.id);
+      expect(ids).toContain(m2.id);
+    });
+
+    it("excludes media attached to a post", async () => {
+      const post = await postService.create({
+        format: "note",
+        bodyMarkdown: "p",
+      });
+      const attached = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.jpg",
+      });
+      const orphan = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/b.jpg",
+      });
+      await mediaService.attachToPost(post.id, [attached.id]);
+
+      const ids = await mediaService.listOrphanedMediaIds({
+        before: now() + 1,
+        limit: 10,
+      });
+
+      expect(ids).toEqual([orphan.id]);
+    });
+
+    it("excludes site asset media (avatars, favicons) referenced by settings", async () => {
+      const orphan = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/site/files/orphan.jpg",
+      });
+      const avatar = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/site/assets/avatar/avatar.png",
+      });
+      const favicon = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/site/assets/favicon/apple-touch-icon.png",
+      });
+
+      const ids = await mediaService.listOrphanedMediaIds({
+        before: now() + 1,
+        limit: 10,
+      });
+
+      expect(ids).toEqual([orphan.id]);
+      expect(ids).not.toContain(avatar.id);
+      expect(ids).not.toContain(favicon.id);
+    });
+
+    it("excludes media created at or after the cutoff", async () => {
+      await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/a.jpg",
+      });
+
+      const ids = await mediaService.listOrphanedMediaIds({
+        before: 1,
+        limit: 10,
+      });
+
+      expect(ids).toEqual([]);
+    });
+
+    it("respects the batch limit", async () => {
+      await mediaService.create({ ...sampleMedia, storageKey: "media/a.jpg" });
+      await mediaService.create({ ...sampleMedia, storageKey: "media/b.jpg" });
+
+      const ids = await mediaService.listOrphanedMediaIds({
+        before: now() + 1,
+        limit: 1,
+      });
+
+      expect(ids).toHaveLength(1);
+    });
+
+    it("returns no IDs when the limit is zero", async () => {
+      await mediaService.create({ ...sampleMedia, storageKey: "media/a.jpg" });
+
+      const ids = await mediaService.listOrphanedMediaIds({
+        before: now() + 1,
+        limit: 0,
+      });
+
+      expect(ids).toEqual([]);
+    });
+  });
+
   describe("validateIds", () => {
     it("passes for valid IDs", async () => {
       const m1 = await mediaService.create({
@@ -1222,25 +1355,24 @@ describe("MediaService", () => {
       expect(result).toBe(false);
     });
 
-    it("deletes poster from storage when posterKey exists", async () => {
+    it("moves storage objects to trash and frees the original keys", async () => {
+      const storage = createMockStorage();
+      await storage.put("media/vid.mp4", new Uint8Array([1]));
+      await storage.put("media/vid.poster.webp", new Uint8Array([2]));
       const media = await mediaService.create({
         ...sampleMedia,
         storageKey: "media/vid.mp4",
         posterKey: "media/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, storage);
 
-      await mediaService.delete(media.id, mockStorage as never);
-      expect(deletedKeys).toContain("media/vid.mp4");
-      expect(deletedKeys).toContain("media/vid.poster.webp");
+      // Originals freed immediately; both objects moved under trash/.
+      expect(storage.files.has("media/vid.mp4")).toBe(false);
+      expect(storage.files.has("media/vid.poster.webp")).toBe(false);
+      expect(
+        [...storage.files.keys()].filter((k) => k.startsWith("trash/")).length,
+      ).toBe(2);
     });
   });
 
@@ -1274,7 +1406,11 @@ describe("MediaService", () => {
       expect(await mediaService.getById(m1.id)).not.toBeNull();
     });
 
-    it("deletes poster keys from storage", async () => {
+    it("moves storage objects to trash and frees the original keys", async () => {
+      const storage = createMockStorage();
+      await storage.put("media/a.mp4", new Uint8Array([1]));
+      await storage.put("media/a-poster.webp", new Uint8Array([2]));
+      await storage.put("media/b.jpg", new Uint8Array([3]));
       const m1 = await mediaService.create({
         ...sampleMedia,
         storageKey: "media/a.mp4",
@@ -1285,20 +1421,128 @@ describe("MediaService", () => {
         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], storage);
+
+      // Three originals freed, three trash copies remain.
+      expect(storage.files.has("media/a.mp4")).toBe(false);
+      expect(storage.files.has("media/a-poster.webp")).toBe(false);
+      expect(storage.files.has("media/b.jpg")).toBe(false);
+      expect(
+        [...storage.files.keys()].filter((k) => k.startsWith("trash/")).length,
+      ).toBe(3);
+    });
+  });
+
+  describe("storage purge (recycle window)", () => {
+    const FAR_FUTURE = () => now() + 365 * 24 * 60 * 60;
+
+    it("moves a deleted object to trash with a recorded original_key", async () => {
+      const storage = createMockStorage();
+      await storage.put("media/x.jpg", new Uint8Array([1]));
+      const m = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/x.jpg",
+      });
+
+      await mediaService.delete(m.id, storage);
+
+      const rows = await db
+        .select()
+        .from(storagePurge)
+        .where(eq(storagePurge.siteId, DEFAULT_TEST_SITE_ID));
+      expect(rows).toHaveLength(1);
+      expect(rows[0]!.originalKey).toBe("media/x.jpg");
+      expect(rows[0]!.storageKey.startsWith("trash/")).toBe(true);
+      expect(storage.files.has(rows[0]!.storageKey)).toBe(true);
+      expect(storage.files.has("media/x.jpg")).toBe(false);
+    });
+
+    it("purges trashed objects once due (storageKey + posterKey)", async () => {
+      const storage = createMockStorage();
+      await storage.put("media/v.mp4", new Uint8Array([1]));
+      await storage.put("media/v-poster.webp", new Uint8Array([2]));
+      const m = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/v.mp4",
+        posterKey: "media/v-poster.webp",
+      });
+      await mediaService.delete(m.id, storage);
+
+      const purged = await mediaService.purgeDueStorageObjects(
+        { before: FAR_FUTURE(), limit: 50, provider: "r2" },
+        storage,
+      );
+
+      expect(purged).toBe(2);
+      expect(storage.files.size).toBe(0);
+    });
+
+    it("retains trash whose recycle window has not elapsed", async () => {
+      const storage = createMockStorage();
+      await storage.put("media/keep.jpg", new Uint8Array([1]));
+      const m = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/keep.jpg",
+      });
+      await mediaService.delete(m.id, storage);
+
+      // before = now → the 30-day-out purge_after is not yet due.
+      const purged = await mediaService.purgeDueStorageObjects(
+        { before: now(), limit: 50, provider: "r2" },
+        storage,
+      );
+
+      expect(purged).toBe(0);
+      // Original freed, but the trash copy is retained.
+      expect(storage.files.has("media/keep.jpg")).toBe(false);
+      expect(
+        [...storage.files.keys()].some((k) => k.startsWith("trash/")),
+      ).toBe(true);
+    });
+
+    it("deletes immediately with no recycle when the driver lacks copy", async () => {
+      const storage = createNoCopyStorage();
+      await storage.put("media/nocopy.jpg", new Uint8Array([1]));
+      const m = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/nocopy.jpg",
+      });
+
+      await mediaService.delete(m.id, storage);
+
+      // Deleted outright; nothing in trash, nothing queued.
+      expect(storage.files.size).toBe(0);
+      const rows = await db
+        .select()
+        .from(storagePurge)
+        .where(eq(storagePurge.siteId, DEFAULT_TEST_SITE_ID));
+      expect(rows).toHaveLength(0);
+    });
+
+    it("respects the batch limit", async () => {
+      const storage = createMockStorage();
+      await storage.put("media/p1.jpg", new Uint8Array([1]));
+      await storage.put("media/p2.jpg", new Uint8Array([2]));
+      const m1 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/p1.jpg",
+      });
+      const m2 = await mediaService.create({
+        ...sampleMedia,
+        storageKey: "media/p2.jpg",
+      });
+      await mediaService.deleteByIds([m1.id, m2.id], storage);
+
+      const purged = await mediaService.purgeDueStorageObjects(
+        { before: FAR_FUTURE(), limit: 1, provider: "r2" },
+        storage,
+      );
 
-      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);
+      expect(purged).toBe(1);
+      // One trash object purged, one remains.
+      expect(
+        [...storage.files.keys()].filter((k) => k.startsWith("trash/")).length,
+      ).toBe(1);
     });
   });
 });

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

@@ -842,6 +842,59 @@ describe("PostService", () => {
       expect(posts[0]?.bodyText).toBe("root post");
     });
 
+    it("filters thread roots by reply presence", async () => {
+      const threadRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "thread root",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "reply",
+        replyToId: threadRoot.id,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "standalone",
+      });
+
+      const threads = await postService.list({
+        excludeReplies: true,
+        hasReplies: true,
+      });
+      expect(threads.map((p) => p.bodyText)).toEqual(["thread root"]);
+
+      const singles = await postService.list({
+        excludeReplies: true,
+        hasReplies: false,
+      });
+      expect(singles.map((p) => p.bodyText)).toEqual(["standalone"]);
+    });
+
+    it("ignores draft replies when filtering by reply presence", async () => {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root with draft reply",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "draft reply",
+        replyToId: root.id,
+        status: "draft",
+      });
+
+      const threads = await postService.list({
+        excludeReplies: true,
+        hasReplies: true,
+      });
+      expect(threads).toHaveLength(0);
+
+      const singles = await postService.list({
+        excludeReplies: true,
+        hasReplies: false,
+      });
+      expect(singles.map((p) => p.bodyText)).toEqual(["root with draft reply"]);
+    });
+
     it("supports offset pagination", async () => {
       for (let i = 0; i < 5; i++) {
         await postService.create({
@@ -944,6 +997,34 @@ describe("PostService", () => {
       expect(count).toBe(1);
     });
 
+    it("counts thread roots by reply presence", async () => {
+      const threadRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "thread root",
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "reply",
+        replyToId: threadRoot.id,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "standalone",
+      });
+
+      const threadCount = await postService.count({
+        excludeReplies: true,
+        hasReplies: true,
+      });
+      expect(threadCount).toBe(1);
+
+      const singleCount = await postService.count({
+        excludeReplies: true,
+        hasReplies: false,
+      });
+      expect(singleCount).toBe(1);
+    });
+
     it("can stop counting after a small limit", async () => {
       const collection = await collectionService.create({
         slug: "rated",

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

@@ -446,6 +446,61 @@ describe("SettingsService", () => {
       expect(await settingsService.get("SITE_LANGUAGE")).toBe("en");
     });
 
+    it("stores a valid dashboard language and reports the change", async () => {
+      const result = await settingsService.updateLocaleSettings(
+        {
+          siteLanguage: "fr",
+          dashboardLanguage: "zh-Hant",
+          cjkSerifFont: "off",
+          timeZone: "UTC",
+        },
+        { oldLanguage: "fr", oldDashboardLanguage: "" },
+      );
+
+      expect(result.languageChanged).toBe(true);
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("fr");
+      expect(await settingsService.get("DASHBOARD_LANGUAGE")).toBe("zh-Hant");
+    });
+
+    it("clears DASHBOARD_LANGUAGE when dashboard language is blank", async () => {
+      await settingsService.set("DASHBOARD_LANGUAGE", "zh-Hans");
+      await settingsService.updateLocaleSettings(
+        {
+          siteLanguage: "en",
+          dashboardLanguage: "",
+          cjkSerifFont: "off",
+          timeZone: "UTC",
+        },
+        { oldLanguage: "en", oldDashboardLanguage: "zh-Hans" },
+      );
+
+      expect(await settingsService.get("DASHBOARD_LANGUAGE")).toBeNull();
+    });
+
+    it("leaves DASHBOARD_LANGUAGE untouched when not provided", async () => {
+      await settingsService.set("DASHBOARD_LANGUAGE", "zh-Hans");
+      await settingsService.updateLocaleSettings(
+        { siteLanguage: "en", cjkSerifFont: "off", timeZone: "UTC" },
+        { oldLanguage: "en" },
+      );
+
+      expect(await settingsService.get("DASHBOARD_LANGUAGE")).toBe("zh-Hans");
+    });
+
+    it("rejects a dashboard language Jant is not translated into", async () => {
+      await expect(
+        settingsService.updateLocaleSettings(
+          {
+            siteLanguage: "en",
+            dashboardLanguage: "fr",
+            cjkSerifFont: "off",
+            timeZone: "UTC",
+          },
+          { oldLanguage: "en" },
+        ),
+      ).rejects.toThrow();
+    });
+
     it("updates grouped feed, home, and search settings independently", async () => {
       await settingsService.updateFeedSettings({ mainRssFeed: "latest" });
       await settingsService.updateHomeBranding(true);

package/src/services/bootstrap.ts

@@ -13,6 +13,7 @@ import {
   baseLocale,
   isValidContentLanguage,
   normalizeContentLanguage,
+  resolveCatalogLocale,
 } from "../i18n/locales.js";
 import { createNavItemService } from "./navigation.js";
 import { createSettingsService } from "./settings.js";
@@ -65,6 +66,12 @@ export function createBootstrapService(
           ? normalizeContentLanguage(data.siteLanguage)
           : baseLocale;
       await settings.set("SITE_LANGUAGE", siteLanguage);
+      // Pin the dashboard UI locale to the detected catalog language so it stays
+      // stable if the operator later changes the public content language.
+      await settings.set(
+        "DASHBOARD_LANGUAGE",
+        resolveCatalogLocale(siteLanguage),
+      );
       if (data.cjkSerifFont && data.cjkSerifFont !== "off") {
         await settings.set("CJK_SERIF_FONT", data.cjkSerifFont);
       }