@beechcms/api 0.4.0-preview.9 → 0.4.1

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

@@ -0,0 +1,312 @@
+import { describe, it, expect, vi } from 'vitest'
+import { D1ContentRepository } from './content.repository.d1'
+import { EntryNotFoundError, SlugConflictError } from '@beechcms/core'
+import type { Seed } from '@beechcms/core'
+
+const SEED = {
+  slug: 'posts',
+  displayNameAlias: 'title',
+  allowDrafts: true,
+  branches: [
+    { id: 'br_01', alias: 'title', type: 'text' },
+    { id: 'br_02', alias: 'body', type: 'text' },
+  ],
+} as unknown as Seed
+
+const NO_DRAFT_SEED = {
+  slug: 'produtos',
+  displayNameAlias: 'name',
+  allowDrafts: false,
+  branches: [{ id: 'br_01', alias: 'name', type: 'text' }],
+} as unknown as Seed
+
+function makeMockDb(opts: {
+  firstResult?: unknown
+  allResults?: unknown[]
+  runChanges?: number
+  batchResults?: unknown[]
+} = {}) {
+  const { firstResult = null, allResults = [], runChanges = 1, batchResults = [] } = opts
+  const runMock = vi.fn().mockResolvedValue({ success: true, meta: { changes: runChanges } })
+  const firstMock = vi.fn().mockResolvedValue(firstResult)
+  const allMock = vi.fn().mockResolvedValue({ results: allResults })
+  const bindMock = vi.fn(() => ({ run: runMock, first: firstMock, all: allMock }))
+  const stmt = { bind: bindMock, run: runMock, first: firstMock, all: allMock }
+  const prepareMock = vi.fn(() => stmt)
+  const batchMock = vi.fn().mockResolvedValue(batchResults)
+  return { db: { prepare: prepareMock, batch: batchMock } as any, prepareMock, bindMock, runMock, firstMock, allMock, batchMock }
+}
+
+// ─── findMany ─────────────────────────────────────────────────────────────────
+
+describe('D1ContentRepository', () => {
+  describe('findMany', () => {
+    it('returns mapped items and total from batch results', async () => {
+      const row = { id: 'e1', slug: 'post-1', status: 'published', title: 'Hello', body: null, created_at: 1000, updated_at: 1000 }
+      const { db } = makeMockDb({
+        batchResults: [
+          { results: [row] },
+          { results: [{ total: 1 }] },
+        ],
+      })
+      const result = await new D1ContentRepository(db).findMany(SEED, { pagination: { limit: 10, offset: 0 } })
+      expect(result.items).toHaveLength(1)
+      expect(result.items[0].id).toBe('e1')
+      expect(result.total).toBe(1)
+    })
+
+    it('returns empty items and zero total when table is empty', async () => {
+      const { db } = makeMockDb({
+        batchResults: [{ results: [] }, { results: [{ total: 0 }] }],
+      })
+      const result = await new D1ContentRepository(db).findMany(SEED, {})
+      expect(result.items).toHaveLength(0)
+      expect(result.total).toBe(0)
+    })
+
+    it('wraps D1 errors in RepositoryError', async () => {
+      const { db } = makeMockDb()
+      db.batch = vi.fn().mockRejectedValue(new Error('D1 error'))
+      await expect(new D1ContentRepository(db).findMany(SEED, {})).rejects.toThrow('findMany')
+    })
+  })
+
+  // ─── findById ───────────────────────────────────────────────────────────────
+
+  describe('findById', () => {
+    it('returns the entry when found', async () => {
+      const row = { id: 'e1', slug: 'p', status: 'draft', title: 'T', body: null, created_at: 0, updated_at: 0 }
+      const { db } = makeMockDb({ firstResult: row })
+      const result = await new D1ContentRepository(db).findById(SEED, 'e1')
+      expect(result.id).toBe('e1')
+      expect(result.title).toBe('T')
+    })
+
+    it('throws EntryNotFoundError when the row does not exist', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      await expect(new D1ContentRepository(db).findById(SEED, 'missing')).rejects.toBeInstanceOf(EntryNotFoundError)
+    })
+
+    it('queries the correct content table', async () => {
+      const { db, prepareMock } = makeMockDb({ firstResult: { id: 'e1', slug: null, status: 'draft', title: null, body: null } })
+      await new D1ContentRepository(db).findById(SEED, 'e1')
+      expect(prepareMock).toHaveBeenCalledWith(expect.stringContaining('content_posts'))
+    })
+  })
+
+  // ─── findBySlug ─────────────────────────────────────────────────────────────
+
+  describe('findBySlug', () => {
+    it('returns the entry when the slug is found', async () => {
+      const row = { id: 'e1', slug: 'my-post', status: 'published', title: 'T', body: null }
+      const { db } = makeMockDb({ firstResult: row })
+      const result = await new D1ContentRepository(db).findBySlug(SEED, 'my-post')
+      expect(result.slug).toBe('my-post')
+    })
+
+    it('throws EntryNotFoundError when slug does not exist', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      await expect(new D1ContentRepository(db).findBySlug(SEED, 'ghost')).rejects.toBeInstanceOf(EntryNotFoundError)
+    })
+  })
+
+  // ─── getFacets ───────────────────────────────────────────────────────────────
+
+  describe('getFacets', () => {
+    it('returns status counts mapped from status GROUP BY results', async () => {
+      const { db, allMock } = makeMockDb()
+      allMock.mockResolvedValueOnce({ results: [{ status: 'published', count: 3 }, { status: 'draft', count: 1 }] })
+      const result = await new D1ContentRepository(db).getFacets(SEED)
+      expect(result.statuses).toEqual({ published: 3, draft: 1 })
+    })
+
+    it('returns empty tagsByColumn when seed has no tag branches', async () => {
+      const { db, allMock } = makeMockDb()
+      allMock.mockResolvedValueOnce({ results: [] })
+      const result = await new D1ContentRepository(db).getFacets(SEED)
+      expect(result.tagsByColumn).toEqual({})
+    })
+  })
+
+  // ─── existsSlug ─────────────────────────────────────────────────────────────
+
+  describe('existsSlug', () => {
+    it('returns true when the slug row is found', async () => {
+      const { db } = makeMockDb({ firstResult: { 1: 1 } })
+      expect(await new D1ContentRepository(db).existsSlug(SEED, 'existing-slug')).toBe(true)
+    })
+
+    it('returns false when the slug row is not found', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      expect(await new D1ContentRepository(db).existsSlug(SEED, 'new-slug')).toBe(false)
+    })
+
+    it('appends AND id != ? clause when excludeId is provided', async () => {
+      const { db, bindMock } = makeMockDb({ firstResult: null })
+      await new D1ContentRepository(db).existsSlug(SEED, 'slug', 'exclude-me')
+      expect(bindMock).toHaveBeenCalledWith('slug', 'exclude-me')
+    })
+  })
+
+  // ─── create ─────────────────────────────────────────────────────────────────
+
+  describe('create', () => {
+    it('calls INSERT INTO the content table', async () => {
+      const { db, prepareMock } = makeMockDb({ firstResult: null }) // existsSlug → null
+      await new D1ContentRepository(db).create(SEED, 'new-id', 'my-slug', 'draft', { title: 'Hello' })
+      const calls = prepareMock.mock.calls.map(c => c[0] as string)
+      expect(calls.some(sql => sql.includes('INSERT INTO content_posts'))).toBe(true)
+    })
+
+    it('throws SlugConflictError when the slug already exists', async () => {
+      const { db } = makeMockDb({ firstResult: { 1: 1 } }) // existsSlug → found
+      await expect(
+        new D1ContentRepository(db).create(SEED, 'id', 'taken-slug', 'draft', {}),
+      ).rejects.toBeInstanceOf(SlugConflictError)
+    })
+  })
+
+  // ─── update ─────────────────────────────────────────────────────────────────
+
+  describe('update', () => {
+    it('calls UPDATE with provided status and branch data', async () => {
+      const { db, prepareMock, runMock } = makeMockDb({ runChanges: 1 })
+      runMock.mockResolvedValue({ success: true, meta: { changes: 1 } })
+      await new D1ContentRepository(db).update(SEED, 'e1', { title: 'New' }, 'published')
+      const calls = prepareMock.mock.calls.map(c => c[0] as string)
+      expect(calls.some(sql => sql.includes('UPDATE content_posts'))).toBe(true)
+    })
+
+    it('throws EntryNotFoundError when no rows are updated', async () => {
+      const { db } = makeMockDb({ runChanges: 0 })
+      await expect(new D1ContentRepository(db).update(SEED, 'ghost', { title: 'X' })).rejects.toBeInstanceOf(EntryNotFoundError)
+    })
+
+    it('returns early without a DB call when there is nothing to update', async () => {
+      const { db, prepareMock } = makeMockDb()
+      await new D1ContentRepository(db).update(SEED, 'e1', {}) // no data, no status
+      // existsSlug is not called; only prepare calls would be for UPDATE which shouldn't happen
+      const updateCalls = prepareMock.mock.calls.filter(c => (c[0] as string).includes('UPDATE content_posts'))
+      expect(updateCalls).toHaveLength(0)
+    })
+  })
+
+  // ─── delete ─────────────────────────────────────────────────────────────────
+
+  describe('delete', () => {
+    it('returns the row data and calls DELETE', async () => {
+      const row = { id: 'e1', slug: 'p', status: 'published', title: 'T', body: null }
+      const { db, prepareMock } = makeMockDb({ firstResult: row })
+      const result = await new D1ContentRepository(db).delete(SEED, 'e1')
+      expect(result.row.id).toBe('e1')
+      const sqls = prepareMock.mock.calls.map(c => c[0] as string)
+      expect(sqls.some(s => s.includes('DELETE FROM content_posts'))).toBe(true)
+    })
+
+    it('throws EntryNotFoundError when the entry does not exist', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      await expect(new D1ContentRepository(db).delete(SEED, 'missing')).rejects.toBeInstanceOf(EntryNotFoundError)
+    })
+  })
+
+  // ─── saveDraft ───────────────────────────────────────────────────────────────
+
+  describe('saveDraft', () => {
+    it('calls INSERT OR REPLACE into the draft table', async () => {
+      const { db, prepareMock } = makeMockDb()
+      await new D1ContentRepository(db).saveDraft(SEED, 'e1', { title: 'Draft title' })
+      const sqls = prepareMock.mock.calls.map(c => c[0] as string)
+      expect(sqls.some(s => s.includes('content_posts_drafts'))).toBe(true)
+    })
+
+    it('throws RepositoryError when seed does not allow drafts', async () => {
+      const { db } = makeMockDb()
+      await expect(new D1ContentRepository(db).saveDraft(NO_DRAFT_SEED, 'e1', {})).rejects.toThrow('Drafts not allowed')
+    })
+  })
+
+  // ─── getDraft ────────────────────────────────────────────────────────────────
+
+  describe('getDraft', () => {
+    it('returns null when seed does not allow drafts', async () => {
+      const { db } = makeMockDb()
+      expect(await new D1ContentRepository(db).getDraft(NO_DRAFT_SEED, 'e1')).toBeNull()
+    })
+
+    it('returns null when no draft row exists', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      expect(await new D1ContentRepository(db).getDraft(SEED, 'e1')).toBeNull()
+    })
+
+    it('returns deserialized draft data for non-null branch values', async () => {
+      const draftRow = { entry_id: 'e1', title: 'Draft T', body: null }
+      const { db } = makeMockDb({ firstResult: draftRow })
+      const result = await new D1ContentRepository(db).getDraft(SEED, 'e1')
+      expect(result).not.toBeNull()
+      expect(result!.title).toBe('Draft T')
+      expect(result).not.toHaveProperty('body') // null branch values are omitted
+    })
+  })
+
+  // ─── hasDraft ─────────────────────────────────────────────────────────────────
+
+  describe('hasDraft', () => {
+    it('returns false immediately when seed does not allow drafts', async () => {
+      const { db, prepareMock } = makeMockDb()
+      expect(await new D1ContentRepository(db).hasDraft(NO_DRAFT_SEED, 'e1')).toBe(false)
+      expect(prepareMock).not.toHaveBeenCalled()
+    })
+
+    it('returns true when a draft exists', async () => {
+      const { db } = makeMockDb({ firstResult: { 1: 1 } })
+      expect(await new D1ContentRepository(db).hasDraft(SEED, 'e1')).toBe(true)
+    })
+
+    it('returns false when no draft exists', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      expect(await new D1ContentRepository(db).hasDraft(SEED, 'e1')).toBe(false)
+    })
+  })
+
+  // ─── publishDraft ─────────────────────────────────────────────────────────────
+
+  describe('publishDraft', () => {
+    it('returns early when seed does not allow drafts', async () => {
+      const { db, batchMock } = makeMockDb()
+      await new D1ContentRepository(db).publishDraft(NO_DRAFT_SEED, 'e1')
+      expect(batchMock).not.toHaveBeenCalled()
+    })
+
+    it('throws EntryNotFoundError when no draft exists', async () => {
+      const { db } = makeMockDb({ firstResult: null })
+      await expect(new D1ContentRepository(db).publishDraft(SEED, 'e1')).rejects.toBeInstanceOf(EntryNotFoundError)
+    })
+
+    it('calls batch with UPDATE and DELETE statements when draft exists', async () => {
+      const draftRow = { entry_id: 'e1', title: 'Draft', body: null }
+      const { db, batchMock, firstMock } = makeMockDb()
+      firstMock.mockResolvedValueOnce(draftRow)
+      batchMock.mockResolvedValueOnce([{}, {}])
+      await new D1ContentRepository(db).publishDraft(SEED, 'e1')
+      expect(batchMock).toHaveBeenCalledTimes(1)
+      const batchArgs: any[] = batchMock.mock.calls[0][0]
+      expect(batchArgs).toHaveLength(2)
+    })
+  })
+
+  // ─── deleteDraft ─────────────────────────────────────────────────────────────
+
+  describe('deleteDraft', () => {
+    it('returns early when seed does not allow drafts', async () => {
+      const { db, prepareMock } = makeMockDb()
+      await new D1ContentRepository(db).deleteDraft(NO_DRAFT_SEED, 'e1')
+      expect(prepareMock).not.toHaveBeenCalled()
+    })
+
+    it('calls DELETE on the draft table when drafts are allowed', async () => {
+      const { db, prepareMock } = makeMockDb()
+      await new D1ContentRepository(db).deleteDraft(SEED, 'e1')
+      expect(prepareMock).toHaveBeenCalledWith(expect.stringContaining('content_posts_drafts'))
+    })
+  })
+})

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 [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})`)
+    }
+  }
+}