@jant/core 0.3.23 → 0.3.24

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

@@ -54,14 +54,12 @@ describe("SearchService", () => {
 
   it("finds posts by content", async () => {
     await postService.create({
-      type: "note",
-      content: "Hello world from jant",
-      visibility: "featured",
+      format: "note",
+      body: "Hello world from jant",
     });
     await postService.create({
-      type: "note",
-      content: "Another post entirely",
-      visibility: "featured",
+      format: "note",
+      body: "Another post entirely",
     });
 
     const d1 = createMockD1(sqlite);
@@ -69,15 +67,14 @@ describe("SearchService", () => {
 
     const results = await searchService.search("jant");
     expect(results.length).toBeGreaterThanOrEqual(1);
-    expect(results[0]?.post.content).toContain("jant");
+    expect(results[0]?.post.body).toContain("jant");
   });
 
   it("finds posts by title", async () => {
     await postService.create({
-      type: "article",
+      format: "note",
       title: "Introduction to TypeScript",
-      content: "Some article body",
-      visibility: "quiet",
+      body: "Some article body",
     });
 
     const d1 = createMockD1(sqlite);
@@ -88,33 +85,31 @@ describe("SearchService", () => {
     expect(results[0]?.post.title).toContain("TypeScript");
   });
 
-  it("respects visibility filter", async () => {
+  it("respects status filter", async () => {
     await postService.create({
-      type: "note",
-      content: "visible post about testing",
-      visibility: "featured",
+      format: "note",
+      body: "published post about testing",
     });
     await postService.create({
-      type: "note",
-      content: "draft post about testing",
-      visibility: "draft",
+      format: "note",
+      body: "draft post about testing",
+      status: "draft",
     });
 
     const d1 = createMockD1(sqlite);
     const searchService = createSearchService(d1);
 
     const results = await searchService.search("testing", {
-      visibility: ["featured"],
+      status: ["published"],
     });
 
-    expect(results.every((r) => r.post.visibility === "featured")).toBe(true);
+    expect(results.every((r) => r.post.status === "published")).toBe(true);
   });
 
   it("excludes deleted posts", async () => {
     const post = await postService.create({
-      type: "note",
-      content: "deleted post with unique search term xyzzy",
-      visibility: "featured",
+      format: "note",
+      body: "deleted post with unique search term xyzzy",
     });
     await postService.delete(post.id);
 
@@ -128,9 +123,8 @@ describe("SearchService", () => {
   it("supports limit and offset", async () => {
     for (let i = 0; i < 5; i++) {
       await postService.create({
-        type: "note",
-        content: `searchable post number ${i}`,
-        visibility: "featured",
+        format: "note",
+        body: `searchable post number ${i}`,
       });
     }
 

package/src/services/collection.ts

@@ -1,69 +1,43 @@
 /**
- * Collection Service
+ * Collection Service (v2)
  *
- * Manages collections and post-collection relationships
+ * Manages collections. Posts belong to collections via posts.collection_id (1:M).
  */
 
-import { eq, desc, and } from "drizzle-orm";
+import { eq, asc, sql, desc } from "drizzle-orm";
 import type { Database } from "../db/index.js";
-import { collections, postCollections, posts } from "../db/schema.js";
+import { collections, posts } from "../db/schema.js";
 import { now } from "../lib/time.js";
-import type { Collection, Post } from "../types.js";
+import type {
+  Collection,
+  CreateCollection,
+  UpdateCollection,
+  SortOrder,
+} from "../types.js";
 
 export interface CollectionService {
   getById(id: number): Promise<Collection | null>;
-  getByPath(path: string): Promise<Collection | null>;
+  getBySlug(slug: string): Promise<Collection | null>;
   list(): Promise<Collection[]>;
-  create(data: CreateCollectionData): Promise<Collection>;
-  update(id: number, data: UpdateCollectionData): Promise<Collection | null>;
+  create(data: CreateCollection): Promise<Collection>;
+  update(id: number, data: UpdateCollection): Promise<Collection | null>;
   delete(id: number): Promise<boolean>;
-  addPost(collectionId: number, postId: number): Promise<void>;
-  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 {
-  title: string;
-  path?: string;
-  description?: string;
-}
-
-export interface UpdateCollectionData {
-  title?: string;
-  path?: string | null;
-  description?: string;
+  reorder(ids: number[]): Promise<void>;
+  /** Get post count per collection */
+  getPostCounts(): Promise<Map<number, number>>;
 }
 
 export function createCollectionService(db: Database): CollectionService {
   function toCollection(row: typeof collections.$inferSelect): Collection {
     return {
       id: row.id,
+      slug: row.slug,
       title: row.title,
-      path: row.path,
       description: row.description,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-    };
-  }
-
-  function toPost(row: typeof posts.$inferSelect): Post {
-    return {
-      id: row.id,
-      type: row.type as Post["type"],
-      visibility: row.visibility as Post["visibility"],
-      title: row.title,
-      path: row.path,
-      content: row.content,
-      contentHtml: row.contentHtml,
-      sourceUrl: row.sourceUrl,
-      sourceName: row.sourceName,
-      sourceDomain: row.sourceDomain,
-      replyToId: row.replyToId,
-      threadId: row.threadId,
-      deletedAt: row.deletedAt,
-      publishedAt: row.publishedAt,
+      icon: row.icon,
+      sortOrder: row.sortOrder as SortOrder,
+      position: row.position,
+      showDivider: row.showDivider,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
@@ -79,11 +53,11 @@ export function createCollectionService(db: Database): CollectionService {
       return result[0] ? toCollection(result[0]) : null;
     },
 
-    async getByPath(path) {
+    async getBySlug(slug) {
       const result = await db
         .select()
         .from(collections)
-        .where(eq(collections.path, path))
+        .where(eq(collections.slug, slug))
         .limit(1);
       return result[0] ? toCollection(result[0]) : null;
     },
@@ -92,19 +66,32 @@ export function createCollectionService(db: Database): CollectionService {
       const rows = await db
         .select()
         .from(collections)
-        .orderBy(desc(collections.createdAt));
+        .orderBy(asc(collections.position), desc(collections.createdAt));
       return rows.map(toCollection);
     },
 
     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(collections);
+        // 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(collections)
         .values({
+          slug: data.slug,
           title: data.title,
-          path: data.path || null,
           description: data.description ?? null,
+          icon: data.icon ?? null,
+          sortOrder: data.sortOrder ?? "newest",
+          position,
+          showDivider: data.showDivider ? 1 : 0,
           createdAt: timestamp,
           updatedAt: timestamp,
         })
@@ -124,9 +111,14 @@ export function createCollectionService(db: Database): CollectionService {
       };
 
       if (data.title !== undefined) updates.title = data.title;
-      if (data.path !== undefined) updates.path = data.path;
+      if (data.slug !== undefined) updates.slug = data.slug;
       if (data.description !== undefined)
         updates.description = data.description;
+      if (data.icon !== undefined) updates.icon = data.icon;
+      if (data.sortOrder !== undefined) updates.sortOrder = data.sortOrder;
+      if (data.position !== undefined) updates.position = data.position;
+      if (data.showDivider !== undefined)
+        updates.showDivider = data.showDivider ? 1 : 0;
 
       const result = await db
         .update(collections)
@@ -138,10 +130,11 @@ export function createCollectionService(db: Database): CollectionService {
     },
 
     async delete(id) {
-      // Delete all post-collection relationships first
+      // Clear collection_id on posts that belong to this collection
       await db
-        .delete(postCollections)
-        .where(eq(postCollections.collectionId, id));
+        .update(posts)
+        .set({ collectionId: null })
+        .where(eq(posts.collectionId, id));
 
       const result = await db
         .delete(collections)
@@ -150,71 +143,36 @@ export function createCollectionService(db: Database): CollectionService {
       return result.length > 0;
     },
 
-    async addPost(collectionId, postId) {
+    async reorder(ids) {
       const timestamp = now();
-
-      // Upsert the relationship
-      await db
-        .insert(postCollections)
-        .values({
-          postId,
-          collectionId,
-          addedAt: timestamp,
-        })
-        .onConflictDoNothing();
-    },
-
-    async removePost(collectionId, postId) {
-      await db
-        .delete(postCollections)
-        .where(
-          and(
-            eq(postCollections.collectionId, collectionId),
-            eq(postCollections.postId, postId),
-          ),
-        );
-    },
-
-    async getPosts(collectionId) {
-      const rows = await db
-        .select({ post: posts })
-        .from(postCollections)
-        .innerJoin(posts, eq(postCollections.postId, posts.id))
-        .where(eq(postCollections.collectionId, collectionId))
-        .orderBy(desc(postCollections.addedAt));
-
-      return rows.map((r) => toPost(r.post));
+      for (let i = 0; i < ids.length; i++) {
+        await db
+          .update(collections)
+          .set({ position: i, updatedAt: timestamp })
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- loop index guarantees element exists
+          .where(eq(collections.id, ids[i]!));
+      }
     },
 
-    async getCollectionsForPost(postId) {
+    async getPostCounts() {
       const rows = await db
-        .select({ collection: collections })
-        .from(postCollections)
-        .innerJoin(
-          collections,
-          eq(postCollections.collectionId, collections.id),
+        .select({
+          collectionId: posts.collectionId,
+          count: sql<number>`count(*)`.as("count"),
+        })
+        .from(posts)
+        .where(
+          sql`${posts.collectionId} IS NOT NULL AND ${posts.deletedAt} IS NULL`,
         )
-        .where(eq(postCollections.postId, postId));
-
-      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);
+        .groupBy(posts.collectionId);
 
-      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);
+      const counts = new Map<number, number>();
+      for (const row of rows) {
+        if (row.collectionId !== null) {
+          counts.set(row.collectionId, row.count);
+        }
       }
+      return counts;
     },
   };
 }

package/src/services/index.ts

@@ -1,5 +1,5 @@
 /**
- * Services
+ * Services (v2)
  *
  * Business logic layer
  */
@@ -7,6 +7,7 @@
 import type { Database } from "../db/index.js";
 import { createSettingsService, type SettingsService } from "./settings.js";
 import { createPostService, type PostService } from "./post.js";
+import { createPageService, type PageService } from "./page.js";
 import { createRedirectService, type RedirectService } from "./redirect.js";
 import { createMediaService, type MediaService } from "./media.js";
 import {
@@ -14,37 +15,37 @@ import {
   type CollectionService,
 } from "./collection.js";
 import { createSearchService, type SearchService } from "./search.js";
-import {
-  createNavigationLinkService,
-  type NavigationLinkService,
-} from "./navigation.js";
+import { createNavItemService, type NavItemService } from "./navigation.js";
 
 export interface Services {
   settings: SettingsService;
   posts: PostService;
+  pages: PageService;
   redirects: RedirectService;
   media: MediaService;
   collections: CollectionService;
   search: SearchService;
-  navigationLinks: NavigationLinkService;
+  navItems: NavItemService;
 }
 
 export function createServices(db: Database, d1: D1Database): Services {
   return {
     settings: createSettingsService(db),
     posts: createPostService(db),
+    pages: createPageService(db),
     redirects: createRedirectService(db),
     media: createMediaService(db),
     collections: createCollectionService(db),
     search: createSearchService(d1),
-    navigationLinks: createNavigationLinkService(db),
+    navItems: createNavItemService(db),
   };
 }
 
 export type { SettingsService } from "./settings.js";
 export type { PostService, PostFilters } from "./post.js";
+export type { PageService } from "./page.js";
 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";
+export type { NavItemService } from "./navigation.js";

package/src/services/navigation.ts

@@ -1,42 +1,37 @@
 /**
- * Navigation Link Service
+ * Nav Item Service (v2)
  *
- * Manages navigation links displayed on public pages
+ * Manages navigation items (page links and external links)
  */
 
 import { eq, asc, sql } from "drizzle-orm";
 import type { Database } from "../db/index.js";
-import { navigationLinks } from "../db/schema.js";
+import { navItems } from "../db/schema.js";
 import { now } from "../lib/time.js";
 import type {
-  NavigationLink,
-  CreateNavigationLink,
-  UpdateNavigationLink,
+  NavItem,
+  NavItemType,
+  CreateNavItem,
+  UpdateNavItem,
 } 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>;
+export interface NavItemService {
+  list(): Promise<NavItem[]>;
+  getById(id: number): Promise<NavItem | null>;
+  create(data: CreateNavItem): Promise<NavItem>;
+  update(id: number, data: UpdateNavItem): Promise<NavItem | 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 {
+export function createNavItemService(db: Database): NavItemService {
+  function toNavItem(row: typeof navItems.$inferSelect): NavItem {
     return {
       id: row.id,
+      type: row.type as NavItemType,
       label: row.label,
       url: row.url,
+      pageId: row.pageId,
       position: row.position,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
@@ -47,18 +42,18 @@ export function createNavigationLinkService(
     async list() {
       const rows = await db
         .select()
-        .from(navigationLinks)
-        .orderBy(asc(navigationLinks.position));
-      return rows.map(toNavigationLink);
+        .from(navItems)
+        .orderBy(asc(navItems.position));
+      return rows.map(toNavItem);
     },
 
     async getById(id) {
       const result = await db
         .select()
-        .from(navigationLinks)
-        .where(eq(navigationLinks.id, id))
+        .from(navItems)
+        .where(eq(navItems.id, id))
         .limit(1);
-      return result[0] ? toNavigationLink(result[0]) : null;
+      return result[0] ? toNavItem(result[0]) : null;
     },
 
     async create(data) {
@@ -68,16 +63,18 @@ export function createNavigationLinkService(
       if (position === undefined) {
         const maxResult = await db
           .select({ maxPos: sql<number>`COALESCE(MAX(position), -1)` })
-          .from(navigationLinks);
+          .from(navItems);
         // 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)
+        .insert(navItems)
         .values({
+          type: data.type,
           label: data.label,
           url: data.url,
+          pageId: data.pageId ?? null,
           position,
           createdAt: timestamp,
           updatedAt: timestamp,
@@ -85,36 +82,38 @@ export function createNavigationLinkService(
         .returning();
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-      return toNavigationLink(result[0]!);
+      return toNavItem(result[0]!);
     },
 
     async update(id, data) {
       const existing = await db
         .select()
-        .from(navigationLinks)
-        .where(eq(navigationLinks.id, id))
+        .from(navItems)
+        .where(eq(navItems.id, id))
         .limit(1);
       if (!existing[0]) return null;
 
       const timestamp = now();
       const result = await db
-        .update(navigationLinks)
+        .update(navItems)
         .set({
+          ...(data.type !== undefined && { type: data.type }),
           ...(data.label !== undefined && { label: data.label }),
           ...(data.url !== undefined && { url: data.url }),
+          ...(data.pageId !== undefined && { pageId: data.pageId }),
           ...(data.position !== undefined && { position: data.position }),
           updatedAt: timestamp,
         })
-        .where(eq(navigationLinks.id, id))
+        .where(eq(navItems.id, id))
         .returning();
 
-      return result[0] ? toNavigationLink(result[0]) : null;
+      return result[0] ? toNavItem(result[0]) : null;
     },
 
     async delete(id) {
       const result = await db
-        .delete(navigationLinks)
-        .where(eq(navigationLinks.id, id))
+        .delete(navItems)
+        .where(eq(navItems.id, id))
         .returning();
       return result.length > 0;
     },
@@ -123,43 +122,11 @@ export function createNavigationLinkService(
       const timestamp = now();
       for (let i = 0; i < ids.length; i++) {
         await db
-          .update(navigationLinks)
+          .update(navItems)
           .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]!));
+          .where(eq(navItems.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);
-    },
   };
 }