@beechcms/api 0.4.0-preview.12 → 0.4.0-preview.13

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

@@ -1,88 +1,130 @@
-/// <reference types="@cloudflare/workers-types" />
-import { Hono } from 'hono'
-import type { Env, Variables } from '../../types'
-
-const notificationsApp = new Hono<{ Bindings: Env; Variables: Variables }>()
-
-// GET /notifications — lista con ETag/304
-notificationsApp.get('/notifications', async (c) => {
-    try {
-        const { DB } = c.env
-
-        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 count = stats?.count ?? 0
-        const latest = stats?.latest ?? 0
-        const readSum = stats?.read_sum ?? 0
-        const etag = `W/"${count}-${latest}-${readSum}"`
-
-        const ifNoneMatch = c.req.header('If-None-Match')
-        if (ifNoneMatch === etag) {
-            return new Response(null, { status: 304 })
-        }
-
-        const result = await DB.prepare(
-            'SELECT id, title, message, type, is_read, created_at FROM notifications ORDER BY created_at DESC LIMIT 50'
-        ).all()
-
-        c.header('ETag', etag)
-        c.header('Cache-Control', 'no-cache, must-revalidate')
-
-        return c.json(result.results ?? [])
-    } catch (err) {
-        console.error('Notifications fetch error:', err)
-        return c.json({ error: 'Failed to fetch notifications' }, 500)
-    }
-})
-
-
-// PATCH /notifications/:id/read — segna come letta
-notificationsApp.patch('/notifications/:id/read', async (c) => {
-    try {
-        const id = c.req.param('id')
-        const { DB } = c.env
-        await DB.prepare('UPDATE notifications SET is_read = 1 WHERE id = ?').bind(id).run()
-        return c.json({ success: true })
-    } catch (err) {
-        return c.json({ error: 'Failed to update notification' }, 500)
-    }
-})
-// PATCH /notifications/:id/unread - Segna come non letta
-notificationsApp.patch('/notifications/:id/unread', async (c) => {
-    try {
-        const id = c.req.param('id')
-        const { DB } = c.env
-        await DB.prepare('UPDATE notifications SET is_read = 0 WHERE id = ?').bind(id).run()
-        return c.json({ success: true })
-    } catch (err) {
-        return c.json({ error: 'Failed to update notification' }, 500)
-    }
-})
-
-
-// DELETE /notifications/:id — elimina notifica
-notificationsApp.delete('/notifications/:id', async (c) => {
-    try {
-        const id = c.req.param('id')
-        const { DB } = c.env
-        await DB.prepare('DELETE FROM notifications WHERE id = ?').bind(id).run()
-        return c.json({ success: true })
-    } catch (err) {
-        return c.json({ error: 'Failed to delete notification' }, 500)
-    }
-})
-
-
-// POST /notifications/mark-all-read — segna tutte come lette
-notificationsApp.post('/notifications/mark-all-read', async (c) => {
-    try {
-        const { DB } = c.env
-        await DB.prepare('UPDATE notifications SET is_read = 1').run()
-        return c.json({ success: true })
-    } catch (err) {
-        return c.json({ error: 'Failed to update notifications' }, 500)
-    }
-})
-export { notificationsApp }
+/// <reference types="@cloudflare/workers-types" />
+import { Hono } from 'hono'
+import type { Env, Variables } from '../../types'
+
+/**
+ * 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.
+ */
+const notificationsApp = new Hono<{ Bindings: Env; Variables: Variables }>()
+
+/**
+ * GET /notifications
+ * Fetches the latest 50 notifications.
+ * Implements ETag/304 Not Modified caching based on count and last update.
+ */
+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 ifNoneMatch = context.req.header('If-None-Match')
+    if (ifNoneMatch === etag) {
+      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()
+
+    context.header('ETag', etag)
+    context.header('Cache-Control', 'no-cache, must-revalidate')
+
+    return context.json(dbResult.results ?? [])
+  } catch (error) {
+    console.error('[Notifications] Fetch error:', error)
+    return context.json({ error: 'Failed to fetch notifications' }, 500)
+  }
+})
+
+/**
+ * PATCH /notifications/:id/read
+ * Marks a specific 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()
+
+    return context.json({ success: true })
+  } catch (error) {
+    console.error('[Notifications] Mark read error:', error)
+    return context.json({ error: 'Failed to update notification' }, 500)
+  }
+})
+
+/**
+ * PATCH /notifications/:id/unread
+ * Marks a specific 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()
+
+    return context.json({ success: true })
+  } catch (error) {
+    console.error('[Notifications] Mark unread error:', error)
+    return context.json({ error: 'Failed to update notification' }, 500)
+  }
+})
+
+/**
+ * DELETE /notifications/:id
+ * Permanently deletes 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()
+
+    return context.json({ success: true })
+  } catch (error) {
+    console.error('[Notifications] Delete error:', error)
+    return context.json({ error: 'Failed to delete notification' }, 500)
+  }
+})
+
+/**
+ * POST /notifications/mark-all-read
+ * Marks all notifications in the database 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()
+
+    return context.json({ success: true })
+  } catch (error) {
+    console.error('[Notifications] Mark all read error:', error)
+    return context.json({ error: 'Failed to update notifications' }, 500)
+  }
+})
+
+export { notificationsApp }

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

@@ -1,15 +1,15 @@
-/// <reference types="@cloudflare/workers-types" />
-import { Hono } from 'hono'
-import type { Env, Variables } from '../../types'
-import { requestPasswordReset } from './request'
-import { resetPassword } from './reset'
-
-export const passwordResetApp = new Hono<{ Bindings: Env; Variables: Variables }>()
-
-// Feature flag: lets the dashboard know whether to show the forgot-password link
-passwordResetApp.get('/auth/features', (c) => {
-  return c.json({ passwordReset: Boolean(c.env.RESEND_API_KEY) })
-})
-
-passwordResetApp.post('/auth/forgot-password', requestPasswordReset)
-passwordResetApp.post('/auth/reset-password', resetPassword)
+/// <reference types="@cloudflare/workers-types" />
+import { Hono } from 'hono'
+import type { Env, Variables } from '../../types'
+import { requestPasswordReset } from './request'
+import { resetPassword } from './reset'
+
+export const passwordResetApp = new Hono<{ Bindings: Env; Variables: Variables }>()
+
+// Feature flag: lets the dashboard know whether to show the forgot-password link
+passwordResetApp.get('/auth/features', (context) => {
+  return context.json({ passwordReset: Boolean(context.env.RESEND_API_KEY) })
+})
+
+passwordResetApp.post('/auth/forgot-password', requestPasswordReset)
+passwordResetApp.post('/auth/reset-password', resetPassword)

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

@@ -1,88 +1,106 @@
-/// <reference types="@cloudflare/workers-types" />
-import type { Context } from 'hono'
-import type { Env, Variables } from '../../types'
-import { sendPasswordResetEmail, resolveEmailLocale } from '../email'
-
-const TOKEN_EXPIRY_SECONDS = 30 * 60
-
-async function sha256hex(text: string): Promise<string> {
-  const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text))
-  return Array.from(new Uint8Array(buf))
-    .map(b => b.toString(16).padStart(2, '0'))
-    .join('')
-}
-
-export async function requestPasswordReset(
-  c: Context<{ Bindings: Env; Variables: Variables }>
-): Promise<Response> {
-  if (!c.env.RESEND_API_KEY) {
-    return c.json({ error: 'Not available' }, 503)
-  }
-
-  let body: Record<string, unknown>
-  try {
-    body = await c.req.json()
-  } catch {
-    return c.json({ error: 'Invalid request body' }, 400)
-  }
-
-  if (typeof body.email !== 'string' || !body.email.trim()) {
-    return c.json({ error: 'Invalid request' }, 400)
-  }
-
-  const email = body.email.trim().toLowerCase()
-  const locale = resolveEmailLocale(body.locale)
-
-  if (c.env.FORGOT_PASSWORD_RATE_LIMITER) {
-    const ip = c.req.raw.headers.get('cf-connecting-ip') ?? 'unknown'
-    const { success } = await c.env.FORGOT_PASSWORD_RATE_LIMITER.limit({ key: ip })
-    if (!success) {
-      return c.json({ error: 'Too many requests' }, 429)
-    }
-  }
-
-  // Sempre 200 per evitare user enumeration
-  const user = await c.env.DB
-    .prepare('SELECT id FROM users WHERE email = ?')
-    .bind(email)
-    .first<{ id: string }>()
-
-  if (!user) {
-    return c.json({ success: true })
-  }
-
-  // Invalida eventuali token pendenti per lo stesso utente prima di emetterne uno nuovo
-  await c.env.DB
-    .prepare('UPDATE password_reset_tokens SET used_at = unixepoch() WHERE user_id = ? AND used_at IS NULL')
-    .bind(user.id)
-    .run()
-
-  const token = crypto.randomUUID()
-  const tokenHash = await sha256hex(token)
-  const expiresAt = Math.floor(Date.now() / 1000) + TOKEN_EXPIRY_SECONDS
-
-  await c.env.DB
-    .prepare('INSERT INTO password_reset_tokens (id, user_id, token_hash, expires_at) VALUES (?, ?, ?, ?)')
-    .bind(crypto.randomUUID(), user.id, tokenHash, expiresAt)
-    .run()
-
-  const appUrl = (c.env.APP_URL ?? new URL(c.req.url).origin).replace(/\/$/, '')
-  const resetUrl = `${appUrl}/admin/reset-password?token=${token}`
-
-  try {
-    await sendPasswordResetEmail({
-      to: email,
-      resetUrl,
-      locale,
-      apiKey: c.env.RESEND_API_KEY,
-      from: c.env.EMAIL_FROM,
-      isDev: c.env.ENV !== 'production',
-    })
-  } catch (err) {
-    if (c.env.ENV !== 'production') {
-      console.error('[password-reset] invio email fallito:', err)
-    }
-  }
-
-  return c.json({ success: true })
-}
+/// <reference types="@cloudflare/workers-types" />
+import type { Context } from 'hono'
+import type { Env, Variables } from '../../types'
+import { sendPasswordResetEmail, resolveEmailLocale } from '../email'
+
+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.
+ */
+export async function requestPasswordReset(
+  context: Context<{ Bindings: Env; Variables: Variables }>
+): Promise<Response> {
+  const { env, req } = context
+
+  if (!env.RESEND_API_KEY) {
+    return context.json({ error: 'Service not available' }, 503)
+  }
+
+  let payload: Record<string, unknown>
+  try {
+    payload = await req.json()
+  } catch {
+    return context.json({ error: 'Invalid request body' }, 400)
+  }
+
+  const emailInput = payload.email
+  if (typeof emailInput !== 'string' || !emailInput.trim()) {
+    return context.json({ error: 'Invalid request' }, 400)
+  }
+
+  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)
+    }
+  }
+
+  // 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 }>()
+
+  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 resetToken = crypto.randomUUID()
+  const hashedResetToken = await computeSha256Hash(resetToken)
+  const expirationTimestamp = Math.floor(Date.now() / 1000) + 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()
+
+  const baseUrl = (env.APP_URL ?? new URL(req.url).origin).replace(/\/$/, '')
+  const resetUrl = `${baseUrl}/admin/reset-password?token=${resetToken}`
+
+  try {
+    await sendPasswordResetEmail({
+      to: normalizedEmail,
+      resetUrl,
+      locale: emailLocale,
+      apiKey: env.RESEND_API_KEY,
+      from: env.EMAIL_FROM,
+      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)
+    }
+  }
+
+  return context.json({ success: true })
+}
+