@beechcms/api 0.4.0-preview.8 → 0.4.0

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

package/src/shared/fts-sync.ts

@@ -1,4 +1,4 @@
-// v0.4.0: FTS sync handled automatically by SQL triggers (generateFtsTriggers).
-// syncFts/deleteFts eliminated. This file kept as empty module to avoid import errors
-// during the Phase 4 → Phase 6 transition.
-export {}
+// v0.4.0: FTS sync handled automatically by SQL triggers (generateFtsTriggers).
+// syncFts/deleteFts eliminated. This file kept as empty module to avoid import errors
+// during the Phase 4 → Phase 6 transition.
+export {}

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

@@ -0,0 +1,56 @@
+import { IdempotencyRepository, IdempotencyRecord } from '@beechcms/core'
+import { BaseD1Repository } from './base.repository.d1.js'
+
+export class D1IdempotencyRepository extends BaseD1Repository implements IdempotencyRepository {
+  /**
+   * Looks up an idempotency record by its key.
+   */
+  async lookup(idempotencyKey: string): Promise<IdempotencyRecord | null> {
+    const idempotencyRecordResult = await this.database.prepare(
+      `SELECT idempotency_key, request_fingerprint, response_status, response_body, expires_at
+       FROM public_idempotency_keys WHERE idempotency_key = ? LIMIT 1`
+    ).bind(idempotencyKey).first<any>()
+
+    if (!idempotencyRecordResult) {
+      return null
+    }
+
+    return {
+      key: idempotencyRecordResult.idempotency_key,
+      fingerprint: idempotencyRecordResult.request_fingerprint,
+      responseStatus: idempotencyRecordResult.response_status,
+      responseBody: idempotencyRecordResult.response_body,
+      expiresAt: idempotencyRecordResult.expires_at
+    }
+  }
+
+  /**
+   * Stores or updates an idempotency record.
+   */
+  async store(idempotencyData: IdempotencyRecord): Promise<void> {
+    await this.database.prepare(
+      `INSERT INTO public_idempotency_keys (idempotency_key, request_fingerprint, response_status, response_body, created_at, expires_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(idempotency_key) DO UPDATE SET
+         request_fingerprint = excluded.request_fingerprint,
+         response_status = excluded.response_status,
+         response_body = excluded.response_body,
+         created_at = excluded.created_at,
+         expires_at = excluded.expires_at`
+    ).bind(
+      idempotencyData.key, 
+      idempotencyData.fingerprint, 
+      idempotencyData.responseStatus, 
+      idempotencyData.responseBody, 
+      Math.floor(Date.now() / 1000), 
+      idempotencyData.expiresAt
+    ).run()
+  }
+
+  /**
+   * Cleans up expired idempotency records.
+   */
+  async cleanup(expirationTimestamp: number): Promise<void> {
+    await this.database.prepare(`DELETE FROM public_idempotency_keys WHERE expires_at < ?`).bind(expirationTimestamp).run()
+  }
+}

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

@@ -0,0 +1,64 @@
+import { MediaRepository, MediaObject } from '@beechcms/core'
+
+/**
+ * Implementation of MediaRepository using Cloudflare D1.
+ * Provides methods to track media uploads, retrieve media metadata, and manage the media library state in the database.
+ */
+export class D1MediaRepository implements MediaRepository {
+  constructor(private database: D1Database) {}
+
+  /**
+   * Registers a new media upload in the database.
+   */
+  async trackUpload(mediaObject: MediaObject): Promise<void> {
+    await this.database.prepare(
+      'INSERT INTO media_objects (key, filename, mime_type, size_bytes, uploaded_by) VALUES (?, ?, ?, ?, ?)'
+    ).bind(
+      mediaObject.key, 
+      mediaObject.filename, 
+      mediaObject.mime_type, 
+      mediaObject.size_bytes, 
+      mediaObject.uploaded_by
+    ).run()
+  }
+
+  /**
+   * Retrieves a media object's metadata by its unique key.
+   */
+  async getByKey(mediaKey: string): Promise<MediaObject | null> {
+    return await this.database.prepare(
+      'SELECT key, filename, mime_type, size_bytes, uploaded_by, created_at FROM media_objects WHERE key = ?'
+    ).bind(mediaKey).first<MediaObject>()
+  }
+
+  /**
+   * Removes the metadata tracking for a specific media key.
+   */
+  async untrack(mediaKey: string): Promise<void> {
+    await this.database.prepare('DELETE FROM media_objects WHERE key = ?').bind(mediaKey).run()
+  }
+
+  /**
+   * Lists media objects with pagination support.
+   */
+  async list(paginationOptions: { limit: number; offset: number }): Promise<{ items: MediaObject[]; total: number }> {
+    const { results: mediaItems } = await this.database.prepare(
+      'SELECT key, filename, mime_type, size_bytes, uploaded_by, created_at FROM media_objects ORDER BY created_at DESC LIMIT ? OFFSET ?'
+    ).bind(paginationOptions.limit, paginationOptions.offset).all<MediaObject>()
+
+    const totalCountRecord = await this.database.prepare('SELECT COUNT(*) as total FROM media_objects').first<{ total: number }>()
+
+    return {
+      items: mediaItems ?? [],
+      total: totalCountRecord?.total ?? 0
+    }
+  }
+
+  /**
+   * Returns the total number of media objects in the database.
+   */
+  async count(): Promise<number> {
+    const totalCountRecord = await this.database.prepare('SELECT COUNT(*) as total FROM media_objects').first<{ total: number }>()
+    return totalCountRecord?.total ?? 0
+  }
+}

