@beechcms/api 0.4.0-preview.9 → 0.4.1

package/src/shared/apply-policies.ts

@@ -1,63 +1,63 @@
-/// <reference types="@cloudflare/workers-types" />
-import { resolvePolicies, sha256hex } from '@beechcms/core'
-import type { Seed } from '@beechcms/core'
-
-class PrivacyPolicyError extends Error {
-  readonly status = 501 as const
-  constructor(message: string) {
-    super(message)
-    this.name = 'PrivacyPolicyError'
-  }
-}
-
-export { PrivacyPolicyError }
-
-/** Applica la privacy policy ai campi del payload prima della scrittura su DB. */
-export async function applyPrivacy(
-  data: Record<string, unknown>,
-  seed: Seed,
-): Promise<Record<string, unknown>> {
-  const result: Record<string, unknown> = {}
-  for (const [alias, value] of Object.entries(data)) {
-    const branch = seed.branches.find((b) => b.alias === alias)
-    if (!branch) {
-      result[alias] = value
-      continue
-    }
-    const { privacy } = resolvePolicies(branch)
-    if (privacy === 'encrypt') {
-      throw new PrivacyPolicyError(
-        `Field '${alias}' uses 'encrypt' privacy which is not yet implemented.`,
-      )
-    }
-    if (privacy === 'hash' && value != null) {
-      result[alias] = await sha256hex(String(value))
-    } else {
-      result[alias] = value
-    }
-  }
-  return result
-}
-
-/** Applica la visibility policy ai campi del payload in uscita verso il client. */
-export function applyVisibility(
-  data: Record<string, unknown>,
-  seed: Seed,
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-  for (const [alias, value] of Object.entries(data)) {
-    const branch = seed.branches.find((b) => b.alias === alias)
-    if (!branch) {
-      result[alias] = value
-      continue
-    }
-    const { visibility } = resolvePolicies(branch)
-    if (visibility === 'hidden') continue
-    if (visibility === 'masked') {
-      result[alias] = typeof value === 'string' && value.length > 0 ? '••••••••' : null
-    } else {
-      result[alias] = value
-    }
-  }
-  return result
-}
+/// <reference types="@cloudflare/workers-types" />
+import { resolvePolicies, sha256hex } from '@beechcms/core'
+import type { Seed } from '@beechcms/core'
+
+class PrivacyPolicyError extends Error {
+  readonly status = 501 as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'PrivacyPolicyError'
+  }
+}
+
+export { PrivacyPolicyError }
+
+/** Applica la privacy policy ai campi del payload prima della scrittura su DB. */
+export async function applyPrivacy(
+  data: Record<string, unknown>,
+  seed: Seed,
+): Promise<Record<string, unknown>> {
+  const result: Record<string, unknown> = {}
+  for (const [alias, value] of Object.entries(data)) {
+    const branch = seed.branches.find((b) => b.alias === alias)
+    if (!branch) {
+      result[alias] = value
+      continue
+    }
+    const { privacy } = resolvePolicies(branch)
+    if (privacy === 'encrypt') {
+      throw new PrivacyPolicyError(
+        `Field '${alias}' uses 'encrypt' privacy which is not yet implemented.`,
+      )
+    }
+    if (privacy === 'hash' && value != null) {
+      result[alias] = await sha256hex(String(value))
+    } else {
+      result[alias] = value
+    }
+  }
+  return result
+}
+
+/** Applica la visibility policy ai campi del payload in uscita verso il client. */
+export function applyVisibility(
+  data: Record<string, unknown>,
+  seed: Seed,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [alias, value] of Object.entries(data)) {
+    const branch = seed.branches.find((b) => b.alias === alias)
+    if (!branch) {
+      result[alias] = value
+      continue
+    }
+    const { visibility } = resolvePolicies(branch)
+    if (visibility === 'hidden') continue
+    if (visibility === 'masked') {
+      result[alias] = typeof value === 'string' && value.length > 0 ? '••••••••' : null
+    } else {
+      result[alias] = value
+    }
+  }
+  return result
+}

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/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 database: 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-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-utils.ts

