@beechcms/api 0.4.0-preview.1 → 0.4.0-preview.11

package/src/public/query-builder.ts

@@ -1,4 +1,4 @@
-import type { Seed } from '@beechcms/core'
+import type { Seed, FilterGroup, FilterOperator, FilterType, BranchType } from '@beechcms/core'
 import { parsePositiveInt } from '../shared/query-utils'
 
 export type PublicQueryInput = {
@@ -7,8 +7,8 @@ export type PublicQueryInput = {
   latest?: string
 }
 
-type PublicFilterLogic = 'AND' | 'OR'
-type PublicFilterOperator =
+export type PublicFilterLogic = 'AND' | 'OR'
+export type PublicFilterOperator =
   | 'eq'
   | 'neq'
   | 'gt'
@@ -27,13 +27,13 @@ type PublicFilterOperator =
   | 'has_any_tag'
   | 'has_all_tags'
 
-type PublicFilterCondition = {
+export type PublicFilterCondition = {
   field: string
   op: PublicFilterOperator
   value?: unknown
 }
 
-type ParsedPublicFilter = {
+export type ParsedPublicFilter = {
   where: PublicFilterCondition[]
   logic: PublicFilterLogic
 }
@@ -45,29 +45,10 @@ const PUBLIC_FILTER_OPERATORS = new Set<PublicFilterOperator>([
   'has_tag', 'has_any_tag', 'has_all_tags',
 ])
 
-const SYSTEM_COLUMNS = new Set(['id', 'slug', 'status', 'created_at', 'updated_at'])
-
 function asString(value: unknown): string | null {
   return typeof value === 'string' && value.trim() ? value.trim() : null
 }
 
-/**
- * Risolve il nome colonna SQL per un campo.
- * In v0.4.0 il nome colonna = branch.alias (nessun json_extract).
- */
-function resolveFieldExpression(
-  seed: Seed | null,
-  field: string
-): { expr: string; fieldType: string } | null {
-  if (SYSTEM_COLUMNS.has(field)) {
-    const type = field === 'created_at' || field === 'updated_at' ? 'number' : 'text'
-    return { expr: field, fieldType: type }
-  }
-  const branch = seed?.branches.find((b) => b.alias === field)
-  if (!branch) return null
-  return { expr: branch.alias, fieldType: branch.type }
-}
-
 function validateLogic(logicRaw: unknown): PublicFilterLogic {
   if (logicRaw === undefined) return 'AND'
   if (typeof logicRaw !== 'string') throw new TypeError("Invalid filter: 'logic' must be 'AND' or 'OR'")
@@ -105,124 +86,54 @@ export function parsePublicFilter(raw: string | undefined): ParsedPublicFilter |
   return { where, logic }
 }
 
-function ensureValueArray(value: unknown, op: PublicFilterOperator, field: string): unknown[] {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new TypeError(`Invalid filter: operator '${op}' for field '${field}' requires a non-empty array`)
-  }
-  return value
-}
-
-function buildTextOperation(
-  op: PublicFilterOperator,
-  expr: string,
-  field: string,
-  value: unknown
-): { clause: string; bindings: Array<string | number> } {
-  const str = asString(value)
-  if (!str) throw new TypeError(`Invalid filter: operator '${op}' for field '${field}' requires a string value`)
-  if (op === 'contains')     return { clause: `LOWER(CAST(${expr} AS TEXT)) LIKE LOWER(?)`, bindings: [`%${str}%`] }
-  if (op === 'not_contains') return { clause: `LOWER(CAST(${expr} AS TEXT)) NOT LIKE LOWER(?)`, bindings: [`%${str}%`] }
-  if (op === 'starts_with')  return { clause: `LOWER(CAST(${expr} AS TEXT)) LIKE LOWER(?)`, bindings: [`${str}%`] }
-  return { clause: `LOWER(CAST(${expr} AS TEXT)) LIKE LOWER(?)`, bindings: [`%${str}`] }
-}
+const SYSTEM_COLUMNS = new Set(['id', 'slug', 'status', 'created_at', 'updated_at'])
 
-function buildSetOperation(
-  op: PublicFilterOperator,
-  expr: string,
-  field: string,
-  value: unknown
-): { clause: string; bindings: Array<string | number> } {
-  const values = ensureValueArray(value, op, field)
-  const placeholders = values.map(() => '?').join(',')
-  return {
-    clause: `${expr} ${op === 'in' ? 'IN' : 'NOT IN'} (${placeholders})`,
-    bindings: values as Array<string | number>,
+function mapBranchToFilterType(type: BranchType): FilterType {
+  switch (type) {
+    case 'richtext':
+    case 'file':
+      return 'text'
+    case 'json':
+      return 'json'
+    case 'tags':
+      return 'tags'
+    case 'number':
+      return 'number'
+    case 'boolean':
+      return 'boolean'
+    case 'date':
+      return 'date'
+    case 'text':
+    default:
+      return 'text'
   }
 }
 
-function buildTagOperation(
-  op: PublicFilterOperator,
-  expr: string,
-  field: string,
-  value: unknown
-): { clause: string; bindings: Array<string | number> } {
-  const tags = op === 'has_tag' ? [value] : ensureValueArray(value, op, field)
-  const cleaned = tags.map((item) => asString(item)).filter((item): item is string => item !== null)
-  if (cleaned.length === 0) {
-    throw new TypeError(`Invalid filter: operator '${op}' for field '${field}' requires tag string values`)
-  }
-  if (op === 'has_tag' || op === 'has_any_tag') {
-    const placeholders = cleaned.map(() => '?').join(',')
-    return {
-      clause: `EXISTS (SELECT 1 FROM json_each(${expr}) je WHERE CAST(je.value AS TEXT) IN (${placeholders}))`,
-      bindings: cleaned,
-    }
-  }
-  const allParts = cleaned.map(() => `EXISTS (SELECT 1 FROM json_each(${expr}) je WHERE CAST(je.value AS TEXT) = ?)`)
-  return { clause: allParts.join(' AND '), bindings: cleaned }
-}
-
-function buildConditionClause(
-  condition: PublicFilterCondition,
-  seed: Seed | null
-): { clause: string; bindings: Array<string | number> } | null {
-  const fieldMeta = resolveFieldExpression(seed, condition.field)
-  if (!fieldMeta) return null
-  const { expr, fieldType } = fieldMeta
-  const { op, value, field } = condition
-
-  if (op === 'is_empty')     return { clause: `(${expr} IS NULL OR TRIM(CAST(${expr} AS TEXT)) = '')`, bindings: [] }
-  if (op === 'is_not_empty') return { clause: `(${expr} IS NOT NULL AND TRIM(CAST(${expr} AS TEXT)) <> '')`, bindings: [] }
-  if (op === 'contains' || op === 'not_contains' || op === 'starts_with' || op === 'ends_with') {
-    return buildTextOperation(op, expr, field, value)
-  }
-  if (op === 'in' || op === 'not_in') return buildSetOperation(op, expr, field, value)
-  if (op === 'has_tag' || op === 'has_any_tag' || op === 'has_all_tags') {
-    if (fieldType !== 'json') throw new TypeError(`Invalid filter: operator '${op}' requires a json field`)
-    return buildTagOperation(op, expr, field, value)
-  }
-
-  if (op === 'eq' || op === 'neq') {
-    if (typeof value === 'boolean') {
-      return { clause: `${expr} ${op === 'eq' ? '=' : '!='} ?`, bindings: [value ? 1 : 0] }
-    }
-    if (typeof value === 'number' && !Number.isNaN(value)) {
-      return { clause: `${expr} ${op === 'eq' ? '=' : '!='} ?`, bindings: [value] }
-    }
-    const textValue = asString(value)
-    if (!textValue) throw new TypeError(`Invalid filter: operator '${op}' for field '${field}' requires a scalar value`)
+/**
+ * Trasforma il filtro pubblico in FilterGroup[] per il Repository.
+ * Zero SQL: la logica di generazione query risiede esclusivamente nel Repository/Engine core.
+ */
+export function toEngineFilters(seed: Seed, parsedFilter: ParsedPublicFilter | null): FilterGroup[] {
+  if (!parsedFilter || parsedFilter.where.length === 0) return []
+  
+  // Note: Repository currently joins groups with AND. 
+  // Public API supports logic: OR but the core engine currently defaults to AND for top-level groups.
+  // We map each condition to a group for maximum compatibility with the engine's buildFilterCondition.
+  return parsedFilter.where.map((cond) => {
+    const branch = seed.branches.find(b => b.alias === cond.field)
+    const type: FilterType = branch 
+      ? mapBranchToFilterType(branch.type) 
+      : (SYSTEM_COLUMNS.has(cond.field) ? 'system' : 'text')
+    
     return {
-      clause: `LOWER(TRIM(CAST(${expr} AS TEXT))) ${op === 'eq' ? '=' : '!='} LOWER(TRIM(?))`,
-      bindings: [textValue],
+      column: cond.field,
+      type,
+      conditions: [{
+        op: cond.op as FilterOperator,
+        value: cond.value as any
+      }]
     }
-  }
-
-  const numberValue = typeof value === 'number' && !Number.isNaN(value) ? value : null
-  const textValue = asString(value)
-  const mathOp = op === 'gt' ? '>' : op === 'gte' ? '>=' : op === 'lt' ? '<' : op === 'lte' ? '<=' : null
-  if (!mathOp) throw new TypeError(`Invalid filter: operator '${op}' is not supported`)
-  if ((fieldType === 'number' || field === 'created_at' || field === 'updated_at') && numberValue !== null) {
-    return { clause: `${expr} ${mathOp} ?`, bindings: [numberValue] }
-  }
-  if (textValue) return { clause: `CAST(${expr} AS TEXT) ${mathOp} ?`, bindings: [textValue] }
-  throw new TypeError(`Invalid filter: operator '${op}' for field '${field}' requires a compatible value`)
-}
-
-export function buildPublicFilterWhereClause(
-  seed: Seed | null,
-  parsedFilter: ParsedPublicFilter | null
-): { clause: string; bindings: Array<string | number> } {
-  if (!parsedFilter || parsedFilter.where.length === 0) return { clause: '', bindings: [] }
-  const clauses: string[] = []
-  const bindings: Array<string | number> = []
-  for (const condition of parsedFilter.where) {
-    const built = buildConditionClause(condition, seed)
-    if (!built) continue
-    clauses.push(`(${built.clause})`)
-    bindings.push(...built.bindings)
-  }
-  if (clauses.length === 0) return { clause: '', bindings: [] }
-  return { clause: clauses.join(` ${parsedFilter.logic} `), bindings }
+  })
 }
 
 export function parsePublicPagination(input: PublicQueryInput): { page: number; limit: number } {

package/src/search-utils.ts

@@ -175,6 +175,10 @@ export function buildFtsQuery(
 
 // ─── Mapper ──────────────────────────────────────────────────────────────────
 
+function stripHtmlPreserveMark(html: string): string {
+  return html.replace(/<(?!\/?mark\b)[^>]*>/gi, ' ').replace(/\s+/g, ' ').trim()
+}
+
 export function mapFtsRow(row: FtsRow): SearchResultItem {
   return {
     id:          row.entry_id,
@@ -182,7 +186,7 @@ export function mapFtsRow(row: FtsRow): SearchResultItem {
     slug:        row.slug,
     status:      row.status,
     title:       row.title ?? "",
-    excerpt:     row.excerpt ?? "",
+    excerpt:     stripHtmlPreserveMark(row.excerpt ?? ""),
     data:        {},
   }
 }

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

@@ -0,0 +1,28 @@
+/// <reference types="@cloudflare/workers-types" />
+import { RepositoryError } from '@beechcms/core'
+
+/**
+ * Base class for D1-backed repositories.
+ * Handles the D1 instance and provides common database utilities and error mapping.
+ */
+export abstract class BaseD1Repository {
+  constructor(protected readonly db: D1Database) {}
+
+  /**
+   * Utility method to extract a table name for a given seed.
+   */
+  protected getTableName(slug: string, isDraft = false): string {
+    return isDraft ? `content_${slug}_drafts` : `content_${slug}`
+  }
+
+  /**
+   * Helper to map generic D1 errors to Beech RepositoryErrors.
+   * This centralizes error handling for all D1 repositories.
+   */
+  protected mapError(error: any, context: string): RepositoryError {
+    const message = error?.message || 'Unknown database error'
+    // In the future, we can add more specific SQLite error code checks here
+    // (e.g., checking for UNIQUE constraint via string matching or codes if available)
+    return new RepositoryError(`${context}: ${message}`, error)
+  }
+}

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

@@ -0,0 +1,382 @@
+/// <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 [results, countResult] = await this.db.batch([
+        this.db.prepare(sql).bind(...bindings),
+        this.db.prepare(countSql).bind(...countBindings)
+      ])
+
+      const items = (results.results || []).map((row) => this.rowToData(seed, row))
+      const total = (countResult.results?.[0] as any)?.total || 0
+
+      return { items, total }
+    } catch (error) {
+      throw this.mapError(error, `findMany(${seed.slug})`)
+    }
+  }
+
+  async findById(seed: Seed, id: string): Promise<Record<string, any>> {
+    try {
+      const table = this.getTableName(seed.slug)
+      const row = await this.db
+        .prepare(`SELECT * FROM ${table} WHERE id = ? LIMIT 1`)
+        .bind(id)
+        .first()
+
+      if (!row) {
+        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+      }
+
+      return this.rowToData(seed, row)
+    } 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 table = this.getTableName(seed.slug)
+      const row = await this.db
+        .prepare(`SELECT * FROM ${table} WHERE slug = ? LIMIT 1`)
+        .bind(slug)
+        .first()
+
+      if (!row) {
+        throw new EntryNotFoundError(`Entry with slug "${slug}" not found in ${seed.slug}`)
+      }
+
+      return this.rowToData(seed, row)
+    } 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 table = this.getTableName(seed.slug)
+      
+      // Status counts
+      const statusResults = await this.db
+        .prepare(`SELECT status, COUNT(*) as count FROM ${table} GROUP BY status`)
+        .all()
+      
+      const statuses: Record<string, number> = {}
+      for (const row of statusResults.results || []) {
+        statuses[row.status as string] = row.count as number
+      }
+
+      // Tags facets (for branches of type 'tags')
+      const tagsByColumn: Record<string, string[]> = {}
+      const tagBranches = seed.branches.filter(b => b.type === 'tags')
+      
+      for (const branch of tagBranches) {
+        // SQLite json_each for tags stored as JSON arrays
+        const tagResults = await this.db
+          .prepare(`SELECT DISTINCT value FROM ${table}, json_each(${table}.${branch.alias}) WHERE value IS NOT NULL`)
+          .all()
+        tagsByColumn[branch.alias] = (tagResults.results || []).map(r => r.value as string)
+      }
+
+      return { statuses, tagsByColumn }
+    } catch (error) {
+      throw this.mapError(error, `getFacets(${seed.slug})`)
+    }
+  }
+
+  async existsSlug(seed: Seed, slug: string, excludeId?: string): Promise<boolean> {
+    try {
+      const table = this.getTableName(seed.slug)
+      let sql = `SELECT 1 FROM ${table} WHERE slug = ?`
+      const bindings: any[] = [slug]
+      
+      if (excludeId) {
+        sql += ` AND id != ?`
+        bindings.push(excludeId)
+      }
+      
+      const row = await this.db.prepare(sql).bind(...bindings).first()
+      return row !== 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 table = this.getTableName(seed.slug)
+      const cols = ['id', 'slug', 'status']
+      const placeholders = ['?', '?', '?']
+      const bindings: any[] = [id, slug, status]
+
+      for (const branch of seed.branches) {
+        if (Object.hasOwn(data, branch.alias)) {
+          cols.push(branch.alias)
+          placeholders.push('?')
+          bindings.push(serializeForDb(branch, data[branch.alias]))
+        }
+      }
+
+      const sql = `INSERT INTO ${table} (${cols.join(', ')}) VALUES (${placeholders.join(', ')})`
+      await this.db.prepare(sql).bind(...bindings).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 table = this.getTableName(seed.slug)
+      const setParts: string[] = []
+      const bindings: any[] = []
+
+      if (status) {
+        setParts.push('status = ?')
+        bindings.push(status)
+      }
+
+      for (const branch of seed.branches) {
+        if (Object.hasOwn(data, branch.alias)) {
+          setParts.push(`${branch.alias} = ?`)
+          bindings.push(serializeForDb(branch, data[branch.alias]))
+        }
+      }
+
+      if (setParts.length === 0) return
+
+      setParts.push('updated_at = (unixepoch())')
+      
+      const sql = `UPDATE ${table} SET ${setParts.join(', ')} WHERE id = ?`
+      bindings.push(id)
+
+      const result = await this.db.prepare(sql).bind(...bindings).run()
+      if (result.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 table = this.getTableName(seed.slug)
+      
+      // We need to return the row for R2 cleanup
+      const row = await this.db
+        .prepare(`SELECT * FROM ${table} WHERE id = ?`)
+        .bind(id)
+        .first()
+
+      if (!row) {
+        throw new EntryNotFoundError(`Entry ${id} not found in ${seed.slug}`)
+      }
+
+      await this.db.prepare(`DELETE FROM ${table} WHERE id = ?`).bind(id).run()
+
+      return { row: this.rowToData(seed, row) }
+    } 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 table = this.getTableName(seed.slug, true)
+      const cols = ['entry_id']
+      const placeholders = ['?']
+      const bindings: any[] = [entryId]
+      const updateParts: string[] = []
+
+      for (const branch of seed.branches) {
+        if (Object.hasOwn(data, branch.alias)) {
+          const val = serializeForDb(branch, data[branch.alias])
+          cols.push(branch.alias)
+          placeholders.push('?')
+          bindings.push(val)
+          updateParts.push(`${branch.alias} = EXCLUDED.${branch.alias}`)
+        }
+      }
+
+      updateParts.push('updated_at = (unixepoch())')
+
+      const sql = `
+        INSERT INTO ${table} (${cols.join(', ')}) 
+        VALUES (${placeholders.join(', ')})
+        ON CONFLICT(entry_id) DO UPDATE SET ${updateParts.join(', ')}
+      `
+      await this.db.prepare(sql).bind(...bindings).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 table = this.getTableName(seed.slug, true)
+      const row = await this.db
+        .prepare(`SELECT * FROM ${table} WHERE entry_id = ?`)
+        .bind(entryId)
+        .first()
+
+      if (!row) return null
+
+      // Filter out nulls from draft row (only include provided fields)
+      const data: Record<string, any> = {}
+      for (const branch of seed.branches) {
+        if (row[branch.alias] !== null) {
+          data[branch.alias] = deserializeFromDb(branch, row[branch.alias])
+        }
+      }
+
+      return data
+    } 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 table = this.getTableName(seed.slug, true)
+      const row = await this.db
+        .prepare(`SELECT 1 FROM ${table} WHERE entry_id = ? LIMIT 1`)
+        .bind(entryId)
+        .first()
+      return row !== 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 draftTable = this.getTableName(seed.slug, true)
+      const liveTable = this.getTableName(seed.slug)
+
+      const draftRow = await this.db
+        .prepare(`SELECT * FROM ${draftTable} WHERE entry_id = ?`)
+        .bind(entryId)
+        .first()
+
+      if (!draftRow) {
+        throw new EntryNotFoundError(`No draft found for ${entryId} in ${seed.slug}`)
+      }
+
+      // Build UPDATE for live table
+      const setParts: string[] = []
+      const bindings: any[] = []
+
+      for (const branch of seed.branches) {
+        if (draftRow[branch.alias] !== null) {
+          setParts.push(`${branch.alias} = ?`)
+          bindings.push(draftRow[branch.alias])
+        }
+      }
+
+      setParts.push('updated_at = (unixepoch())')
+      
+      const updateSql = `UPDATE ${liveTable} SET ${setParts.join(', ')} WHERE id = ?`
+      bindings.push(entryId)
+
+      // Atomic batch
+      await this.db.batch([
+        this.db.prepare(updateSql).bind(...bindings),
+        this.db.prepare(`DELETE FROM ${draftTable} 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 table = this.getTableName(seed.slug, true)
+      await this.db.prepare(`DELETE FROM ${table} WHERE entry_id = ?`).bind(entryId).run()
+    } catch (error) {
+      throw this.mapError(error, `deleteDraft(${seed.slug}, ${entryId})`)
+    }
+  }
+}