@beechcms/api 0.4.0 → 0.4.1

package/src/search-utils.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest'
+import { encodeCursor, decodeCursor, buildFtsQuery, mapFtsRow } from './search-utils'
+import type { Seed } from '@beechcms/core'
+
+const TEXT_SEED = {
+  slug: 'articoli',
+  displayNameAlias: 'title',
+  branches: [
+    { id: 'br_01', alias: 'title', type: 'text', policies: { search: true } },
+  ],
+} as unknown as Seed
+
+const SECOND_SEED = {
+  slug: 'team',
+  displayNameAlias: 'name',
+  branches: [
+    { id: 'br_01', alias: 'name', type: 'text', policies: { search: true } },
+  ],
+} as unknown as Seed
+
+const NO_FTS_SEED = {
+  slug: 'prodotti',
+  displayNameAlias: 'nome',
+  branches: [
+    { id: 'br_01', alias: 'price', type: 'number' },
+  ],
+} as unknown as Seed
+
+// ─── encodeCursor / decodeCursor ─────────────────────────────────────────────
+
+describe('encodeCursor / decodeCursor', () => {
+  it('roundtrip preserves rank and entryId', () => {
+    const cursor = encodeCursor(-1.23456, 'entry-abc')
+    const decoded = decodeCursor(cursor)
+    expect(decoded?.rank).toBeCloseTo(-1.23456)
+    expect(decoded?.entryId).toBe('entry-abc')
+  })
+
+  it('entryId without colons roundtrips correctly (UUID-style IDs)', () => {
+    const entryId = 'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+    const cursor = encodeCursor(-3.7, entryId)
+    const decoded = decodeCursor(cursor)
+    expect(decoded?.rank).toBeCloseTo(-3.7)
+    expect(decoded?.entryId).toBe(entryId)
+  })
+
+  it('returns null for invalid base64', () => {
+    expect(decodeCursor('!!!not-base64!!!')).toBeNull()
+  })
+
+  it('returns null when decoded string has no colon separator', () => {
+    expect(decodeCursor(btoa('noseparator'))).toBeNull()
+  })
+})
+
+// ─── buildFtsQuery ───────────────────────────────────────────────────────────
+
+describe('buildFtsQuery', () => {
+  it('returns empty-result query when no seed has a searchable FTS branch', () => {
+    const result = buildFtsQuery(
+      { q: 'hello', schemaSlug: null, status: null, limit: 20, cursor: null },
+      [NO_FTS_SEED],
+    )
+    expect(result.sql).toContain('WHERE 1=0')
+    expect(result.binds).toHaveLength(0)
+    expect(result.countSql).toContain('SELECT 0 as total')
+  })
+
+  it('throws EMPTY_QUERY when all terms are stripped or too short (single chars)', () => {
+    expect(() =>
+      buildFtsQuery({ q: 'a b', schemaSlug: null, status: null, limit: 20, cursor: null }, [TEXT_SEED]),
+    ).toThrow('EMPTY_QUERY')
+  })
+
+  it('generates a query referencing the seed FTS and content tables', () => {
+    const result = buildFtsQuery(
+      { q: 'hello', schemaSlug: null, status: null, limit: 20, cursor: null },
+      [TEXT_SEED],
+    )
+    expect(result.sql).toContain('fts_articoli')
+    expect(result.sql).toContain('content_articoli')
+    expect(result.sql).toContain('LIMIT ?')
+    expect(result.binds.at(-1)).toBe(21) // limit + 1 for has-more detection
+  })
+
+  it('UNION ALLs multiple seeds when no schemaSlug filter is set', () => {
+    const result = buildFtsQuery(
+      { q: 'test', schemaSlug: null, status: null, limit: 10, cursor: null },
+      [TEXT_SEED, SECOND_SEED],
+    )
+    expect(result.sql).toContain('UNION ALL')
+    expect(result.sql).toContain('fts_articoli')
+    expect(result.sql).toContain('fts_team')
+  })
+
+  it('limits query to the requested schemaSlug when provided', () => {
+    const result = buildFtsQuery(
+      { q: 'test', schemaSlug: 'articoli', status: null, limit: 20, cursor: null },
+      [TEXT_SEED, SECOND_SEED],
+    )
+    expect(result.sql).toContain('fts_articoli')
+    expect(result.sql).not.toContain('fts_team')
+  })
+
+  it('adds status filter to WHERE clause and bind values', () => {
+    const result = buildFtsQuery(
+      { q: 'hello', schemaSlug: null, status: 'published', limit: 20, cursor: null },
+      [TEXT_SEED],
+    )
+    expect(result.sql).toContain('ce.status = ?')
+    expect(result.binds).toContain('published')
+  })
+
+  it('adds cursor-based pagination condition when cursor is valid', () => {
+    const cursor = encodeCursor(-1.5, 'entry-123')
+    const result = buildFtsQuery(
+      { q: 'hello', schemaSlug: null, status: null, limit: 20, cursor },
+      [TEXT_SEED],
+    )
+    expect(result.sql).toContain('bm25')
+    expect(result.binds).toContain('entry-123')
+  })
+
+  it('ignores an invalid cursor and produces no pagination condition', () => {
+    const result = buildFtsQuery(
+      { q: 'hello', schemaSlug: null, status: null, limit: 20, cursor: 'bad-cursor' },
+      [TEXT_SEED],
+    )
+    expect(result.binds).not.toContain('entry-123')
+  })
+
+  it('countSql wraps each seed count in a SUM', () => {
+    const result = buildFtsQuery(
+      { q: 'test', schemaSlug: null, status: null, limit: 10, cursor: null },
+      [TEXT_SEED, SECOND_SEED],
+    )
+    expect(result.countSql).toContain('SUM')
+    expect(result.countSql).toContain('fts_articoli')
+    expect(result.countSql).toContain('fts_team')
+  })
+
+  it('count binds do not include the limit+1 sentinel', () => {
+    const result = buildFtsQuery(
+      { q: 'hello', schemaSlug: null, status: null, limit: 5, cursor: null },
+      [TEXT_SEED],
+    )
+    expect(result.countBinds).not.toContain(6) // limit + 1 must not appear in count binds
+  })
+
+  it('single-character terms (length < 2) are filtered out', () => {
+    // 'a b c' — single-char terms discarded; result depends on remaining terms
+    expect(() =>
+      buildFtsQuery({ q: 'a b c', schemaSlug: null, status: null, limit: 20, cursor: null }, [TEXT_SEED]),
+    ).toThrow('EMPTY_QUERY')
+  })
+
+  it('numeric terms are quoted without prefix expansion', () => {
+    const result = buildFtsQuery(
+      { q: '2024', schemaSlug: null, status: null, limit: 20, cursor: null },
+      [TEXT_SEED],
+    )
+    expect(result.binds[0]).toContain('"2024"')
+  })
+})
+
+// ─── mapFtsRow ───────────────────────────────────────────────────────────────
+
+describe('mapFtsRow', () => {
+  it('maps all FtsRow fields to SearchResultItem', () => {
+    const row = {
+      entry_id: 'e1', schema_slug: 'articoli', slug: 'my-post',
+      status: 'published', title: 'My Post', excerpt: 'A snippet', rank: -1,
+    }
+    const result = mapFtsRow(row)
+    expect(result.id).toBe('e1')
+    expect(result.schema_slug).toBe('articoli')
+    expect(result.slug).toBe('my-post')
+    expect(result.status).toBe('published')
+    expect(result.title).toBe('My Post')
+    expect(result.excerpt).toBe('A snippet')
+    expect(result.data).toEqual({})
+  })
+
+  it('strips HTML tags from excerpt but preserves <mark> and </mark>', () => {
+    const row = {
+      entry_id: 'e1', schema_slug: 'a', slug: null, status: 'draft',
+      title: null, excerpt: '<p>A <mark>word</mark> here</p>', rank: 0,
+    }
+    expect(mapFtsRow(row).excerpt).toBe('A <mark>word</mark> here')
+  })
+
+  it('collapses multiple whitespace characters in excerpt', () => {
+    const row = {
+      entry_id: 'e1', schema_slug: 'a', slug: null, status: 'draft',
+      title: null, excerpt: '<p>  lots   of  space  </p>', rank: 0,
+    }
+    expect(mapFtsRow(row).excerpt).toBe('lots of space')
+  })
+
+  it('returns empty string for null title', () => {
+    const row = {
+      entry_id: 'e1', schema_slug: 'a', slug: null, status: 'draft',
+      title: null, excerpt: '', rank: 0,
+    }
+    expect(mapFtsRow(row).title).toBe('')
+  })
+})

