@consilioweb/payload-support 0.5.1

package/src/endpoints/pending-emails-process.ts

@@ -0,0 +1,224 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { escapeHtml } from '../utils/emailTemplate'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+import { readSupportSettings } from '../utils/readSettings'
+
+/**
+ * POST /api/support/pending-emails/:id/process
+ * Admin-only endpoint to process a pending email.
+ */
+export function createPendingEmailsProcessEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/pending-emails/:id/process',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const id = req.routeParams?.id as string
+        const body = await req.json!()
+        const { action, ticketId, clientId: overrideClientId } = body as {
+          action: string
+          ticketId?: number
+          clientId?: number
+        }
+
+        if (!['create_ticket', 'add_to_ticket', 'ignore'].includes(action)) {
+          return Response.json({ error: 'Invalid action' }, { status: 400 })
+        }
+
+        const pendingEmail = await payload.findByID({
+          collection: slugs.pendingEmails as any,
+          id: Number(id),
+          depth: 1,
+          overrideAccess: true,
+        }) as any
+
+        if (!pendingEmail) {
+          return Response.json({ error: 'Pending email not found' }, { status: 404 })
+        }
+
+        if (pendingEmail.status !== 'pending') {
+          return Response.json({ error: 'Email already processed' }, { status: 409 })
+        }
+
+        let clientId = overrideClientId || (typeof pendingEmail.client === 'object' ? pendingEmail.client?.id : pendingEmail.client)
+        let clientDoc = typeof pendingEmail.client === 'object' ? pendingEmail.client : null
+
+        if (overrideClientId && overrideClientId !== clientDoc?.id) {
+          clientDoc = await payload.findByID({
+            collection: slugs.supportClients as any,
+            id: overrideClientId,
+            depth: 0,
+            overrideAccess: true,
+          })
+
+          await payload.update({
+            collection: slugs.pendingEmails as any,
+            id: Number(id),
+            data: { client: overrideClientId },
+            overrideAccess: true,
+          })
+        }
+
+        const settings = await readSupportSettings(payload)
+        const clientEmail = clientDoc?.email || pendingEmail.senderEmail || ''
+        const clientName = clientDoc?.firstName || pendingEmail.senderName || clientEmail
+        const portalUrl = `${process.env.NEXT_PUBLIC_SERVER_URL || ''}/support/dashboard`
+
+        if (!clientId && action !== 'ignore') {
+          return Response.json({ error: 'No client associated with this pending email' }, { status: 400 })
+        }
+
+        const attachments = (pendingEmail.attachments as Array<{ file: { id: number } | number }> | undefined)?.map((a: any) => ({
+          file: typeof a.file === 'object' ? a.file.id : a.file,
+        })) || []
+
+        if (action === 'ignore') {
+          await payload.update({
+            collection: slugs.pendingEmails as any,
+            id: Number(id),
+            data: {
+              status: 'ignored',
+              processedAction: 'ignored',
+              processedAt: new Date().toISOString(),
+            },
+            overrideAccess: true,
+          })
+          return Response.json({ action: 'ignored', pendingEmailId: Number(id) })
+        }
+
+        if (action === 'create_ticket') {
+          const newTicket = await payload.create({
+            collection: slugs.tickets as any,
+            data: {
+              subject: pendingEmail.subject,
+              client: clientId!,
+              status: 'open',
+              priority: 'normal',
+              category: 'question',
+              source: 'email',
+            },
+            overrideAccess: true,
+          }) as any
+
+          await payload.create({
+            collection: slugs.ticketMessages as any,
+            data: {
+              ticket: newTicket.id,
+              body: pendingEmail.body,
+              authorType: 'email',
+              authorClient: clientId,
+              isInternal: false,
+              ...(attachments.length > 0 && { attachments }),
+            },
+            overrideAccess: true,
+          })
+
+          // Send confirmation email
+          try {
+            await payload.sendEmail({
+              to: clientEmail,
+              replyTo: settings.email.replyToAddress || process.env.SUPPORT_REPLY_TO || '',
+              subject: `[${newTicket.ticketNumber}] ${pendingEmail.subject}`,
+              html: `<div style="font-family: system-ui, sans-serif; max-width: 600px; margin: 0 auto;">
+                <p>Bonjour <strong>${escapeHtml(clientName)}</strong>,</p>
+                <p>Votre demande a été enregistrée sous le numéro <strong>${newTicket.ticketNumber}</strong>.</p>
+                <p>Sujet : ${escapeHtml(pendingEmail.subject)}</p>
+                <p><a href="${portalUrl}">Accéder à mon espace</a></p>
+                <p style="font-size: 14px; color: #666;">Vous pouvez aussi répondre directement à cet email.</p>
+              </div>`,
+            })
+          } catch (err) {
+            console.error('[pending-email-process] Failed to send notification:', err)
+          }
+
+          await payload.update({
+            collection: slugs.pendingEmails as any,
+            id: Number(id),
+            data: {
+              status: 'processed',
+              processedAction: 'ticket_created',
+              processedTicket: newTicket.id,
+              processedAt: new Date().toISOString(),
+            },
+            overrideAccess: true,
+          })
+
+          return Response.json({
+            action: 'ticket_created',
+            ticketNumber: newTicket.ticketNumber,
+            ticketId: newTicket.id,
+          })
+        }
+
+        if (action === 'add_to_ticket') {
+          if (!ticketId) {
+            return Response.json({ error: 'ticketId is required for add_to_ticket' }, { status: 400 })
+          }
+
+          const targetTicket = await payload.findByID({
+            collection: slugs.tickets as any,
+            id: ticketId,
+            depth: 0,
+            overrideAccess: true,
+          }) as any
+
+          if (!targetTicket) {
+            return Response.json({ error: 'Target ticket not found' }, { status: 404 })
+          }
+
+          await payload.create({
+            collection: slugs.ticketMessages as any,
+            data: {
+              ticket: ticketId,
+              body: pendingEmail.body,
+              authorType: 'email',
+              authorClient: clientId,
+              isInternal: false,
+              ...(attachments.length > 0 && { attachments }),
+            },
+            overrideAccess: true,
+          })
+
+          if (targetTicket.status === 'resolved') {
+            await payload.update({
+              collection: slugs.tickets as any,
+              id: ticketId,
+              data: { status: 'open' },
+              overrideAccess: true,
+            })
+          }
+
+          await payload.update({
+            collection: slugs.pendingEmails as any,
+            id: Number(id),
+            data: {
+              status: 'processed',
+              processedAction: 'message_added',
+              processedTicket: ticketId,
+              processedAt: new Date().toISOString(),
+            },
+            overrideAccess: true,
+          })
+
+          return Response.json({
+            action: 'message_added',
+            ticketNumber: targetTicket.ticketNumber,
+            ticketId: targetTicket.id,
+          })
+        }
+
+        return Response.json({ error: 'Invalid action' }, { status: 400 })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[pending-email-process] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/presence.ts

