@jant/core 0.3.26 → 0.3.28

package/src/services/collection.ts

@@ -1,15 +1,20 @@
 /**
  * Collection Service (v2)
  *
- * Manages collections. Posts belong to collections via posts.collection_id (1:M).
+ * Manages collections. Posts belong to collections via post_collections junction table (M:N).
  */
 
-import { eq, asc, sql, desc } from "drizzle-orm";
+import { eq, asc, sql, desc, and } from "drizzle-orm";
 import type { Database } from "../db/index.js";
-import { collections, posts } from "../db/schema.js";
+import {
+  collections,
+  collectionDividers,
+  postCollections,
+} from "../db/schema.js";
 import { now } from "../lib/time.js";
 import type {
   Collection,
+  CollectionDivider,
   CreateCollection,
   UpdateCollection,
   SortOrder,
@@ -23,8 +28,26 @@ export interface CollectionService {
   update(id: number, data: UpdateCollection): Promise<Collection | null>;
   delete(id: number): Promise<boolean>;
   reorder(ids: number[]): Promise<void>;
+  /** Reorder mixed collections and dividers using prefixed IDs (e.g. "c-1", "d-2") */
+  reorderAll(items: string[]): Promise<void>;
+  /** Create a standalone divider with auto-assigned position */
+  createDivider(): Promise<CollectionDivider>;
+  /** Delete a divider by ID */
+  deleteDivider(id: number): Promise<boolean>;
+  /** List all dividers ordered by position */
+  listDividers(): Promise<CollectionDivider[]>;
   /** Get post count per collection */
   getPostCounts(): Promise<Map<number, number>>;
+  /** Add a post to a collection */
+  addPost(collectionId: number, postId: number): Promise<void>;
+  /** Remove a post from a collection */
+  removePost(collectionId: number, postId: number): Promise<void>;
+  /** Get all collections a post belongs to */
+  getCollectionsByPostId(postId: number): Promise<Collection[]>;
+  /** Get all post IDs in a collection */
+  getPostIds(collectionId: number): Promise<number[]>;
+  /** Sync a post's collection memberships (replace all with given IDs) */
+  syncPostCollections(postId: number, collectionIds: number[]): Promise<void>;
 }
 
 export function createCollectionService(db: Database): CollectionService {
@@ -37,7 +60,17 @@ export function createCollectionService(db: Database): CollectionService {
       icon: row.icon,
       sortOrder: row.sortOrder as SortOrder,
       position: row.position,
-      showDivider: row.showDivider,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  function toDivider(
+    row: typeof collectionDividers.$inferSelect,
+  ): CollectionDivider {
+    return {
+      id: row.id,
+      position: row.position,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
@@ -75,11 +108,11 @@ export function createCollectionService(db: Database): CollectionService {
 
       let position = data.position;
       if (position === undefined) {
-        const maxResult = await db
-          .select({ maxPos: sql<number>`COALESCE(MAX(position), -1)` })
-          .from(collections);
+        const result = await db.all<{ maxPos: number }>(
+          sql`SELECT COALESCE(MAX(pos), -1) AS maxPos FROM (SELECT position AS pos FROM ${collections} UNION ALL SELECT position AS pos FROM ${collectionDividers})`,
+        );
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- aggregate always returns one row
-        position = maxResult[0]!.maxPos + 1;
+        position = result[0]!.maxPos + 1;
       }
 
       const result = await db
@@ -91,7 +124,6 @@ export function createCollectionService(db: Database): CollectionService {
           icon: data.icon ?? null,
           sortOrder: data.sortOrder ?? "newest",
           position,
-          showDivider: data.showDivider ? 1 : 0,
           createdAt: timestamp,
           updatedAt: timestamp,
         })
@@ -117,8 +149,6 @@ export function createCollectionService(db: Database): CollectionService {
       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)
@@ -130,12 +160,7 @@ export function createCollectionService(db: Database): CollectionService {
     },
 
     async delete(id) {
-      // Clear collection_id on posts that belong to this collection
-      await db
-        .update(posts)
-        .set({ collectionId: null })
-        .where(eq(posts.collectionId, id));
-
+      // Junction table entries are cleaned up by ON DELETE CASCADE
       const result = await db
         .delete(collections)
         .where(eq(collections.id, id))
@@ -144,35 +169,149 @@ export function createCollectionService(db: Database): CollectionService {
     },
 
     async reorder(ids) {
+      // Delegate to reorderAll with "c-" prefix for backward compat
+      await this.reorderAll(ids.map((id) => `c-${id}`));
+    },
+
+    async reorderAll(items) {
+      if (items.length === 0) return;
       const timestamp = now();
-      for (let i = 0; i < ids.length; i++) {
-        await db
+      const queries = items.map((item, i) => {
+        const [prefix, idStr] = item.split("-");
+        const id = Number(idStr);
+        if (prefix === "d") {
+          return db
+            .update(collectionDividers)
+            .set({ position: i, updatedAt: timestamp })
+            .where(eq(collectionDividers.id, id));
+        }
+        return 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]!));
-      }
+          .where(eq(collections.id, id));
+      });
+      await db.batch(
+        queries as [(typeof queries)[number], ...(typeof queries)[number][]],
+      );
+    },
+
+    async createDivider() {
+      const timestamp = now();
+
+      const maxResult = await db.all<{ maxPos: number }>(
+        sql`SELECT COALESCE(MAX(pos), -1) AS maxPos FROM (SELECT position AS pos FROM ${collections} UNION ALL SELECT position AS pos FROM ${collectionDividers})`,
+      );
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- aggregate always returns one row
+      const position = maxResult[0]!.maxPos + 1;
+
+      const result = await db
+        .insert(collectionDividers)
+        .values({
+          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 toDivider(result[0]!);
+    },
+
+    async deleteDivider(id) {
+      const result = await db
+        .delete(collectionDividers)
+        .where(eq(collectionDividers.id, id))
+        .returning();
+      return result.length > 0;
+    },
+
+    async listDividers() {
+      const rows = await db
+        .select()
+        .from(collectionDividers)
+        .orderBy(asc(collectionDividers.position));
+      return rows.map(toDivider);
     },
 
     async getPostCounts() {
       const rows = await db
         .select({
-          collectionId: posts.collectionId,
+          collectionId: postCollections.collectionId,
           count: sql<number>`count(*)`.as("count"),
         })
-        .from(posts)
-        .where(
-          sql`${posts.collectionId} IS NOT NULL AND ${posts.deletedAt} IS NULL`,
+        .from(postCollections)
+        .innerJoin(
+          sql`posts`,
+          sql`posts.id = ${postCollections.postId} AND posts.deleted_at IS NULL`,
         )
-        .groupBy(posts.collectionId);
+        .groupBy(postCollections.collectionId);
 
       const counts = new Map<number, number>();
       for (const row of rows) {
-        if (row.collectionId !== null) {
-          counts.set(row.collectionId, row.count);
-        }
+        counts.set(row.collectionId, row.count);
       }
       return counts;
     },
+
+    async addPost(collectionId, postId) {
+      await db
+        .insert(postCollections)
+        .values({ postId, collectionId })
+        .onConflictDoNothing();
+    },
+
+    async removePost(collectionId, postId) {
+      await db
+        .delete(postCollections)
+        .where(
+          and(
+            eq(postCollections.postId, postId),
+            eq(postCollections.collectionId, collectionId),
+          ),
+        );
+    },
+
+    async getCollectionsByPostId(postId) {
+      const rows = await db
+        .select({ collection: collections })
+        .from(postCollections)
+        .innerJoin(
+          collections,
+          eq(postCollections.collectionId, collections.id),
+        )
+        .where(eq(postCollections.postId, postId))
+        .orderBy(asc(collections.position));
+
+      return rows.map((r) => toCollection(r.collection));
+    },
+
+    async getPostIds(collectionId) {
+      const rows = await db
+        .select({ postId: postCollections.postId })
+        .from(postCollections)
+        .where(eq(postCollections.collectionId, collectionId));
+
+      return rows.map((r) => r.postId);
+    },
+
+    async syncPostCollections(postId, collectionIds) {
+      if (collectionIds.length === 0) {
+        // Only delete — single statement, no batch needed
+        await db
+          .delete(postCollections)
+          .where(eq(postCollections.postId, postId));
+        return;
+      }
+      // Delete existing + insert new atomically
+      const deleteQuery = db
+        .delete(postCollections)
+        .where(eq(postCollections.postId, postId));
+      const insertQuery = db
+        .insert(postCollections)
+        .values(
+          collectionIds.map((collectionId) => ({ postId, collectionId })),
+        );
+      await db.batch([deleteQuery, insertQuery]);
+    },
   };
 }

package/src/services/index.ts

@@ -16,6 +16,7 @@ import {
 } from "./collection.js";
 import { createSearchService, type SearchService } from "./search.js";
 import { createNavItemService, type NavItemService } from "./navigation.js";
+import { createAuthService, type AuthService } from "./auth.js";
 
 export interface Services {
   settings: SettingsService;
@@ -26,11 +27,13 @@ export interface Services {
   collections: CollectionService;
   search: SearchService;
   navItems: NavItemService;
+  auth: AuthService;
 }
 
 export function createServices(db: Database, d1: D1Database): Services {
+  const settings = createSettingsService(db);
   return {
-    settings: createSettingsService(db),
+    settings,
     posts: createPostService(db),
     pages: createPageService(db),
     redirects: createRedirectService(db),
@@ -38,14 +41,16 @@ export function createServices(db: Database, d1: D1Database): Services {
     collections: createCollectionService(db),
     search: createSearchService(d1),
     navItems: createNavItemService(db),
+    auth: createAuthService(db, settings),
   };
 }
 
 export type { SettingsService } from "./settings.js";
 export type { PostService, PostFilters } from "./post.js";
-export type { PageService } from "./page.js";
+export type { PageService, PageFilters } from "./page.js";
 export type { RedirectService } from "./redirect.js";
-export type { MediaService } from "./media.js";
+export type { MediaService, MediaFilters } from "./media.js";
 export type { CollectionService } from "./collection.js";
 export type { SearchService, SearchResult, SearchOptions } from "./search.js";
 export type { NavItemService } from "./navigation.js";
+export type { AuthService } from "./auth.js";

package/src/services/media.ts

@@ -4,24 +4,31 @@
  * Handles media upload and management with pluggable storage backends.
  */
 
-import { eq, desc, inArray, asc } from "drizzle-orm";
+import { eq, desc, inArray, asc, sql, and } from "drizzle-orm";
 import { uuidv7 } from "uuidv7";
 import type { Database } from "../db/index.js";
 import { media } from "../db/schema.js";
 import { now } from "../lib/time.js";
 import type { Media } from "../types.js";
 
+export interface MediaFilters {
+  limit?: number;
+  /** Filter by MIME type prefix, e.g. "image/" */
+  mimePrefix?: string;
+}
+
 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[]>;
+  list(filters?: MediaFilters): Promise<Media[]>;
   create(data: CreateMediaData): Promise<Media>;
   delete(id: string): Promise<boolean>;
   getByStorageKey(storageKey: string): Promise<Media | null>;
   attachToPost(postId: number, mediaIds: string[]): Promise<void>;
   detachFromPost(postId: number): Promise<void>;
+  updateAlt(id: string, alt: string): Promise<void>;
 }
 
 export interface CreateMediaData {
@@ -118,10 +125,18 @@ export function createMediaService(db: Database): MediaService {
       return result[0] ? toMedia(result[0]) : null;
     },
 
-    async list(limit = 100) {
+    async list(filters?: MediaFilters) {
+      const limit = filters?.limit ?? 100;
+      const conditions = [];
+      if (filters?.mimePrefix) {
+        conditions.push(
+          sql`${media.mimeType} LIKE ${filters.mimePrefix + "%"}`,
+        );
+      }
       const rows = await db
         .select()
         .from(media)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
         .orderBy(desc(media.createdAt))
         .limit(limit);
       return rows.map(toMedia);
@@ -156,21 +171,29 @@ export function createMediaService(db: Database): MediaService {
     },
 
     async attachToPost(postId, mediaIds) {
-      // Clear existing attachments
-      await db
+      const clearQuery = 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
+      const validIds = mediaIds.filter((id): id is string => Boolean(id));
+      if (validIds.length === 0) {
+        // Only clear — single statement, no batch needed
+        await clearQuery;
+        return;
+      }
+
+      // Clear existing + re-attach atomically
+      const attachQueries = validIds.map((mediaId, i) =>
+        db
           .update(media)
           .set({ postId, position: i })
-          .where(eq(media.id, mediaId));
-      }
+          .where(eq(media.id, mediaId)),
+      );
+      await db.batch([clearQuery, ...attachQueries] as [
+        typeof clearQuery,
+        ...(typeof attachQueries)[number][],
+      ]);
     },
 
     async detachFromPost(postId) {
@@ -180,6 +203,10 @@ export function createMediaService(db: Database): MediaService {
         .where(eq(media.postId, postId));
     },
 
+    async updateAlt(id, alt) {
+      await db.update(media).set({ alt }).where(eq(media.id, id));
+    },
+
     async delete(id) {
       const result = await db.delete(media).where(eq(media.id, id)).returning();
       return result.length > 0;

package/src/services/navigation.ts

@@ -21,6 +21,7 @@ export interface NavItemService {
   create(data: CreateNavItem): Promise<NavItem>;
   update(id: number, data: UpdateNavItem): Promise<NavItem | null>;
   delete(id: number): Promise<boolean>;
+  deleteByPageId(pageId: number): Promise<boolean>;
   reorder(ids: number[]): Promise<void>;
 }
 
@@ -118,15 +119,26 @@ export function createNavItemService(db: Database): NavItemService {
       return result.length > 0;
     },
 
+    async deleteByPageId(pageId) {
+      const result = await db
+        .delete(navItems)
+        .where(eq(navItems.pageId, pageId))
+        .returning();
+      return result.length > 0;
+    },
+
     async reorder(ids) {
+      if (ids.length === 0) return;
       const timestamp = now();
-      for (let i = 0; i < ids.length; i++) {
-        await db
+      const queries = ids.map((id, i) =>
+        db
           .update(navItems)
           .set({ position: i, updatedAt: timestamp })
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- loop index guarantees element exists
-          .where(eq(navItems.id, ids[i]!));
-      }
+          .where(eq(navItems.id, id)),
+      );
+      await db.batch(
+        queries as [(typeof queries)[number], ...(typeof queries)[number][]],
+      );
     },
   };
 }

package/src/services/page.ts

@@ -4,17 +4,21 @@
  * CRUD operations for standalone pages (about, now, etc.)
  */
 
-import { eq, desc, sql } from "drizzle-orm";
+import { eq, desc, sql, and } from "drizzle-orm";
 import type { Database } from "../db/index.js";
 import { pages, navItems } from "../db/schema.js";
 import { now } from "../lib/time.js";
 import { render as renderMarkdown } from "../lib/markdown.js";
 import type { Page, Status, CreatePage, UpdatePage } from "../types.js";
 
+export interface PageFilters {
+  status?: Status;
+}
+
 export interface PageService {
   getById(id: number): Promise<Page | null>;
   getBySlug(slug: string): Promise<Page | null>;
-  list(): Promise<Page[]>;
+  list(filters?: PageFilters): Promise<Page[]>;
   listNotInNav(): Promise<Page[]>;
   create(data: CreatePage): Promise<Page>;
   update(id: number, data: UpdatePage): Promise<Page | null>;
@@ -54,8 +58,16 @@ export function createPageService(db: Database): PageService {
       return result[0] ? toPage(result[0]) : null;
     },
 
-    async list() {
-      const rows = await db.select().from(pages).orderBy(desc(pages.createdAt));
+    async list(filters?: PageFilters) {
+      const conditions = [];
+      if (filters?.status) {
+        conditions.push(eq(pages.status, filters.status));
+      }
+      const rows = await db
+        .select()
+        .from(pages)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .orderBy(desc(pages.createdAt));
       return rows.map(toPage);
     },
 
@@ -118,6 +130,14 @@ export function createPageService(db: Database): PageService {
           .where(eq(navItems.pageId, id));
       }
 
+      // If title changed, update related nav_items label
+      if (data.title !== undefined && data.title !== existing.title) {
+        await db
+          .update(navItems)
+          .set({ label: data.title ?? existing.slug, updatedAt: timestamp })
+          .where(eq(navItems.pageId, id));
+      }
+
       const result = await db
         .update(pages)
         .set(updates)

package/src/services/post.ts

@@ -7,8 +7,9 @@
  */
 
 import { eq, and, isNull, desc, or, inArray, sql } from "drizzle-orm";
+import type { BatchItem } from "drizzle-orm/batch";
 import type { Database } from "../db/index.js";
-import { posts } from "../db/schema.js";
+import { posts, postCollections } from "../db/schema.js";
 import { now } from "../lib/time.js";
 import { render as renderMarkdown } from "../lib/markdown.js";
 import type { Format, Status, Post, CreatePost, UpdatePost } from "../types.js";
@@ -70,7 +71,10 @@ export function createPostService(db: Database): PostService {
       conditions.push(eq(posts.format, filters.format));
     }
     if (filters.collectionId !== undefined) {
-      conditions.push(eq(posts.collectionId, filters.collectionId));
+      // Filter by collection via junction table
+      conditions.push(
+        sql`${posts.id} IN (SELECT post_id FROM post_collections WHERE collection_id = ${filters.collectionId})`,
+      );
     }
     if (filters.threadId) {
       conditions.push(eq(posts.threadId, filters.threadId));
@@ -99,7 +103,6 @@ export function createPostService(db: Database): PostService {
       bodyHtml: row.bodyHtml,
       quoteText: row.quoteText,
       rating: row.rating,
-      collectionId: row.collectionId,
       replyToId: row.replyToId,
       threadId: row.threadId,
       deletedAt: row.deletedAt,
@@ -200,7 +203,6 @@ export function createPostService(db: Database): PostService {
           bodyHtml,
           quoteText: data.quoteText ?? null,
           rating: data.rating ?? null,
-          collectionId: data.collectionId ?? null,
           replyToId: data.replyToId ?? null,
           threadId,
           publishedAt: data.publishedAt ?? timestamp,
@@ -210,7 +212,19 @@ export function createPostService(db: Database): PostService {
         .returning();
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-      return toPost(result[0]!);
+      const post = toPost(result[0]!);
+
+      // Sync collection memberships if provided
+      if (data.collectionIds && data.collectionIds.length > 0) {
+        await db.insert(postCollections).values(
+          data.collectionIds.map((collectionId) => ({
+            postId: post.id,
+            collectionId,
+          })),
+        );
+      }
+
+      return post;
     },
 
     async update(id, data) {
@@ -228,8 +242,6 @@ export function createPostService(db: Database): PostService {
       if (data.url !== undefined) updates.url = data.url;
       if (data.quoteText !== undefined) updates.quoteText = data.quoteText;
       if (data.rating !== undefined) updates.rating = data.rating;
-      if (data.collectionId !== undefined)
-        updates.collectionId = data.collectionId;
       if (data.publishedAt !== undefined)
         updates.publishedAt = data.publishedAt;
       if (data.pinned !== undefined) updates.pinned = data.pinned ? 1 : 0;
@@ -249,22 +261,78 @@ export function createPostService(db: Database): PostService {
       if (statusChanged) updates.status = data.status;
       if (featuredChanged) updates.featured = data.featured ? 1 : 0;
 
-      // If this is a root post and status/featured changed, cascade to thread
-      if ((statusChanged || featuredChanged) && !existing.threadId) {
-        await this.updateThreadStatusAndFeatured(
-          id,
-          data.status ?? (existing.status as Status),
-          data.featured !== undefined ? data.featured : existing.featured === 1,
+      // Build all write queries for atomic execution via D1 batch
+      const needsCascade =
+        (statusChanged || featuredChanged) && !existing.threadId;
+      const needsCollectionSync = data.collectionIds !== undefined;
+      const hasExtraWrites = needsCascade || needsCollectionSync;
+
+      if (!hasExtraWrites) {
+        // Simple case: only the post update
+        const result = await db
+          .update(posts)
+          .set(updates)
+          .where(eq(posts.id, id))
+          .returning();
+        return result[0] ? toPost(result[0]) : null;
+      }
+
+      // Complex case: batch cascade + update + collection sync atomically
+      const writeQueries: BatchItem<"sqlite">[] = [];
+
+      if (needsCascade) {
+        writeQueries.push(
+          db
+            .update(posts)
+            .set({
+              status: data.status ?? (existing.status as Status),
+              featured: (
+                data.featured !== undefined
+                  ? data.featured
+                  : existing.featured === 1
+              )
+                ? 1
+                : 0,
+              updatedAt: timestamp,
+            })
+            .where(eq(posts.threadId, id)),
         );
       }
 
-      const result = await db
-        .update(posts)
-        .set(updates)
-        .where(eq(posts.id, id))
-        .returning();
+      // Post update is always present; track its index for result extraction
+      const updateIdx = writeQueries.length;
+      writeQueries.push(
+        db.update(posts).set(updates).where(eq(posts.id, id)).returning(),
+      );
 
-      return result[0] ? toPost(result[0]) : null;
+      if (needsCollectionSync) {
+        writeQueries.push(
+          db.delete(postCollections).where(eq(postCollections.postId, id)),
+        );
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guarded by needsCollectionSync
+        if (data.collectionIds!.length > 0) {
+          writeQueries.push(
+            db.insert(postCollections).values(
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guarded by needsCollectionSync
+              data.collectionIds!.map((collectionId) => ({
+                postId: id,
+                collectionId,
+              })),
+            ),
+          );
+        }
+      }
+
+      const results = await db.batch(
+        writeQueries as [
+          (typeof writeQueries)[number],
+          ...(typeof writeQueries)[number][],
+        ],
+      );
+      const updateResult = results[updateIdx] as
+        | (typeof posts.$inferSelect)[]
+        | undefined;
+      return updateResult?.[0] ? toPost(updateResult[0]) : null;
     },
 
     async delete(id) {

package/src/services/search.ts

@@ -106,7 +106,6 @@ export function createSearchService(d1: D1Database): SearchService {
           bodyHtml: row.body_html,
           quoteText: row.quote_text,
           rating: row.rating,
-          collectionId: row.collection_id,
           replyToId: row.reply_to_id,
           threadId: row.thread_id,
           deletedAt: row.deleted_at,