package/src/shared/notification-service.ts

@@ -1,56 +1,56 @@
-import { Context } from 'hono'
-
-export interface NotificationParams {
-  title: string
-  message: string
-  type?: 'info' | 'success' | 'warning' | 'error'
-}
-
-/**
- * Crea una notifica persistente nel database D1.
- * Usata principalmente per segnalare azioni provenienti dalle Public API.
- */
-export async function createNotification(
-  c: Context<any>,
-  params: NotificationParams
-): Promise<void> {
-  const db = c.env.DB as D1Database
-  if (!db) return
-
-  const { title, message, type = 'info' } = params
-  const id = crypto.randomUUID()
-
-  // Usiamo waitUntil per non bloccare la richiesta dell'utente esterno
-  let executionCtx: { waitUntil: (p: Promise<any>) => void } | undefined
-  try {
-    executionCtx = c.executionCtx
-  } catch {
-    // In ambiente di test Hono lancia se non presente
-  }
-
-  if (executionCtx) {
-    executionCtx.waitUntil((async () => {
-      try {
-        await db.prepare(
-          `INSERT INTO notifications (id, title, message, type)
-           VALUES (?, ?, ?, ?)`
-        ).bind(id, title, message, type).run()
-      } catch (err) {
-        console.error('Failed to create notification:', err)
-      }
-    })())
-  } else {
-    // Fallback sync per test o ambienti senza executionCtx (se vogliamo che le notifiche siano create)
-    // Oppure semplicemente ignoriamo. In questo caso, per i test, meglio tentare di crearle
-    // ma dato che è un'azione opzionale "background", in test possiamo saltarla o farla sync.
-    // Facciamola sync se non c'è executionCtx per garantire che i test che verificano le notifiche (se ce ne sono) passino.
-    try {
-      await db.prepare(
-        `INSERT INTO notifications (id, title, message, type)
-         VALUES (?, ?, ?, ?)`
-      ).bind(id, title, message, type).run()
-    } catch (err) {
-      console.error('Failed to create notification (sync fallback):', err)
-    }
-  }
-}
+import { Context } from 'hono'
+
+export interface NotificationParams {
+  title: string
+  message: string
+  type?: 'info' | 'success' | 'warning' | 'error'
+}
+
+/**
+ * Crea una notifica persistente nel database D1.
+ * Usata principalmente per segnalare azioni provenienti dalle Public API.
+ */
+export async function createNotification(
+  c: Context<any>,
+  params: NotificationParams
+): Promise<void> {
+  const db = c.env.DB as D1Database
+  if (!db) return
+
+  const { title, message, type = 'info' } = params
+  const id = crypto.randomUUID()
+
+  // Usiamo waitUntil per non bloccare la richiesta dell'utente esterno
+  let executionCtx: { waitUntil: (p: Promise<any>) => void } | undefined
+  try {
+    executionCtx = c.executionCtx
+  } catch {
+    // In ambiente di test Hono lancia se non presente
+  }
+
+  if (executionCtx) {
+    executionCtx.waitUntil((async () => {
+      try {
+        await db.prepare(
+          `INSERT INTO notifications (id, title, message, type)
+           VALUES (?, ?, ?, ?)`
+        ).bind(id, title, message, type).run()
+      } catch (err) {
+        console.error('Failed to create notification:', err)
+      }
+    })())
+  } else {
+    // Fallback sync per test o ambienti senza executionCtx (se vogliamo che le notifiche siano create)
+    // Oppure semplicemente ignoriamo. In questo caso, per i test, meglio tentare di crearle
+    // ma dato che è un'azione opzionale "background", in test possiamo saltarla o farla sync.
+    // Facciamola sync se non c'è executionCtx per garantire che i test che verificano le notifiche (se ce ne sono) passino.
+    try {
+      await db.prepare(
+        `INSERT INTO notifications (id, title, message, type)
+         VALUES (?, ?, ?, ?)`
+      ).bind(id, title, message, type).run()
+    } catch (err) {
+      console.error('Failed to create notification (sync fallback):', err)
+    }
+  }
+}