@consilioweb/payload-support 0.5.1

package/src/components/TicketConversation/types.ts

@@ -0,0 +1,54 @@
+export interface Attachment {
+  file: { id: number; url?: string; filename?: string; mimeType?: string; sizes?: Record<string, { url?: string }> } | number
+}
+
+export interface Message {
+  id: string | number
+  body: string
+  bodyHtml?: string
+  authorType: 'client' | 'admin' | 'email'
+  isInternal?: boolean
+  isSolution?: boolean
+  attachments?: Attachment[]
+  createdAt: string
+  fromChat?: boolean
+}
+
+export interface TimeEntry {
+  id: string | number
+  duration: number
+  description?: string
+  date: string
+}
+
+export interface ClientInfo {
+  id: number
+  company: string
+  firstName: string
+  lastName: string
+  email: string
+  phone?: string
+}
+
+export interface CannedResponse {
+  id: string | number
+  title: string
+  body: string
+  category?: string
+}
+
+export interface ActivityEntry {
+  id: string | number
+  action: string
+  detail?: string
+  actorType?: string
+  actorEmail?: string
+  createdAt: string
+}
+
+export interface SatisfactionSurvey {
+  id: string | number
+  rating: number
+  comment?: string
+  createdAt: string
+}

package/src/components/TicketConversation/utils.ts

@@ -0,0 +1,25 @@
+export function getDateLabel(dateStr: string): string {
+  const date = new Date(dateStr)
+  const today = new Date()
+  const yesterday = new Date(today)
+  yesterday.setDate(yesterday.getDate() - 1)
+
+  if (date.toDateString() === today.toDateString()) return "Aujourd'hui"
+  if (date.toDateString() === yesterday.toDateString()) return 'Hier'
+  return date.toLocaleDateString('fr-FR', { day: 'numeric', month: 'short', year: 'numeric' })
+}
+
+export function formatMessageDate(dateStr: string): string {
+  const date = new Date(dateStr)
+  const today = new Date()
+  const yesterday = new Date(today)
+  yesterday.setDate(yesterday.getDate() - 1)
+  const time = date.toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit' })
+
+  if (date.toDateString() === today.toDateString()) return time
+  if (date.toDateString() === yesterday.toDateString()) return `Hier, ${time}`
+  if (date.getFullYear() === today.getFullYear()) {
+    return `${date.toLocaleDateString('fr-FR', { day: 'numeric', month: 'short' })}, ${time}`
+  }
+  return `${date.toLocaleDateString('fr-FR', { day: 'numeric', month: 'short', year: 'numeric' })}, ${time}`
+}

package/src/endpoints/admin-chat-stream.ts

