@beechcms/api 0.4.0 → 0.4.2

package/src/shared/background-notification-service.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi } from 'vitest'
+import { BackgroundNotificationService } from './background-notification-service'
+import type { INotificationRepository, NotificationRecord } from '@beechcms/core'
+
+function makeRepository(opts: { createShouldThrow?: boolean } = {}): INotificationRepository {
+  return {
+    list: vi.fn().mockResolvedValue([]),
+    stats: vi.fn().mockResolvedValue({ totalCount: 0, latestCreatedAt: 0, readCount: 0 }),
+    create: opts.createShouldThrow
+      ? vi.fn().mockRejectedValue(new Error('db down'))
+      : vi.fn().mockResolvedValue('generated-id'),
+    markRead: vi.fn(),
+    markUnread: vi.fn(),
+    markAllRead: vi.fn(),
+    delete: vi.fn(),
+  } as unknown as INotificationRepository & {
+    create: ReturnType<typeof vi.fn>
+  }
+}
+
+describe('BackgroundNotificationService', () => {
+  it('delegates persistence to the repository with the provided fields', async () => {
+    const repo = makeRepository()
+    await new BackgroundNotificationService(repo).notify({
+      title: 'Hello',
+      message: 'World',
+      type: 'success',
+    })
+    expect(repo.create).toHaveBeenCalledWith({
+      title: 'Hello',
+      message: 'World',
+      type: 'success',
+    })
+  })
+
+  it('defaults to type "info" when none is provided', async () => {
+    const repo = makeRepository()
+    await new BackgroundNotificationService(repo).notify({ title: 'T', message: 'M' })
+    expect(repo.create).toHaveBeenCalledWith({ title: 'T', message: 'M', type: 'info' })
+  })
+
+  it('delegates to the background scheduler when provided', () => {
+    const repo = makeRepository()
+    const schedule = vi.fn()
+    new BackgroundNotificationService(repo, schedule).notify({ title: 'T', message: 'M' })
+    expect(schedule).toHaveBeenCalledTimes(1)
+    expect(schedule.mock.calls[0][0]).toBeInstanceOf(Promise)
+  })
+
+  it('never throws to the caller when the repository write fails', async () => {
+    const repo = makeRepository({ createShouldThrow: true })
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const service = new BackgroundNotificationService(repo)
+    await expect(service.notify({ title: 'T', message: 'M' })).resolves.toBeUndefined()
+    expect(consoleSpy).toHaveBeenCalled()
+    consoleSpy.mockRestore()
+  })
+})

package/src/shared/background-notification-service.ts

@@ -0,0 +1,48 @@
+import type {
+  INotificationService,
+  CreateNotificationInput,
+  INotificationRepository,
+  NotificationType,
+} from '@beechcms/core'
+
+const DEFAULT_NOTIFICATION_TYPE: NotificationType = 'info'
+
+type ScheduleBackgroundTask = (task: Promise<unknown>) => void
+
+/**
+ * Production implementation of {@link INotificationService}.
+ *
+ * Delegates persistence to the injected {@link INotificationRepository}.
+ * When `scheduleBackgroundTask` is provided (wired to
+ * `c.executionCtx.waitUntil`), the repository write runs after the response
+ * is flushed so the public-API request that triggered it is never delayed.
+ */
+export class BackgroundNotificationService implements INotificationService {
+  constructor(
+    private readonly notificationRepository: INotificationRepository,
+    private readonly scheduleBackgroundTask?: ScheduleBackgroundTask
+  ) {}
+
+  notify(input: CreateNotificationInput): Promise<void> | void {
+    const persistPromise = this.runPersist(input)
+
+    if (this.scheduleBackgroundTask) {
+      this.scheduleBackgroundTask(persistPromise)
+      return
+    }
+
+    return persistPromise
+  }
+
+  private async runPersist(input: CreateNotificationInput): Promise<void> {
+    try {
+      await this.notificationRepository.create({
+        title: input.title,
+        message: input.message,
+        type: input.type ?? DEFAULT_NOTIFICATION_TYPE,
+      })
+    } catch (error) {
+      console.error('BackgroundNotificationService: failed to create notification', error)
+    }
+  }
+}

