@beechcms/api 0.4.3 → 0.6.0-preview.1

package/src/shared/content.repository.d1.ts

@@ -1,20 +1,47 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
+// See LICENSE in the repository root for license terms.
+
 /// <reference types="@cloudflare/workers-types" />
 import {
   ContentRepository,
   EntryNotFoundError,
   RepositoryError,
   SlugConflictError,
-  Seed,
-  SelectOptions,
+  RelationTargetNotFoundError,
+  type BulkFieldUpdate,
+  type DraftSummary,
+  type Seed,
+  type Branch,
+  type SelectOptions,
   buildSelectQuery,
   deserializeFromDb,
   serializeForDb,
 } from '@beechcms/core'
 import { BaseD1Repository } from './base.repository.d1'
 
+// ── Private helpers ───────────────────────────────────────────────────────────
+
+function multiRelBranches(seed: Seed): Branch[] {
+  return seed.branches.filter(b => b.type === 'relation' && b.multiple === true)
+}
+
+function singleRelBranches(seed: Seed): Branch[] {
+  return seed.branches.filter(b => b.type === 'relation' && !b.multiple)
+}
+
+function jTable(seedSlug: string, branchAlias: string): string {
+  return `rel_${seedSlug}_${branchAlias}`
+}
+
+function jDraftTable(seedSlug: string, branchAlias: string): string {
+  return `rel_${seedSlug}_${branchAlias}_drafts`
+}
+
 export class D1ContentRepository extends BaseD1Repository implements ContentRepository {
   /**
-   * Helper to deserialize a DB row using the Seed's branch definitions.
+   * Deserializes a DB row using the Seed's branch definitions.
+   * Skips multi-relation branches — their values come from junction tables.
    */
   private rowToData(seed: Seed, row: any): Record<string, any> {
     const data: Record<string, any> = {
@@ -26,6 +53,8 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
     }
 
     for (const branch of seed.branches) {
+      // Multi-relation values live in junction tables, not as columns on this table
+      if (branch.type === 'relation' && branch.multiple === true) continue
       if (Object.hasOwn(row, branch.alias)) {
         data[branch.alias] = deserializeFromDb(branch, row[branch.alias])
       }
@@ -34,31 +63,92 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
     return data
   }
 
+  /**
+   * Fetches multi-relation arrays for a single entry and attaches them to `data`.
+   */
+  private async attachMultiRelations(
+    seed: Seed,
+    entryId: string,
+    data: Record<string, any>,
+  ): Promise<void> {
+    const branches = multiRelBranches(seed)
+    if (branches.length === 0) return
+
+    const stmts = branches.map(b =>
+      this.database
+        .prepare(`SELECT target_id FROM ${jTable(seed.slug, b.alias)} WHERE parent_id = ? ORDER BY position ASC`)
+        .bind(entryId),
+    )
+
+    const results = await this.database.batch(stmts)
+    for (let i = 0; i < branches.length; i++) {
+      data[branches[i].alias] = (results[i].results ?? []).map((r: any) => r.target_id)
+    }
+  }
+
+  /**
+   * Fetches multi-relation arrays for a list of entries and attaches them.
+   * One query per multi-relation branch (O(R) queries, R = branch count).
+   */
+  private async attachMultiRelationsMany(
+    seed: Seed,
+    entries: Record<string, any>[],
+  ): Promise<void> {
+    const branches = multiRelBranches(seed)
+    if (branches.length === 0 || entries.length === 0) return
+
+    const ids = entries.map(e => e.id)
+    const placeholders = ids.map(() => '?').join(', ')
+
+    const stmts = branches.map(b =>
+      this.database
+        .prepare(
+          `SELECT parent_id, target_id FROM ${jTable(seed.slug, b.alias)}` +
+          ` WHERE parent_id IN (${placeholders}) ORDER BY parent_id, position ASC`,
+        )
+        .bind(...ids),
+    )
+
+    const results = await this.database.batch(stmts)
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i]
+      const byParent = new Map<string, string[]>()
+      for (const row of results[i].results ?? []) {
+        const r = row as Record<string, unknown>
+        const pid = r.parent_id as string
+        if (!byParent.has(pid)) byParent.set(pid, [])
+        byParent.get(pid)!.push(r.target_id as string)
+      }
+      for (const entry of entries) {
+        entry[branch.alias] = byParent.get(entry.id) ?? []
+      }
+    }
+  }
+
   async findMany(
     seed: Seed,
     options: SelectOptions
   ): Promise<{ items: Record<string, any>[]; total: number }> {
     try {
       const { sql, bindings } = buildSelectQuery(seed, options)
-      
-      // We need the total count for pagination. 
-      // We build a count query by replacing the SELECT part.
-      // Note: buildSelectQuery might have joins and where clauses.
+
       const countSql = sql
         .replace(/SELECT .* FROM/, 'SELECT COUNT(*) as total FROM')
         .replace(/ ORDER BY .*$/, '')
         .replace(/ LIMIT \? OFFSET \?$/, '')
-      
+
       const countBindings = bindings.slice(0, bindings.length - (options.pagination ? 2 : 0))
 
       const [batchResults, totalCountResult] = await this.database.batch([
         this.database.prepare(sql).bind(...bindings),
-        this.database.prepare(countSql).bind(...countBindings)
+        this.database.prepare(countSql).bind(...countBindings),
       ])
 
-      const contentEntries = (batchResults.results || []).map((entryRow) => this.rowToData(seed, entryRow))
+      const contentEntries = (batchResults.results || []).map(row => this.rowToData(seed, row))
       const totalEntriesCount = (totalCountResult.results?.[0] as any)?.total || 0
 
+      await this.attachMultiRelationsMany(seed, contentEntries)
+
       return { items: contentEntries, total: totalEntriesCount }
     } catch (error) {
       throw this.mapError(error, `findMany(${seed.slug})`)
@@ -77,7 +167,9 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
         throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
       }
 
-      return this.rowToData(seed, entryRow)
+      const data = this.rowToData(seed, entryRow)
+      await this.attachMultiRelations(seed, id, data)
+      return data
     } catch (error) {
       if (error instanceof EntryNotFoundError) throw error
       throw this.mapError(error, `findById(${seed.slug}, ${id})`)
@@ -96,7 +188,9 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
         throw new EntryNotFoundError(`Entry with slug "${slug}" not found in ${seed.slug}`)
       }
 