@@ -0,0 +1,238 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+/**
+ * GET /api/support/admin-chat-stream?session=xxx
+ * Server-Sent Events endpoint for real-time chat messages (admin-side).
+ * Streams new messages + typing indicators for a specific session.
+ *
+ * Without ?session parameter, streams session list updates (new sessions, status changes).
+ */
+export function createAdminChatStreamEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/admin-chat-stream',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs)
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        return Response.json({ error: 'Unauthorized' }, { status: 401 })
+      }
+
+      const url = new URL(req.url!)
+      const sessionId = url.searchParams.get('session')
+
+      // Session-specific stream: messages for one chat session
+      if (sessionId) {
+        return createSessionStream(req, slugs, sessionId)
+      }
+
+      // Session list stream: updates on all active sessions
+      return createSessionListStream(req, slugs)
+    },
+  }
+}
+
+/**
+ * Stream messages for a specific chat session (admin view).
+ */
+function createSessionStream(
+  req: any,
+  slugs: CollectionSlugs,
+  sessionId: string,
+): Response {
+  let lastCheck = new Date().toISOString()
+  const encoder = new TextEncoder()
+
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(
+        encoder.encode(
+          `data: ${JSON.stringify({ type: 'connected', session: sessionId })}\n\n`,
+        ),
+      )
+
+      // Poll DB every 2 seconds for new messages in this session
+      const interval = setInterval(async () => {
+        try {
+          const messages = await req.payload.find({
+            collection: slugs.chatMessages as any,
+            where: {
+              session: { equals: sessionId },
+              createdAt: { greater_than: lastCheck },
+            },
+            sort: 'createdAt',
+            limit: 50,
+            depth: 1,
+            overrideAccess: true,
+          })
+
+          if (messages.docs.length > 0) {
+            const data = JSON.stringify({
+              type: 'messages',
+              data: messages.docs,
+            })
+            controller.enqueue(encoder.encode(`data: ${data}\n\n`))
+            lastCheck = (messages.docs[messages.docs.length - 1] as any).createdAt
+
+            // Check if session was closed
+            const lastMsg = messages.docs[messages.docs.length - 1] as any
+            if (lastMsg.status === 'closed') {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: 'closed', session: sessionId })}\n\n`,
+                ),
+              )
+            }
+          }
+        } catch (error) {
+          console.warn('[support] admin-chat-stream SSE poll error:', error)
+        }
+      }, 2000)
+
+      // Heartbeat every 30s
+      const heartbeat = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(`: heartbeat\n\n`))
+        } catch {
+          // Stream already closed
+        }
+      }, 30000)
+
+      req.signal?.addEventListener('abort', () => {
+        clearInterval(interval)
+        clearInterval(heartbeat)
+        try {
+          controller.close()
+        } catch {
+          // Already closed
+        }
+      })
+    },
+  })
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  })
+}
+
+/**
+ * Stream session list updates (admin overview of all chat sessions).
+ * Emits a snapshot of active/closed sessions every 5 seconds.
+ */
+function createSessionListStream(req: any, slugs: CollectionSlugs): Response {
+  const encoder = new TextEncoder()
+  let lastSessionHash = ''
+
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(
+        encoder.encode(`data: ${JSON.stringify({ type: 'connected', mode: 'sessions' })}\n\n`),
+      )
+
+      const interval = setInterval(async () => {
+        try {
+          const recentMessages = await req.payload.find({
+            collection: slugs.chatMessages as any,
+            sort: '-createdAt',
+            limit: 50,
+            depth: 1,
+            overrideAccess: true,
+          })
+
+          const sessionsMap = new Map<
+            string,
+            {
+              session: string
+              client: unknown
+              lastMessage: string
+              lastMessageAt: string
+              senderType: string
+              status: string
+              messageCount: number
+              unreadCount: number
+            }
+          >()
+
+          for (const msg of recentMessages.docs) {
+            const m = msg as any
+            const sid = m.session
+            if (!sessionsMap.has(sid)) {
+              sessionsMap.set(sid, {
+                session: sid,
+                client: m.client,
+                lastMessage: m.message,
+                lastMessageAt: m.createdAt,
+                senderType: m.senderType,
+                status: m.status || 'active',
+                messageCount: 0,
+                unreadCount: 0,
+              })
+            }
+            const s = sessionsMap.get(sid)!
+            s.messageCount++
+            if (m.senderType === 'client') s.unreadCount++
+            else if (m.senderType === 'agent') s.unreadCount = 0
+          }
+
+          const sessions = Array.from(sessionsMap.values()).sort(
+            (a, b) => new Date(b.lastMessageAt).getTime() - new Date(a.lastMessageAt).getTime(),
+          )
+
+          const active = sessions.filter((s) => s.status === 'active')
+          const closed = sessions.filter((s) => s.status === 'closed')
+
+          // Only emit if data changed (simple hash comparison)
+          const hash = JSON.stringify({ active: active.length, closed: closed.length, lastMsg: active[0]?.lastMessageAt })
+          if (hash !== lastSessionHash) {
+            lastSessionHash = hash
+
+            const data = JSON.stringify({
+              type: 'sessions',
+              data: { active, closed, totalActive: active.length },
+            })
+            controller.enqueue(encoder.encode(`data: ${data}\n\n`))
+          }
+        } catch (error) {
+          console.warn('[support] admin-chat-stream sessions SSE error:', error)
+        }
+      }, 5000)
+
+      // Heartbeat every 30s
+      const heartbeat = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(`: heartbeat\n\n`))
+        } catch {
+          // Stream already closed
+        }
+      }, 30000)
+
+      req.signal?.addEventListener('abort', () => {
+        clearInterval(interval)
+        clearInterval(heartbeat)
+        try {
+          controller.close()
+        } catch {
+          // Already closed
+        }
+      })
+    },
+  })
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  })
+}

package/src/endpoints/admin-chat.ts

@@ -0,0 +1,263 @@
+import type { Endpoint } from 'payload'
+import type { Where } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { RateLimiter } from '../utils/rateLimiter'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+const adminChatLimiter = new RateLimiter(60_000, 30) // 30 per minute
+
+/**
+ * GET /api/support/admin-chat?session=xxx&after=timestamp
+ * GET /api/support/admin-chat (no session = list active sessions)
+ */
+export function createAdminChatGetEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/admin-chat',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const url = new URL(req.url!)
+        const session = url.searchParams.get('session')
+        const after = url.searchParams.get('after')
+
+        if (session) {
+          const where: Where = { session: { equals: session } }
+          if (after) where.createdAt = { greater_than: after }
+
+          const messages = await payload.find({
+            collection: slugs.chatMessages as any,
+            where,
+            sort: 'createdAt',
+            limit: 200,
+            depth: 1,
+            overrideAccess: true,
+          })
+
+          return new Response(JSON.stringify({ messages: messages.docs, session }), {
+            headers: {
+              'Content-Type': 'application/json',
+              'Cache-Control': 'private, max-age=300, stale-while-revalidate=600',
+            },
+          })
+        }
+
+        // List recent sessions: fetch only recent messages, limit to 50
+        const recentMessages = await payload.find({
+          collection: slugs.chatMessages as any,
+          sort: '-createdAt',
+          limit: 50,
+          depth: 1,
+          overrideAccess: true,
+        })
+
+        const sessionsMap = new Map<string, {
+          session: string
+          client: unknown
+          lastMessage: string
+          lastMessageAt: string
+          senderType: string
+          status: string
+          messageCount: number
+          unreadCount: number
+        }>()
+
+        for (const msg of recentMessages.docs) {
+          const m = msg as any
+          const sid = m.session
+          if (!sessionsMap.has(sid)) {
+            sessionsMap.set(sid, {
+              session: sid,
+              client: m.client,
+              lastMessage: m.message,
+              lastMessageAt: m.createdAt,
+              senderType: m.senderType,
+              status: m.status || 'active',
+              messageCount: 0,
+              unreadCount: 0,
+            })
+          }
+          const s = sessionsMap.get(sid)!
+          s.messageCount++
+          if (m.senderType === 'client') s.unreadCount++
+          else if (m.senderType === 'agent') s.unreadCount = 0
+        }
+
+        const sessions = Array.from(sessionsMap.values())
+          .sort((a, b) => new Date(b.lastMessageAt).getTime() - new Date(a.lastMessageAt).getTime())
+
+        const activeSessions = sessions.filter((s) => s.status === 'active')
+        const closedSessions = sessions.filter((s) => s.status === 'closed')
+
+        return new Response(JSON.stringify({ active: activeSessions, closed: closedSessions, totalActive: activeSessions.length }), {
+          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-chat] GET Error:', error)
+        return Response.json({ error: 'Erreur interne du serveur' }, { status: 500 })
+      }
+    },
+  }
+}
+
+/**
+ * POST /api/support/admin-chat
+ * Admin sends a message or closes a session.
+ */
+export function createAdminChatPostEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/admin-chat',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        let body: { action?: string; session?: string; message?: string }
+        try {
+          body = await req.json!()
+        } catch {
+          return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+        }
+        const { action, session, message } = body
+
+        if (!session) {
+          return Response.json({ error: 'Session requise' }, { status: 400 })
+        }
+
+        const sessionMsg = await payload.find({
+          collection: slugs.chatMessages as any,
+          where: { session: { equals: session } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        if (sessionMsg.docs.length === 0) {
+          return Response.json({ error: 'Session introuvable' }, { status: 404 })
+        }
+
+        const clientId = typeof (sessionMsg.docs[0] as any).client === 'object'
+          ? (sessionMsg.docs[0] as any).client.id
+          : (sessionMsg.docs[0] as any).client
+
+        // Agent sends a message
+        if (action === 'send' && message) {
+          if (adminChatLimiter.check(String(req.user.id))) {
+            return Response.json({ error: 'Rate limit atteint.' }, { status: 429 })
+          }
+
+          const trimmedMessage = String(message).trim()
+          if (!trimmedMessage || trimmedMessage.length > 2000) {
+            return Response.json({ error: 'Message invalide (1-2000 caractères).' }, { status: 400 })
+          }
+
+          const newMsg = await payload.create({
+            collection: slugs.chatMessages as any,
+            data: {
+              session,
+              client: clientId,
+              senderType: 'agent',
+              agent: req.user.id,
+              message: trimmedMessage,
+              status: 'active',
+            },
+            overrideAccess: true,
+          })
+
+          // Try to link to ticket
+          try {
+            const linkedTicket = await payload.find({
+              collection: slugs.tickets as any,
+              where: { chatSession: { equals: session } },
+              limit: 1,
+              depth: 0,
+              overrideAccess: true,
+            })
+            if (linkedTicket.docs.length > 0) {
+              const ticketId = linkedTicket.docs[0].id
+              await payload.create({
+                collection: slugs.ticketMessages as any,
+                data: {
+                  ticket: ticketId,
+                  body: trimmedMessage,
+                  authorType: 'admin',
+                  skipNotification: true,
+                },
+                overrideAccess: true,
+              })
+              await payload.update({
+                collection: slugs.chatMessages as any,
+                id: newMsg.id,
+                data: { ticket: ticketId },
+                overrideAccess: true,
+              })
+            }
+          } catch (err) {
+            console.error('[admin-chat] Failed to link message to ticket:', err)
+          }
+
+          return Response.json({ message: newMsg })
+        }
+
+        // Admin closes session
+        if (action === 'close') {
+          await payload.create({
+            collection: slugs.chatMessages as any,
+            data: {
+              session,
+              client: clientId,
+              senderType: 'system',
+              message: 'Chat terminé par un agent.',
+              status: 'closed',
+            },
+            overrideAccess: true,
+          })
+
+          try {
+            const linkedTicket = await payload.find({
+              collection: slugs.tickets as any,
+              where: { chatSession: { equals: session } },
+              limit: 1,
+              depth: 0,
+              overrideAccess: true,
+            })
+            if (linkedTicket.docs.length > 0) {
+              await payload.create({
+                collection: slugs.ticketMessages as any,
+                data: {
+                  ticket: linkedTicket.docs[0].id,
+                  body: 'Session de chat terminée par un agent.',
+                  authorType: 'admin',
+                  isInternal: true,
+                  skipNotification: true,
+                },
+                overrideAccess: true,
+              })
+            }
+          } catch (err) {
+            console.error('[admin-chat] Failed to update ticket on close:', err)
+          }
+
+          return Response.json({ closed: true })
+        }
+
+        return Response.json({ error: 'Action invalide' }, { status: 400 })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[admin-chat] POST Error:', error)
+        return Response.json({ error: 'Erreur interne du serveur' }, { status: 500 })
+      }
+    },
+  }
+}