@consilioweb/payload-support 1.1.0 → 2.0.0

package/src/__tests__/webhookSecurity.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+import {
+  DEFAULT_INBOUND_EMAIL_LIMITS,
+  validateInboundEmailPayload,
+  verifySecret,
+} from '../utils/webhookSecurity'
+import { createProcessDigestsEndpoint } from '../endpoints/process-digests'
+import { resolveSlugs } from '../utils/slugs'
+
+describe('verifySecret', () => {
+  it('accepts an exact secret and rejects missing, malformed or different values', () => {
+    expect(verifySecret('expected-secret', 'expected-secret')).toBe(true)
+    expect(verifySecret(undefined, 'expected-secret')).toBe(false)
+    expect(verifySecret('short', 'expected-secret')).toBe(false)
+    expect(verifySecret('different-secret', 'expected-secret')).toBe(false)
+  })
+})
+
+describe('cron endpoint authentication', () => {
+  it('rejects missing, forged and query-string secrets', async () => {
+    process.env.CRON_SECRET = 'expected-secret'
+    const endpoint = createProcessDigestsEndpoint(resolveSlugs())
+    for (const request of [
+      { headers: new Headers(), url: 'http://localhost/api/support/process-digests' },
+      { headers: new Headers({ 'x-cron-secret': 'forged' }), url: 'http://localhost/api/support/process-digests' },
+      { headers: new Headers(), url: 'http://localhost/api/support/process-digests?secret=expected-secret' },
+    ]) {
+      const response = await endpoint.handler(request as never)
+      expect(response.status).toBe(401)
+    }
+  })
+})
+
+describe('inbound email limits', () => {
+  const base = { senderEmail: 'client@example.com', subject: 'Help', body: 'Hello' }
+
+  it('rejects requests larger than 25 MiB', () => {
+    expect(validateInboundEmailPayload(base, DEFAULT_INBOUND_EMAIL_LIMITS.maxRequestBytes + 1))
+      .toEqual({ code: 'request_too_large', status: 413 })
+  })
+
+  it('rejects more than 10 attachments', () => {
+    const attachments = Array.from({ length: 11 }, (_, index) => ({ filename: `${index}.txt`, size: 1 }))
+    expect(validateInboundEmailPayload({ ...base, attachments }))
+      .toEqual({ code: 'too_many_attachments', status: 413 })
+  })
+
+  it('rejects an attachment larger than 10 MiB', () => {
+    const attachments = [{ filename: 'large.zip', size: DEFAULT_INBOUND_EMAIL_LIMITS.maxAttachmentBytes + 1 }]
+    expect(validateInboundEmailPayload({ ...base, attachments }))
+      .toEqual({ code: 'attachment_too_large', status: 413 })
+  })
+
+  it('rejects oversized text fields', () => {
+    expect(validateInboundEmailPayload({ ...base, subject: 'x'.repeat(1_001) }))
+      .toEqual({ code: 'text_field_too_large', status: 413 })
+  })
+})

package/src/collections/PendingEmails.ts

@@ -1,5 +1,6 @@
 import type { CollectionConfig } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
+import { verifySecret } from '../utils/webhookSecurity'
 
 // ─── Collection factory ──────────────────────────────────
 
@@ -20,7 +21,7 @@ export function createPendingEmailsCollection(slugs: CollectionSlugs): Collectio
         // Allow admin users or webhook calls with secret header
         if (req.user?.collection === slugs.users) return true
         const webhookSecret = req.headers.get('x-webhook-secret')
-        if (webhookSecret && process.env.SUPPORT_WEBHOOK_SECRET && webhookSecret === process.env.SUPPORT_WEBHOOK_SECRET) return true
+        if (verifySecret(webhookSecret, process.env.SUPPORT_WEBHOOK_SECRET)) return true
         return false
       },
     },

package/src/collections/SupportClients.ts

@@ -1,6 +1,7 @@
 import type { CollectionConfig, CollectionAfterChangeHook, CollectionBeforeLoginHook } from 'payload'
 import { APIError } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
+import type { SupportCapabilities } from '../types'
 import { escapeHtml, emailWrapper, emailButton, emailParagraph } from '../utils/emailTemplate'
 import { readSupportSettings } from '../utils/readSettings'
 