@@ -0,0 +1,104 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+// In-memory presence state: ticketId -> Map<userId, { name, email, timestamp }>
+const presenceState = new Map<string, Map<string | number, { name: string; email: string; ts: number }>>()
+
+const PRESENCE_TTL = 30_000 // 30 seconds
+
+function cleanExpired(ticketId: string) {
+  const viewers = presenceState.get(ticketId)
+  if (!viewers) return
+  const now = Date.now()
+  for (const [userId, entry] of viewers) {
+    if (now - entry.ts > PRESENCE_TTL) {
+      viewers.delete(userId)
+    }
+  }
+  if (viewers.size === 0) presenceState.delete(ticketId)
+}
+
+/**
+ * POST /api/support/presence — Register or remove presence on a ticket
+ */
+export function createPresencePostEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/presence',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs)
+
+        const { ticketId, action } = (await req.json!()) as { ticketId: number; action: 'join' | 'leave' }
+        if (!ticketId || !action) {
+          return Response.json({ error: 'ticketId and action required' }, { status: 400 })
+        }
+
+        const key = String(ticketId)
+
+        if (action === 'join') {
+          if (!presenceState.has(key)) {
+            presenceState.set(key, new Map())
+          }
+          presenceState.get(key)!.set(req.user.id, {
+            name: (req.user as any).firstName || req.user.email || 'Admin',
+            email: req.user.email || '',
+            ts: Date.now(),
+          })
+        } else if (action === 'leave') {
+          presenceState.get(key)?.delete(req.user.id)
+          if (presenceState.get(key)?.size === 0) presenceState.delete(key)
+        }
+
+        return Response.json({ ok: true })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.warn('[presence] POST error:', error)
+        return Response.json({ error: 'Error' }, { status: 500 })
+      }
+    },
+  }
+}
+
+/**
+ * GET /api/support/presence?ticketId=123 — Get list of admins viewing this ticket
+ */
+export function createPresenceGetEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/presence',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs)
+
+        const url = new URL(req.url!)
+        const ticketId = url.searchParams.get('ticketId')
+        if (!ticketId) {
+          return Response.json({ error: 'ticketId required' }, { status: 400 })
+        }
+
+        cleanExpired(ticketId)
+        const viewers = presenceState.get(ticketId)
+
+        if (!viewers || viewers.size === 0) {
+          return Response.json({ viewers: [] })
+        }
+
+        const result: { name: string; email: string }[] = []
+        for (const [userId, entry] of viewers) {
+          if (userId !== req.user.id) {
+            result.push({ name: entry.name, email: entry.email })
+          }
+        }
+
+        return Response.json({ viewers: result })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        return Response.json({ viewers: [] })
+      }
+    },
+  }
+}

