@beechcms/api 0.5.0 → 0.6.0-preview.2

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

@@ -1,382 +1,851 @@
-/// <reference types="@cloudflare/workers-types" />
-import {
-  ContentRepository,
-  EntryNotFoundError,
-  RepositoryError,
-  SlugConflictError,
-  Seed,
-  SelectOptions,
-  buildSelectQuery,
-  deserializeFromDb,
-  serializeForDb,
-} from '@beechcms/core'
-import { BaseD1Repository } from './base.repository.d1'
-
-export class D1ContentRepository extends BaseD1Repository implements ContentRepository {
-  /**
-   * Helper to deserialize a DB row using the Seed's branch definitions.
-   */
-  private rowToData(seed: Seed, row: any): Record<string, any> {
-    const data: Record<string, any> = {
-      id: row.id,
-      slug: row.slug,
-      status: row.status,
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-    }
-
-    for (const branch of seed.branches) {
-      if (Object.hasOwn(row, branch.alias)) {
-        data[branch.alias] = deserializeFromDb(branch, row[branch.alias])
-      }
-    }
-
-    return data
-  }
-
-  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)
-      ])
-
-      const contentEntries = (batchResults.results || []).map((entryRow) => this.rowToData(seed, entryRow))
-      const totalEntriesCount = (totalCountResult.results?.[0] as any)?.total || 0
-
-      return { items: contentEntries, total: totalEntriesCount }
-    } catch (error) {
-      throw this.mapError(error, `findMany(${seed.slug})`)
-    }
-  }
-
-  async findById(seed: Seed, id: string): Promise<Record<string, any>> {
-    try {
-      const tableName = this.getTableName(seed.slug)
-      const entryRow = await this.database
-        .prepare(`SELECT * FROM ${tableName} WHERE id = ? LIMIT 1`)
-        .bind(id)
-        .first()
-
-      if (!entryRow) {
-        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
-      }
-
-      return this.rowToData(seed, entryRow)
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) throw error
-      throw this.mapError(error, `findById(${seed.slug}, ${id})`)
-    }
-  }
-
-  async findBySlug(seed: Seed, slug: string): Promise<Record<string, any>> {
-    try {
-      const tableName = this.getTableName(seed.slug)
-      const entryRow = await this.database
-        .prepare(`SELECT * FROM ${tableName} WHERE slug = ? LIMIT 1`)
-        .bind(slug)
-        .first()
-
-      if (!entryRow) {
-        throw new EntryNotFoundError(`Entry with slug "${slug}" not found in ${seed.slug}`)
-      }
-
-      return this.rowToData(seed, entryRow)
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) throw error
-      throw this.mapError(error, `findBySlug(${seed.slug}, ${slug})`)
-    }
-  }
-
-  async getFacets(seed: Seed): Promise<{
-    statuses: Record<string, number>
-    tagsByColumn: Record<string, string[]>
-  }> {
-    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()
-        tagsByColumn[branch.alias] = (tagResults.results || []).map(row => row.value as string)
-      }
-
-      return { statuses: statusesCount, tagsByColumn }
-    } catch (error) {
-      throw this.mapError(error, `getFacets(${seed.slug})`)
-    }
-  }
-
-  async existsSlug(seed: Seed, slug: string, excludeId?: string): Promise<boolean> {
-    try {
-      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) {
-      throw this.mapError(error, `existsSlug(${seed.slug}, ${slug})`)
-    }
-  }
-
-  async create(
-    seed: Seed,
-    id: string,
-    slug: string,
-    status: string,
-    data: Record<string, any>
-  ): Promise<void> {
-    try {
-      if (await this.existsSlug(seed, slug)) {
-        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]
-
-      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]))
-        }
-      }
-
-      const sql = `INSERT INTO ${tableName} (${columnNames.join(', ')}) VALUES (${placeholders.join(', ')})`
-      await this.database.prepare(sql).bind(...queryBindings).run()
-    } catch (error) {
-      if (error instanceof SlugConflictError) throw error
-      throw this.mapError(error, `create(${seed.slug})`)
-    }
-  }
-
-  async update(
-    seed: Seed,
-    id: string,
-    data: Record<string, any>,
-    status?: string
-  ): Promise<void> {
-    try {
-      const tableName = this.getTableName(seed.slug)
-      const updateClauses: string[] = []
-      const queryBindings: any[] = []
-
-      if (status) {
-        updateClauses.push('status = ?')
-        queryBindings.push(status)
-      }
-
-      for (const branch of seed.branches) {
-        if (Object.hasOwn(data, branch.alias)) {
-          updateClauses.push(`${branch.alias} = ?`)
-          queryBindings.push(serializeForDb(branch, data[branch.alias]))
-        }
-      }
-
-      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}`)
-      }
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) throw error
-      throw this.mapError(error, `update(${seed.slug}, ${id})`)
-    }
-  }
-
-  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)
-        .first()
-
-      if (!entryRow) {
-        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
-      }
-
-      await this.database.prepare(`DELETE FROM ${tableName} WHERE id = ?`).bind(id).run()
-
-      return { row: this.rowToData(seed, entryRow) }
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) throw error
-      throw this.mapError(error, `delete(${seed.slug}, ${id})`)
-    }
-  }
-
-  async saveDraft(seed: Seed, entryId: string, data: Record<string, any>): Promise<void> {
-    try {
-      if (!seed.allowDrafts) {
-        throw new RepositoryError(`Drafts not allowed for ${seed.slug}`)
-      }
-
-      const draftTableName = this.getTableName(seed.slug, true)
-      const columnNames = ['entry_id']
-      const placeholders = ['?']
-      const queryBindings: any[] = [entryId]
-      const updateClauses: string[] = []
-
-      for (const branch of seed.branches) {
-        if (Object.hasOwn(data, branch.alias)) {
-          const serializedValue = serializeForDb(branch, data[branch.alias])
-          columnNames.push(branch.alias)
-          placeholders.push('?')
-          queryBindings.push(serializedValue)
-          updateClauses.push(`${branch.alias} = EXCLUDED.${branch.alias}`)
-        }
-      }
-
-      updateClauses.push('updated_at = (unixepoch())')
-
-      const sql = `
-        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()
-    } catch (error) {
-      throw this.mapError(error, `saveDraft(${seed.slug}, ${entryId})`)
-    }
-  }
-
-  async getDraft(seed: Seed, entryId: string): Promise<Record<string, any> | null> {
-    try {
-      if (!seed.allowDrafts) return null
-
-      const draftTableName = this.getTableName(seed.slug, true)
-      const draftRow = await this.database
-        .prepare(`SELECT * FROM ${draftTableName} WHERE entry_id = ?`)
-        .bind(entryId)
-        .first()
-
-      if (!draftRow) return null
-
-      // Filter out nulls from draft row (only include explicitly provided fields)
-      const draftData: Record<string, any> = {}
-      for (const branch of seed.branches) {
-        if (draftRow[branch.alias] !== null) {
-          draftData[branch.alias] = deserializeFromDb(branch, draftRow[branch.alias])
-        }
-      }
-
-      return draftData
-    } catch (error) {
-      throw this.mapError(error, `getDraft(${seed.slug}, ${entryId})`)
-    }
-  }
-
-  async hasDraft(seed: Seed, entryId: string): Promise<boolean> {
-    try {
-      if (!seed.allowDrafts) return false
-      const draftTableName = this.getTableName(seed.slug, true)
-      const draftExistsResult = await this.database
-        .prepare(`SELECT 1 FROM ${draftTableName} WHERE entry_id = ? LIMIT 1`)
-        .bind(entryId)
-        .first()
-      return draftExistsResult !== null
-    } catch (error) {
-      throw this.mapError(error, `hasDraft(${seed.slug}, ${entryId})`)
-    }
-  }
-
-  async publishDraft(seed: Seed, entryId: string): Promise<void> {
-    try {
-      if (!seed.allowDrafts) return
-
-      const draftTableName = this.getTableName(seed.slug, true)
-      const liveTableName = this.getTableName(seed.slug)
-
-      const draftRow = await this.database
-        .prepare(`SELECT * FROM ${draftTableName} WHERE entry_id = ?`)
-        .bind(entryId)
-        .first()
-
-      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 updateClauses: string[] = []
-      const queryBindings: any[] = []
-
-      for (const branch of seed.branches) {
-        if (draftRow[branch.alias] !== null) {
-          updateClauses.push(`${branch.alias} = ?`)
-          queryBindings.push(draftRow[branch.alias])
-        }
-      }
-
-      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([
-        this.database.prepare(updateSql).bind(...queryBindings),
-        this.database.prepare(`DELETE FROM ${draftTableName} WHERE entry_id = ?`).bind(entryId)
-      ])
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) throw error
-      throw this.mapError(error, `publishDraft(${seed.slug}, ${entryId})`)
-    }
-  }
-
-  async deleteDraft(seed: Seed, entryId: string): Promise<void> {
-    try {
-      if (!seed.allowDrafts) return
-      const draftTableName = this.getTableName(seed.slug, true)
-      await this.database.prepare(`DELETE FROM ${draftTableName} WHERE entry_id = ?`).bind(entryId).run()
-    } catch (error) {
-      throw this.mapError(error, `deleteDraft(${seed.slug}, ${entryId})`)
-    }
-  }
-}
+// 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,
+  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 {
+  /**
+   * 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> = {
+      id: row.id,
+      slug: row.slug,
+      status: row.status,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+    }
+
+    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])
+      }
+    }
+
+    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)
+
+      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),
+      ])
+
+      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})`)
+    }
+  }
+
+  async findById(seed: Seed, id: string): Promise<Record<string, any>> {
+    try {
+      const tableName = this.getTableName(seed.slug)
+      const entryRow = await this.database
+        .prepare(`SELECT * FROM ${tableName} WHERE id = ? LIMIT 1`)
+        .bind(id)
+        .first()
+
+      if (!entryRow) {
+        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+      }
+
+      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})`)
+    }
+  }
+
+  async findBySlug(seed: Seed, slug: string): Promise<Record<string, any>> {
+    try {
+      const tableName = this.getTableName(seed.slug)
+      const entryRow = await this.database
+        .prepare(`SELECT * FROM ${tableName} WHERE slug = ? LIMIT 1`)
+        .bind(slug)
+        .first()
+
+      if (!entryRow) {
+        throw new EntryNotFoundError(`Entry with slug "${slug}" not found in ${seed.slug}`)
+      }
+
+      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})`)
+    }
+  }
+
+  async getFacets(seed: Seed): Promise<{
+    statuses: Record<string, number>
+    tagsByColumn: Record<string, string[]>
+  }> {
+    try {
+      const tableName = this.getTableName(seed.slug)
+
+      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
+      }
+
+      const tagsByColumn: Record<string, string[]> = {}
+      const tagBranches = seed.branches.filter(branch => branch.type === 'tags')
+
+      for (const branch of tagBranches) {
+        const tagResults = await this.database
+          .prepare(`SELECT DISTINCT value FROM ${tableName}, json_each(${tableName}.${branch.alias}) WHERE value IS NOT NULL`)
+          .all()
+        tagsByColumn[branch.alias] = (tagResults.results || []).map(row => row.value as string)
+      }
+
+      return { statuses: statusesCount, tagsByColumn }
+    } catch (error) {
+      throw this.mapError(error, `getFacets(${seed.slug})`)
+    }
+  }
+
+  async existsSlug(seed: Seed, slug: string, excludeId?: string): Promise<boolean> {
+    try {
+      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) {
+      throw this.mapError(error, `existsSlug(${seed.slug}, ${slug})`)
+    }
+  }
+
+
+  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,
+    slug: string,
+    status: string,
+    data: Record<string, any>
+  ): Promise<void> {
+    try {
+      if (await this.existsSlug(seed, slug)) {
+        throw new SlugConflictError(`Slug "${slug}" already exists for ${seed.slug}`)
+      }
+
+      const batchStmts: D1PreparedStatement[] = [
+        this.buildCreateMainStmt(seed, id, slug, status, data),
+      ]
+
+      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))
+      }
+
+      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})`)
+    }
+  }
+
+  async update(
+    seed: Seed,
+    id: string,
+    data: Record<string, any>,
+    status?: string
+  ): Promise<void> {
+    try {
+      const { stmt, junctionUpdates } = this.buildUpdateMainStmt(seed, id, data, status)
+      
+      if (!stmt && junctionUpdates.length === 0) return
+
+      const batchStmts: D1PreparedStatement[] = []
+      if (stmt) batchStmts.push(stmt)
+
+      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 (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
+      throw this.mapError(error, `update(${seed.slug}, ${id})`)
+    }
+  }
+
+  async delete(seed: Seed, id: string): Promise<{ row: Record<string, any> }> {
+    try {
+      const tableName = this.getTableName(seed.slug)
+
+      const entryRow = await this.database
+        .prepare(`SELECT * FROM ${tableName} WHERE id = ?`)
+        .bind(id)
+        .first()
+
+      if (!entryRow) {
+        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+      }
+
+      await this.database.prepare(`DELETE FROM ${tableName} WHERE id = ?`).bind(id).run()
+
+      return { row: this.rowToData(seed, entryRow) }
+    } catch (error) {
+      if (error instanceof EntryNotFoundError) throw error
+      throw this.mapError(error, `delete(${seed.slug}, ${id})`)
+    }
+  }
+
+  async saveDraft(seed: Seed, entryId: string, data: Record<string, any>): Promise<void> {
+    try {
+      if (!seed.allowDrafts) {
+        throw new RepositoryError(`Drafts not allowed for ${seed.slug}`)
+      }
+
+      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)
+          placeholders.push('?')
+          queryBindings.push(serializedValue)
+          updateClauses.push(`${branch.alias} = EXCLUDED.${branch.alias}`)
+        }
+      }
+
+      updateClauses.push('updated_at = (unixepoch())')
+
+      const sql = `
+        INSERT INTO ${draftTableName} (${columnNames.join(', ')})
+        VALUES (${placeholders.join(', ')})
+        ON CONFLICT(entry_id) DO UPDATE SET ${updateClauses.join(', ')}
+      `
+
+      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})`)
+    }
+  }
+
+  async getDraft(seed: Seed, entryId: string): Promise<Record<string, any> | null> {
+    try {
+      if (!seed.allowDrafts) return null
+
+      const draftTableName = this.getTableName(seed.slug, true)
+      const draftRow = await this.database
+        .prepare(`SELECT * FROM ${draftTableName} WHERE entry_id = ?`)
+        .bind(entryId)
+        .first()
+
+      if (!draftRow) return null
+
+      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})`)
+    }
+  }
+
+  async hasDraft(seed: Seed, entryId: string): Promise<boolean> {
+    try {
+      if (!seed.allowDrafts) return false
+      const draftTableName = this.getTableName(seed.slug, true)
+      const draftExistsResult = await this.database
+        .prepare(`SELECT 1 FROM ${draftTableName} WHERE entry_id = ? LIMIT 1`)
+        .bind(entryId)
+        .first()
+      return draftExistsResult !== null
+    } catch (error) {
+      throw this.mapError(error, `hasDraft(${seed.slug}, ${entryId})`)
+    }
+  }
+
+  async publishDraft(seed: Seed, entryId: string): Promise<void> {
+    try {
+      if (!seed.allowDrafts) return
+
+      const draftTableName = this.getTableName(seed.slug, true)
+      const liveTableName = this.getTableName(seed.slug)
+
+      const draftRow = await this.database
+        .prepare(`SELECT * FROM ${draftTableName} WHERE entry_id = ?`)
+        .bind(entryId)
+        .first<Record<string, unknown>>()
+
+      if (!draftRow) {
+        throw new EntryNotFoundError(`No draft found for ${entryId} in ${seed.slug}`)
+      }
+
+      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])
+        }
+      }
+
+      updateClauses.push('updated_at = (unixepoch())')
+      const updateSql = `UPDATE ${liveTableName} SET ${updateClauses.join(', ')} WHERE id = ?`
+      queryBindings.push(entryId)
+
+      const batchStmts: D1PreparedStatement[] = [
+        this.database.prepare(updateSql).bind(...queryBindings),
+        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
+      const draftTableName = this.getTableName(seed.slug, true)
+      await this.database.prepare(`DELETE FROM ${draftTableName} WHERE entry_id = ?`).bind(entryId).run()
+    } catch (error) {
+      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')
+    }
+  }
+}