@@ -92,7 +93,10 @@ function createEnforce2FA(slugs: CollectionSlugs): CollectionBeforeLoginHook {
 
 // ─── Collection factory ──────────────────────────────────
 
-export function createSupportClientsCollection(slugs: CollectionSlugs): CollectionConfig {
+export function createSupportClientsCollection(
+  slugs: CollectionSlugs,
+  options?: { capabilities?: SupportCapabilities },
+): CollectionConfig {
   return {
     slug: slugs.supportClients,
     labels: {
@@ -354,6 +358,44 @@ export function createSupportClientsCollection(slugs: CollectionSlugs): Collecti
           position: 'sidebar',
         },
       },
+      ...(options?.capabilities?.sms ? [
+        {
+          name: 'notifyBySmsChannel',
+          type: 'checkbox' as const,
+          defaultValue: false,
+          label: 'Canal SMS activé',
+          admin: { position: 'sidebar' as const },
+        },
+      ] : []),
+      ...(options?.capabilities?.aiTitles || options?.capabilities?.aiSummaries ? [
+        {
+          name: 'preferredFormality',
+          type: 'select' as const,
+          defaultValue: 'auto',
+          label: 'Formule IA',
+          options: [
+            { label: 'Auto', value: 'auto' },
+            { label: 'Tutoiement', value: 'tutoyer' },
+            { label: 'Vouvoiement', value: 'vouvoyer' },
+          ],
+          admin: { position: 'sidebar' as const },
+        },
+        {
+          name: 'preferredTone',
+          type: 'select' as const,
+          defaultValue: 'auto',
+          label: 'Ton IA',
+          options: [
+            { label: 'Auto', value: 'auto' },
+            { label: 'Neutre / professionnel', value: 'neutre' },
+            { label: 'Amical', value: 'amical' },
+            { label: 'Direct / concis', value: 'direct' },
+            { label: 'Formel', value: 'formel' },
+          ],
+          admin: { position: 'sidebar' as const },
+        },
+        { name: 'lastRewriteStyle', type: 'text' as const, admin: { hidden: true } },
+      ] : []),
     ],
     hooks: {
       beforeLogin: [createEnforce2FA(slugs)],

package/src/collections/SupportCounters.ts

@@ -0,0 +1,14 @@
+import type { CollectionConfig } from 'payload'
+
+export function createSupportCountersCollection(slug = 'support-counters'): CollectionConfig {
+  return {
+    slug,
+    admin: { hidden: true },
+    access: { create: () => false, read: () => false, update: () => false, delete: () => false },
+    fields: [
+      { name: 'key', type: 'text', required: true, unique: true, index: true },
+      { name: 'nextValue', type: 'number', required: true, min: 1 },
+    ],
+    timestamps: false,
+  }
+}

package/src/collections/SupportRateLimits.ts

@@ -0,0 +1,20 @@
+import type { CollectionConfig } from 'payload'
+
+export function createSupportRateLimitsCollection(slug = 'support-rate-limits'): CollectionConfig {
+  return {
+    slug,
+    admin: { hidden: true },
+    access: {
+      create: () => false,
+      read: () => false,
+      update: () => false,
+      delete: () => false,
+    },
+    fields: [
+      { name: 'key', type: 'text', required: true, unique: true, index: true },
+      { name: 'count', type: 'number', required: true, min: 1 },
+      { name: 'resetAt', type: 'date', required: true, index: true },
+    ],
+    timestamps: false,
+  }
+}

package/src/collections/TicketMessages.ts

@@ -1,5 +1,6 @@
 import type { CollectionConfig, CollectionBeforeChangeHook, CollectionAfterChangeHook, Where } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
+import type { SupportCapabilities } from '../types'
 import { escapeHtml, emailWrapper, emailButton, emailQuote, emailParagraph, emailRichContent, emailTrackingPixel } from '../utils/emailTemplate'
 import { fireWebhooks } from '../utils/fireWebhooks'
 import { createAdminNotification } from '../utils/adminNotification'
@@ -403,8 +404,70 @@ function createNotifyMentions(slugs: CollectionSlugs): CollectionAfterChangeHook
   }
 }
 
+function createSmsNotification(
+  slugs: CollectionSlugs,
+  capability: NonNullable<SupportCapabilities['sms']>,
+): CollectionAfterChangeHook {
+  return async ({ doc, operation, req }) => {
+    try {
+      if (operation !== 'create' || !doc.notifyBySms) return doc
+      if (doc.authorType !== 'admin' || doc.isInternal) return doc
+      if (doc.scheduledAt && !doc.scheduledSent) return doc
+      if (capability.adapter.isConfigured && !capability.adapter.isConfigured()) return doc
+
+      const ticketId = typeof doc.ticket === 'object' ? doc.ticket.id : doc.ticket
+      const ticket = await req.payload.findByID({
+        collection: slugs.tickets,
+        id: ticketId,
+        depth: 1,
+        overrideAccess: true,
+      }) as Record<string, unknown>
+      const client = typeof ticket.client === 'object' && ticket.client
+        ? ticket.client as Record<string, unknown>
+        : null
+      if (!client) return doc
+      const target = (typeof doc.smsTo === 'string' && doc.smsTo.trim()) || String(client.phone || '')
+      if (!target) return doc
+      const fallback = `ConsilioWEB : nouvelle réponse au ticket ${String(ticket.ticketNumber || '')}.`
+      const message = (typeof doc.smsMessage === 'string' && doc.smsMessage.trim())
+        || (capability.buildMessage ? await capability.buildMessage({ client, ticket }) : fallback)
+      const result = await capability.adapter.send({
+        message,
+        to: target,
+        payload: req.payload,
+        ticket,
+        client,
+      })
+      if (!result.sent && !result.skipped) {
+        req.payload.logger?.warn(`[support:sms] Delivery failed: ${result.error || 'unknown error'}`)
+      }
+    } catch (error) {
+      req.payload.logger?.warn(`[support:sms] Adapter error: ${error instanceof Error ? error.message : String(error)}`)
+    }
+    return doc
+  }
+}
+
+function createThreadCleanup(
+  capability: NonNullable<SupportCapabilities['threadCleanup']>,
+): CollectionAfterChangeHook {
+  return async ({ doc, operation, req }) => {
+    if (operation !== 'create' || doc.isInternal) return doc
+    if (doc.authorType !== 'client' && doc.authorType !== 'email') return doc
+    const ticketId = typeof doc.ticket === 'object' ? doc.ticket.id : doc.ticket
+    if (!ticketId) return doc
+    try {
+      await capability.clean(req.payload, ticketId, doc.id)
+    } catch (error) {
+      req.payload.logger?.warn(`[support:thread-cleanup] ${error instanceof Error ? error.message : String(error)}`)
+    }
+    return doc
+  }
+}
+
 export function createTicketMessagesCollection(slugs: CollectionSlugs, options?: {
   notificationSlug?: string
+  capabilities?: SupportCapabilities
 }): CollectionConfig {
   const notificationSlug = options?.notificationSlug || 'admin-notifications'
 
@@ -458,10 +521,22 @@ export function createTicketMessagesCollection(slugs: CollectionSlugs, options?:
       { name: 'emailSentAt', type: 'date', label: 'Email envoye le', admin: { hidden: true } },
       { name: 'emailSentTo', type: 'text', label: 'Email envoye a', admin: { hidden: true } },
       { name: 'emailOpenedAt', type: 'date', label: 'Email ouvert le', admin: { hidden: true } },
+      ...(options?.capabilities?.sms ? [
+        { name: 'notifyBySms', type: 'checkbox' as const, defaultValue: false, admin: { hidden: true } },
+        { name: 'smsTo', type: 'text' as const, admin: { hidden: true } },
+        { name: 'smsMessage', type: 'textarea' as const, admin: { hidden: true } },
+      ] : []),
+      ...(options?.capabilities?.threadCleanup ? [
+        { name: 'isMarkedAsNoise', type: 'checkbox' as const, defaultValue: false, admin: { hidden: true } },
+        { name: 'noiseReason', type: 'text' as const, admin: { hidden: true } },
+        { name: 'emailContext', type: 'json' as const, admin: { hidden: true } },
+        { name: 'emailBodyOriginal', type: 'textarea' as const, admin: { hidden: true } },
+      ] : []),
     ],
     hooks: {
       beforeChange: [createSanitizeMessageHtml(), createResolveMentions(slugs), createAssignAuthor(slugs)],
       afterChange: [
+        ...(options?.capabilities?.sms ? [createSmsNotification(slugs, options.capabilities.sms)] : []),
         createAutoUpdateStatus(slugs),
         createNotifyClient(slugs),
         createTrackFirstResponse(slugs),
@@ -471,6 +546,7 @@ export function createTicketMessagesCollection(slugs: CollectionSlugs, options?:
         createFireMessageWebhooks(slugs),
         createDispatchWebhookOnReply(slugs),
         createNotifyMentions(slugs),
+        ...(options?.capabilities?.threadCleanup ? [createThreadCleanup(options.capabilities.threadCleanup)] : []),
       ],
     },
     access: {

package/src/collections/Tickets.ts

@@ -7,6 +7,7 @@ import type {
   Where,
 } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
+import type { SupportCapabilities } from '../types'
 import { escapeHtml, emailWrapper, emailParagraph, emailButton } from '../utils/emailTemplate'
 import { fireWebhooks } from '../utils/fireWebhooks'
 import { createAdminNotification } from '../utils/adminNotification'
@@ -21,46 +22,73 @@ import { dbFind, dbCreate, dbDelete } from '../utils/db'
 
 // ─── Hooks ───────────────────────────────────────────────
 
-function createAssignTicketNumber(slugs: CollectionSlugs): CollectionBeforeChangeHook {
+const ticketNumberQueues = new Map<string, Promise<void>>()
+
+async function withTicketNumberLock<T>(key: string, operation: () => Promise<T>): Promise<T> {
+  const previous = ticketNumberQueues.get(key) ?? Promise.resolve()
+  let release!: () => void
+  const gate = new Promise<void>((resolve) => { release = resolve })
+  const queued = previous.then(() => gate)
+  ticketNumberQueues.set(key, queued)
+  await previous
+  try {
+    return await operation()
+  } finally {
+    release()
+    if (ticketNumberQueues.get(key) === queued) ticketNumberQueues.delete(key)
+  }
+}
+
+function createAssignTicketNumber(
+  slugs: CollectionSlugs,
+  options?: { prefix?: string; padding?: number },
+): CollectionBeforeChangeHook {
   return async ({ data, operation, req }) => {
     if (operation === 'create') {
-      // Retry loop to handle unique constraint collisions (e.g. concurrent inserts in SQLite).
-      let retries = 3
-      while (retries > 0) {
-        try {
-          const countResult = await req.payload.count({
-            collection: slugs.tickets,
-            overrideAccess: true,
-          })
-          const baseNumber = countResult.totalDocs + 1
-          data.ticketNumber = `TK-${String(baseNumber).padStart(4, '0')}`
-
-          // Double-check: if this number already exists, append a timestamp suffix
-          const existing = await req.payload.find({
-            collection: slugs.tickets,
-            where: { ticketNumber: { equals: data.ticketNumber } },
-            limit: 1,
-            depth: 0,
+      const value = await withTicketNumberLock(slugs.tickets, async () => {
+        const counterResult = await req.payload.find({
+          collection: slugs.counters as any,
+          where: { key: { equals: slugs.tickets } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+          req,
+        })
+        const counter = counterResult.docs[0] as { id: number | string; nextValue: number } | undefined
+        if (counter) {
+          const allocated = Number(counter.nextValue)
+          await req.payload.update({
+            collection: slugs.counters as any,
+            id: counter.id,
+            data: { nextValue: allocated + 1 },
             overrideAccess: true,
+            req,
           })
-          if (existing.docs.length > 0) {
-            const suffix = Date.now() % 10000
-            data.ticketNumber = `TK-${String(baseNumber + suffix).padStart(4, '0')}`
-          }
-          break
-        } catch (error: any) {
-          if (
-            retries > 1 &&
-            (error?.message?.includes('UNIQUE') ||
-              error?.message?.includes('unique') ||
-              error?.code === 'SQLITE_CONSTRAINT')
-          ) {
-            retries--
-            continue
-          }
-          throw error
+          return allocated
         }
-      }
+
+        const tickets = await req.payload.find({
+          collection: slugs.tickets as any,
+          limit: 0,
+          depth: 0,
+          overrideAccess: true,
+          select: { ticketNumber: true },
+          req,
+        })
+        const highest = tickets.docs.reduce((max, ticket) => {
+          const match = String((ticket as { ticketNumber?: string }).ticketNumber || '').match(/(\d+)$/)
+          return match ? Math.max(max, Number(match[1])) : max
+        }, 0)
+        const allocated = highest + 1
+        await req.payload.create({
+          collection: slugs.counters as any,
+          data: { key: slugs.tickets, nextValue: allocated + 1 },
+          overrideAccess: true,
+          req,
+        })
+        return allocated
+      })
+      data.ticketNumber = `${options?.prefix ?? 'TK-'}${String(value).padStart(options?.padding ?? 4, '0')}`
     }
     return data
   }
@@ -87,7 +115,10 @@ function createRestrictClientUpdates(slugs: CollectionSlugs): CollectionBeforeCh
   return async ({ data, operation, req, originalDoc }) => {
     if (operation !== 'update') return data
     if (req.user?.collection !== slugs.supportClients) return data
-    const allowedStatuses = ['open', 'resolved']
+    // Clients may move a ticket to: open / waiting_support (reopen) or resolved (close).
+    // 'waiting_support' is required so the reopen button actually puts the ball back
+    // in the support team's court instead of being silently rejected.
+    const allowedStatuses = ['open', 'waiting_support', 'resolved']
     const newData: Record<string, unknown> = {}
     if (data.status && allowedStatuses.includes(data.status as string)) {
       newData.status = data.status
@@ -159,7 +190,10 @@ function createTrackSLA(slugs: CollectionSlugs): CollectionAfterChangeHook {
   }
 }
 
-function createTrackAiSummaryOnResolve(slugs: CollectionSlugs): CollectionAfterChangeHook {
+function createTrackAiSummaryOnResolve(
+  slugs: CollectionSlugs,
+  generator?: SupportCapabilities['aiSummaries'],
+): CollectionAfterChangeHook {
   return async ({ doc, previousDoc, operation, req }) => {
     if (operation !== 'update' || !previousDoc) return doc
     const wasResolved = previousDoc.status === 'resolved'
@@ -185,7 +219,10 @@ function createTrackAiSummaryOnResolve(slugs: CollectionSlugs): CollectionAfterC
     if (!wasResolved && isResolved && !doc.aiSummary) {
       // setImmediate keeps the response snappy; failures are logged inside the util.
       setImmediate(() => {
-        generateTicketSynthesis({ payload: req.payload, slugs, ticketId: doc.id })
+        const operation = generator
+          ? generator.generate(req.payload, doc.id)
+          : generateTicketSynthesis({ payload: req.payload, slugs, ticketId: doc.id })
+        operation
           .catch((err) => console.error('[support] Background ai synthesis failed:', err))
       })
     }
@@ -193,6 +230,36 @@ function createTrackAiSummaryOnResolve(slugs: CollectionSlugs): CollectionAfterC
   }
 }
 
+function createTrackWaitingSince(): CollectionBeforeChangeHook {
+  return ({ data, originalDoc, operation }) => {
+    if (operation !== 'update') return data
+    const previous = originalDoc?.status
+    const next = data.status ?? previous
+    if (next === 'waiting_client' && previous !== 'waiting_client') {
+      data.waitingSince = new Date().toISOString()
+      data.autoCloseRemindedAt = null
+    } else if (next !== 'waiting_client' && previous === 'waiting_client') {
+      data.waitingSince = null
+      data.autoCloseRemindedAt = null
+    }
+    return data
+  }
+}
+
+function createGenerateTitleOnCreate(
+  generator: NonNullable<SupportCapabilities['aiTitles']>,
+): CollectionAfterChangeHook {
+  return ({ doc, operation, req }) => {
+    if (operation === 'create' && doc?.id && !doc.displayTitle) {
+      setImmediate(() => {
+        generator.generate(req.payload, doc.id)
+          .catch((err) => console.error('[support] Background title generation failed:', err))
+      })
+    }
+    return doc
+  }
+}
+
 function createLogTicketActivity(slugs: CollectionSlugs): CollectionAfterChangeHook {
   return async ({ doc, previousDoc, operation, req }) => {
     if (operation !== 'update' || !previousDoc) return doc
@@ -438,11 +505,14 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
   projectCollectionSlug?: string
   documentsCollectionSlug?: string
   notificationSlug?: string
+  ticketNumber?: { prefix?: string; padding?: number }
+  capabilities?: SupportCapabilities
 }): CollectionConfig {
   const notificationSlug = options?.notificationSlug || 'admin-notifications'
 
   // Build dynamic fields
   const dynamicFields: Field[] = []
+  const capabilities = options?.capabilities
 
   // Conversation UI field at the top
   dynamicFields.push({
@@ -466,6 +536,29 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
     })
   }
 
+  if (capabilities?.aiTitles) {
+    dynamicFields.push(
+      {
+        name: 'displayTitle',
+        type: 'text',
+        label: "Titre d'affichage",
+        admin: { description: "Titre court suggéré par l'IA, éditable sans modifier le sujet email." },
+      },
+      {
+        name: 'displayTitleStatus',
+        type: 'select',
+        defaultValue: 'none',
+        options: [
+          { label: 'Aucun', value: 'none' },
+          { label: 'Génération en cours', value: 'pending' },
+          { label: 'Suggéré', value: 'suggested' },
+          { label: 'Validé', value: 'validated' },
+          { label: 'Échec', value: 'error' },
+        ],
+      },
+    )
+  }
+
   // Billing collapsible fields
   const billingFields: Field[] = [
     {
@@ -546,6 +639,41 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
     },
   ]
 
+  if (capabilities?.detailedBilling) {
+    billingFields.push(
+      {
+        name: 'billedAt',
+        type: 'date',
+        label: 'Facturé le',
+      },
+      {
+        name: 'billingLines',
+        type: 'array',
+        label: 'Lignes de facturation',
+        fields: [
+          { name: 'period', type: 'text', label: 'Période (AAAA-MM)' },
+          { name: 'label', type: 'text', label: 'Libellé' },
+          { name: 'amount', type: 'number', label: 'Montant (€)' },
+          { name: 'billingType', type: 'select', options: ['hourly', 'flat'], defaultValue: 'flat', label: 'Type' },
+          { name: 'billed', type: 'checkbox', defaultValue: false, label: 'Facturé' },
+          { name: 'billedAt', type: 'date', label: 'Facturé le' },
+        ],
+      },
+    )
+  }
+
+  if (capabilities?.volunteering) {
+    billingFields.push(
+      { name: 'volunteer', type: 'checkbox', defaultValue: false, label: 'Bénévolat (non facturé)' },
+      {
+        name: 'volunteerValue',
+        type: 'number',
+        label: 'Valeur offerte (€)',
+        admin: { condition: (data) => Boolean(data?.volunteer) },
+      },
+    )
+  }
+
   return {
     slug: slugs.tickets,
     labels: { singular: 'Ticket', plural: 'Tickets' },
@@ -685,6 +813,19 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
           { name: 'mergedInto', type: 'relationship', relationTo: slugs.tickets, label: 'Fusionne dans', admin: { readOnly: true } },
           { name: 'autoCloseRemindedAt', type: 'date', label: 'Rappel auto-close envoye', admin: { readOnly: true, date: { displayFormat: 'dd/MM/yyyy HH:mm' } } },
           { name: 'autoCloseScheduledAt', type: 'date', index: true, label: 'Fermeture auto programmee', admin: { readOnly: true, date: { displayFormat: 'dd/MM/yyyy HH:mm' }, description: 'Echeance ferme posee par une relance manuelle. Le ticket se ferme apres cette date sans reponse client.' } },
+          { name: 'waitingSince', type: 'date', index: true, label: 'En attente depuis', admin: { readOnly: true } },
+          {
+            name: 'relanceDelayDays',
+            type: 'select',
+            defaultValue: '2',
+            label: 'Délai de relance client',
+            options: [
+              { label: '1 jour', value: '1' },
+              { label: '2 jours', value: '2' },
+              { label: '3 jours', value: '3' },
+            ],
+          },
+          { name: 'satisfactionRemindedAt', type: 'date', admin: { hidden: true, readOnly: true } },
         ],
       },
       // Sidebar
@@ -750,15 +891,17 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
     ],
     hooks: {
       beforeChange: [
-        createAssignTicketNumber(slugs),
+        createAssignTicketNumber(slugs, options?.ticketNumber),
         createAssignClientOnCreate(slugs),
         createAutoAssignAdmin(slugs),
         autoPaidAt,
+        createTrackWaitingSince(),
         createRestrictClientUpdates(slugs),
       ],
       afterChange: [
         createTrackSLA(slugs),
-        createTrackAiSummaryOnResolve(slugs),
+        createTrackAiSummaryOnResolve(slugs, capabilities?.aiSummaries),
+        ...(capabilities?.aiTitles ? [createGenerateTitleOnCreate(capabilities.aiTitles)] : []),
         createAssignSlaDeadlines(slugs, notificationSlug),
         createPauseSlaOnHold(slugs),
         createCheckSlaOnResolve(slugs, notificationSlug),

package/src/collections/index.ts

@@ -21,3 +21,5 @@ export { createNotificationQueueCollection } from './NotificationQueue'
 export { createAutomationRulesCollection } from './AutomationRules'
 export { createSupportTeamCollection } from './SupportTeam'
 export { createPushSubscriptionCollection } from './PushSubscription'
+export { createSupportRateLimitsCollection } from './SupportRateLimits'
+export { createSupportCountersCollection } from './SupportCounters'