package/src/shared/content-utils.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi } from 'vitest'
+import { rowToApiData, rowToEntry, buildInsertBindings, buildUpdateBindings, hasDraft } from './content-utils'
+import type { Seed } from '@beechcms/core'
+
+const SEED = {
+  slug: 'articoli',
+  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: 'prodotti',
+  displayNameAlias: 'nome',
+  allowDrafts: false,
+  branches: [
+    { id: 'br_01', alias: 'nome', type: 'text' },
+  ],
+} as unknown as Seed
+
+// ─── rowToApiData ─────────────────────────────────────────────────────────────
+
+describe('rowToApiData', () => {
+  it('returns an object keyed by branch aliases with deserialized values', () => {
+    const result = rowToApiData(SEED, { title: 'Hello', body: 'World' })
+    expect(result).toHaveProperty('title', 'Hello')
+    expect(result).toHaveProperty('body', 'World')
+  })
+
+  it('uses null for missing branch values', () => {
+    const result = rowToApiData(SEED, {})
+    expect(result.title).toBeNull()
+    expect(result.body).toBeNull()
+  })
+
+  it('only includes keys for branches defined in the seed', () => {
+    const result = rowToApiData(SEED, { title: 'Hi', unknownCol: 'ignored' })
+    expect(Object.keys(result)).toEqual(['title', 'body'])
+    expect(result).not.toHaveProperty('unknownCol')
+  })
+})
+
+// ─── rowToEntry ───────────────────────────────────────────────────────────────
+
+describe('rowToEntry', () => {
+  it('maps a DB row to a ContentEntry with correct system fields', () => {
+    const row = {
+      id: 'entry-1', slug: 'my-post', status: 'published',
+      title: 'Hello', body: 'World', created_at: 1000, updated_at: 2000,
+    }
+    const entry = rowToEntry(SEED, row)
+    expect(entry.id).toBe('entry-1')
+    expect(entry.schema_slug).toBe('articoli')
+    expect(entry.slug).toBe('my-post')
+    expect(entry.status).toBe('published')
+    expect(entry.created_at).toBe(1000)
+    expect(entry.updated_at).toBe(2000)
+    expect(entry.hasPendingDraft).toBe(false)
+  })
+
+  it('defaults hasPendingDraft to false when not provided', () => {
+    const entry = rowToEntry(SEED, { id: 'e1', slug: null, status: 'draft', title: null, body: null, created_at: null, updated_at: null })
+    expect(entry.hasPendingDraft).toBe(false)
+  })
+
+  it('passes through hasPendingDraft when explicitly set to true', () => {
+    const entry = rowToEntry(SEED, { id: 'e1', slug: null, status: 'draft', title: null, body: null }, true)
+    expect(entry.hasPendingDraft).toBe(true)
+  })
+
+  it('defaults slug to null and status to draft for missing values', () => {
+    const entry = rowToEntry(SEED, { id: 'e1' })
+    expect(entry.slug).toBeNull()
+    expect(entry.status).toBe('draft')
+  })
+})
+
+// ─── buildInsertBindings ──────────────────────────────────────────────────────
+
+describe('buildInsertBindings', () => {
+  it('returns cols, placeholders, and bindings for each matching branch alias', () => {
+    const { cols, placeholders, bindings } = buildInsertBindings(SEED, { title: 'Hi', body: 'There' })
+    expect(cols).toContain('title')
+    expect(cols).toContain('body')
+    expect(placeholders).toHaveLength(2)
+    expect(placeholders.every(p => p === '?')).toBe(true)
+    expect(bindings).toHaveLength(2)
+  })
+
+  it('omits branches not present in the payload', () => {
+    const { cols, bindings } = buildInsertBindings(SEED, { title: 'Only title' })
+    expect(cols).toEqual(['title'])
+    expect(bindings).toHaveLength(1)
+  })
+
+  it('returns empty arrays when payload has no matching aliases', () => {
+    const { cols, placeholders, bindings } = buildInsertBindings(SEED, { unknownField: 'x' })
+    expect(cols).toHaveLength(0)
+    expect(placeholders).toHaveLength(0)
+    expect(bindings).toHaveLength(0)
+  })
+})
+
+// ─── buildUpdateBindings ──────────────────────────────────────────────────────
+
+describe('buildUpdateBindings', () => {
+  it('returns a SET clause and bindings for each matching branch alias', () => {
+    const { setClause, bindings } = buildUpdateBindings(SEED, { title: 'New', body: 'Content' })
+    expect(setClause).toContain('title = ?')
+    expect(setClause).toContain('body = ?')
+    expect(bindings).toHaveLength(2)
+  })
+
+  it('builds a single-field SET clause', () => {
+    const { setClause, bindings } = buildUpdateBindings(SEED, { title: 'Updated' })
+    expect(setClause).toBe('title = ?')
+    expect(bindings).toHaveLength(1)
+  })
+
+  it('returns empty setClause and bindings for non-matching payload', () => {
+    const { setClause, bindings } = buildUpdateBindings(SEED, { ghost: 'field' })
+    expect(setClause).toBe('')
+    expect(bindings).toHaveLength(0)
+  })
+})
+
+// ─── hasDraft ─────────────────────────────────────────────────────────────────
+
+describe('hasDraft', () => {
+  function makeMockDb(firstResult: unknown) {
+    const firstMock = vi.fn().mockResolvedValue(firstResult)
+    const bindMock = vi.fn(() => ({ first: firstMock }))
+    const prepareMock = vi.fn(() => ({ bind: bindMock }))
+    return { db: { prepare: prepareMock } as any, prepareMock, bindMock }
+  }
+
+  it('returns false immediately when seed does not allow drafts', async () => {
+    const { db, prepareMock } = makeMockDb(null)
+    expect(await hasDraft(db, NO_DRAFT_SEED, 'e1')).toBe(false)
+    expect(prepareMock).not.toHaveBeenCalled()
+  })
+
+  it('returns true when a draft row exists', async () => {
+    const { db } = makeMockDb({ 1: 1 })
+    expect(await hasDraft(db, SEED, 'entry-1')).toBe(true)
+  })
+
+  it('returns false when no draft row is found', async () => {
+    const { db } = makeMockDb(null)
+    expect(await hasDraft(db, SEED, 'entry-1')).toBe(false)
+  })
+
+  it('queries the correct drafts table for the seed slug', async () => {
+    const { db, prepareMock } = makeMockDb(null)
+    await hasDraft(db, SEED, 'entry-1')
+    expect(prepareMock).toHaveBeenCalledWith(expect.stringContaining('content_articoli_drafts'))
+  })
+})

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'))
+    })
+  })
+})