@consilioweb/payload-support 0.10.1 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consilioweb/payload-support",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Payload CMS plugin — professional support & ticketing system with AI, SLA, time tracking, live chat, and more",
   "type": "module",
   "main": "./dist/index.cjs",

package/src/collections/ClientSummaries.ts

@@ -59,6 +59,22 @@ export function createClientSummariesCollection(slugs: CollectionSlugs): Collect
         admin: { readOnly: true },
         // Array of strings: "Hébergé chez OVH", "Site WordPress", etc.
       },
+      {
+        name: 'nextActions',
+        type: 'array',
+        label: 'Prochaines actions suggérées',
+        admin: { description: 'Liste des actions suggérées par l\'IA' },
+        fields: [
+          { name: 'label', type: 'text', required: true },
+          {
+            name: 'priority',
+            type: 'select',
+            options: ['now', 'today', 'this-week'],
+            defaultValue: 'today',
+          },
+          { name: 'done', type: 'checkbox', defaultValue: false },
+        ],
+      },
       // ── Stats ──
       {
         name: 'ticketCount',

package/src/collections/TicketCollaborators.ts

@@ -0,0 +1,93 @@
+import type { CollectionConfig } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+
+/**
+ * Collaborators (viewers/contributors) added to a ticket by the primary client owner.
+ *
+ * Created via the `/api/support/tickets/:id/invite` endpoint. Each row links a
+ * ticket to a `support-clients` (the invitee) with a role: `viewer` (read-only)
+ * or `collaborator` (can post messages, when wired up later).
+ *
+ * Access logic on Tickets/TicketMessages should OR this table to grant access
+ * to invited clients without losing existing ownership-based rules.
+ */
+export function createTicketCollaboratorsCollection(slugs: CollectionSlugs): CollectionConfig {
+  return {
+    slug: 'ticket-collaborators',
+    labels: {
+      singular: 'Collaborateur ticket',
+      plural: 'Collaborateurs tickets',
+    },
+    admin: {
+      useAsTitle: 'email',
+      group: 'Support',
+      defaultColumns: ['email', 'ticket', 'client', 'role', 'invitedBy', 'createdAt'],
+    },
+    access: {
+      // Admins always; clients only see rows that reference them.
+      read: ({ req }) => {
+        if (req.user?.collection === slugs.users) return true
+        if (req.user?.collection === slugs.supportClients) {
+          return { client: { equals: req.user.id } }
+        }
+        return false
+      },
+      create: ({ req }) => !!req.user,
+      update: () => false,
+      delete: ({ req }) => req.user?.collection === slugs.users,
+    },
+    fields: [
+      {
+        name: 'ticket',
+        type: 'relationship',
+        relationTo: slugs.tickets,
+        required: true,
+        hasMany: false,
+        label: 'Ticket',
+      },
+      {
+        name: 'client',
+        type: 'relationship',
+        relationTo: slugs.supportClients,
+        required: true,
+        label: 'Client invité',
+      },
+      {
+        name: 'email',
+        type: 'email',
+        index: true,
+        label: 'Email invité',
+        admin: { description: 'Cache de l\'email du client invité au moment de l\'invitation' },
+      },
+      {
+        name: 'role',
+        type: 'select',
+        defaultValue: 'viewer',
+        options: [
+          { label: 'Lecteur', value: 'viewer' },
+          { label: 'Collaborateur', value: 'collaborator' },
+        ],
+        label: 'Rôle',
+      },
+      {
+        name: 'invitedBy',
+        type: 'relationship',
+        relationTo: [slugs.users, slugs.supportClients],
+        required: true,
+        label: 'Invité par',
+      },
+      {
+        name: 'acceptedAt',
+        type: 'date',
+        label: 'Accepté le',
+      },
+      {
+        name: 'invitationToken',
+        type: 'text',
+        index: true,
+        admin: { hidden: true },
+      },
+    ],
+    timestamps: true,
+  }
+}

package/src/collections/TicketFeedback.ts

@@ -0,0 +1,116 @@
+import type { CollectionConfig, CollectionAfterChangeHook } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { createAdminNotification } from '../utils/adminNotification'
+
+// ─── Hooks ───────────────────────────────────────────────
+
+function createAlertOnLowRating(slugs: CollectionSlugs, notificationSlug: string): CollectionAfterChangeHook {
+  return async ({ doc, operation, req }) => {
+    if (operation !== 'create') return doc
+    const rating = typeof doc.rating === 'number' ? doc.rating : Number(doc.rating)
+    if (!Number.isFinite(rating) || rating > 2) return doc
+
+    try {
+      const ticketId = typeof doc.ticket === 'object' ? doc.ticket?.id : doc.ticket
+      const ticketNumber = typeof doc.ticket === 'object' ? doc.ticket?.ticketNumber : undefined
+      const ticketLabel = ticketNumber || (ticketId ? `#${ticketId}` : '?')
+
+      await createAdminNotification(req.payload, {
+        title: `Client mecontent : ${ticketLabel}`,
+        message: `Note ${rating}/5${doc.comment ? ` — ${String(doc.comment).slice(0, 200)}` : ''}`,
+        type: 'satisfaction',
+        link: ticketId ? `/admin/collections/${slugs.tickets}/${ticketId}` : undefined,
+      }, notificationSlug)
+    } catch (err) {
+      console.error('[support] Failed to alert on low rating:', err)
+    }
+    return doc
+  }
+}
+
+// ─── Collection factory ──────────────────────────────────
+
+export function createTicketFeedbackCollection(slugs: CollectionSlugs, options?: {
+  notificationSlug?: string
+}): CollectionConfig {
+  const notificationSlug = options?.notificationSlug || 'admin-notifications'
+
+  return {
+    slug: 'ticket-feedback',
+    labels: {
+      singular: 'Feedback ticket',
+      plural: 'Feedbacks tickets',
+    },
+    admin: {
+      useAsTitle: 'rating',
+      group: 'Support',
+      defaultColumns: ['ticket', 'rating', 'client', 'submittedFrom', 'createdAt'],
+    },
+    access: {
+      // Creation is gated by the dedicated endpoint (signed token / portal session).
+      // We accept admins and authenticated support clients here; anonymous creation
+      // must go through the endpoint which uses overrideAccess.
+      create: ({ req }) => {
+        if (req.user?.collection === slugs.users) return true
+        if (req.user?.collection === slugs.supportClients) return true
+        return false
+      },
+      read: ({ req }) => {
+        // Admins only — keeps feedback private from clients
+        return req.user?.collection === slugs.users
+      },
+      update: () => false,
+      delete: ({ req }) => req.user?.collection === slugs.users,
+    },
+    fields: [
+      {
+        name: 'ticket',
+        type: 'relationship',
+        relationTo: slugs.tickets,
+        required: true,
+        hasMany: false,
+        unique: true,
+        label: 'Ticket',
+        admin: { readOnly: true },
+      },
+      {
+        name: 'rating',
+        type: 'number',
+        required: true,
+        min: 1,
+        max: 5,
+        label: 'Note (1-5)',
+        admin: { description: '1 = tres insatisfait, 5 = tres satisfait' },
+      },
+      {
+        name: 'comment',
+        type: 'textarea',
+        label: 'Commentaire',
+        admin: { description: 'Commentaire optionnel du client' },
+      },
+      {
+        name: 'client',
+        type: 'relationship',
+        relationTo: slugs.supportClients,
+        label: 'Client',
+        admin: { readOnly: true },
+      },
+      {
+        name: 'submittedFrom',
+        type: 'select',
+        defaultValue: 'portal',
+        label: 'Source',
+        options: [
+          { label: 'Portail', value: 'portal' },
+          { label: 'Email', value: 'email' },
+          { label: 'Admin', value: 'admin' },
+        ],
+        admin: { readOnly: true },
+      },
+    ],
+    hooks: {
+      afterChange: [createAlertOnLowRating(slugs, notificationSlug)],
+    },
+    timestamps: true,
+  }
+}

package/src/collections/TicketMessages.ts

@@ -311,6 +311,15 @@ export function createTicketMessagesCollection(slugs: CollectionSlugs, options?:
         name: 'attachments', type: 'array', label: 'Pieces jointes',
         fields: [{ name: 'file', type: 'upload', relationTo: slugs.media, required: true, label: 'Fichier' }],
       },
+      {
+        name: 'fromAlias',
+        type: 'text',
+        label: 'Alias d\'expéditeur',
+        admin: {
+          description: 'Si défini, le message est envoyé au nom de cet alias plutôt que de l\'agent authentifié',
+          position: 'sidebar',
+        },
+      },
       { name: 'isInternal', type: 'checkbox', defaultValue: false, label: 'Note interne', admin: { position: 'sidebar' } },
       { name: 'isSolution', type: 'checkbox', defaultValue: false, label: 'Reponse solution', admin: { position: 'sidebar' } },
       { name: 'skipNotification', type: 'checkbox', defaultValue: false, label: 'Sans notification', admin: { position: 'sidebar', condition: (data) => data?.skipNotification === true } },

package/src/collections/Tickets.ts

@@ -4,6 +4,7 @@ import type {
   CollectionAfterChangeHook,
   CollectionBeforeDeleteHook,
   Field,
+  Where,
 } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
 import { escapeHtml } from '../utils/emailTemplate'
@@ -604,6 +605,8 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
               { label: 'Ouvert', value: 'open' },
               { label: 'En attente client', value: 'waiting_client' },
               { label: 'Resolu', value: 'resolved' },
+              { label: 'Ferme', value: 'closed' },
+              { label: 'Escalade', value: 'escalated' },
             ],
             admin: { width: '50%' },
           },
