@consilioweb/payload-support 0.5.1

package/src/endpoints/admin-stats.ts

@@ -0,0 +1,200 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+/**
+ * GET /api/support/admin-stats
+ * Admin-only endpoint returning support analytics.
+ * Uses count queries and paginated aggregation to avoid loading all tickets in memory.
+ */
+export function createAdminStatsEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/admin-stats',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        // ── Status counts via individual count queries ──
+        const statuses = ['open', 'waiting_client', 'resolved'] as const
+        const statusCounts = await Promise.all(
+          statuses.map(async (status) => {
+            const result = await payload.count({
+              collection: slugs.tickets as any,
+              where: { status: { equals: status } },
+              overrideAccess: true,
+            })
+            return [status, result.totalDocs] as const
+          }),
+        )
+        const byStatus: Record<string, number> = Object.fromEntries(statusCounts)
+        const total = statusCounts.reduce((sum, [, count]) => sum + count, 0)
+
+        // ── Priority counts ──
+        const priorities = ['low', 'normal', 'high', 'urgent'] as const
+        const priorityCounts = await Promise.all(
+          priorities.map(async (priority) => {
+            const result = await payload.count({
+              collection: slugs.tickets as any,
+              where: { priority: { equals: priority } },
+              overrideAccess: true,
+            })
+            return [priority, result.totalDocs] as const
+          }),
+        )
+        const byPriority: Record<string, number> = Object.fromEntries(priorityCounts)
+
+        // ── Category counts ──
+        const categories = ['bug', 'content', 'feature', 'question', 'hosting'] as const
+        const categoryCounts = await Promise.all(
+          categories.map(async (category) => {
+            const result = await payload.count({
+              collection: slugs.tickets as any,
+              where: { category: { equals: category } },
+              overrideAccess: true,
+            })
+            return [category, result.totalDocs] as const
+          }),
+        )
+        const byCategory: Record<string, number> = Object.fromEntries(
+          categoryCounts.filter(([, count]) => count > 0),
+        )
+
+        // ── Time-based counts ──
+        const now = new Date()
+        const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
+        const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+
+        const [created7, created30] = await Promise.all([
+          payload.count({
+            collection: slugs.tickets as any,
+            where: { createdAt: { greater_than_equal: sevenDaysAgo.toISOString() } },
+            overrideAccess: true,
+          }),
+          payload.count({
+            collection: slugs.tickets as any,
+            where: { createdAt: { greater_than_equal: thirtyDaysAgo.toISOString() } },
+            overrideAccess: true,
+          }),
+        ])
+
+        // ── Averages: paginate with limit:100, only fetch needed fields ──
+        const PAGE_SIZE = 100
+        const MAX_PAGES = 50
+        let totalResponseTimeMs = 0
+        let responseTimeCount = 0
+        let totalResolutionTimeMs = 0
+        let resolutionTimeCount = 0
+        let totalTimeMinutes = 0
+
+        let page = 1
+        let hasMore = true
+
+        while (hasMore && page <= MAX_PAGES) {
+          const batch = await payload.find({
+            collection: slugs.tickets as any,
+            limit: PAGE_SIZE,
+            page,
+            depth: 0,
+            overrideAccess: true,
+            select: {
+              firstResponseAt: true,
+              resolvedAt: true,
+              createdAt: true,
+              totalTimeMinutes: true,
+            },
+          })
+
+          for (const t of batch.docs) {
+            const doc = t as Record<string, unknown>
+            if (doc.firstResponseAt && doc.createdAt) {
+              const responseTime = new Date(String(doc.firstResponseAt)).getTime() - new Date(String(doc.createdAt)).getTime()
+              if (responseTime > 0) { totalResponseTimeMs += responseTime; responseTimeCount++ }
+            }
+            if (doc.resolvedAt && doc.createdAt) {
+              const resolutionTime = new Date(String(doc.resolvedAt)).getTime() - new Date(String(doc.createdAt)).getTime()
+              if (resolutionTime > 0) { totalResolutionTimeMs += resolutionTime; resolutionTimeCount++ }
+            }
+            totalTimeMinutes += (doc.totalTimeMinutes as number) || 0
+          }
+
+          hasMore = batch.hasNextPage ?? false
+          page++
+        }
+
+        // ── Satisfaction: use count + paginated average ──
+        const surveyCount = await payload.count({
+          collection: slugs.satisfactionSurveys as any,
+          overrideAccess: true,
+        })
+
+        let satisfactionAvg = 0
+        if (surveyCount.totalDocs > 0) {
+          let totalRating = 0
+          let surveyPage = 1
+          let surveyHasMore = true
+          while (surveyHasMore && surveyPage <= MAX_PAGES) {
+            const batch = await payload.find({
+              collection: slugs.satisfactionSurveys as any,
+              limit: PAGE_SIZE,
+              page: surveyPage,
+              depth: 0,
+              overrideAccess: true,
+              select: { rating: true },
+            })
+            for (const s of batch.docs) {
+              totalRating += ((s as any).rating || 0)
+            }
+            surveyHasMore = batch.hasNextPage ?? false
+            surveyPage++
+          }
+          satisfactionAvg = Math.round((totalRating / surveyCount.totalDocs) * 10) / 10
+        }
+
+        const [clientCount, pendingEmailsCount] = await Promise.all([
+          payload.count({
+            collection: slugs.supportClients as any,
+            overrideAccess: true,
+          }),
+          payload.count({
+            collection: slugs.pendingEmails as any,
+            where: { status: { equals: 'pending' } },
+            overrideAccess: true,
+          }),
+        ])
+
+        return new Response(JSON.stringify({
+          total,
+          byStatus,
+          byPriority,
+          byCategory,
+          createdLast7Days: created7.totalDocs,
+          createdLast30Days: created30.totalDocs,
+          avgResponseTimeHours: responseTimeCount > 0
+            ? Math.round((totalResponseTimeMs / responseTimeCount / (1000 * 60 * 60)) * 10) / 10
+            : null,
+          avgResolutionTimeHours: resolutionTimeCount > 0
+            ? Math.round((totalResolutionTimeMs / resolutionTimeCount / (1000 * 60 * 60)) * 10) / 10
+            : null,
+          totalTimeMinutes,
+          satisfactionAvg,
+          satisfactionCount: surveyCount.totalDocs,
+          clientCount: clientCount.totalDocs,
+          pendingEmailsCount: pendingEmailsCount.totalDocs,
+        }), {
+          headers: {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'private, max-age=300, stale-while-revalidate=600',
+          },
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[admin-stats] Error:', error)
+        return Response.json({ error: 'Internal error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/ai.ts

@@ -0,0 +1,199 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+import { readSupportSettings, type SupportSettings } from '../utils/readSettings'
+
+function getClient(aiSettings: SupportSettings['ai']) {
+  // Dynamic import to avoid hard dependency
+  const Anthropic = require('@anthropic-ai/sdk').default
+  if (aiSettings.provider === 'ollama') {
+    const baseURL = process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1'
+    return new Anthropic({ apiKey: 'ollama', baseURL })
+  }
+  return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+}
+
+function getModel(aiSettings: SupportSettings['ai']): string {
+  return aiSettings.model || 'claude-haiku-4-5-20251001'
+}
+
+type AiAction = 'sentiment' | 'synthesis' | 'suggest_reply' | 'rewrite'
+
+/**
+ * POST /api/support/ai
+ * Admin-only endpoint for AI features in support.
+ */
+export function createAiEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/ai',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const settings = await readSupportSettings(payload)
+        const aiSettings = settings.ai
+        let body: Record<string, unknown>
+        try {
+          body = await req.json!()
+        } catch {
+          return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+        }
+        const { action } = body as { action: AiAction }
+
+        const anthropic = getClient(aiSettings)
+        const model = getModel(aiSettings)
+
+        if (action === 'sentiment') {
+          if (!aiSettings.enableSentiment) {
+            return Response.json({ sentiment: 'neutre', disabled: true })
+          }
+          const { text } = body as { text: string }
+          if (!text) return Response.json({ error: 'text required' }, { status: 400 })
+
+          const res = await anthropic.messages.create({
+            model,
+            max_tokens: 20,
+            messages: [
+              {
+                role: 'user',
+                content: `Analyse le sentiment de ce message de support client. Réponds UNIQUEMENT par un seul mot parmi : frustré, mécontent, neutre, satisfait, urgent. Pas d'explication.\n\nMessage : "${text.slice(0, 500)}"`,
+              },
+            ],
+          })
+
+          const raw = (res.content[0].type === 'text' ? res.content[0].text : '').toLowerCase().trim()
+          return Response.json({ sentiment: raw })
+        }
+
+        if (action === 'synthesis') {
+          if (!aiSettings.enableSynthesis) {
+            return Response.json({ synthesis: '', disabled: true })
+          }
+          const { messages: msgs, ticketSubject, clientName, clientCompany } = body as {
+            messages: Array<{ authorType: string; body: string; createdAt: string }>
+            ticketSubject: string
+            clientName?: string
+            clientCompany?: string
+          }
+
+          const conversation = msgs
+            .map((m) => {
+              const author = m.authorType === 'admin' ? 'Support' : 'Client'
+              const date = new Date(m.createdAt).toLocaleDateString('fr-FR', {
+                day: 'numeric',
+                month: 'short',
+                hour: '2-digit',
+                minute: '2-digit',
+                timeZone: 'Europe/Paris',
+              })
+              return `[${date}] ${author}: ${m.body}`
+            })
+            .join('\n\n')
+
+          const prompt = `Tu es un agent de support technique senior. Analyse cette conversation de support et génère une synthèse structurée.
+
+Sujet du ticket : ${ticketSubject}
+Client : ${clientName || 'Inconnu'}${clientCompany ? ` — ${clientCompany}` : ''}
+
+Conversation :
+${conversation}
+
+Génère une synthèse avec ces sections (en markdown) :
+## Résumé
+2-3 phrases résumant la situation
+
+## Chronologie
+- Points clés de la conversation
+
+## Problème principal
+Description du problème ou de la demande
+
+## Actions
+- Ce qui a été fait
+- Prochaines étapes
+
+## Notes importantes
+Points d'attention éventuels`
+
+          const res = await anthropic.messages.create({
+            model,
+            max_tokens: 1000,
+            messages: [{ role: 'user', content: prompt }],
+          })
+
+          const text = res.content[0].type === 'text' ? res.content[0].text : ''
+          return Response.json({ synthesis: text })
+        }
+
+        if (action === 'suggest_reply') {
+          if (!aiSettings.enableSuggestion) {
+            return Response.json({ reply: '', disabled: true })
+          }
+          const { messages: msgs, clientName, clientCompany } = body as {
+            messages: Array<{ authorType: string; body: string }>
+            clientName?: string
+            clientCompany?: string
+          }
+
+          const conversation = msgs
+            .slice(-10)
+            .map((m) => {
+              const author = m.authorType === 'admin' ? 'Support' : 'Client'
+              return `${author}: ${m.body}`
+            })
+            .join('\n\n')
+
+          const prompt = `Tu es un agent de support technique. Tu réponds de manière professionnelle, chaleureuse et concise en français.
+
+Contexte client : ${clientCompany || ''} — ${clientName || 'client'}
+
+Conversation récente :
+${conversation}
+
+Rédige une réponse appropriée au dernier message du client. Sois concis (3-5 phrases max), professionnel mais chaleureux. Tutoie si le client tutoie, vouvoie sinon. Ne mets pas de signature.`
+
+          const res = await anthropic.messages.create({
+            model,
+            max_tokens: 500,
+            messages: [{ role: 'user', content: prompt }],
+          })
+
+          const text = res.content[0].type === 'text' ? res.content[0].text : ''
+          return Response.json({ reply: text })
+        }
+
+        if (action === 'rewrite') {
+          if (!aiSettings.enableRewrite) {
+            return Response.json({ rewritten: '', disabled: true })
+          }
+          const { text } = body as { text: string }
+          if (!text?.trim()) return Response.json({ error: 'text required' }, { status: 400 })
+
+          const prompt = `Tu es un agent de support technique professionnel. Reformule le texte ci-dessous de manière plus professionnelle et corrige les fautes d'orthographe/grammaire. Garde le même sens et le même ton (tutoiement/vouvoiement). Ne change pas le fond du message, améliore uniquement la forme. Réponds UNIQUEMENT avec le texte reformulé, sans commentaire ni explication.
+
+Texte original :
+${text}`
+
+          const res = await anthropic.messages.create({
+            model,
+            max_tokens: 500,
+            messages: [{ role: 'user', content: prompt }],
+          })
+
+          const rewritten = res.content[0].type === 'text' ? res.content[0].text : ''
+          return Response.json({ rewritten })
+        }
+
+        return Response.json({ error: 'Invalid action' }, { status: 400 })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[support/ai] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/apply-macro.ts

@@ -0,0 +1,144 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+interface MacroAction {
+  type: 'set_status' | 'set_priority' | 'add_tag' | 'send_reply' | 'assign'
+  value: string
+}
+
+/**
+ * POST /api/support/apply-macro
+ * Apply a macro (multi-action shortcut) to a ticket. Admin-only.
+ */
+export function createApplyMacroEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/apply-macro',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const body = await req.json!()
+        const { macroId, ticketId } = body
+
+        if (!macroId || !ticketId) {
+          return Response.json({ error: 'macroId and ticketId are required' }, { status: 400 })
+        }
+
+        const macro = await payload.findByID({
+          collection: slugs.macros as any,
+          id: macroId,
+          depth: 0,
+          overrideAccess: true,
+        }) as any
+
+        if (!macro) return Response.json({ error: 'Macro not found' }, { status: 404 })
+        if (!macro.isActive) return Response.json({ error: 'Macro is disabled' }, { status: 400 })
+
+        const ticket = await payload.findByID({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          depth: 0,
+          overrideAccess: true,
+        }) as any
+
+        if (!ticket) return Response.json({ error: 'Ticket not found' }, { status: 404 })
+
+        const appliedActions: { type: string; value: string; success: boolean; error?: string }[] = []
+        const actions: MacroAction[] = macro.actions || []
+
+        for (const action of actions) {
+          try {
+            switch (action.type) {
+              case 'set_status':
+                await payload.update({
+                  collection: slugs.tickets as any,
+                  id: ticketId,
+                  data: { status: action.value },
+                  overrideAccess: true,
+                })
+                appliedActions.push({ type: action.type, value: action.value, success: true })
+                break
+
+              case 'set_priority':
+                await payload.update({
+                  collection: slugs.tickets as any,
+                  id: ticketId,
+                  data: { priority: action.value },
+                  overrideAccess: true,
+                })
+                appliedActions.push({ type: action.type, value: action.value, success: true })
+                break
+
+              case 'add_tag': {
+                const currentTags = Array.isArray(ticket.tags) ? [...ticket.tags] : []
+                if (!currentTags.includes(action.value)) {
+                  currentTags.push(action.value)
+                }
+                await payload.update({
+                  collection: slugs.tickets as any,
+                  id: ticketId,
+                  data: { tags: currentTags },
+                  overrideAccess: true,
+                })
+                appliedActions.push({ type: action.type, value: action.value, success: true })
+                break
+              }
+
+              case 'send_reply':
+                await payload.create({
+                  collection: slugs.ticketMessages as any,
+                  data: {
+                    ticket: ticketId,
+                    body: action.value,
+                    authorType: 'admin',
+                    isInternal: false,
+                  },
+                  overrideAccess: true,
+                })
+                appliedActions.push({ type: action.type, value: action.value, success: true })
+                break
+
+              case 'assign': {
+                const userId = parseInt(action.value, 10)
+                if (isNaN(userId)) {
+                  appliedActions.push({ type: action.type, value: action.value, success: false, error: 'Invalid user ID' })
+                  break
+                }
+                await payload.update({
+                  collection: slugs.tickets as any,
+                  id: ticketId,
+                  data: { assignedTo: userId },
+                  overrideAccess: true,
+                })
+                appliedActions.push({ type: action.type, value: action.value, success: true })
+                break
+              }
+
+              default:
+                appliedActions.push({ type: action.type, value: action.value, success: false, error: 'Unknown action type' })
+            }
+          } catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err)
+            appliedActions.push({ type: action.type, value: action.value, success: false, error: errorMsg })
+          }
+        }
+
+        return Response.json({
+          applied: true,
+          macroName: macro.name,
+          ticketId,
+          actions: appliedActions,
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[apply-macro] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}