package/src/search-utils.ts

@@ -2,7 +2,7 @@
 // Pure functions — zero Hono dependencies, importable from Vitest.
 // v0.4.0: FTS is per-seed (fts_{slug}), joined with content_{slug} for metadata.
 
-import type { Seed } from "@beechcms/core"
+import type { Seed, SearchResultRow } from "@beechcms/core"
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -190,3 +190,20 @@ export function mapFtsRow(row: FtsRow): SearchResultItem {
     data:        {},
   }
 }
+
+/**
+ * Maps a repository-shaped SearchResultRow (camelCase) to the wire-format
+ * SearchResultItem returned by the /api/search route. Keeps the HTML
+ * stripping behaviour previously inlined inside mapFtsRow.
+ */
+export function mapSearchResultRow(row: SearchResultRow): SearchResultItem {
+  return {
+    id:          row.entryId,
+    schema_slug: row.schemaSlug,
+    slug:        row.slug,
+    status:      row.status,
+    title:       row.title ?? "",
+    excerpt:     stripHtmlPreserveMark(row.excerpt ?? ""),
+    data:        {},
+  }
+}

package/src/search.ts

@@ -4,69 +4,58 @@ import { Hono }              from "hono"
 import type { Env, Variables } from "./types"
 import { authMiddleware }    from "./middleware"
 import {
-  buildFtsQuery,
   encodeCursor,
-  mapFtsRow,
-  type FtsRow,
+  mapSearchResultRow,
   type SearchResponse,
 } from "./search-utils"
 
 export const searchRouter = new Hono<{ Bindings: Env; Variables: Variables }>()
 
