@jant/core 0.3.38 → 0.3.40

package/src/services/collection.ts

@@ -2,28 +2,34 @@
  * Collection Service (v2)
  *
  * Manages collections. Posts belong to collections via post_collections junction table (M:N).
- * Sidebar ordering is managed through the sidebar_items table with fractional indexing.
+ * Sidebar ordering is managed through the collection_directory_item table with fractional indexing.
  */
 
 import { eq, asc, sql, and, inArray, desc } from "drizzle-orm";
-import type { BatchItem } from "drizzle-orm/batch";
 import { generateKeyBetween } from "fractional-indexing";
-import { uuidv7 } from "uuidv7";
-import { type Database, batchQueryRows } from "../db/index.js";
 import {
-  collections,
-  pathRegistry,
-  sidebarItems,
-  postCollections,
-} from "../db/schema.js";
+  type Database,
+  batchQueryRows,
+  supportsDrizzleTransaction,
+} from "../db/index.js";
+import type { DatabaseDialect } from "../db/dialect.js";
+import {
+  sqliteSchemaBundle,
+  type DatabaseSchema,
+} from "../db/schema-bundle.js";
+import { createEntityId } from "../lib/ids.js";
 import { now } from "../lib/time.js";
 import type {
   Collection,
+  CollectionDirectoryCollection,
+  CollectionDirectoryItem,
+  CollectionsDirectoryData,
   SidebarItem,
   SidebarItemType,
   CreateCollection,
   UpdateCollection,
-  SortOrder,
+  UpdateSidebarItem,
+  CollectionSortOrder,
 } from "../types.js";
 import { ConflictError } from "../lib/errors.js";
 import {
@@ -31,6 +37,12 @@ import {
   toCollectionPath,
   type PathService,
 } from "./path.js";
+import {
+  CollectionDescriptionValueSchema,
+  CollectionSlugSchema,
+  CollectionTitleSchema,
+  parseValidated,
+} from "../lib/schemas.js";
 
 const POSITION_RETRY_ATTEMPTS = 5;
 
@@ -52,10 +64,41 @@ function isUniqueConstraintError(err: unknown): boolean {
   return false;
 }
 
+export interface ResolvedCollectionSelection {
+  collections: Collection[];
+  slugs: string[];
+  slugExpression: string;
+}
+
+function parseCollectionSelectionSlugs(
+  slugExpression: string,
+): string[] | null {
+  const parts = slugExpression.split("+");
+  if (parts.length === 0) return null;
+
+  const seen = new Set<string>();
+  const slugs: string[] = [];
+
+  for (const part of parts) {
+    const slug = part.trim();
+    if (!slug) return null;
+    if (seen.has(slug)) continue;
+    seen.add(slug);
+    slugs.push(slug);
+  }
+
+  return slugs.length > 0 ? slugs : null;
+}
+
 export interface CollectionService {
   getById(id: string): Promise<Collection | null>;
   getBySlug(slug: string): Promise<Collection | null>;
+  getBySlugs(slugs: string[]): Promise<Collection[]>;
+  resolveSelection(
+    slugExpression: string,
+  ): Promise<ResolvedCollectionSelection | null>;
   list(): Promise<Collection[]>;
+  listDirectoryData(): Promise<CollectionsDirectoryData>;
   /** List collections sorted by most recent post addition (for compose dialog) */
   listByRecentActivity(): Promise<Collection[]>;
   create(data: CreateCollection): Promise<Collection>;
@@ -67,9 +110,15 @@ export interface CollectionService {
   createSidebarItem(
     type: SidebarItemType,
     collectionId?: string,
+    label?: string | null,
   ): Promise<SidebarItem>;
   /** Delete a sidebar item by ID */
   deleteSidebarItem(id: string): Promise<boolean>;
+  /** Update a sidebar item */
+  updateSidebarItem(
+    id: string,
+    data: UpdateSidebarItem,
+  ): Promise<SidebarItem | null>;
   /** Move a sidebar item between two neighbors */
   moveSidebarItem(
     id: string,
@@ -96,19 +145,70 @@ export interface CollectionService {
 
 export function createCollectionService(
   db: Database,
-  paths: PathService = createPathService(db),
+  siteId: string,
+  paths: PathService | undefined,
+  databaseSchema: DatabaseSchema = sqliteSchemaBundle,
+  databaseDialect: DatabaseDialect = "sqlite",
 ): CollectionService {
+  const resolvedPaths = paths ?? createPathService(db, siteId, databaseSchema);
+  const {
+    collections,
+    pathRegistry,
+    collectionDirectoryItems: sidebarItems,
+    postCollections,
+    posts,
+  } = databaseSchema;
+  const usesBatchWrites = !supportsDrizzleTransaction(db, databaseDialect);
+
+  function normalizeCreateCollectionInput(
+    data: CreateCollection,
+  ): CreateCollection {
+    return {
+      slug: parseValidated(CollectionSlugSchema, data.slug),
+      title: parseValidated(CollectionTitleSchema, data.title),
+      description:
+        data.description === undefined
+          ? undefined
+          : parseValidated(CollectionDescriptionValueSchema, data.description),
+      sortOrder: data.sortOrder,
+    };
+  }
+
+  function normalizeUpdateCollectionInput(
+    data: UpdateCollection,
+  ): UpdateCollection {
+    const normalized: UpdateCollection = {};
+
+    if (data.slug !== undefined) {
+      normalized.slug = parseValidated(CollectionSlugSchema, data.slug);
+    }
+    if (data.title !== undefined) {
+      normalized.title = parseValidated(CollectionTitleSchema, data.title);
+    }
+    if (data.description !== undefined) {
+      normalized.description =
+        data.description === null
+          ? null
+          : parseValidated(CollectionDescriptionValueSchema, data.description);
+    }
+    if (data.sortOrder !== undefined) {
+      normalized.sortOrder = data.sortOrder;
+    }
+
+    return normalized;
+  }
+
   function toCollection(
     row: typeof collections.$inferSelect,
     slug: string,
   ): Collection {
     return {
       id: row.id,
+      siteId: row.siteId,
       slug,
       title: row.title,
       description: row.description,
-      icon: row.icon,
-      sortOrder: row.sortOrder as SortOrder,
+      sortOrder: row.sortOrder as CollectionSortOrder,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
@@ -117,18 +217,26 @@ export function createCollectionService(
   function toSidebarItem(row: typeof sidebarItems.$inferSelect): SidebarItem {
     return {
       id: row.id,
+      siteId: row.siteId,
       type: row.type as SidebarItemType,
       collectionId: row.collectionId,
+      label: row.label,
       position: row.position,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
   }
 
+  function normalizeSidebarLabel(label?: string | null): string | null {
+    const trimmed = label?.trim();
+    return trimmed ? trimmed : null;
+  }
+
   async function getLastSidebarPosition(): Promise<string | null> {
     const rows = await db
       .select({ position: sidebarItems.position })
       .from(sidebarItems)
+      .where(eq(sidebarItems.siteId, siteId))
       .orderBy(sql`${sidebarItems.position} DESC`)
       .limit(1);
     return rows[0]?.position ?? null;
@@ -138,6 +246,7 @@ export function createCollectionService(
     const rows = await db
       .select({ id: sidebarItems.id, position: sidebarItems.position })
       .from(sidebarItems)
+      .where(eq(sidebarItems.siteId, siteId))
       .orderBy(asc(sidebarItems.position));
     return excludeId ? rows.filter((row) => row.id !== excludeId) : rows;
   }
@@ -151,7 +260,7 @@ export function createCollectionService(
     const rows = await db
       .select({ id: pathRegistry.id })
       .from(pathRegistry)
-      .where(eq(pathRegistry.path, path))
+      .where(and(eq(pathRegistry.siteId, siteId), eq(pathRegistry.path, path)))
       .limit(1);
     return rows.length > 0;
   }
@@ -189,7 +298,7 @@ export function createCollectionService(
     row: typeof collections.$inferSelect | undefined,
   ): Promise<Collection | null> {
     if (!row) return null;
-    const slug = await paths.getCollectionSlug(row.id);
+    const slug = await resolvedPaths.getCollectionSlug(row.id);
     if (!slug) return null;
     return toCollection(row, slug);
   }
@@ -198,7 +307,9 @@ export function createCollectionService(
     rows: (typeof collections.$inferSelect)[],
   ): Promise<Collection[]> {
     if (rows.length === 0) return [];
-    const slugMap = await paths.getCollectionSlugMap(rows.map((row) => row.id));
+    const slugMap = await resolvedPaths.getCollectionSlugMap(
+      rows.map((row) => row.id),
+    );
     return rows
       .map((row) => {
         const slug = slugMap.get(row.id);
@@ -207,32 +318,195 @@ export function createCollectionService(
       .filter((row): row is Collection => row !== null);
   }
 
+  async function getPostCollectionIds(postId: string): Promise<string[]> {
+    const rows = await db
+      .select({ collectionId: postCollections.collectionId })
+      .from(postCollections)
+      .where(
+        and(
+          eq(postCollections.siteId, siteId),
+          eq(postCollections.postId, postId),
+        ),
+      );
+
+    return rows.map((row) => row.collectionId);
+  }
+
+  async function listDirectoryCollections(): Promise<
+    CollectionDirectoryCollection[]
+  > {
+    const postCount = sql<number>`
+      COUNT(
+        CASE
+          WHEN ${posts.id} IS NOT NULL AND ${posts.deletedAt} IS NULL THEN 1
+        END
+      )
+    `.as("post_count");
+    const recentActivityAt = sql<number | null>`
+      MAX(
+        CASE
+          WHEN ${posts.id} IS NOT NULL AND ${posts.deletedAt} IS NULL
+          THEN COALESCE(
+            ${posts.lastActivityAt},
+            ${posts.publishedAt},
+            ${posts.updatedAt}
+          )
+        END
+      )
+    `.as("recent_activity_at");
+
+    const rows = await db
+      .select({
+        collection: collections,
+        postCount,
+        recentActivityAt,
+      })
+      .from(collections)
+      .leftJoin(
+        postCollections,
+        and(
+          eq(postCollections.siteId, siteId),
+          eq(collections.id, postCollections.collectionId),
+        ),
+      )
+      .leftJoin(
+        posts,
+        and(eq(posts.siteId, siteId), eq(postCollections.postId, posts.id)),
+      )
+      .where(eq(collections.siteId, siteId))
+      .groupBy(collections.id)
+      .orderBy(asc(collections.createdAt));
+
+    if (rows.length === 0) return [];
+
+    const slugMap = await resolvedPaths.getCollectionSlugMap(
+      rows.map((row) => row.collection.id),
+    );
+
+    return rows
+      .map((row) => {
+        const slug = slugMap.get(row.collection.id);
+        if (!slug) return null;
+
+        return {
+          ...toCollection(row.collection, slug),
+          postCount: row.postCount,
+          recentActivityAt: row.recentActivityAt ?? row.collection.updatedAt,
+        };
+      })
+      .filter((row): row is CollectionDirectoryCollection => row !== null);
+  }
+
+  function buildDirectoryItems(
+    directoryCollections: CollectionDirectoryCollection[],
+    orderedSidebarItems: SidebarItem[],
+  ): CollectionDirectoryItem[] {
+    const collectionMap = new Map(
+      directoryCollections.map((collection) => [collection.id, collection]),
+    );
+    const seenCollections = new Set<string>();
+    const items: CollectionDirectoryItem[] = [];
+
+    for (const item of orderedSidebarItems) {
+      if (item.type === "divider") {
+        items.push({
+          id: item.id,
+          type: "divider",
+          label: item.label,
+        });
+        continue;
+      }
+
+      const collection = item.collectionId
+        ? collectionMap.get(item.collectionId)
+        : undefined;
+      if (!collection) continue;
+
+      seenCollections.add(collection.id);
+      items.push({
+        id: item.id,
+        type: "collection",
+        collection,
+      });
+    }
+
+    for (const collection of directoryCollections) {
+      if (seenCollections.has(collection.id)) continue;
+      items.push({
+        id: collection.id,
+        type: "collection",
+        collection,
+      });
+    }
+
+    return items;
+  }
+
   return {
     async getById(id) {
       const result = await db
         .select()
         .from(collections)
-        .where(eq(collections.id, id))
+        .where(and(eq(collections.siteId, siteId), eq(collections.id, id)))
         .limit(1);
       return hydrateCollection(result[0]);
     },
 
     async getBySlug(slug) {
-      const resolved = await paths.resolve(toCollectionPath(slug));
+      const resolved = await resolvedPaths.resolve(toCollectionPath(slug));
       if (!resolved || resolved.kind !== "slug" || !resolved.collectionId) {
         return null;
       }
       return this.getById(resolved.collectionId);
     },
 
+    async getBySlugs(slugs) {
+      if (slugs.length === 0) return [];
+
+      const collections = await Promise.all(
+        slugs.map((slug) => this.getBySlug(slug)),
+      );
+      return collections.filter(
+        (collection): collection is Collection => collection !== null,
+      );
+    },
+
+    async resolveSelection(slugExpression) {
+      const slugs = parseCollectionSelectionSlugs(slugExpression);
+      if (!slugs) return null;
+
+      const collections = await this.getBySlugs(slugs);
+      if (collections.length !== slugs.length) return null;
+
+      return {
+        collections,
+        slugs,
+        slugExpression: slugs.join("+"),
+      };
+    },
+
     async list() {
       const rows = await db
         .select()
         .from(collections)
+        .where(eq(collections.siteId, siteId))
         .orderBy(asc(collections.createdAt));
       return hydrateCollections(rows);
     },
 
+    async listDirectoryData() {
+      const [directoryCollections, orderedSidebarItems] = await Promise.all([
+        listDirectoryCollections(),
+        this.listSidebarItems(),
+      ]);
+
+      return {
+        collections: directoryCollections,
+        items: buildDirectoryItems(directoryCollections, orderedSidebarItems),
+        sidebarItems: orderedSidebarItems,
+      };
+    },
+
     async listByRecentActivity() {
       const lastAddedAt = sql<
         number | null
@@ -242,63 +516,107 @@ export function createCollectionService(
         .from(collections)
         .leftJoin(
           postCollections,
-          eq(collections.id, postCollections.collectionId),
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(collections.id, postCollections.collectionId),
+          ),
         )
+        .where(eq(collections.siteId, siteId))
         .groupBy(collections.id)
-        .orderBy(desc(sql`last_added_at`), asc(collections.createdAt));
+        .orderBy(desc(sql`last_added_at`), desc(collections.createdAt));
       return hydrateCollections(rows.map((row) => row.collection));
     },
 
     async create(data) {
-      const id = uuidv7();
+      const normalizedData = normalizeCreateCollectionInput(data);
+      const id = createEntityId("collection");
       const timestamp = now();
-      const slugPath = toCollectionPath(data.slug);
+      const slugPath = toCollectionPath(normalizedData.slug);
 
       for (let attempt = 0; attempt < POSITION_RETRY_ATTEMPTS; attempt += 1) {
         try {
           const position = await getAppendSidebarPosition();
-          const writeQueries: BatchItem<"sqlite">[] = [
-            db.insert(collections).values({
-              id,
-              title: data.title,
-              description: data.description ?? null,
-              icon: data.icon ?? null,
-              sortOrder: data.sortOrder ?? "newest",
-              createdAt: timestamp,
-              updatedAt: timestamp,
-            }),
-            db.insert(pathRegistry).values({
-              id: uuidv7(),
-              path: slugPath,
-              kind: "slug",
-              postId: null,
-              collectionId: id,
-              redirectToPath: null,
-              redirectType: null,
-              createdAt: timestamp,
-              updatedAt: timestamp,
-            }),
-            db.insert(sidebarItems).values({
-              id: uuidv7(),
-              type: "collection",
-              collectionId: id,
-              position,
-              createdAt: timestamp,
-              updatedAt: timestamp,
-            }),
-          ];
-
-          await db.batch(
-            writeQueries as [
-              (typeof writeQueries)[number],
-              ...(typeof writeQueries)[number][],
-            ],
-          );
+          if (usesBatchWrites) {
+            const writeQueries = [
+              db.insert(collections).values({
+                id,
+                siteId,
+                title: normalizedData.title,
+                description: normalizedData.description ?? null,
+                sortOrder: normalizedData.sortOrder ?? "newest",
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              }),
+              db.insert(pathRegistry).values({
+                id: createEntityId("path"),
+                siteId,
+                path: slugPath,
+                kind: "slug",
+                postId: null,
+                collectionId: id,
+                redirectToPath: null,
+                redirectType: null,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              }),
+              db.insert(sidebarItems).values({
+                id: createEntityId("collectionDirectoryItem"),
+                siteId,
+                type: "collection",
+                collectionId: id,
+                position,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              }),
+            ];
+
+            await db.batch(
+              writeQueries as [
+                (typeof writeQueries)[number],
+                ...(typeof writeQueries)[number][],
+              ],
+            );
+          } else {
+            await db.transaction(async (tx) => {
+              await tx.insert(collections).values({
+                id,
+                siteId,
+                title: normalizedData.title,
+                description: normalizedData.description ?? null,
+                sortOrder: normalizedData.sortOrder ?? "newest",
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              });
+
+              await tx.insert(pathRegistry).values({
+                id: createEntityId("path"),
+                siteId,
+                path: slugPath,
+                kind: "slug",
+                postId: null,
+                collectionId: id,
+                redirectToPath: null,
+                redirectType: null,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              });
+
+              await tx.insert(sidebarItems).values({
+                id: createEntityId("collectionDirectoryItem"),
+                siteId,
+                type: "collection",
+                collectionId: id,
+                position,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              });
+            });
+          }
 
           const collection = await this.getById(id);
           if (!collection) {
             throw new ConflictError(
-              `Slug "${data.slug}" could not be resolved`,
+              `Slug "${normalizedData.slug}" could not be resolved`,
             );
           }
           return collection;
@@ -307,7 +625,9 @@ export function createCollectionService(
             throw err;
           }
           if (isUniqueConstraintError(err) && (await pathExists(slugPath))) {
-            throw new ConflictError(`Slug "${data.slug}" is already in use`);
+            throw new ConflictError(
+              `Slug "${normalizedData.slug}" is already in use`,
+            );
           }
           if (attempt === POSITION_RETRY_ATTEMPTS - 1) {
             throw err;
@@ -319,15 +639,21 @@ export function createCollectionService(
     },
 
     async update(id, data) {
+      const normalizedData = normalizeUpdateCollectionInput(data);
       const existing = await this.getById(id);
       if (!existing) return null;
 
-      if (data.slug !== undefined && data.slug !== existing.slug) {
+      if (
+        normalizedData.slug !== undefined &&
+        normalizedData.slug !== existing.slug
+      ) {
         try {
-          await paths.updateCollectionSlug(id, data.slug);
+          await resolvedPaths.updateCollectionSlug(id, normalizedData.slug);
         } catch (err) {
           if (err instanceof ConflictError) {
-            throw new ConflictError(`Slug "${data.slug}" is already in use`);
+            throw new ConflictError(
+              `Slug "${normalizedData.slug}" is already in use`,
+            );
           }
           throw err;
         }
@@ -338,17 +664,20 @@ export function createCollectionService(
         updatedAt: timestamp,
       };
 
-      if (data.title !== undefined) updates.title = data.title;
-      if (data.description !== undefined) {
-        updates.description = data.description;
+      if (normalizedData.title !== undefined) {
+        updates.title = normalizedData.title;
+      }
+      if (normalizedData.description !== undefined) {
+        updates.description = normalizedData.description;
+      }
+      if (normalizedData.sortOrder !== undefined) {
+        updates.sortOrder = normalizedData.sortOrder;
       }
-      if (data.icon !== undefined) updates.icon = data.icon;
-      if (data.sortOrder !== undefined) updates.sortOrder = data.sortOrder;
 
       const result = await db
         .update(collections)
         .set(updates)
-        .where(eq(collections.id, id))
+        .where(and(eq(collections.siteId, siteId), eq(collections.id, id)))
         .returning();
 
       return hydrateCollection(result[0]);
@@ -357,11 +686,23 @@ export function createCollectionService(
     async delete(id) {
       await db
         .delete(postCollections)
-        .where(eq(postCollections.collectionId, id));
-      await db.delete(sidebarItems).where(eq(sidebarItems.collectionId, id));
+        .where(
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(postCollections.collectionId, id),
+          ),
+        );
+      await db
+        .delete(sidebarItems)
+        .where(
+          and(
+            eq(sidebarItems.siteId, siteId),
+            eq(sidebarItems.collectionId, id),
+          ),
+        );
       const result = await db
         .delete(collections)
-        .where(eq(collections.id, id))
+        .where(and(eq(collections.siteId, siteId), eq(collections.id, id)))
         .returning();
       return result.length > 0;
     },
@@ -370,13 +711,16 @@ export function createCollectionService(
       const rows = await db
         .select()
         .from(sidebarItems)
+        .where(eq(sidebarItems.siteId, siteId))
         .orderBy(asc(sidebarItems.position));
       return rows.map(toSidebarItem);
     },
 
-    async createSidebarItem(type, collectionId) {
-      const id = uuidv7();
+    async createSidebarItem(type, collectionId, label) {
+      const id = createEntityId("collectionDirectoryItem");
       const timestamp = now();
+      const normalizedLabel =
+        type === "divider" ? normalizeSidebarLabel(label) : null;
 
       for (let attempt = 0; attempt < POSITION_RETRY_ATTEMPTS; attempt += 1) {
         try {
@@ -384,8 +728,10 @@ export function createCollectionService(
             .insert(sidebarItems)
             .values({
               id,
+              siteId,
               type,
               collectionId: collectionId ?? null,
+              label: normalizedLabel,
               position: await getAppendSidebarPosition(),
               createdAt: timestamp,
               updatedAt: timestamp,
@@ -403,7 +749,12 @@ export function createCollectionService(
             const existing = await db
               .select({ id: sidebarItems.id })
               .from(sidebarItems)
-              .where(eq(sidebarItems.collectionId, collectionId))
+              .where(
+                and(
+                  eq(sidebarItems.siteId, siteId),
+                  eq(sidebarItems.collectionId, collectionId),
+                ),
+              )
               .limit(1);
             if (existing.length > 0) {
               throw new ConflictError("Collection is already in the sidebar.");
@@ -424,16 +775,42 @@ export function createCollectionService(
     async deleteSidebarItem(id) {
       const result = await db
         .delete(sidebarItems)
-        .where(eq(sidebarItems.id, id))
+        .where(and(eq(sidebarItems.siteId, siteId), eq(sidebarItems.id, id)))
         .returning();
       return result.length > 0;
     },
 
+    async updateSidebarItem(id, data) {
+      const existing = await db
+        .select()
+        .from(sidebarItems)
+        .where(and(eq(sidebarItems.siteId, siteId), eq(sidebarItems.id, id)))
+        .limit(1);
+      const item = existing[0];
+      if (!item) return null;
+
+      if (data.label === undefined) {
+        return toSidebarItem(item);
+      }
+
+      const result = await db
+        .update(sidebarItems)
+        .set({
+          label:
+            item.type === "divider" ? normalizeSidebarLabel(data.label) : null,
+          updatedAt: now(),
+        })
+        .where(and(eq(sidebarItems.siteId, siteId), eq(sidebarItems.id, id)))
+        .returning();
+
+      return result[0] ? toSidebarItem(result[0]) : null;
+    },
+
     async moveSidebarItem(id, afterId, beforeId) {
       const items = await db
         .select()
         .from(sidebarItems)
-        .where(eq(sidebarItems.id, id))
+        .where(and(eq(sidebarItems.siteId, siteId), eq(sidebarItems.id, id)))
         .limit(1);
       if (!items[0]) return null;
 
@@ -446,7 +823,9 @@ export function createCollectionService(
               position: await getSidebarMovePosition(id, afterId, beforeId),
               updatedAt: timestamp,
             })
-            .where(eq(sidebarItems.id, id))
+            .where(
+              and(eq(sidebarItems.siteId, siteId), eq(sidebarItems.id, id)),
+            )
             .returning();
 
           return result[0] ? toSidebarItem(result[0]) : null;
@@ -472,8 +851,9 @@ export function createCollectionService(
         .from(postCollections)
         .innerJoin(
           sql`post`,
-          sql`post.id = ${postCollections.postId} AND post.deleted_at IS NULL`,
+          sql`post.id = ${postCollections.postId} AND post.deleted_at IS NULL AND post.site_id = ${siteId}`,
         )
+        .where(eq(postCollections.siteId, siteId))
         .groupBy(postCollections.collectionId);
 
       const counts = new Map<string, number>();
@@ -486,7 +866,7 @@ export function createCollectionService(
     async addPost(collectionId, postId) {
       await db
         .insert(postCollections)
-        .values({ postId, collectionId, createdAt: now() })
+        .values({ siteId, postId, collectionId, createdAt: now() })
         .onConflictDoNothing();
     },
 
@@ -495,6 +875,7 @@ export function createCollectionService(
         .delete(postCollections)
         .where(
           and(
+            eq(postCollections.siteId, siteId),
             eq(postCollections.postId, postId),
             eq(postCollections.collectionId, collectionId),
           ),
@@ -509,7 +890,13 @@ export function createCollectionService(
           collections,
           eq(postCollections.collectionId, collections.id),
         )
-        .where(eq(postCollections.postId, postId))
+        .where(
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(collections.siteId, siteId),
+            eq(postCollections.postId, postId),
+          ),
+        )
         .orderBy(asc(collections.createdAt));
 
       return hydrateCollections(rows.map((row) => row.collection));
@@ -530,12 +917,18 @@ export function createCollectionService(
             collections,
             eq(postCollections.collectionId, collections.id),
           )
-          .where(inArray(postCollections.postId, chunk))
+          .where(
+            and(
+              eq(postCollections.siteId, siteId),
+              eq(collections.siteId, siteId),
+              inArray(postCollections.postId, chunk),
+            ),
+          )
           .orderBy(asc(collections.createdAt)),
       );
 
       const collectionRows = rows.map((row) => row.collection);
-      const slugMap = await paths.getCollectionSlugMap(
+      const slugMap = await resolvedPaths.getCollectionSlugMap(
         collectionRows.map((row) => row.id),
       );
 
@@ -554,30 +947,93 @@ export function createCollectionService(
       const rows = await db
         .select({ postId: postCollections.postId })
         .from(postCollections)
-        .where(eq(postCollections.collectionId, collectionId));
+        .where(
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(postCollections.collectionId, collectionId),
+          ),
+        );
 
       return rows.map((row) => row.postId);
     },
 
     async syncPostCollections(postId, collectionIds) {
-      if (collectionIds.length === 0) {
-        await db
-          .delete(postCollections)
-          .where(eq(postCollections.postId, postId));
+      const nextCollectionIds = [...new Set(collectionIds)];
+      const existingCollectionIds = await getPostCollectionIds(postId);
+      const existingIds = new Set(existingCollectionIds);
+      const nextIds = new Set(nextCollectionIds);
+      const removedIds = existingCollectionIds.filter((id) => !nextIds.has(id));
+      const addedIds = nextCollectionIds.filter((id) => !existingIds.has(id));
+
+      if (removedIds.length === 0 && addedIds.length === 0) {
         return;
       }
 
-      const deleteQuery = db
-        .delete(postCollections)
-        .where(eq(postCollections.postId, postId));
-      const insertQuery = db.insert(postCollections).values(
-        collectionIds.map((collectionId) => ({
-          postId,
-          collectionId,
-          createdAt: now(),
-        })),
-      );
-      await db.batch([deleteQuery, insertQuery]);
+      if (usesBatchWrites) {
+        const writeQueries = [];
+
+        if (removedIds.length > 0) {
+          writeQueries.push(
+            db
+              .delete(postCollections)
+              .where(
+                and(
+                  eq(postCollections.siteId, siteId),
+                  eq(postCollections.postId, postId),
+                  inArray(postCollections.collectionId, removedIds),
+                ),
+              ),
+          );
+        }
+
+        if (addedIds.length > 0) {
+          const timestamp = now();
+          writeQueries.push(
+            db.insert(postCollections).values(
+              addedIds.map((collectionId) => ({
+                siteId,
+                postId,
+                collectionId,
+                createdAt: timestamp,
+              })),
+            ),
+          );
+        }
+
+        await db.batch(
+          writeQueries as [
+            (typeof writeQueries)[number],
+            ...(typeof writeQueries)[number][],
+          ],
+        );
+        return;
+      }
+
+      await db.transaction(async (tx) => {
+        if (removedIds.length > 0) {
+          await tx
+            .delete(postCollections)
+            .where(
+              and(
+                eq(postCollections.siteId, siteId),
+                eq(postCollections.postId, postId),
+                inArray(postCollections.collectionId, removedIds),
+              ),
+            );
+        }
+
+        if (addedIds.length > 0) {
+          const timestamp = now();
+          await tx.insert(postCollections).values(
+            addedIds.map((collectionId) => ({
+              siteId,
+              postId,
+              collectionId,
+              createdAt: timestamp,
+            })),
+          );
+        }
+      });
     },
   };
 }