@@ -807,9 +810,36 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
         if (req.user?.collection === slugs.supportClients) return true
         return false
       },
-      read: ({ req }) => {
+      read: async ({ req }) => {
         if (req.user?.collection === slugs.users) return true
         if (req.user?.collection === slugs.supportClients) {
+          // Owner OR collaborator (via ticket-collaborators table).
+          // We resolve the collaborator ticket-ids upfront so we keep a single Where
+          // expression — Payload's access fns support async returns.
+          let collabTicketIds: Array<number | string> = []
+          try {
+            const rows = await req.payload.find({
+              collection: 'ticket-collaborators' as any,
+              where: { client: { equals: req.user.id } },
+              limit: 1000,
+              depth: 0,
+              overrideAccess: true,
+            })
+            collabTicketIds = rows.docs
+              .map((r: any) => (typeof r.ticket === 'object' ? r.ticket?.id : r.ticket))
+              .filter((v: unknown): v is number | string => v !== undefined && v !== null)
+          } catch {
+            // ticket-collaborators collection may not yet exist on older deployments — fall back to owner-only.
+          }
+          if (collabTicketIds.length > 0) {
+            const where: Where = {
+              or: [
+                { client: { equals: req.user.id } },
+                { id: { in: collabTicketIds } },
+              ],
+            }
+            return where
+          }
           return { client: { equals: req.user.id } }
         }
         return false

package/src/collections/index.ts

@@ -15,3 +15,5 @@ export { createSlaPoliciesCollection } from './SlaPolicies'
 export { createMacrosCollection } from './Macros'
 export { createTicketStatusesCollection } from './TicketStatuses'
 export { createClientSummariesCollection } from './ClientSummaries'
+export { createTicketFeedbackCollection } from './TicketFeedback'
+export { createTicketCollaboratorsCollection } from './TicketCollaborators'

package/src/components/TicketConversation/locales/en.json

@@ -176,6 +176,12 @@
     }
   },
   "composer": {
+    "aiSuggestion": {
+      "label": "Contextual suggestion",
+      "ignore": "Dismiss",
+      "insert": "Insert",
+      "loading": "Generating…"
+    },
     "placeholder": "Write a reply to the client...",
     "placeholderInternal": "Internal note...",
     "placeholderReplyTo": "Reply to {{name}}...",
@@ -209,6 +215,11 @@
     "shortcuts": {
       "sendHint": "\u2318Enter to send",
       "noteHint": "\u2318\u21e7N internal note"
+    },
+    "aliases": {
+      "label": "Send as",
+      "tooltip": "Choose a sender alias for this message",
+      "self": "(default)"
     }
   },
   "settings": {
@@ -788,7 +799,20 @@
     "statusWaiting": "Waiting",
     "statusResolved": "Resolved",
     "selectTicket": "Select a ticket from the list",
-    "notFound": "Ticket not found"
+    "notFound": "Ticket not found",
+    "sidebar": {
+      "tabs": {
+        "overview": "Overview",
+        "client": "Client",
+        "activity": "Activity"
+      },
+      "previousTickets": "Previous tickets"
+    },
+    "aiCard": {
+      "nextActions": {
+        "title": "Suggested next actions"
+      }
+    }
   },
   "settingsView": {
     "configTitle": "Support Module Configuration",

package/src/components/TicketConversation/locales/fr.json

@@ -176,6 +176,12 @@
     }
   },
   "composer": {
+    "aiSuggestion": {
+      "label": "Suggestion contextuelle",
+      "ignore": "Ignorer",
+      "insert": "Insérer",
+      "loading": "Génération…"
+    },
     "placeholder": "Écrire une réponse au client...",
     "placeholderInternal": "Note interne...",
     "placeholderReplyTo": "Répondre à {{name}}...",
@@ -209,6 +215,11 @@
     "shortcuts": {
       "sendHint": "\u2318Enter pour envoyer",
       "noteHint": "\u2318\u21e7N note interne"
+    },
+    "aliases": {
+      "label": "Envoyer en tant que",
+      "tooltip": "Choisir un alias d'exp\u00e9diteur pour ce message",
+      "self": "(par d\u00e9faut)"
     }
   },
   "settings": {
@@ -788,7 +799,20 @@
     "statusWaiting": "En attente",
     "statusResolved": "Resolu",
     "selectTicket": "Selectionnez un ticket depuis la liste",
-    "notFound": "Ticket introuvable"
+    "notFound": "Ticket introuvable",
+    "sidebar": {
+      "tabs": {
+        "overview": "Vue d'ensemble",
+        "client": "Client",
+        "activity": "Activite"
+      },
+      "previousTickets": "Tickets precedents"
+    },
+    "aiCard": {
+      "nextActions": {
+        "title": "Prochaines actions suggérées"
+      }
+    }
   },
   "settingsView": {
     "configTitle": "Configuration du module Support",

package/src/endpoints/escalate.ts

@@ -0,0 +1,44 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+/**
+ * POST /api/support/tickets/:id/escalate
+ *
+ * Admin-only. Transitions a ticket to the "escalated" status.
+ * Used when a ticket needs senior attention or is breaching SLA.
+ */
+export function createEscalateEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/tickets/:id/escalate',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs)
+
+        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 ticket = await req.payload.update({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          data: { status: 'escalated' },
+          overrideAccess: true,
+        })
+
+        return Response.json({ ok: true, ticket })
+      } catch (err) {
+        const authResponse = handleAuthError(err)
+        if (authResponse) return authResponse
+        console.error('[support/escalate] Error:', err)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/index.ts

@@ -5,6 +5,7 @@ import type { SupportFeatures } from '../types'
 import { createAiEndpoint } from './ai'
 import { createClientIntelligenceEndpoint } from './client-intelligence'
 import { createSearchEndpoint } from './search'
+import { createKbSearchEndpoint } from './kb-search'
 import { createBulkActionEndpoint } from './bulk-action'
 import { createMergeTicketsEndpoint } from './merge-tickets'
 import { createSplitTicketEndpoint } from './split-ticket'
@@ -42,10 +43,15 @@ import { createMergeClientsEndpoint } from './merge-clients'
 import { createImportConversationEndpoint } from './import-conversation'
 import { createProcessScheduledEndpoint } from './process-scheduled'
 import { createUserPrefsGetEndpoint, createUserPrefsPostEndpoint } from './user-prefs'
+import { createEscalateEndpoint } from './escalate'
+import { createTicketFeedbackEndpoint } from './ticket-feedback'
+import { createTransferTicketEndpoint } from './transfer-ticket'
+import { createInviteCollaboratorEndpoint } from './invite-collaborator'
 
 // Re-export all individual endpoint creators
 export { createAiEndpoint } from './ai'
 export { createSearchEndpoint } from './search'
+export { createKbSearchEndpoint } from './kb-search'
 export { createBulkActionEndpoint } from './bulk-action'
 export { createMergeTicketsEndpoint } from './merge-tickets'
 export { createSplitTicketEndpoint } from './split-ticket'
@@ -84,6 +90,10 @@ export { createImportConversationEndpoint } from './import-conversation'
 export { createProcessScheduledEndpoint } from './process-scheduled'
 export { createUserPrefsGetEndpoint, createUserPrefsPostEndpoint } from './user-prefs'
 export type { UserPrefs } from './user-prefs'
+export { createEscalateEndpoint } from './escalate'
+export { createTicketFeedbackEndpoint } from './ticket-feedback'
+export { createTransferTicketEndpoint } from './transfer-ticket'
+export { createInviteCollaboratorEndpoint } from './invite-collaborator'
 
 export interface SupportEndpointOptions {
   oauth?: OAuthGoogleOptions
@@ -101,6 +111,7 @@ export function createSupportEndpoints(slugs: CollectionSlugs, options?: Support
   // Core endpoints (always present)
   const endpoints: Endpoint[] = [
     createSearchEndpoint(slugs),
+    createKbSearchEndpoint(slugs),
     createSettingsGetEndpoint(slugs),
     createSettingsPostEndpoint(slugs),
     createAdminStatsEndpoint(slugs),
@@ -117,6 +128,10 @@ export function createSupportEndpoints(slugs: CollectionSlugs, options?: Support
     createResendNotificationEndpoint(slugs),
     createUserPrefsGetEndpoint(slugs),
     createUserPrefsPostEndpoint(slugs),
+    createEscalateEndpoint(slugs),
+    createTicketFeedbackEndpoint(slugs),
+    createTransferTicketEndpoint(slugs),
+    createInviteCollaboratorEndpoint(slugs),
   ]
 
   // Conditional endpoints based on feature flags