package/src/endpoints/process-scheduled.ts

@@ -0,0 +1,144 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { escapeHtml } from '../utils/emailTemplate'
+import { fireWebhooks } from '../utils/fireWebhooks'
+import { readSupportSettings } from '../utils/readSettings'
+
+/**
+ * POST /api/support/process-scheduled
+ * Process all scheduled replies whose scheduledAt has passed and scheduledSent is false.
+ * Protected by x-cron-secret header (same as auto-close).
+ */
+export function createProcessScheduledEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/process-scheduled',
+    method: 'post',
+    handler: async (req) => {
+      const secret = req.headers.get('x-cron-secret')
+      const expectedSecret = process.env.CRON_SECRET
+
+      if (!expectedSecret || secret !== expectedSecret) {
+        return Response.json({ error: 'Non autorisé' }, { status: 401 })
+      }
+
+      try {
+        const payload = req.payload
+        const now = new Date()
+        const settings = await readSupportSettings(payload)
+        const replyTo = settings.email.replyToAddress || process.env.SUPPORT_EMAIL || ''
+        const results = { processed: 0, errors: 0 }
+
+        // Find all messages where scheduledAt is in the past and scheduledSent is not true
+        const scheduled = await payload.find({
+          collection: slugs.ticketMessages as any,
+          where: {
+            and: [
+              { scheduledAt: { less_than_equal: now.toISOString() } },
+              {
+                or: [
+                  { scheduledSent: { equals: false } },
+                  { scheduledSent: { exists: false } },
+                ],
+              },
+            ],
+          },
+          limit: 100,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        for (const message of scheduled.docs) {
+          try {
+            const msg = message as any
+            const ticketId = typeof msg.ticket === 'object' ? msg.ticket.id : msg.ticket
+
+            // Fetch the ticket with client data
+            const ticket = await payload.findByID({
+              collection: slugs.tickets as any,
+              id: ticketId,
+              depth: 1,
+              overrideAccess: true,
+            })
+
+            if (!ticket) {
+              console.warn(`[process-scheduled] Ticket ${ticketId} not found for message ${msg.id}`)
+              results.errors++
+              continue
+            }
+
+            const t = ticket as any
+            const client = typeof t.client === 'object' ? t.client : null
+
+            // Send email notification to client (same logic as createNotifyClient hook)
+            if (client?.email && msg.authorType === 'admin' && !msg.isInternal) {
+              const ticketNumber = t.ticketNumber || 'TK-????'
+              const subject = t.subject || 'Support'
+              const baseUrl = process.env.NEXT_PUBLIC_SERVER_URL || ''
+              const preview = msg.body?.length > 500 ? msg.body.slice(0, 500) + '...' : msg.body
+
+              await payload.sendEmail({
+                to: client.email,
+                ...(replyTo ? { replyTo } : {}),
+                subject: `Re: [${ticketNumber}] ${subject}`,
+                html: `<p>Bonjour ${escapeHtml(client.firstName || '')},</p><p>Notre équipe a répondu à votre ticket <strong>${escapeHtml(ticketNumber)}</strong>.</p><blockquote style="border-left:4px solid #2563eb;padding:12px;margin:16px 0;background:#f8fafc;">${escapeHtml(preview)}</blockquote><p><a href="${baseUrl}/support/tickets/${ticketId}">Consulter le ticket</a></p>`,
+              })
+
+              // Record email delivery info
+              await payload.update({
+                collection: slugs.ticketMessages as any,
+                id: msg.id,
+                data: {
+                  scheduledSent: true,
+                  emailSentAt: now.toISOString(),
+                  emailSentTo: client.email,
+                },
+                overrideAccess: true,
+              })
+            } else {
+              // No email needed (internal note or no client email), just mark as sent
+              await payload.update({
+                collection: slugs.ticketMessages as any,
+                id: msg.id,
+                data: { scheduledSent: true },
+                overrideAccess: true,
+              })
+            }
+
+            // Update ticket status if this is an admin reply
+            if (msg.authorType === 'admin' && !msg.isInternal) {
+              await payload.update({
+                collection: slugs.tickets as any,
+                id: ticketId,
+                data: { status: 'waiting_client' },
+                overrideAccess: true,
+              })
+            }
+
+            // Fire webhook for the now-sent reply
+            fireWebhooks(payload, slugs, 'ticket_replied', {
+              ticketId,
+              messageId: msg.id,
+              authorType: msg.authorType,
+              scheduled: true,
+              body: msg.body?.length > 500 ? msg.body.slice(0, 500) + '...' : msg.body,
+            })
+
+            results.processed++
+          } catch (err) {
+            console.error(`[process-scheduled] Error processing message ${(message as any).id}:`, err)
+            results.errors++
+          }
+        }
+
+        return Response.json({
+          success: true,
+          ...results,
+          timestamp: now.toISOString(),
+        })
+      } catch (error) {
+        console.error('[process-scheduled] Error:', error)
+        return Response.json({ error: 'Erreur interne' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/purge-logs.ts

@@ -0,0 +1,58 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+/**
+ * DELETE /api/support/purge-logs?collection=email-logs&days=30
+ * Purge old logs older than X days. Admin-only.
+ */
+export function createPurgeLogsEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/purge-logs',
+    method: 'delete',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const url = new URL(req.url!)
+        const collection = url.searchParams.get('collection')
+        const days = Number(url.searchParams.get('days') || '0')
+
+        // Map collection param to slug
+        const allowedCollections: Record<string, string> = {
+          'email-logs': slugs.emailLogs,
+          'auth-logs': slugs.authLogs,
+        }
+
+        if (!collection || !allowedCollections[collection]) {
+          return Response.json({ error: 'Invalid collection. Use email-logs or auth-logs.' }, { status: 400 })
+        }
+
+        const cutoff = days > 0 ? new Date(Date.now() - days * 86400000).toISOString() : null
+
+        const result = await payload.delete({
+          collection: allowedCollections[collection] as any,
+          where: cutoff
+            ? { createdAt: { less_than: cutoff } }
+            : { id: { exists: true } },
+          overrideAccess: true,
+        })
+
+        const count = Array.isArray(result.docs) ? result.docs.length : 0
+
+        return Response.json({
+          purged: count,
+          collection,
+          days: days || 'all',
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[purge-logs] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/resend-notification.ts

@@ -0,0 +1,99 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+import { RateLimiter } from '../utils/rateLimiter'
+import { escapeHtml } from '../utils/emailTemplate'
+import { readSupportSettings } from '../utils/readSettings'
+
+const resendLimiter = new RateLimiter(60 * 60 * 1000, 10) // 10 per hour
+
+/**
+ * POST /api/support/resend-notification
+ * Resend the email notification for a specific ticket message. Admin-only.
+ */
+export function createResendNotificationEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/resend-notification',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        if (resendLimiter.check(String(req.user.id))) {
+          return Response.json(
+            { error: 'Trop de renvois. Réessayez dans une heure.' },
+            { status: 429 },
+          )
+        }
+
+        let body: { messageId?: string | number }
+        try {
+          body = await req.json!()
+        } catch {
+          return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+        }
+        const { messageId } = body
+
+        if (!messageId) {
+          return Response.json({ error: 'messageId requis' }, { status: 400 })
+        }
+
+        const message = await payload.findByID({
+          collection: slugs.ticketMessages as any,
+          id: messageId,
+          depth: 0,
+          overrideAccess: true,
+        }) as any
+
+        if (!message) {
+          return Response.json({ error: 'Message introuvable' }, { status: 404 })
+        }
+
+        const ticketId = typeof message.ticket === 'object' ? message.ticket.id : message.ticket
+        const ticket = await payload.findByID({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          depth: 1,
+          overrideAccess: true,
+        }) as any
+
+        if (!ticket) {
+          return Response.json({ error: 'Ticket introuvable' }, { status: 404 })
+        }
+
+        const client = typeof ticket.client === 'object' ? ticket.client : null
+        if (!client?.email) {
+          return Response.json({ error: 'Client sans email' }, { status: 400 })
+        }
+
+        const settings = await readSupportSettings(payload)
+        const ticketNumber = ticket.ticketNumber || 'TK-????'
+        const subject = ticket.subject || 'Support'
+        const baseUrl = process.env.NEXT_PUBLIC_SERVER_URL || ''
+        const portalUrl = `${baseUrl}/support/tickets/${ticketId}`
+        const preview = message.body?.length > 500 ? message.body.slice(0, 500) + '...' : message.body
+
+        await payload.sendEmail({
+          to: client.email,
+          replyTo: settings.email.replyToAddress || process.env.SUPPORT_REPLY_TO || '',
+          subject: `Re: [${ticketNumber}] ${subject}`,
+          html: `<div style="font-family: system-ui, sans-serif; max-width: 600px; margin: 0 auto;">
+            <p>Bonjour <strong>${escapeHtml(client.firstName || '')}</strong>,</p>
+            <p>Notre équipe a apporté une réponse à votre ticket <strong>${escapeHtml(ticketNumber)}</strong> — <em>${escapeHtml(subject)}</em>.</p>
+            <blockquote style="border-left: 4px solid #ccc; padding: 8px 16px; margin: 16px 0; color: #555;">${escapeHtml(preview)}</blockquote>
+            <p><a href="${portalUrl}">Consulter le ticket</a></p>
+          </div>`,
+        })
+
+        return Response.json({ success: true })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[resend-notification] Error:', error)
+        return Response.json({ error: 'Erreur interne' }, { status: 500 })
+      }
+    },
+  }
+}