@consilioweb/payload-support 0.10.1 → 0.12.0

package/src/endpoints/invite-collaborator.ts

@@ -0,0 +1,215 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { handleAuthError, AuthError } from '../utils/auth'
+import { escapeHtml, emailWrapper, emailButton, emailParagraph } from '../utils/emailTemplate'
+import { readSupportSettings } from '../utils/readSettings'
+import { randomBytes } from 'crypto'
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+
+/**
+ * POST /api/support/tickets/:id/invite
+ *
+ * Authenticated endpoint — admin OR ticket owner can invite an additional
+ * `support-clients` to view or collaborate on the ticket.
+ *
+ * Body: { email: string, role?: 'viewer' | 'collaborator' }
+ *
+ * Behaviour:
+ *  - Verifies access (ownership or admin)
+ *  - Looks up an existing `support-clients` with this email; creates one if missing.
+ *    Newly-created clients are minimal (firstName="Invité", lastName="", company="—")
+ *    so they can be enriched later via the standard portal flow.
+ *  - Upserts a row into `ticket-collaborators` (one per (ticket, client)).
+ *  - Sends an invitation email with a magic link `/support/tickets/:id?inviteToken=...`.
+ *  - Returns { ok, invitedTo, role }.
+ */
+export function createInviteCollaboratorEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/tickets/:id/invite',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        if (!req.user) throw new AuthError('Authentication required', 401)
+
+        const idRaw = req.routeParams?.id as string | undefined
+        if (!idRaw) return Response.json({ error: 'missing-id' }, { status: 400 })
+        const ticketId = Number(idRaw)
+        if (Number.isNaN(ticketId)) return Response.json({ error: 'invalid-id' }, { status: 400 })
+
+        let body: { email?: string; role?: 'viewer' | 'collaborator' }
+        try {
+          body = await req.json!()
+        } catch {
+          return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+        }
+
+        const email = (body.email || '').trim().toLowerCase()
+        if (!email || !EMAIL_RE.test(email) || email.length > 254) {
+          return Response.json({ error: 'Email invalide' }, { status: 400 })
+        }
+        const role = body.role === 'collaborator' ? 'collaborator' : 'viewer'
+
+        const payload = req.payload
+
+        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 isAdmin = req.user.collection === slugs.users
+        const ownerId = typeof ticket.client === 'object' ? ticket.client?.id : ticket.client
+        const isOwner =
+          req.user.collection === slugs.supportClients && ownerId === req.user.id
+        if (!isAdmin && !isOwner) {
+          return Response.json({ error: 'Forbidden' }, { status: 403 })
+        }
+
+        // Prevent inviting the primary owner (no-op)
+        const ownerEmail =
+          typeof ticket.client === 'object' ? (ticket.client?.email as string | undefined) : undefined
+        if (ownerEmail && ownerEmail.toLowerCase() === email) {
+          return Response.json({ error: 'Ce client est déjà propriétaire du ticket' }, { status: 400 })
+        }
+
+        // Find-or-create the invited support-client
+        let inviteeId: number | string | null = null
+        const existing = await payload.find({
+          collection: slugs.supportClients as any,
+          where: { email: { equals: email } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+        if (existing.docs.length > 0) {
+          inviteeId = (existing.docs[0] as any).id
+        } else {
+          // Create a placeholder client; password is random — the invitee will reset
+          // via the forgotPassword flow triggered by the SupportClients afterChange hook.
+          const tempPassword = randomBytes(16).toString('hex')
+          const created = await payload.create({
+            collection: slugs.supportClients as any,
+            data: {
+              email,
+              firstName: 'Invité',
+              lastName: email.split('@')[0]?.slice(0, 40) || '',
+              company: '—',
+              password: tempPassword,
+            } as any,
+            overrideAccess: true,
+            // Skip the "welcome" hook firing — let invitation email do the welcome instead
+            context: { skipInviteEmail: true } as any,
+          })
+          inviteeId = (created as any).id
+        }
+
+        if (!inviteeId) {
+          return Response.json({ error: 'Impossible de créer le client invité' }, { status: 500 })
+        }
+
+        // Upsert ticket-collaborator row (one per (ticket, client))
+        const dupe = await payload.find({
+          collection: 'ticket-collaborators' as any,
+          where: {
+            and: [
+              { ticket: { equals: ticketId } },
+              { client: { equals: inviteeId } },
+            ],
+          },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        const invitationToken = randomBytes(24).toString('hex')
+
+        if (dupe.docs.length > 0) {
+          await payload.update({
+            collection: 'ticket-collaborators' as any,
+            id: (dupe.docs[0] as any).id,
+            data: { role, invitationToken },
+            overrideAccess: true,
+          })
+        } else {
+          await payload.create({
+            collection: 'ticket-collaborators' as any,
+            data: {
+              ticket: ticketId,
+              client: inviteeId,
+              email,
+              role,
+              invitedBy: {
+                relationTo: req.user.collection,
+                value: req.user.id,
+              },
+              invitationToken,
+            } as any,
+            overrideAccess: true,
+          })
+        }
+
+        // Send invitation email
+        const settings = await readSupportSettings(payload).catch(() => null)
+        const replyTo = settings?.email?.replyToAddress || process.env.SUPPORT_REPLY_TO || ''
+        const baseUrl = process.env.NEXT_PUBLIC_SERVER_URL || ''
+        const ticketNumber = (ticket.ticketNumber as string) || `#${ticketId}`
+        const subject = (ticket.subject as string) || 'Ticket'
+        const inviteUrl = `${baseUrl}/support/tickets/${ticketId}?inviteToken=${invitationToken}`
+        const inviterLabel =
+          req.user.collection === slugs.users
+            ? 'L\'équipe support'
+            : `${(req.user as any).firstName || ''} ${(req.user as any).lastName || ''}`.trim() || 'Un collègue'
+
+        const roleLabel = role === 'collaborator' ? 'collaborateur (peut répondre)' : 'lecteur (consultation)'
+
+        await payload.sendEmail({
+          to: email,
+          ...(replyTo ? { replyTo } : {}),
+          subject: `Invitation au ticket ${ticketNumber}`,
+          html: emailWrapper(
+            `Invitation à un ticket support`,
+            [
+              emailParagraph(`Bonjour,`),
+              emailParagraph(
+                `<strong>${escapeHtml(inviterLabel)}</strong> vous invite à consulter le ticket <strong>${escapeHtml(ticketNumber)}</strong> — <em>${escapeHtml(subject)}</em>.`,
+              ),
+              emailParagraph(`Rôle attribué : <strong>${escapeHtml(roleLabel)}</strong>.`),
+              baseUrl ? emailButton('Accéder au ticket', inviteUrl) : '',
+              emailParagraph(
+                `<span style="font-size: 12px; color: #94a3b8;">Si vous n'avez pas encore de compte support, vous serez invité à définir un mot de passe pour activer votre accès.</span>`,
+              ),
+            ].join(''),
+          ),
+        })
+
+        // Best-effort email log
+        try {
+          await payload.create({
+            collection: slugs.emailLogs as any,
+            data: {
+              status: 'success',
+              action: 'invite',
+              senderEmail: (req.user as any).email,
+              recipientEmail: email,
+              subject: `Invitation ${ticketNumber}`,
+              ticketNumber,
+            },
+            overrideAccess: true,
+          })
+        } catch {
+          // emailLogs not enabled — skip
+        }
+
+        return Response.json({ ok: true, invitedTo: email, role })
+      } catch (err) {
+        const authResponse = handleAuthError(err)
+        if (authResponse) return authResponse
+        console.error('[support/invite-collaborator] Error:', err)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/kb-search.ts

@@ -0,0 +1,156 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+
+// Combining diacritics range used to strip accents after NFD normalization.
+const DIACRITICS = /[̀-ͯ]/g
+
+/**
+ * Recursively extract plain text from a Lexical (Payload richText) JSON tree.
+ * Returns a single string with nodes' text content joined by spaces.
+ *
+ * The shape we expect is roughly:
+ *   { root: { children: [ { children: [ { type: 'text', text: '...' } ] } ] } }
+ * but we walk anything that has a `children` array or a `text` field so it
+ * also tolerates the older Slate format.
+ */
+function lexicalToPlainText(richText: unknown): string {
+  if (!richText) return ''
+
+  const parts: string[] = []
+
+  const visit = (node: any): void => {
+    if (!node || typeof node !== 'object') return
+    if (typeof node.text === 'string') {
+      parts.push(node.text)
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) visit(child)
+    }
+    if (node.root) visit(node.root)
+  }
+
+  visit(richText)
+  return parts.join(' ').replace(/\s+/g, ' ').trim()
+}
+
+/**
+ * Build a short excerpt (~maxChars) cutting on a word boundary.
+ */
+function buildExcerpt(plain: string, maxChars = 160): string {
+  if (!plain) return ''
+  if (plain.length <= maxChars) return plain
+  const slice = plain.slice(0, maxChars + 1)
+  const lastSpace = slice.lastIndexOf(' ')
+  const cut = lastSpace > 60 ? slice.slice(0, lastSpace) : slice.slice(0, maxChars)
+  return `${cut.trim()}…`
+}
+
+/**
+ * Tokenize a query into lowercase words ≥ 2 chars (no diacritics).
+ */
+function tokenize(q: string): string[] {
+  return q
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(DIACRITICS, '')
+    .split(/[^a-z0-9]+/)
+    .filter((t) => t.length >= 2)
+}
+
+/**
+ * Normalize a string for case/diacritics-insensitive comparison.
+ */
+function normalize(s: string): string {
+  return s.toLowerCase().normalize('NFD').replace(DIACRITICS, '')
+}
+
+/**
+ * GET /api/support/kb/search?q=<query>&limit=5
+ *
+ * Public deflection endpoint: returns published KB articles whose `title` or
+ * `category` matches the query. No auth required (used on the public portal
+ * before/while a client writes a ticket — and also from the chatbot widget).
+ *
+ * Response shape:
+ *   { results: [{ id, title, slug, excerpt, category, score }], total }
+ */
+export function createKbSearchEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/kb/search',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        const url = new URL(req.url!)
+        const q = (url.searchParams.get('q') || '').trim()
+        const limitRaw = parseInt(url.searchParams.get('limit') || '5', 10)
+        const limit = Math.min(Math.max(Number.isNaN(limitRaw) ? 5 : limitRaw, 1), 10)
+
+        if (!q || q.length < 3) {
+          return Response.json({ results: [], total: 0 })
+        }
+
+        const tokens = tokenize(q)
+        if (tokens.length === 0) {
+          return Response.json({ results: [], total: 0 })
+        }
+
+        // Build an OR over (title contains token) ∪ (category contains token)
+        // for each significant token so multi-word queries still match docs
+        // matching any token.
+        const orClauses: any[] = []
+        for (const t of tokens) {
+          orClauses.push({ title: { contains: t } })
+          orClauses.push({ category: { contains: t } })
+        }
+        // Always include the raw query for short single-word matches.
+        orClauses.push({ title: { contains: q } })
+
+        const res = await payload.find({
+          collection: slugs.knowledgeBase as any,
+          where: {
+            and: [
+              { published: { equals: true } },
+              { or: orClauses },
+            ],
+          } as any,
+          // Over-fetch so we can re-rank and trim ourselves.
+          limit: Math.max(limit * 3, 10),
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        const results = res.docs
+          .map((a: any) => {
+            const title: string = a.title || ''
+            const category: string = a.category || ''
+            const titleN = normalize(title)
+            const categoryN = normalize(category)
+            let score = 0
+            for (const t of tokens) {
+              if (titleN.includes(t)) score += 2
+              if (categoryN.includes(t)) score += 1
+            }
+            const plain = lexicalToPlainText(a.body)
+            return {
+              id: a.id,
+              title,
+              slug: a.slug,
+              category,
+              excerpt: buildExcerpt(plain, 160),
+              score,
+            }
+          })
+          .filter((r) => r.score > 0)
+          .sort((a, b) => b.score - a.score)
+          .slice(0, limit)
+
+        return Response.json({ results, total: results.length })
+      } catch (error) {
+        console.error('[kb-search] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/ticket-feedback.ts

@@ -0,0 +1,104 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireClient, handleAuthError } from '../utils/auth'
+
+/**
+ * POST /api/support/tickets/:id/feedback
+ *
+ * Authenticated portal client submits a feedback (rating + optional comment)
+ * for one of their tickets. Only one feedback per ticket is allowed.
+ *
+ * Body: { rating: number (1-5), comment?: string }
+ */
+export function createTicketFeedbackEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/tickets/:id/feedback',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        requireClient(req, slugs)
+        const payload = req.payload
+
+        const idRaw = req.routeParams?.id as string | undefined
+        if (!idRaw) {
+          return Response.json({ error: 'missing-id' }, { status: 400 })
+        }
+        const ticketId = Number(idRaw)
+        if (Number.isNaN(ticketId)) {
+          return Response.json({ error: 'invalid-id' }, { status: 400 })
+        }
+
+        const body = (await req.json!()) as { rating?: unknown; comment?: unknown }
+        const ratingNum = Number(body?.rating)
+        if (!Number.isInteger(ratingNum) || ratingNum < 1 || ratingNum > 5) {
+          return Response.json(
+            { error: 'rating (entier 1-5) requis.' },
+            { status: 400 },
+          )
+        }
+        const comment =
+          typeof body?.comment === 'string' ? body.comment.trim() : undefined
+        if (comment && comment.length > 5000) {
+          return Response.json(
+            { error: 'Le commentaire ne peut pas depasser 5000 caracteres.' },
+            { status: 400 },
+          )
+        }
+
+        // Find ticket and check it belongs to the requesting client
+        const ticket = (await payload.findByID({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          depth: 0,
+          overrideAccess: true,
+        })) as { id: number; client?: number | { id: number } } | null
+
+        if (!ticket) {
+          return Response.json({ error: 'Ticket introuvable.' }, { status: 404 })
+        }
+
+        const ticketClientId =
+          typeof ticket.client === 'object' && ticket.client !== null
+            ? ticket.client.id
+            : ticket.client
+        if (ticketClientId !== req.user.id) {
+          return Response.json({ error: 'forbidden' }, { status: 403 })
+        }
+
+        // Check no feedback already exists for this ticket
+        const existing = await payload.find({
+          collection: 'ticket-feedback' as any,
+          where: { ticket: { equals: ticketId } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+        if (existing.docs.length > 0) {
+          return Response.json(
+            { error: 'Feedback deja soumis pour ce ticket.' },
+            { status: 409 },
+          )
+        }
+
+        const feedback = await payload.create({
+          collection: 'ticket-feedback' as any,
+          data: {
+            ticket: ticketId,
+            client: req.user.id,
+            rating: ratingNum,
+            ...(comment ? { comment } : {}),
+            submittedFrom: 'portal',
+          },
+          overrideAccess: true,
+        })
+
+        return Response.json({ success: true, feedback })
+      } catch (err) {
+        const authResponse = handleAuthError(err)
+        if (authResponse) return authResponse
+        console.error('[support/ticket-feedback] Error:', err)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}