@@ -1,108 +1,82 @@
-/// <reference types="@cloudflare/workers-types" />
-import { deserializeFromDb, serializeForDb } from '@beechcms/core'
-import type { Seed } from '@beechcms/core'
-import type { ContentEntry } from './query-utils'
-
-/** Deserializza ogni branch colonna di un DB row in formato API alias. */
-export function rowToApiData(seed: Seed, row: Record<string, unknown>): Record<string, unknown> {
-  const data: Record<string, unknown> = {}
-  for (const branch of seed.branches) {
-    data[branch.alias] = deserializeFromDb(branch, row[branch.alias] ?? null)
-  }
-  return data
-}
-
-/** Converte un row della tabella content_{slug} in ContentEntry per le risposte API. */
-export function rowToEntry(
-  seed: Seed,
-  row: Record<string, unknown>,
-  hasPendingDraft = false
-): ContentEntry {
-  return {
-    id: row.id as string,
-    schema_slug: seed.slug,
-    slug: (row.slug as string | null) ?? null,
-    status: (row.status as string) ?? 'draft',
-    data: rowToApiData(seed, row),
-    hasPendingDraft,
-    created_at: (row.created_at as number | null) ?? null,
-    updated_at: (row.updated_at as number | null) ?? null,
-  }
-}
-
-export interface InsertBindings {
-  cols: string[]
-  placeholders: string[]
-  bindings: (string | number | null)[]
-}
-
-/** Costruisce colonne, placeholders e bindings per INSERT INTO content_{slug}. */
-export function buildInsertBindings(seed: Seed, payload: Record<string, unknown>): InsertBindings {
-  const cols: string[] = []
-  const placeholders: string[] = []
-  const bindings: (string | number | null)[] = []
-  for (const branch of seed.branches) {
-    if (Object.hasOwn(payload, branch.alias)) {
-      cols.push(branch.alias)
-      placeholders.push('?')
-      bindings.push(serializeForDb(branch, payload[branch.alias]))
-    }
-  }
-  return { cols, placeholders, bindings }
-}
-
-export interface UpdateBindings {
-  setClause: string
-  bindings: (string | number | null)[]
-}
-
-/** Costruisce SET clause e bindings per UPDATE content_{slug}. */
-export function buildUpdateBindings(seed: Seed, payload: Record<string, unknown>): UpdateBindings {
-  const setParts: string[] = []
-  const bindings: (string | number | null)[] = []
-  for (const branch of seed.branches) {
-    if (Object.hasOwn(payload, branch.alias)) {
-      setParts.push(`${branch.alias} = ?`)
-      bindings.push(serializeForDb(branch, payload[branch.alias]))
-    }
-  }
-  return { setClause: setParts.join(', '), bindings }
-}
-
-/** Controlla se esiste un draft pendente in content_{slug}_drafts. */
-export async function hasDraft(db: D1Database, seed: Seed, entryId: string): Promise<boolean> {
-  if (!seed.allowDrafts) return false
-  const row = await db
-    .prepare(`SELECT 1 FROM content_${seed.slug}_drafts WHERE entry_id = ? LIMIT 1`)
-    .bind(entryId)
-    .first()
-  return row !== null
-}
-
-/** Scrive un evento CRUD in content_event_log per l'activity feed. */
-export async function logContentEvent(
-  db: D1Database,
-  opts: {
-    action: 'create' | 'update' | 'delete'
-    schemaSlug: string
-    entryId: string
-    userId?: string | null
-    details?: Record<string, unknown>
-  }
-): Promise<void> {
-  await db
-    .prepare(
-      `INSERT INTO content_event_log (id, schema_slug, entry_id, action, user_id, details, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`
-    )
-    .bind(
-      crypto.randomUUID(),
-      opts.schemaSlug,
-      opts.entryId,
-      opts.action,
-      opts.userId ?? null,
-      opts.details ? JSON.stringify(opts.details) : null,
-      Math.floor(Date.now() / 1000)
-    )
-    .run()
-}
+/// <reference types="@cloudflare/workers-types" />
+import { deserializeFromDb, serializeForDb } from '@beechcms/core'
+import type { Seed } from '@beechcms/core'
+import type { ContentEntry } from './query-utils'
+
+/** Deserializza ogni branch colonna di un DB row in formato API alias. */
+export function rowToApiData(seed: Seed, row: Record<string, unknown>): Record<string, unknown> {
+  const data: Record<string, unknown> = {}
+  for (const branch of seed.branches) {
+    data[branch.alias] = deserializeFromDb(branch, row[branch.alias] ?? null)
+  }
+  return data
+}
+
+/** Converte un row della tabella content_{slug} in ContentEntry per le risposte API. */
+export function rowToEntry(
+  seed: Seed,
+  row: Record<string, unknown>,
+  hasPendingDraft = false
+): ContentEntry {
+  return {
+    id: row.id as string,
+    schema_slug: seed.slug,
+    slug: (row.slug as string | null) ?? null,
+    status: (row.status as string) ?? 'draft',
+    data: rowToApiData(seed, row),
+    hasPendingDraft,
+    created_at: (row.created_at as number | null) ?? null,
+    updated_at: (row.updated_at as number | null) ?? null,
+  }
+}
+
+export interface InsertBindings {
+  cols: string[]
+  placeholders: string[]
+  bindings: (string | number | null)[]
+}
+
+/** Costruisce colonne, placeholders e bindings per INSERT INTO content_{slug}. */
+export function buildInsertBindings(seed: Seed, payload: Record<string, unknown>): InsertBindings {
+  const cols: string[] = []
+  const placeholders: string[] = []
+  const bindings: (string | number | null)[] = []
+  for (const branch of seed.branches) {
+    if (Object.hasOwn(payload, branch.alias)) {
+      cols.push(branch.alias)
+      placeholders.push('?')
+      bindings.push(serializeForDb(branch, payload[branch.alias]))
+    }
+  }
+  return { cols, placeholders, bindings }
+}
+
+export interface UpdateBindings {
+  setClause: string
+  bindings: (string | number | null)[]
+}
+
+/** Costruisce SET clause e bindings per UPDATE content_{slug}. */
+export function buildUpdateBindings(seed: Seed, payload: Record<string, unknown>): UpdateBindings {
+  const setParts: string[] = []
+  const bindings: (string | number | null)[] = []
+  for (const branch of seed.branches) {
+    if (Object.hasOwn(payload, branch.alias)) {
+      setParts.push(`${branch.alias} = ?`)
+      bindings.push(serializeForDb(branch, payload[branch.alias]))
+    }
+  }
+  return { setClause: setParts.join(', '), bindings }
+}
+
+/** Controlla se esiste un draft pendente in content_{slug}_drafts. */
+export async function hasDraft(db: D1Database, seed: Seed, entryId: string): Promise<boolean> {
+  if (!seed.allowDrafts) return false
+  const row = await db
+    .prepare(`SELECT 1 FROM content_${seed.slug}_drafts WHERE entry_id = ? LIMIT 1`)
+    .bind(entryId)
+    .first()
+  return row !== null
+}
+
+