-searchRouter.use("*", async (c, next) => {
-  return authMiddleware(c.env.JWT_SECRET, {
-    issuer: c.env.JWT_ISSUER,
-    audience: c.env.JWT_AUDIENCE,
-  })(c, next)
-})
+searchRouter.use("*", authMiddleware())
 
 // GET /api/search?q=...&schema_slug=...&status=...&limit=20&cursor=...
 searchRouter.get("/", async (c) => {
-  const q          = c.req.query("q")?.trim() ?? ""
+  const queryText  = c.req.query("q")?.trim() ?? ""
   const schemaSlug = c.req.query("schema_slug") ?? null
   const status     = c.req.query("status") ?? null
   const rawLimit   = parseInt(c.req.query("limit") ?? "20", 10)
   const limit      = Math.min(Math.max(rawLimit, 1), 50)
   const cursor     = c.req.query("cursor") ?? null
 
-  if (q.length < 2) {
+  if (queryText.length < 2) {
     return c.json({ error: "Il parametro 'q' deve avere almeno 2 caratteri." }, 400)
   }
 
-  const seeds = Object.values(c.get('seedRegistry'))
+  const seeds = c.get('seedRegistry').all()
+  const searchRepository = c.get('searchRepository')
 
-  let queryParts: ReturnType<typeof buildFtsQuery>
-  try {
-    queryParts = buildFtsQuery({ q, schemaSlug, status, limit, cursor }, seeds)
-  } catch (e) {
-    if ((e as Error).message === "EMPTY_QUERY") {
-      return c.json({ items: [], nextCursor: null, total: 0 } satisfies SearchResponse)
-    }
-    throw e
+  const queryOptions = {
+    queryText,
+    schemaSlug,
+    statusFilter: status,
+    limit,
+    cursor,
   }
+  const countOptions = { queryText, schemaSlug, statusFilter: status }
 
-  const { sql, binds, countSql, countBinds } = queryParts
-
-  const [ftsResult, countResult] = await Promise.all([
-    c.env.DB.prepare(sql).bind(...binds).all<FtsRow>(),
-    c.env.DB.prepare(countSql).bind(...countBinds).first<{ total: number }>(),
+  const [rawRows, countResult] = await Promise.all([
+    searchRepository.search(queryOptions, seeds),
+    searchRepository.count(countOptions, seeds),
   ])
 
-  const rows  = ftsResult.results ?? []
-  const total = countResult?.total ?? 0
-
-  const hasMore  = rows.length > limit
-  const pageRows = hasMore ? rows.slice(0, limit) : rows
+  const hasMore  = rawRows.length > limit
+  const pageRows = hasMore ? rawRows.slice(0, limit) : rawRows
 
-  const nextCursor = hasMore
-    ? encodeCursor(pageRows.at(-1)!.rank, pageRows.at(-1)!.entry_id)
+  const lastRow = pageRows.at(-1)
+  const nextCursor = hasMore && lastRow
+    ? encodeCursor(lastRow.rank, lastRow.entryId)
     : null
 
   if (pageRows.length === 0) {
-    return c.json({ items: [], nextCursor: null, total } satisfies SearchResponse)
+    return c.json({ items: [], nextCursor: null, total: countResult.total } satisfies SearchResponse)
   }
 
-  const items = pageRows.map(row => mapFtsRow(row))
+  const items = pageRows.map(mapSearchResultRow)
 
-  return c.json({ items, nextCursor, total } satisfies SearchResponse)
+  return c.json({ items, nextCursor, total: countResult.total } satisfies SearchResponse)
 })

package/src/shared/apply-policies.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest'
+import { applyPrivacy, applyVisibility, PrivacyPolicyError } from './apply-policies'
+import type { Seed } from '@beechcms/core'
+
+function makeSeed(branches: any[]): Seed {
+  return { slug: 'test', displayNameAlias: 'title', branches } as unknown as Seed
+}
+
+// ─── applyPrivacy ─────────────────────────────────────────────────────────────
+
+describe('applyPrivacy', () => {
+  it('passes through fields with no privacy policy (default: public)', async () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'title', type: 'text' }])
+    const result = await applyPrivacy({ title: 'Hello' }, seed)
+    expect(result.title).toBe('Hello')
+  })
+
+  it('hashes the value when branch privacy is "hash"', async () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'email', type: 'text', policies: { privacy: 'hash' } }])
+    const result = await applyPrivacy({ email: 'user@test.com' }, seed)
+    // sha256 produces a 64-char hex string
+    expect(typeof result.email).toBe('string')
+    expect((result.email as string).length).toBe(64)
+    expect(result.email).not.toBe('user@test.com')
+  })
+
+  it('leaves null/undefined values unhashed even when privacy is "hash"', async () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'email', type: 'text', policies: { privacy: 'hash' } }])
+    const result = await applyPrivacy({ email: null }, seed)
+    expect(result.email).toBeNull()
+  })
+
+  it('throws PrivacyPolicyError for "encrypt" privacy (not yet implemented)', async () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'secret', type: 'text', policies: { privacy: 'encrypt' } }])
+    await expect(applyPrivacy({ secret: 'value' }, seed)).rejects.toBeInstanceOf(PrivacyPolicyError)
+  })
+
+  it('passes through fields not present in the seed branches unchanged', async () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'title', type: 'text' }])
+    const result = await applyPrivacy({ title: 'Hi', extraField: 'extra' }, seed)
+    expect(result.extraField).toBe('extra')
+  })
+})
+
+// ─── applyVisibility ──────────────────────────────────────────────────────────
+
+describe('applyVisibility', () => {
+  it('includes fields with default (visible) visibility', () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'title', type: 'text' }])
+    const result = applyVisibility({ title: 'Hello' }, seed)
+    expect(result.title).toBe('Hello')
+  })
+
+  it('omits fields with visibility "hidden"', () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'internal', type: 'text', policies: { visibility: 'hidden' } }])
+    const result = applyVisibility({ internal: 'secret' }, seed)
+    expect(result).not.toHaveProperty('internal')
+  })
+
+  it('masks non-empty string fields with visibility "masked"', () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'password', type: 'text', policies: { visibility: 'masked' } }])
+    const result = applyVisibility({ password: 'secret123' }, seed)
+    expect(result.password).toBe('••••••••')
+  })
+
+  it('returns null for empty string fields with visibility "masked"', () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'password', type: 'text', policies: { visibility: 'masked' } }])
+    const result = applyVisibility({ password: '' }, seed)
+    expect(result.password).toBeNull()
+  })
+
+  it('passes through fields not present in the seed branches', () => {
+    const seed = makeSeed([{ id: 'br_01', alias: 'title', type: 'text' }])
+    const result = applyVisibility({ title: 'Hi', extraField: 'pass' }, seed)
+    expect(result.extraField).toBe('pass')
+  })
+})

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