-      return this.rowToData(seed, entryRow)
+      const data = this.rowToData(seed, entryRow)
+      await this.attachMultiRelations(seed, entryRow.id as string, data)
+      return data
     } catch (error) {
       if (error instanceof EntryNotFoundError) throw error
       throw this.mapError(error, `findBySlug(${seed.slug}, ${slug})`)
@@ -109,23 +203,20 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
   }> {
     try {
       const tableName = this.getTableName(seed.slug)
-      
-      // Retrieve count per status
+
       const statusResults = await this.database
         .prepare(`SELECT status, COUNT(*) as count FROM ${tableName} GROUP BY status`)
         .all()
-      
+
       const statusesCount: Record<string, number> = {}
       for (const statusRow of statusResults.results || []) {
         statusesCount[statusRow.status as string] = statusRow.count as number
       }
 
-      // Collect unique tags for branches of type 'tags'
       const tagsByColumn: Record<string, string[]> = {}
       const tagBranches = seed.branches.filter(branch => branch.type === 'tags')
-      
+
       for (const branch of tagBranches) {
-        // Use SQLite json_each to expand tags stored as JSON arrays
         const tagResults = await this.database
           .prepare(`SELECT DISTINCT value FROM ${tableName}, json_each(${tableName}.${branch.alias}) WHERE value IS NOT NULL`)
           .all()
@@ -143,12 +234,12 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
       const tableName = this.getTableName(seed.slug)
       let sql = `SELECT 1 FROM ${tableName} WHERE slug = ?`
       const queryBindings: any[] = [slug]
-      
+
       if (excludeId) {
         sql += ` AND id != ?`
         queryBindings.push(excludeId)
       }
-      
+
       const entryExistsResult = await this.database.prepare(sql).bind(...queryBindings).first()
       return entryExistsResult !== null
     } catch (error) {
@@ -156,6 +247,231 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
     }
   }
 
+
+  private buildCreateMainStmt(
+    seed: Seed,
+    id: string,
+    slug: string,
+    status: string,
+    data: Record<string, any>
+  ): D1PreparedStatement {
+    const tableName = this.getTableName(seed.slug)
+    const columnNames = ['id', 'slug', 'status']
+    const placeholders = ['?', '?', '?']
+    const queryBindings: any[] = [id, slug, status]
+
+    const mRelAliases = new Set(multiRelBranches(seed).map(b => b.alias))
+
+    for (const branch of seed.branches) {
+      if (mRelAliases.has(branch.alias)) continue
+      if (Object.hasOwn(data, branch.alias)) {
+        columnNames.push(branch.alias)
+        placeholders.push('?')
+        queryBindings.push(serializeForDb(branch, data[branch.alias]))
+      }
+    }
+
+    const mainSql = `INSERT INTO ${tableName} (${columnNames.join(', ')}) VALUES (${placeholders.join(', ')})`
+    return this.database.prepare(mainSql).bind(...queryBindings)
+  }
+
+  private buildUpdateMainStmt(
+    seed: Seed,
+    id: string,
+    data: Record<string, any>,
+    status?: string
+  ): { stmt: D1PreparedStatement | null; junctionUpdates: any[] } {
+    const tableName = this.getTableName(seed.slug)
+    const updateClauses: string[] = []
+    const queryBindings: any[] = []
+
+    const mRelBranches = multiRelBranches(seed)
+    const mRelAliases = new Set(mRelBranches.map(b => b.alias))
+
+    if (status) {
+      updateClauses.push('status = ?')
+      queryBindings.push(status)
+    }
+
+    for (const branch of seed.branches) {
+      if (mRelAliases.has(branch.alias)) continue
+      if (Object.hasOwn(data, branch.alias)) {
+        updateClauses.push(`${branch.alias} = ?`)
+        queryBindings.push(serializeForDb(branch, data[branch.alias]))
+      }
+    }
+
+    const junctionUpdates = mRelBranches.filter(b => Object.hasOwn(data, b.alias))
+
+    if (updateClauses.length === 0 && junctionUpdates.length === 0) {
+      return { stmt: null, junctionUpdates: [] }
+    }
+
+    updateClauses.push('updated_at = (unixepoch())')
+
+    const mainSql = `UPDATE ${tableName} SET ${updateClauses.join(', ')} WHERE id = ?`
+    queryBindings.push(id)
+
+    return {
+      stmt: this.database.prepare(mainSql).bind(...queryBindings),
+      junctionUpdates
+    }
+  }
+
+  private buildJunctionInserts(seedSlug: string, parentId: string, branchAlias: string, targetIds: string[]): D1PreparedStatement[] {
+    const jt = jTable(seedSlug, branchAlias)
+    return targetIds.map((targetId, i) =>
+      this.database
+        .prepare(`INSERT INTO ${jt} (parent_id, target_id, position) VALUES (?, ?, ?)`)
+        .bind(parentId, targetId, i),
+    )
+  }
+
+  private buildDraftJunctionInserts(seedSlug: string, entryId: string, branchAlias: string, targetIds: string[]): D1PreparedStatement[] {
+    const jdt = jDraftTable(seedSlug, branchAlias)
+    return targetIds.map((targetId, i) =>
+      this.database
+        .prepare(`INSERT INTO ${jdt} (entry_id, target_id, position) VALUES (?, ?, ?)`)
+        .bind(entryId, targetId, i),
+    )
+  }
+
+  private async validatePublishDraftRelations(seed: Seed, draftRow: Record<string, unknown>, entryId: string) {
+    for (const branch of singleRelBranches(seed)) {
+      const value = draftRow[branch.alias]
+      if (value == null) continue
+      const exists = await this.database
+        .prepare(`SELECT 1 FROM content_${branch.targetSeed} WHERE id = ? LIMIT 1`)
+        .bind(value)
+        .first()
+      if (!exists) {
+        throw new RelationTargetNotFoundError({
+          alias: branch.alias,
+          targetSeed: branch.targetSeed!,
+          value: typeof value === 'string' ? value : (JSON.stringify(value) ?? 'undefined'),
+        })
+      }
+    }
+
+    const mRelBranches = multiRelBranches(seed)
+    const mRelDraftIds = new Map<string, string[]>()
+
+    for (const branch of mRelBranches) {
+      const jdt = jDraftTable(seed.slug, branch.alias)
+      const rows = await this.database
+        .prepare(`SELECT target_id FROM ${jdt} WHERE entry_id = ? ORDER BY position ASC`)
+        .bind(entryId)
+        .all()
+      const targetIds = (rows.results ?? []).map((r: any) => String(r.target_id))
+
+      for (const targetId of targetIds) {
+        const exists = await this.database
+          .prepare(`SELECT 1 FROM content_${branch.targetSeed} WHERE id = ? LIMIT 1`)
+          .bind(targetId)
+          .first()
+        if (!exists) {
+          throw new RelationTargetNotFoundError({
+            alias: branch.alias,
+            targetSeed: branch.targetSeed!,
+            value: targetId,
+          })
+        }
+      }
+      mRelDraftIds.set(branch.alias, targetIds)
+    }
+
+    return { mRelBranches, mRelDraftIds }
+  }
+
+  private getBulkArrayUpdateStmts(seedSlug: string, id: string, alias: string, update: BulkFieldUpdate): D1PreparedStatement[] {
+    const jt = jTable(seedSlug, alias)
+    const stmts: D1PreparedStatement[] = []
+
+    if (update.kind === 'array_replace') {
+      const deleteStmt = this.database.prepare(`DELETE FROM ${jt} WHERE parent_id = ?`).bind(id)
+      const insertStmts = update.value.map((v, i) => 
+        this.database.prepare(`INSERT INTO ${jt} (parent_id, target_id, position) VALUES (?, ?, ?)`).bind(id, v, i)
+      )
+      stmts.push(deleteStmt, ...insertStmts)
+    } else if (update.kind === 'array_add') {
+      for (const targetId of update.value) {
+        stmts.push(
+          this.database
+            .prepare(
+              `INSERT OR IGNORE INTO ${jt} (parent_id, target_id, position) VALUES (?, ?, (SELECT COALESCE(MAX(position), -1) + 1 FROM ${jt} WHERE parent_id = ?))`,
+            )
+            .bind(id, targetId, id),
+        )
+      }
+    } else if (update.kind === 'array_remove' && update.value.length > 0) {
+      const placeholders = update.value.map(() => '?').join(', ')
+      stmts.push(
+        this.database
+          .prepare(`DELETE FROM ${jt} WHERE parent_id = ? AND target_id IN (${placeholders})`)
+          .bind(id, ...update.value),
+      )
+    }
+    return stmts
+  }
+
+  private async processBulkUpdateSingle(
+    seedSlug: string,
+    id: string,
+    fields: Record<string, BulkFieldUpdate>,
+    tableName: string
+  ): Promise<void> {
+    const stmts: D1PreparedStatement[] = []
+
+    const setClauses: string[] = ['updated_at = (unixepoch())']
+    const setBindings: unknown[] = []
+
+    for (const [alias, update] of Object.entries(fields)) {
+      if (update.kind === 'set') {
+        setClauses.unshift(`${alias} = ?`)
+        setBindings.push(update.value)
+      } else {
+        stmts.push(...this.getBulkArrayUpdateStmts(seedSlug, id, alias, update))
+      }
+    }
+
+    stmts.unshift(
+      this.database
+        .prepare(`UPDATE ${tableName} SET ${setClauses.join(', ')} WHERE id = ?`)
+        .bind(...setBindings, id),
+    )
+
+    const results = await this.database.batch(stmts)
+    if ((results[0].meta?.changes ?? 0) === 0) {
+      throw new Error('not-found')
+    }
+  }
+
+  private async processBulkUpdateChunk(
+    seedSlug: string,
+    chunk: string[],
+    fields: Record<string, BulkFieldUpdate>,
+    tableName: string
+  ): Promise<{ updated: number; failed: Array<{ id: string; reason: string }> }> {
+    let updated = 0
+    const failed: Array<{ id: string; reason: string }> = []
+    
+    for (const id of chunk) {
+      try {
+        await this.processBulkUpdateSingle(seedSlug, id, fields, tableName)
+        updated++
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        if (msg === 'not-found') {
+          failed.push({ id, reason: 'not-found' })
+        } else {
+          const isFk = /FOREIGN KEY constraint failed/i.test(msg)
+          failed.push({ id, reason: isFk ? `relation-target-not-found:${id}` : `error:${msg}` })
+        }
+      }
+    }
+    return { updated, failed }
+  }
+
   async create(
     seed: Seed,
     id: string,
@@ -168,21 +484,21 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
         throw new SlugConflictError(`Slug "${slug}" already exists for ${seed.slug}`)
       }
 
-      const tableName = this.getTableName(seed.slug)
-      const columnNames = ['id', 'slug', 'status']
-      const placeholders = ['?', '?', '?']
-      const queryBindings: any[] = [id, slug, status]
+      const batchStmts: D1PreparedStatement[] = [
+        this.buildCreateMainStmt(seed, id, slug, status, data),
+      ]
 
-      for (const branch of seed.branches) {
-        if (Object.hasOwn(data, branch.alias)) {
-          columnNames.push(branch.alias)
-          placeholders.push('?')
-          queryBindings.push(serializeForDb(branch, data[branch.alias]))
-        }
+      for (const branch of multiRelBranches(seed)) {
+        const value = data[branch.alias]
+        if (!Array.isArray(value) || value.length === 0) continue
+        batchStmts.push(...this.buildJunctionInserts(seed.slug, id, branch.alias, value))
       }
 
-      const sql = `INSERT INTO ${tableName} (${columnNames.join(', ')}) VALUES (${placeholders.join(', ')})`
-      await this.database.prepare(sql).bind(...queryBindings).run()
+      if (batchStmts.length === 1) {
+        await batchStmts[0].run()
+      } else {
+        await this.database.batch(batchStmts)
+      }
     } catch (error) {
       if (error instanceof SlugConflictError) throw error
       throw this.mapError(error, `create(${seed.slug})`)
@@ -196,32 +512,30 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
     status?: string
   ): Promise<void> {
     try {
-      const tableName = this.getTableName(seed.slug)
-      const updateClauses: string[] = []
-      const queryBindings: any[] = []
+      const { stmt, junctionUpdates } = this.buildUpdateMainStmt(seed, id, data, status)
+      
+      if (!stmt && junctionUpdates.length === 0) return
 
-      if (status) {
-        updateClauses.push('status = ?')
-        queryBindings.push(status)
-      }
+      const batchStmts: D1PreparedStatement[] = []
+      if (stmt) batchStmts.push(stmt)
 
-      for (const branch of seed.branches) {
-        if (Object.hasOwn(data, branch.alias)) {
-          updateClauses.push(`${branch.alias} = ?`)
-          queryBindings.push(serializeForDb(branch, data[branch.alias]))
-        }
+      for (const branch of junctionUpdates) {
+        const jt = jTable(seed.slug, branch.alias)
+        const value = (data[branch.alias] ?? []) as string[]
+        const deleteStmt = this.database.prepare(`DELETE FROM ${jt} WHERE parent_id = ?`).bind(id)
+        batchStmts.push(deleteStmt, ...this.buildJunctionInserts(seed.slug, id, branch.alias, value))
       }
 
-      if (updateClauses.length === 0) return
-
-      updateClauses.push('updated_at = (unixepoch())')
-      
-      const sql = `UPDATE ${tableName} SET ${updateClauses.join(', ')} WHERE id = ?`
-      queryBindings.push(id)
-
-      const updateResult = await this.database.prepare(sql).bind(...queryBindings).run()
-      if (updateResult.meta.changes === 0) {
-        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+      if (batchStmts.length === 1) {
+        const updateResult = await batchStmts[0].run()
+        if (updateResult.meta.changes === 0) {
+          throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+        }
+      } else if (batchStmts.length > 1) {
+        const results = await this.database.batch(batchStmts)
+        if (stmt && (results[0].meta?.changes ?? 0) === 0) {
+          throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+        }
       }
     } catch (error) {
       if (error instanceof EntryNotFoundError) throw error
@@ -232,8 +546,7 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
   async delete(seed: Seed, id: string): Promise<{ row: Record<string, any> }> {
     try {
       const tableName = this.getTableName(seed.slug)
-      
-      // Retrieve the row before deletion to allow for potential cleanup (e.g., media files in R2)
+
       const entryRow = await this.database
         .prepare(`SELECT * FROM ${tableName} WHERE id = ?`)
         .bind(id)
@@ -259,12 +572,16 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
       }
 
       const draftTableName = this.getTableName(seed.slug, true)
+      const mRelBranches = multiRelBranches(seed)
+      const mRelAliases = new Set(mRelBranches.map(b => b.alias))
+
       const columnNames = ['entry_id']
       const placeholders = ['?']
       const queryBindings: any[] = [entryId]
       const updateClauses: string[] = []
 
       for (const branch of seed.branches) {
+        if (mRelAliases.has(branch.alias)) continue
         if (Object.hasOwn(data, branch.alias)) {
           const serializedValue = serializeForDb(branch, data[branch.alias])
           columnNames.push(branch.alias)
@@ -277,11 +594,38 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
       updateClauses.push('updated_at = (unixepoch())')
 
       const sql = `
-        INSERT INTO ${draftTableName} (${columnNames.join(', ')}) 
+        INSERT INTO ${draftTableName} (${columnNames.join(', ')})
         VALUES (${placeholders.join(', ')})
         ON CONFLICT(entry_id) DO UPDATE SET ${updateClauses.join(', ')}
       `
-      await this.database.prepare(sql).bind(...queryBindings).run()
+
+      const junctionUpdates = mRelBranches.filter(b => Object.hasOwn(data, b.alias))
+
+      if (junctionUpdates.length === 0) {
+        await this.database.prepare(sql).bind(...queryBindings).run()
+        return
+      }
+
+      const batchStmts: D1PreparedStatement[] = [
+        this.database.prepare(sql).bind(...queryBindings),
+      ]
+
+      for (const branch of junctionUpdates) {
+        const jdt = jDraftTable(seed.slug, branch.alias)
+        const value = (data[branch.alias] ?? []) as string[]
+        batchStmts.push(
+          this.database.prepare(`DELETE FROM ${jdt} WHERE entry_id = ?`).bind(entryId),
+        )
+        for (let i = 0; i < value.length; i++) {
+          batchStmts.push(
+            this.database
+              .prepare(`INSERT INTO ${jdt} (entry_id, target_id, position) VALUES (?, ?, ?)`)
+              .bind(entryId, value[i], i),
+          )
+        }
+      }
+
+      await this.database.batch(batchStmts)
     } catch (error) {
       throw this.mapError(error, `saveDraft(${seed.slug}, ${entryId})`)
     }
@@ -299,14 +643,33 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
 
       if (!draftRow) return null
 
-      // Filter out nulls from draft row (only include explicitly provided fields)
+      const mRelBranches = multiRelBranches(seed)
+      const mRelAliases = new Set(mRelBranches.map(b => b.alias))
+
       const draftData: Record<string, any> = {}
       for (const branch of seed.branches) {
+        if (mRelAliases.has(branch.alias)) continue
         if (draftRow[branch.alias] !== null) {
           draftData[branch.alias] = deserializeFromDb(branch, draftRow[branch.alias])
         }
       }
 
+      // Fetch multi-relation draft arrays from junction draft tables
+      if (mRelBranches.length > 0) {
+        const stmts = mRelBranches.map(b =>
+          this.database
+            .prepare(`SELECT target_id FROM ${jDraftTable(seed.slug, b.alias)} WHERE entry_id = ? ORDER BY position ASC`)
+            .bind(entryId),
+        )
+        const results = await this.database.batch(stmts)
+        for (let i = 0; i < mRelBranches.length; i++) {
+          const ids = (results[i].results ?? []).map((r: any) => r.target_id as string)
+          if (ids.length > 0) {
+            draftData[mRelBranches[i].alias] = ids
+          }
+        }
+      }
+
       return draftData
     } catch (error) {
       throw this.mapError(error, `getDraft(${seed.slug}, ${entryId})`)
@@ -337,17 +700,20 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
       const draftRow = await this.database
         .prepare(`SELECT * FROM ${draftTableName} WHERE entry_id = ?`)
         .bind(entryId)
-        .first()
+        .first<Record<string, unknown>>()
 
       if (!draftRow) {
         throw new EntryNotFoundError(`No draft found for ${entryId} in ${seed.slug}`)
       }
 
-      // Build UPDATE clause for the live table using data from the draft
+      const { mRelBranches, mRelDraftIds } = await this.validatePublishDraftRelations(seed, draftRow, entryId)
+
+      const mRelAliases = new Set(mRelBranches.map(b => b.alias))
       const updateClauses: string[] = []
       const queryBindings: any[] = []
 
       for (const branch of seed.branches) {
+        if (mRelAliases.has(branch.alias)) continue
         if (draftRow[branch.alias] !== null) {
           updateClauses.push(`${branch.alias} = ?`)
           queryBindings.push(draftRow[branch.alias])
@@ -355,21 +721,54 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
       }
 
       updateClauses.push('updated_at = (unixepoch())')
-      
       const updateSql = `UPDATE ${liveTableName} SET ${updateClauses.join(', ')} WHERE id = ?`
       queryBindings.push(entryId)
 
-      // Execute batch to atomically update live table and delete draft
-      await this.database.batch([
+      const batchStmts: D1PreparedStatement[] = [
         this.database.prepare(updateSql).bind(...queryBindings),
-        this.database.prepare(`DELETE FROM ${draftTableName} WHERE entry_id = ?`).bind(entryId)
-      ])
+        this.database.prepare(`DELETE FROM ${draftTableName} WHERE entry_id = ?`).bind(entryId),
+      ]
+
+      for (const branch of mRelBranches) {
+        const lt = jTable(seed.slug, branch.alias)
+        const jdt = jDraftTable(seed.slug, branch.alias)
+        const targetIds = mRelDraftIds.get(branch.alias) ?? []
+
+        batchStmts.push(
+          this.database.prepare(`DELETE FROM ${lt} WHERE parent_id = ?`).bind(entryId),
+          this.database.prepare(`DELETE FROM ${jdt} WHERE entry_id = ?`).bind(entryId),
+          ...this.buildJunctionInserts(seed.slug, entryId, branch.alias, targetIds)
+        )
+      }
+
+      await this.database.batch(batchStmts)
     } catch (error) {
       if (error instanceof EntryNotFoundError) throw error
+      if (error instanceof RelationTargetNotFoundError) throw error
       throw this.mapError(error, `publishDraft(${seed.slug}, ${entryId})`)
     }
   }
 
+  async bulkUpdate(
+    seedSlug: string,
+    ids: string[],
+    fields: Record<string, BulkFieldUpdate>,
+  ): Promise<{ updated: number; failed: Array<{ id: string; reason: string }> }> {
+    const CHUNK = 50
+    const tableName = this.getTableName(seedSlug)
+    let updated = 0
+    const failed: Array<{ id: string; reason: string }> = []
+
+    for (let offset = 0; offset < ids.length; offset += CHUNK) {
+      const chunk = ids.slice(offset, offset + CHUNK)
+      const res = await this.processBulkUpdateChunk(seedSlug, chunk, fields, tableName)
+      updated += res.updated
+      failed.push(...res.failed)
+    }
+
+    return { updated, failed }
+  }
+
   async deleteDraft(seed: Seed, entryId: string): Promise<void> {
     try {
       if (!seed.allowDrafts) return
@@ -379,4 +778,74 @@ export class D1ContentRepository extends BaseD1Repository implements ContentRepo
       throw this.mapError(error, `deleteDraft(${seed.slug}, ${entryId})`)
     }
   }
+
+  async findPendingDrafts(seeds: Seed[]): Promise<DraftSummary[]> {
+    try {
+      if (seeds.length === 0) return []
+
+      const unionSelects: string[] = []
+      const bindings: (string | number)[] = []
+
+      for (const seed of seeds) {
+        const draftTable = `content_${seed.slug}_drafts`
+        const liveTable = `content_${seed.slug}`
+        const titleCol = seed.displayNameAlias
+        const seedLabel = seed.labelPlural ?? seed.label
+
+        unionSelects.push(`
+          SELECT
+            ? AS seed_slug,
+            ? AS seed_label,
+            d.entry_id AS id,
+            d.updated_at AS updated_at,
+            COALESCE(d.${titleCol}, l.${titleCol}) AS title
+          FROM ${draftTable} d
+          LEFT JOIN ${liveTable} l ON l.id = d.entry_id
+        `)
+        bindings.push(seed.slug, seedLabel)
+      }
+
+      const sql = `
+        WITH all_drafts AS (
+          ${unionSelects.join('\nUNION ALL\n')}
+        )
+        SELECT
+          ad.seed_slug   AS seedSlug,
+          ad.seed_label  AS seedLabel,
+          ad.id          AS id,
+          ad.updated_at  AS updatedAt,
+          ad.title       AS title,
+          al.user_name   AS lastName,
+          al.user_email  AS lastEmail
+        FROM all_drafts ad
+        LEFT JOIN activity_logs al
+          ON al.id = (
+            SELECT id FROM activity_logs
+            WHERE entity_id = ad.id
+              AND entity_slug = ad.seed_slug
+              AND action = 'update'
+              AND json_extract(details, '$.note') = 'draft saved'
+            ORDER BY created_at DESC
+            LIMIT 1
+          )
+        ORDER BY ad.updated_at DESC
+      `
+
+      const { results } = await this.database.prepare(sql).bind(...bindings).all()
+
+      return (results ?? []).map((row: any): DraftSummary => ({
+        id: String(row.id),
+        seedSlug: String(row.seedSlug),
+        seedLabel: String(row.seedLabel),
+        title: row.title != null && String(row.title).trim() ? String(row.title) : String(row.id),
+        updatedAt: Number(row.updatedAt),
+        lastModifiedBy: {
+          name: row.lastName ?? null,
+          email: row.lastEmail ?? '',
+        },
+      }))
+    } catch (error) {
+      throw this.mapError(error, 'findPendingDrafts')
+    }
+  }
 }