@jant/core 0.3.6 → 0.3.8

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();
+    });
+  });
+});

package/src/services/collection.ts

@@ -21,6 +21,7 @@ export interface CollectionService {
   removePost(collectionId: number, postId: number): Promise<void>;
   getPosts(collectionId: number): Promise<Post[]>;
   getCollectionsForPost(postId: number): Promise<Collection[]>;
+  syncPostCollections(postId: number, collectionIds: number[]): Promise<void>;
 }
 
 export interface CreateCollectionData {
@@ -197,5 +198,23 @@ export function createCollectionService(db: Database): CollectionService {
 
       return rows.map((r) => toCollection(r.collection));
     },
+
+    async syncPostCollections(postId, collectionIds) {
+      const current = await this.getCollectionsForPost(postId);
+      const currentIds = new Set(current.map((c) => c.id));
+      const desiredIds = new Set(collectionIds);
+
+      const toAdd = collectionIds.filter((id) => !currentIds.has(id));
+      const toRemove = current
+        .map((c) => c.id)
+        .filter((id) => !desiredIds.has(id));
+
+      for (const collectionId of toAdd) {
+        await this.addPost(collectionId, postId);
+      }
+      for (const collectionId of toRemove) {
+        await this.removePost(collectionId, postId);
+      }
+    },
   };
 }

package/src/services/index.ts

@@ -14,6 +14,10 @@ import {
   type CollectionService,
 } from "./collection.js";
 import { createSearchService, type SearchService } from "./search.js";
+import {
+  createNavigationLinkService,
+  type NavigationLinkService,
+} from "./navigation.js";
 
 export interface Services {
   settings: SettingsService;
@@ -22,6 +26,7 @@ export interface Services {
   media: MediaService;
   collections: CollectionService;
   search: SearchService;
+  navigationLinks: NavigationLinkService;
 }
 
 export function createServices(db: Database, d1: D1Database): Services {
@@ -32,6 +37,7 @@ export function createServices(db: Database, d1: D1Database): Services {
     media: createMediaService(db),
     collections: createCollectionService(db),
     search: createSearchService(d1),
+    navigationLinks: createNavigationLinkService(db),
   };
 }
 
@@ -41,3 +47,4 @@ export type { RedirectService } from "./redirect.js";
 export type { MediaService } from "./media.js";
 export type { CollectionService } from "./collection.js";
 export type { SearchService, SearchResult, SearchOptions } from "./search.js";
+export type { NavigationLinkService } from "./navigation.js";

package/src/services/media.ts

@@ -4,7 +4,7 @@
  * Handles media upload and management with R2 storage
  */
 
-import { eq, desc } from "drizzle-orm";
+import { eq, desc, inArray, asc } from "drizzle-orm";
 import { uuidv7 } from "uuidv7";
 import type { Database } from "../db/index.js";
 import { media } from "../db/schema.js";
@@ -13,13 +13,19 @@ import type { Media } from "../types.js";
 
 export interface MediaService {
   getById(id: string): Promise<Media | null>;
+  getByIds(ids: string[]): Promise<Media[]>;
+  getByPostId(postId: number): Promise<Media[]>;
+  getByPostIds(postIds: number[]): Promise<Map<number, Media[]>>;
   list(limit?: number): Promise<Media[]>;
   create(data: CreateMediaData): Promise<Media>;
   delete(id: string): Promise<boolean>;
   getByR2Key(r2Key: string): Promise<Media | null>;
+  attachToPost(postId: number, mediaIds: string[]): Promise<void>;
+  detachFromPost(postId: number): Promise<void>;
 }
 
 export interface CreateMediaData {
+  id?: string;
   postId?: number;
   filename: string;
   originalName: string;
@@ -29,6 +35,8 @@ export interface CreateMediaData {
   width?: number;
   height?: number;
   alt?: string;
+  position?: number;
+  blurhash?: string;
 }
 
 export function createMediaService(db: Database): MediaService {
@@ -44,6 +52,8 @@ export function createMediaService(db: Database): MediaService {
       width: row.width,
       height: row.height,
       alt: row.alt,
+      position: row.position,
+      blurhash: row.blurhash,
       createdAt: row.createdAt,
     };
   }
@@ -58,6 +68,45 @@ export function createMediaService(db: Database): MediaService {
       return result[0] ? toMedia(result[0]) : null;
     },
 
+    async getByIds(ids) {
+      if (ids.length === 0) return [];
+      const rows = await db.select().from(media).where(inArray(media.id, ids));
+      return rows.map(toMedia);
+    },
+
+    async getByPostId(postId) {
+      const rows = await db
+        .select()
+        .from(media)
+        .where(eq(media.postId, postId))
+        .orderBy(asc(media.position));
+      return rows.map(toMedia);
+    },
+
+    async getByPostIds(postIds) {
+      const result = new Map<number, Media[]>();
+      if (postIds.length === 0) return result;
+
+      const rows = await db
+        .select()
+        .from(media)
+        .where(inArray(media.postId, postIds))
+        .orderBy(asc(media.position));
+
+      for (const row of rows) {
+        const m = toMedia(row);
+        if (m.postId === null) continue;
+        const list = result.get(m.postId);
+        if (list) {
+          list.push(m);
+        } else {
+          result.set(m.postId, [m]);
+        }
+      }
+
+      return result;
+    },
+
     async getByR2Key(r2Key) {
       const result = await db
         .select()
@@ -77,7 +126,7 @@ export function createMediaService(db: Database): MediaService {
     },
 
     async create(data) {
-      const id = uuidv7();
+      const id = data.id ?? uuidv7();
       const timestamp = now();
 
       const result = await db
@@ -93,6 +142,8 @@ export function createMediaService(db: Database): MediaService {
           width: data.width ?? null,
           height: data.height ?? null,
           alt: data.alt ?? null,
+          position: data.position ?? 0,
+          blurhash: data.blurhash ?? null,
           createdAt: timestamp,
         })
         .returning();
@@ -101,6 +152,31 @@ export function createMediaService(db: Database): MediaService {
       return toMedia(result[0]!);
     },
 
+    async attachToPost(postId, mediaIds) {
+      // Clear existing attachments
+      await db
+        .update(media)
+        .set({ postId: null, position: 0 })
+        .where(eq(media.postId, postId));
+
+      // Set new attachments with position = array index
+      for (let i = 0; i < mediaIds.length; i++) {
+        const mediaId = mediaIds[i];
+        if (!mediaId) continue;
+        await db
+          .update(media)
+          .set({ postId, position: i })
+          .where(eq(media.id, mediaId));
+      }
+    },
+
+    async detachFromPost(postId) {
+      await db
+        .update(media)
+        .set({ postId: null, position: 0 })
+        .where(eq(media.postId, postId));
+    },
+
     async delete(id) {
       const result = await db.delete(media).where(eq(media.id, id)).returning();
       return result.length > 0;