@jant/core 0.3.7 → 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/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

@@ -25,6 +25,7 @@ export interface MediaService {
 }
 
 export interface CreateMediaData {
+  id?: string;
   postId?: number;
   filename: string;
   originalName: string;
@@ -125,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

package/src/services/navigation.ts

@@ -0,0 +1,165 @@
+/**
+ * Navigation Link Service
+ *
+ * Manages navigation links displayed on public pages
+ */
+
+import { eq, asc, sql } from "drizzle-orm";
+import type { Database } from "../db/index.js";
+import { navigationLinks } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import type {
+  NavigationLink,
+  CreateNavigationLink,
+  UpdateNavigationLink,
+} from "../types.js";
+
+export interface NavigationLinkService {
+  list(): Promise<NavigationLink[]>;
+  getById(id: number): Promise<NavigationLink | null>;
+  create(data: CreateNavigationLink): Promise<NavigationLink>;
+  update(
+    id: number,
+    data: UpdateNavigationLink,
+  ): Promise<NavigationLink | null>;
+  delete(id: number): Promise<boolean>;
+  reorder(ids: number[]): Promise<void>;
+  ensureDefaults(): Promise<NavigationLink[]>;
+}
+
+export function createNavigationLinkService(
+  db: Database,
+): NavigationLinkService {
+  function toNavigationLink(
+    row: typeof navigationLinks.$inferSelect,
+  ): NavigationLink {
+    return {
+      id: row.id,
+      label: row.label,
+      url: row.url,
+      position: row.position,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  return {
+    async list() {
+      const rows = await db
+        .select()
+        .from(navigationLinks)
+        .orderBy(asc(navigationLinks.position));
+      return rows.map(toNavigationLink);
+    },
+
+    async getById(id) {
+      const result = await db
+        .select()
+        .from(navigationLinks)
+        .where(eq(navigationLinks.id, id))
+        .limit(1);
+      return result[0] ? toNavigationLink(result[0]) : null;
+    },
+
+    async create(data) {
+      const timestamp = now();
+
+      let position = data.position;
+      if (position === undefined) {
+        const maxResult = await db
+          .select({ maxPos: sql<number>`COALESCE(MAX(position), -1)` })
+          .from(navigationLinks);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- aggregate always returns one row
+        position = maxResult[0]!.maxPos + 1;
+      }
+
+      const result = await db
+        .insert(navigationLinks)
+        .values({
+          label: data.label,
+          url: data.url,
+          position,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        })
+        .returning();
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+      return toNavigationLink(result[0]!);
+    },
+
+    async update(id, data) {
+      const existing = await db
+        .select()
+        .from(navigationLinks)
+        .where(eq(navigationLinks.id, id))
+        .limit(1);
+      if (!existing[0]) return null;
+
+      const timestamp = now();
+      const result = await db
+        .update(navigationLinks)
+        .set({
+          ...(data.label !== undefined && { label: data.label }),
+          ...(data.url !== undefined && { url: data.url }),
+          ...(data.position !== undefined && { position: data.position }),
+          updatedAt: timestamp,
+        })
+        .where(eq(navigationLinks.id, id))
+        .returning();
+
+      return result[0] ? toNavigationLink(result[0]) : null;
+    },
+
+    async delete(id) {
+      const result = await db
+        .delete(navigationLinks)
+        .where(eq(navigationLinks.id, id))
+        .returning();
+      return result.length > 0;
+    },
+
+    async reorder(ids) {
+      const timestamp = now();
+      for (let i = 0; i < ids.length; i++) {
+        await db
+          .update(navigationLinks)
+          .set({ position: i, updatedAt: timestamp })
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- loop index guarantees element exists
+          .where(eq(navigationLinks.id, ids[i]!));
+      }
+    },
+
+    async ensureDefaults() {
+      const existing = await db.select().from(navigationLinks).limit(1);
+      if (existing.length > 0) {
+        const rows = await db
+          .select()
+          .from(navigationLinks)
+          .orderBy(asc(navigationLinks.position));
+        return rows.map(toNavigationLink);
+      }
+
+      const timestamp = now();
+      const defaults = [
+        { label: "Home", url: "/", position: 0 },
+        { label: "Archive", url: "/archive", position: 1 },
+        { label: "RSS", url: "/feed", position: 2 },
+      ];
+
+      for (const link of defaults) {
+        await db.insert(navigationLinks).values({
+          ...link,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        });
+      }
+
+      const rows = await db
+        .select()
+        .from(navigationLinks)
+        .orderBy(asc(navigationLinks.position));
+      return rows.map(toNavigationLink);
+    },
+  };
+}