@beechcms/api 0.4.0 → 0.4.2

package/src/features/draft/draft.handler.ts

@@ -1,48 +1,50 @@
 /// <reference types="@cloudflare/workers-types" />
-import { Hono } from 'hono'
+import { Context, Hono } from 'hono'
 import { 
   validateAndSanitizeSeedPayload, 
-  resolvePolicies, 
-  EntryNotFoundError 
+  resolvePolicies 
 } from '@beechcms/core'
 import { publicProblem } from '../../public/problem-details'
-import { logActivity } from '../../shared/activity-logger'
 import { cleanStr } from '../../shared/query-utils'
 import { applyVisibility } from '../../shared/apply-policies'
 import { AppEnv } from '../../types'
 import { CONTENT_ERRORS } from '../content/constants'
+import { draftGuard } from './draft.middleware'
 
 const draftApp = new Hono<AppEnv>()
 
+
 function normalizeBody(raw: unknown): Record<string, unknown> {
   return typeof raw === 'object' && raw !== null ? (raw as Record<string, unknown>) : {}
 }
 
-function draftNotAllowed(context: any) {
-  return publicProblem(context, {
-    type: 'draft-not-allowed', 
-    title: 'Method Not Allowed', 
-    status: 405,
-    detail: 'This content type does not support pending drafts. Set allowDrafts: true on the Seed to enable.',
+function logDraftActivity(
+  context: Context<AppEnv>,
+  id: string,
+  slug: string,
+  title: string,
+  note: 'draft saved' | 'draft published'
+) {
+  const actor = context.get('jwtPayload')
+  context.get('activityLogger').log({
+    action: 'update',
+    entityType: 'content',
+    entityId: id,
+    entitySlug: slug,
+    details: { title, note },
+    actor: {
+      id: actor.sub,
+      email: actor.email ?? 'unknown',
+      name: actor.name ?? null,
+    },
   })
 }
 
-// PUT /:slug/:id/draft — crea o sovrascrive la bozza in content_{slug}_drafts
-draftApp.put('/:slug/:id/draft', async (context) => {
+// PUT /:slug/:id/draft — Creates or overwrites the pending draft
+draftApp.put('/:slug/:id/draft', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   let body: Record<string, unknown>
   try {
@@ -56,22 +58,6 @@ draftApp.put('/:slug/:id/draft', async (context) => {
     })
   }
 
-  const repository = context.get('repository')
-  try {
-    // Verify entry existence
-    await repository.findById(seed, id)
-  } catch (error) {
-    if (error instanceof EntryNotFoundError) {
-      return publicProblem(context, { 
-        type: 'content-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: CONTENT_ERRORS.NOT_FOUND 
-      })
-    }
-    throw error
-  }
-
   const sensitiveAliases = Object.keys(body).filter((alias) => {
     const branch = seed.branches.find((b) => b.alias === alias)
     return branch != null && resolvePolicies(branch).privacy !== 'plain'
@@ -112,161 +98,73 @@ draftApp.put('/:slug/:id/draft', async (context) => {
     })
   }
 
+  const repository = context.get('repository')
   await repository.saveDraft(seed, id, validation.data)
 
-  logActivity(context, {
-    action: 'update', 
-    entityType: 'content', 
-    entityId: id, 
-    entitySlug: slug,
-    details: { 
-      title: cleanStr(validation.data[seed.displayNameAlias]) ?? id, 
-      note: 'draft saved' 
-    },
-  })
+  const displayTitle = cleanStr(validation.data[seed.displayNameAlias]) ?? id
+  logDraftActivity(context, id, slug, displayTitle, 'draft saved')
 
   return context.json({ success: true })
 })
 
-// GET /:slug/:id/draft — legge la bozza pendente
-draftApp.get('/:slug/:id/draft', async (context) => {
+// GET /:slug/:id/draft — Retrieves the pending draft
+draftApp.get('/:slug/:id/draft', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   const repository = context.get('repository')
   const draft = await repository.getDraft(seed, id)
 
   if (!draft) {
-    try {
-      await repository.findById(seed, id)
-      return publicProblem(context, { 
-        type: 'draft-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: 'No pending draft for this entry' 
-      })
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) {
-        return publicProblem(context, { 
-          type: 'content-not-found', 
-          title: 'Not Found', 
-          status: 404, 
-          detail: CONTENT_ERRORS.NOT_FOUND 
-        })
-      }
-      throw error
-    }
+    return publicProblem(context, { 
+      type: 'draft-not-found', 
+      title: 'Not Found', 
+      status: 404, 
+      detail: 'No pending draft for this entry' 
+    })
   }
 
   return context.json({ data: applyVisibility(draft, seed) })
 })
 
-// POST /:slug/:id/draft/publish — promuove bozza → live atomicamente
-draftApp.post('/:slug/:id/draft/publish', async (context) => {
+// POST /:slug/:id/draft/publish — Atomically promotes draft to live
+draftApp.post('/:slug/:id/draft/publish', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   const repository = context.get('repository')
   const draft = await repository.getDraft(seed, id)
 
   if (!draft) {
-    try {
-      await repository.findById(seed, id)
-      return publicProblem(context, { 
-        type: 'draft-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: 'No pending draft to publish' 
-      })
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) {
-        return publicProblem(context, { 
-          type: 'content-not-found', 
-          title: 'Not Found', 
-          status: 404, 
-          detail: CONTENT_ERRORS.NOT_FOUND 
-        })
-      }
-      throw error
-    }
+    return publicProblem(context, { 
+      type: 'draft-not-found', 
+      title: 'Not Found', 
+      status: 404, 
+      detail: 'No pending draft to publish' 
+    })
   }
 
   await repository.publishDraft(seed, id)
 
   const displayValue = draft[seed.displayNameAlias]
   const displayStr = typeof displayValue === 'string' ? displayValue : id
-
-  logActivity(context, {
-    action: 'update', 
-    entityType: 'content', 
-    entityId: id, 
-    entitySlug: slug,
-    details: { title: displayStr, note: 'draft published' },
-  })
+  logDraftActivity(context, id, slug, displayStr, 'draft published')
 
   return context.json({ success: true })
 })
 
-// DELETE /:slug/:id/draft — scarta la bozza pendente
-draftApp.delete('/:slug/:id/draft', async (context) => {
+// DELETE /:slug/:id/draft — Discards the pending draft
+draftApp.delete('/:slug/:id/draft', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   const repository = context.get('repository')
-  try {
-    await repository.findById(seed, id)
-  } catch (error) {
-    if (error instanceof EntryNotFoundError) {
-      return publicProblem(context, { 
-        type: 'content-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: CONTENT_ERRORS.NOT_FOUND 
-      })
-    }
-    throw error
-  }
-
   await repository.deleteDraft(seed, id)
 
   return context.json({ success: true })
 })
 
 export { draftApp }
-

package/src/features/draft/draft.middleware.ts

@@ -0,0 +1,62 @@
+import { createMiddleware } from 'hono/factory'
+import { EntryNotFoundError } from '@beechcms/core'
+import { publicProblem } from '../../public/problem-details'
+import { CONTENT_ERRORS } from '../content/constants'
+import type { AppEnv } from '../../types'
+
+/**
+ * Middleware that guards draft-related endpoints.
+ * Responsibilities:
+ * 1. Validates that the targeted Seed schema exists.
+ * 2. Ensures the Seed configuration explicitly allows drafts.
+ * 3. Confirms that the main live content entry exists in the repository.
+ */
+export const draftGuard = createMiddleware<AppEnv>(async (context, next) => {
+  const slug = context.req.param('slug')
+  const id = context.req.param('id')
+
+  if (!slug || !id) {
+    return publicProblem(context, {
+      type: 'content-invalid-request',
+      title: 'Bad Request',
+      status: 400,
+      detail: 'Missing required route parameters',
+    })
+  }
+
+  const seed = context.get('getSeed')(slug)
+  if (!seed) {
+    return publicProblem(context, {
+      type: 'content-seed-not-found',
+      title: 'Not Found',
+      status: 404,
+      detail: CONTENT_ERRORS.SEED_NOT_FOUND,
+    })
+  }
+
+  if (!seed.allowDrafts) {
+    return publicProblem(context, {
+      type: 'draft-not-allowed',
+      title: 'Method Not Allowed',
+      status: 405,
+      detail: 'This content type does not support pending drafts. Set allowDrafts: true on the Seed to enable.',
+    })
+  }
+
+  const repository = context.get('repository')
+  try {
+    await repository.findById(seed, id)
+  } catch (error) {
+    if (error instanceof EntryNotFoundError) {
+      return publicProblem(context, {
+        type: 'content-not-found',
+        title: 'Not Found',
+        status: 404,
+        detail: CONTENT_ERRORS.NOT_FOUND,
+      })
+    }
+    throw error
+  }
+
+  await next()
+})

package/src/features/email/email.service.ts

@@ -16,10 +16,12 @@
 import { ResendEmailProvider } from './providers/resend'
 import { buildPasswordResetEmail } from './templates/password-reset'
 import { buildPasswordChangedEmail } from './templates/password-changed'
+import { buildAutomationEmail } from './templates/automation-mail'
 import type { EmailProvider } from './email.provider'
 import type {
   PasswordResetEmailParams,
   PasswordChangedEmailParams,
+  AutomationMailParams,
 } from './email.types'
 
 /** Default sender address (Resend test sender, works without a verified domain). */
@@ -78,3 +80,14 @@ export async function sendPasswordChangedEmail(
     html,
   })
 }
+
+export async function sendAutomationMail(params: AutomationMailParams): Promise<void> {
+  const provider = createProvider(params.apiKey ?? params.resendApiKey ?? '', false)
+  const message = buildAutomationEmail(params)
+  await provider.send({
+    from: params.from ?? DEFAULT_FROM,
+    to: [message.to],
+    subject: message.subject,
+    html: message.html,
+  })
+}

package/src/features/email/email.types.ts

@@ -96,3 +96,13 @@ export interface PasswordResetEmailParams extends BaseEmailParams {
 
 /** Parameters for the "password changed" notification. No additional fields. */
 export type PasswordChangedEmailParams = BaseEmailParams
+
+export interface AutomationMailParams {
+  to: string
+  subject: string
+  /** Plain text or HTML — passed verbatim to provider. */
+  body: string
+  apiKey?: string
+  resendApiKey?: string
+  from?: string
+}

package/src/features/email/index.ts

@@ -16,7 +16,7 @@
  *   PasswordChangedEmailParams — shape dei parametri per sendPasswordChangedEmail
  */
 
-export { sendPasswordResetEmail, sendPasswordChangedEmail } from './email.service'
+export { sendPasswordResetEmail, sendPasswordChangedEmail, sendAutomationMail } from './email.service'
 export {
   resolveEmailLocale,
   SUPPORTED_EMAIL_LOCALES,
@@ -25,4 +25,5 @@ export type {
   EmailLocale,
   PasswordResetEmailParams,
   PasswordChangedEmailParams,
+  AutomationMailParams,
 } from './email.types'

package/src/features/email/templates/automation-mail.ts

@@ -0,0 +1,15 @@
+import type { AutomationMailParams } from '../email.types'
+
+/** Identity builder: automation payloads are already user-authored. */
+export function buildAutomationEmail(params: AutomationMailParams) {
+  return {
+    to: params.to,
+    subject: params.subject,
+    html: params.body,
+    text: stripHtml(params.body),
+  }
+}
+
+function stripHtml(input: string): string {
+  return input.replace(/<[^>]+>/g, '').trim()
+}

package/src/features/notifications/notifications.handler.ts

@@ -3,47 +3,40 @@ import { Hono } from 'hono'
 import type { Env, Variables } from '../../types'
 
 /**
- * Notifications Feature Handler
+ * Notifications Feature Handler.
  *
- * Manages the retrieval, marking as read/unread, and deletion of system notifications.
- * Uses ETags for efficient client-side caching of the notification list.
+ * Manages retrieval, mark read/unread, and deletion of system notifications.
+ * All persistence goes through the {@link INotificationRepository} injected
+ * by `repositoryMiddleware`. The handler owns the HTTP concerns only:
+ * ETag negotiation, status codes, error mapping.
  */
 const notificationsApp = new Hono<{ Bindings: Env; Variables: Variables }>()
 
+const NOTIFICATION_LIST_LIMIT = 50
+
 /**
  * GET /notifications
- * Fetches the latest 50 notifications.
- * Implements ETag/304 Not Modified caching based on count and last update.
+ *
+ * Returns the most recent notifications. The ETag is built from aggregate
+ * stats so unchanged inboxes return 304 without serialising the full list.
  */
 notificationsApp.get('/notifications', async (context) => {
   try {
-    const { DB } = context.env
-
-    // Fetch aggregate stats to generate a robust ETag
-    const stats = await DB.prepare(
-      'SELECT COUNT(*) as count, MAX(created_at) as latest, SUM(is_read) as read_sum FROM notifications'
-    ).first<{ count: number; latest: number | null; read_sum: number | null }>()
-
-    const totalCount = stats?.count ?? 0
-    const lastUpdateTimestamp = stats?.latest ?? 0
-    const totalReadCount = stats?.read_sum ?? 0
-
-    // ETag is derived from count, latest timestamp, and read status to ensure freshness
-    const etag = `W/"${totalCount}-${lastUpdateTimestamp}-${totalReadCount}"`
+    const notificationRepository = context.get('notificationRepository')
+    const notificationStats = await notificationRepository.stats()
+    const etagValue = `W/"${notificationStats.totalCount}-${notificationStats.latestCreatedAt}-${notificationStats.readCount}"`
 
     const ifNoneMatch = context.req.header('If-None-Match')
-    if (ifNoneMatch === etag) {
+    if (ifNoneMatch === etagValue) {
       return new Response(null, { status: 304 })
     }
 
-    const dbResult = await DB.prepare(
-      'SELECT id, title, message, type, is_read, created_at FROM notifications ORDER BY created_at DESC LIMIT 50'
-    ).all()
+    const notifications = await notificationRepository.list(NOTIFICATION_LIST_LIMIT)
 
-    context.header('ETag', etag)
+    context.header('ETag', etagValue)
     context.header('Cache-Control', 'no-cache, must-revalidate')
 
-    return context.json(dbResult.results ?? [])
+    return context.json(notifications)
   } catch (error) {
     console.error('[Notifications] Fetch error:', error)
     return context.json({ error: 'Failed to fetch notifications' }, 500)
@@ -51,18 +44,12 @@ notificationsApp.get('/notifications', async (context) => {
 })
 
 /**
- * PATCH /notifications/:id/read
- * Marks a specific notification as read.
+ * PATCH /notifications/:id/read — mark a single notification as read.
  */
 notificationsApp.patch('/notifications/:id/read', async (context) => {
   try {
     const notificationId = context.req.param('id')
-    const { DB } = context.env
-
-    await DB.prepare('UPDATE notifications SET is_read = 1 WHERE id = ?')
-      .bind(notificationId)
-      .run()
-
+    await context.get('notificationRepository').markRead(notificationId)
     return context.json({ success: true })
   } catch (error) {
     console.error('[Notifications] Mark read error:', error)
@@ -71,18 +58,12 @@ notificationsApp.patch('/notifications/:id/read', async (context) => {
 })
 
 /**
- * PATCH /notifications/:id/unread
- * Marks a specific notification as unread.
+ * PATCH /notifications/:id/unread — mark a single notification as unread.
  */
 notificationsApp.patch('/notifications/:id/unread', async (context) => {
   try {
     const notificationId = context.req.param('id')
-    const { DB } = context.env
-
-    await DB.prepare('UPDATE notifications SET is_read = 0 WHERE id = ?')
-      .bind(notificationId)
-      .run()
-
+    await context.get('notificationRepository').markUnread(notificationId)
     return context.json({ success: true })
   } catch (error) {
     console.error('[Notifications] Mark unread error:', error)
@@ -91,18 +72,12 @@ notificationsApp.patch('/notifications/:id/unread', async (context) => {
 })
 
 /**
- * DELETE /notifications/:id
- * Permanently deletes a notification.
+ * DELETE /notifications/:id — permanently remove a notification.
  */
 notificationsApp.delete('/notifications/:id', async (context) => {
   try {
     const notificationId = context.req.param('id')
-    const { DB } = context.env
-
-    await DB.prepare('DELETE FROM notifications WHERE id = ?')
-      .bind(notificationId)
-      .run()
-
+    await context.get('notificationRepository').delete(notificationId)
     return context.json({ success: true })
   } catch (error) {
     console.error('[Notifications] Delete error:', error)
@@ -111,15 +86,11 @@ notificationsApp.delete('/notifications/:id', async (context) => {
 })
 
 /**
- * POST /notifications/mark-all-read
- * Marks all notifications in the database as read.
+ * POST /notifications/mark-all-read — mark every notification as read.
  */
 notificationsApp.post('/notifications/mark-all-read', async (context) => {
   try {
-    const { DB } = context.env
-
-    await DB.prepare('UPDATE notifications SET is_read = 1').run()
-
+    await context.get('notificationRepository').markAllRead()
     return context.json({ success: true })
   } catch (error) {
     console.error('[Notifications] Mark all read error:', error)

package/src/features/password-reset/request.ts

@@ -2,22 +2,11 @@
 import type { Context } from 'hono'
 import type { Env, Variables } from '../../types'
 import { sendPasswordResetEmail, resolveEmailLocale } from '../email'
+import { sha256hex } from '@beechcms/core'
+import { getClientIp } from '../../shared/request-utils'
 
 const PASSWORD_RESET_TOKEN_EXPIRY_SECONDS = 30 * 60
 
-/**
- * Computes the SHA-256 hash of a string and returns it as a hex string.
- */
-async function computeSha256Hash(text: string): Promise<string> {
-  const encoder = new TextEncoder()
-  const data = encoder.encode(text)
-  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
-  
-  return Array.from(new Uint8Array(hashBuffer))
-    .map(byte => byte.toString(16).padStart(2, '0'))
-    .join('')
-}
-
 /**
  * Handles the password reset request.
  * Generates a reset token, stores its hash in the database, and sends an email to the user.
@@ -46,41 +35,30 @@ export async function requestPasswordReset(
   const normalizedEmail = emailInput.trim().toLowerCase()
   const emailLocale = resolveEmailLocale(payload.locale)
 
-  // Rate limiting based on IP address
-  if (env.FORGOT_PASSWORD_RATE_LIMITER) {
-    const clientIpAddress = req.raw.headers.get('cf-connecting-ip') ?? 'unknown'
-    const { success: isRateLimitAllowed } = await env.FORGOT_PASSWORD_RATE_LIMITER.limit({ key: clientIpAddress })
-    
-    if (!isRateLimitAllowed) {
-      return context.json({ error: 'Too many requests' }, 429)
-    }
+  const clientIpAddress = getClientIp(req)
+  const forgotPasswordRateLimit = await context.get('rateLimiters').getLimiter('forgotPassword').checkLimit(clientIpAddress)
+  if (!forgotPasswordRateLimit.isAllowed) {
+    return context.json({ error: 'Too many requests' }, 429)
   }
 
-  // Find user by email. We always return 200 success even if the user is not found to prevent user enumeration.
-  const registeredUser = await env.DB
-    .prepare('SELECT id FROM users WHERE email = ?')
-    .bind(normalizedEmail)
-    .first<{ id: string }>()
-
+  // Always return 200 even when the user is not found to prevent user enumeration.
+  const registeredUser = await context.get('userRepository').findByEmail(normalizedEmail)
   if (!registeredUser) {
     return context.json({ success: true })
   }
 
-  // Invalidate any existing pending tokens for the same user before issuing a new one.
-  await env.DB
-    .prepare('UPDATE password_reset_tokens SET used_at = unixepoch() WHERE user_id = ? AND used_at IS NULL')
-    .bind(registeredUser.id)
-    .run()
+  const nowTimestamp = Math.floor(Date.now() / 1000)
+  await context.get('passwordResetTokenRepository').invalidatePending(registeredUser.id, nowTimestamp)
 
   const resetToken = crypto.randomUUID()
-  const hashedResetToken = await computeSha256Hash(resetToken)
-  const expirationTimestamp = Math.floor(Date.now() / 1000) + PASSWORD_RESET_TOKEN_EXPIRY_SECONDS
+  const tokenHash = await sha256hex(resetToken)
+  const expiresAt = nowTimestamp + PASSWORD_RESET_TOKEN_EXPIRY_SECONDS
 
-  // Store the hashed token in the database
-  await env.DB
-    .prepare('INSERT INTO password_reset_tokens (id, user_id, token_hash, expires_at) VALUES (?, ?, ?, ?)')
-    .bind(crypto.randomUUID(), registeredUser.id, hashedResetToken, expirationTimestamp)
-    .run()
+  await context.get('passwordResetTokenRepository').create({
+    userId: registeredUser.id,
+    tokenHash,
+    expiresAt,
+  })
 
   const baseUrl = (env.APP_URL ?? new URL(req.url).origin).replace(/\/$/, '')
   const resetUrl = `${baseUrl}/admin/reset-password?token=${resetToken}`
@@ -95,7 +73,6 @@ export async function requestPasswordReset(
       isDev: env.ENV !== 'production',
     })
   } catch (error) {
-    // Only log errors in non-production environments
     if (env.ENV !== 'production') {
       console.error('[password-reset] Failed to send email:', error)
     }
@@ -103,4 +80,3 @@ export async function requestPasswordReset(
 
   return context.json({ success: true })
 }
-