@consilioweb/payload-support 2.0.0 → 3.0.0

package/src/collections/TimeEntries.ts

@@ -1,45 +1,69 @@
-import type { CollectionConfig, CollectionAfterChangeHook } from 'payload'
+import type { CollectionConfig, CollectionAfterChangeHook, CollectionAfterDeleteHook } from 'payload'
+import type { Payload } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
 
 // ─── Hooks ───────────────────────────────────────────────
 
-function createRecalculateTicketTime(slugs: CollectionSlugs): CollectionAfterChangeHook {
-  return async ({ doc, req }) => {
-    if (!doc.ticket) return
+async function recalculateTicketTime(
+  payload: Payload,
+  slugs: CollectionSlugs,
+  ticketId: number | string,
+): Promise<void> {
+  // Sum all time entries for this ticket, paginating to avoid loading all at once
+  let totalMinutes = 0
+  let page = 1
+  let hasMore = true
 
-    const { payload } = req
-    const ticketId = typeof doc.ticket === 'object' ? doc.ticket.id : doc.ticket
+  while (hasMore) {
+    const entries = await payload.find({
+      collection: slugs.timeEntries,
+      where: { ticket: { equals: ticketId } },
+      limit: 100,
+      page,
+      depth: 0,
+      overrideAccess: true,
+      select: { duration: true },
+    })
 
-    // Sum all time entries for this ticket, paginating to avoid loading all at once
-    let totalMinutes = 0
-    let page = 1
-    let hasMore = true
+    for (const entry of entries.docs) {
+      totalMinutes += ((entry.duration as number) || 0)
+    }
 
-    while (hasMore) {
-      const entries = await payload.find({
-        collection: slugs.timeEntries,
-        where: { ticket: { equals: ticketId } },
-        limit: 100,
-        page,
-        depth: 0,
-        overrideAccess: true,
-        select: { duration: true },
-      })
+    hasMore = entries.hasNextPage ?? false
+    page++
+  }
 
-      for (const entry of entries.docs) {
-        totalMinutes += ((entry.duration as number) || 0)
-      }
+  await payload.update({
+    collection: slugs.tickets,
+    id: ticketId,
+    data: { totalTimeMinutes: totalMinutes },
+    overrideAccess: true,
+  })
+}
 
-      hasMore = entries.hasNextPage ?? false
-      page++
-    }
+function createRecalculateTicketTime(slugs: CollectionSlugs): CollectionAfterChangeHook {
+  return async ({ doc, req }) => {
+    if (!doc.ticket) return
+    const ticketId = typeof doc.ticket === 'object' ? doc.ticket.id : doc.ticket
+    await recalculateTicketTime(req.payload, slugs, ticketId)
+  }
+}
 
-    await payload.update({
-      collection: slugs.tickets,
-      id: ticketId,
-      data: { totalTimeMinutes: totalMinutes },
-      overrideAccess: true,
-    })
+/**
+ * Deleting a time entry has to re-roll the ticket total too. Without this the
+ * rollup only ever grows: `tickets.totalTimeMinutes` is what the invoice endpoint
+ * and the CRM view bill on, so a removed entry stayed billed forever.
+ */
+function createRecalculateTicketTimeOnDelete(slugs: CollectionSlugs): CollectionAfterDeleteHook {
+  return async ({ doc, req }) => {
+    if (!doc?.ticket) return
+    const ticketId = typeof doc.ticket === 'object' ? doc.ticket.id : doc.ticket
+    try {
+      await recalculateTicketTime(req.payload, slugs, ticketId)
+    } catch (err) {
+      // The entry is already gone; never fail the delete on the rollup refresh.
+      console.error('[support] Failed to recalculate ticket time after delete:', err)
+    }
   }
 }
 
@@ -105,6 +129,7 @@ export function createTimeEntriesCollection(slugs: CollectionSlugs): CollectionC
     ],
     hooks: {
       afterChange: [createRecalculateTicketTime(slugs)],
+      afterDelete: [createRecalculateTicketTimeOnDelete(slugs)],
     },
     access: {
       create: ({ req }) => req.user?.collection === slugs.users,

package/src/components/TicketConversation/config.ts

@@ -1,82 +1,18 @@
 /**
- * Feature flags for the ticketing module.
- * Each feature can be enabled/disabled by the admin.
- * When disabled, the corresponding UI section is hidden entirely.
+ * Ticketing feature flags — re-export of the shared implementation.
+ *
+ * The flags used to be defined (twice, byte-for-byte) here and in
+ * `views/shared/config.ts`, each reading `localStorage` directly. The single
+ * implementation now lives in `utils/features.ts` and is backed by the server;
+ * both modules are kept as import sites so existing paths keep working.
  */
-export interface TicketingFeatures {
-  /** Time tracking: timer, manual entries, billing */
-  timeTracking: boolean
-  /** AI features: sentiment, synthesis, suggestion, rewrite */
-  ai: boolean
-/** Satisfaction surveys: CSAT rating after resolution */
-  satisfaction: boolean
-  /** Live chat integration: chat → ticket conversion */
-  chat: boolean
-  /** Email tracking: pixel tracking, open/sent status per message */
-  emailTracking: boolean
-  /** Canned responses: quick reply templates */
-  canned: boolean
-  /** Ticket merge: combine two tickets into one */
-  merge: boolean
-  /** Snooze: temporarily hide a ticket */
-  snooze: boolean
-  /** External messages: add messages received outside the system */
-  externalMessages: boolean
-  /** Client history: past tickets, projects, notes sidebar */
-  clientHistory: boolean
-  /** Activity log: audit trail of actions on the ticket */
-  activityLog: boolean
-  /** Split ticket: extract a message into a new ticket */
-  splitTicket: boolean
-  /** Scheduled replies: send a message at a future date */
-  scheduledReplies: boolean
-  /** Auto-close: automatically resolve inactive tickets */
-  autoClose: boolean
-  /** Auto-close delay in days (used by auto-close cron) */
-  autoCloseDays: number
-  /** Round-robin: distribute new tickets evenly among agents */
-  roundRobin: boolean
-}
-
-/** Default features — all enabled */
-export const DEFAULT_FEATURES: TicketingFeatures = {
-  timeTracking: true,
-  ai: true,
-satisfaction: true,
-  chat: true,
-  emailTracking: true,
-  canned: true,
-  merge: true,
-  snooze: true,
-  externalMessages: true,
-  clientHistory: true,
-  activityLog: true,
-  splitTicket: true,
-  scheduledReplies: true,
-  autoClose: true,
-  autoCloseDays: 7,
-  roundRobin: false,
-}
-
-const STORAGE_KEY = 'ticketing_features'
-
-/** Read features from localStorage (falls back to defaults) */
-export function getFeatures(): TicketingFeatures {
-  if (typeof window === 'undefined') return DEFAULT_FEATURES
-  try {
-    const stored = localStorage.getItem(STORAGE_KEY)
-    if (stored) {
-      const parsed = JSON.parse(stored)
-      return { ...DEFAULT_FEATURES, ...parsed }
-    }
-  } catch { /* ignore */ }
-  return DEFAULT_FEATURES
-}
-
-/** Save features to localStorage */
-export function saveFeatures(features: TicketingFeatures): void {
-  if (typeof window === 'undefined') return
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(features))
-  } catch { /* ignore */ }
-}
+export {
+  DEFAULT_TICKETING_FEATURES,
+  DEFAULT_TICKETING_FEATURES as DEFAULT_FEATURES,
+  FEATURES_CACHE_KEY,
+  fetchFeatures,
+  getFeatures,
+  normalizeFeatures,
+  saveFeatures,
+} from '../../utils/features'
+export type { TicketingFeatures } from '../../utils/features'

package/src/components/TicketConversation/hooks/useFeatures.ts

@@ -0,0 +1,109 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  fetchFeatures,
+  getFeatures,
+  hasAdoptedLegacyFeatures,
+  markLegacyFeaturesAdopted,
+  readLegacyFeatures,
+  saveFeatures as persistFeatures,
+  writeFeaturesCache,
+  type TicketingFeatures,
+} from '../../../utils/features'
+
+export interface UseFeaturesResult {
+  /** Current flags — cached values on first paint, server values once loaded. */
+  features: TicketingFeatures
+  /** True until the first server round-trip settles. */
+  loading: boolean
+  /** True when the server could not be reached and cached/default values are shown. */
+  offline: boolean
+  /** Replace the flags locally without persisting (for a settings form). */
+  setFeatures: (features: TicketingFeatures) => void
+  /** Persist the flags server-side. Resolves to false when the write failed. */
+  save: (features: TicketingFeatures) => Promise<boolean>
+}
+
+/**
+ * Read the ticketing feature flags from the server, with the local cache as a
+ * fallback so a screen never blocks on the settings call.
+ *
+ * Also performs the one-shot migration of pre-2.1 installs: when this browser
+ * still holds flags in `localStorage` and the server has never had any saved,
+ * the local values are pushed up once and become the shared truth. Afterwards
+ * the server always wins and `localStorage` is only a cache.
+ */
+export function useFeatures(): UseFeaturesResult {
+  const [features, setFeatures] = useState<TicketingFeatures>(() => getFeatures())
+  const [loading, setLoading] = useState(true)
+  const [offline, setOffline] = useState(false)
+  // Migration must run once per mount at most, even under StrictMode double-effects.
+  const migrationAttempted = useRef(false)
+  // Set as soon as the caller edits the flags, so a slow first load cannot
+  // overwrite a toggle the admin just made in the settings form.
+  const dirty = useRef(false)
+
+  useEffect(() => {
+    const controller = new AbortController()
+    let cancelled = false
+
+    void (async () => {
+      const result = await fetchFeatures(controller.signal)
+      if (cancelled) return
+
+      // Fresh server + legacy browser values => adopt them instead of silently
+      // resetting the admin's configuration to the defaults.
+      if (!result.offline && !result.configured && !migrationAttempted.current && !dirty.current) {
+        migrationAttempted.current = true
+        const legacy = readLegacyFeatures()
+        if (legacy) {
+          const ok = await persistFeatures(legacy)
+          if (cancelled) return
+          if (ok) {
+            markLegacyFeaturesAdopted()
+            setFeatures(legacy)
+            setLoading(false)
+            return
+          }
+        }
+      }
+
+      if (!result.offline && !hasAdoptedLegacyFeatures()) {
+        // Server already configured (by this admin elsewhere, or another admin):
+        // the server wins, and there is nothing left to migrate here.
+        markLegacyFeaturesAdopted()
+      }
+
+      if (!dirty.current) setFeatures(result.features)
+      setOffline(result.offline)
+      setLoading(false)
+    })()
+
+    return () => {
+      cancelled = true
+      controller.abort()
+    }
+  }, [])
+
+  const setLocalFeatures = useCallback((next: TicketingFeatures) => {
+    dirty.current = true
+    setFeatures(next)
+    // Keep the cache aligned with what is on screen, so a reload before saving
+    // does not flash the previous values.
+    writeFeaturesCache(next)
+  }, [])
+
+  const save = useCallback(async (next: TicketingFeatures) => {
+    const ok = await persistFeatures(next)
+    if (ok) {
+      markLegacyFeaturesAdopted()
+      dirty.current = false
+      setFeatures(next)
+      setOffline(false)
+    }
+    return ok
+  }, [])
+
+  return { features, loading, offline, setFeatures: setLocalFeatures, save }
+}

package/src/components/TicketConversation/hooks/useTranslation.ts

@@ -1,22 +1,56 @@
 import { useState, useCallback, useEffect } from 'react'
 import frTranslations from '../locales/fr.json'
 import enTranslations from '../locales/en.json'
+import frViewTranslations from '../../../views/shared/locales/fr.json'
+import enViewTranslations from '../../../views/shared/locales/en.json'
 
 type Locale = 'fr' | 'en'
 
 const LOCALE_STORAGE_KEY = 'support_locale'
 const DEFAULT_LOCALE: Locale = 'fr'
 
+function mergeTranslations(
+  base: Record<string, unknown>,
+  supplement: Record<string, unknown>,
+): Record<string, unknown> {
+  const merged = { ...base }
+
+  for (const [key, value] of Object.entries(supplement)) {
+    const current = merged[key]
+
+    if (
+      current != null
+      && value != null
+      && typeof current === 'object'
+      && typeof value === 'object'
+      && !Array.isArray(current)
+      && !Array.isArray(value)
+    ) {
+      merged[key] = mergeTranslations(
+        current as Record<string, unknown>,
+        value as Record<string, unknown>,
+      )
+      continue
+    }
+
+    if (current === undefined || (typeof current !== 'object' && typeof value === 'object')) {
+      merged[key] = value
+    }
+  }
+
+  return merged
+}
+
 const translations: Record<Locale, Record<string, unknown>> = {
-  fr: frTranslations,
-  en: enTranslations,
+  fr: mergeTranslations(frTranslations, frViewTranslations),
+  en: mergeTranslations(enTranslations, enViewTranslations),
 }
 
 /**
  * Resolve a dot-notation key from a nested object.
  * e.g. getNestedValue(obj, 'ticket.status.open') => 'Ouvert'
  */
-function getNestedValue(obj: Record<string, unknown>, path: string): string {
+export function getNestedValue(obj: Record<string, unknown>, path: string): string {
   const keys = path.split('.')
   let current: unknown = obj
 
@@ -113,4 +147,4 @@ export function useTranslation() {
 }
 
 export type { Locale }
-export { DEFAULT_LOCALE, LOCALE_STORAGE_KEY }
+export { DEFAULT_LOCALE, LOCALE_STORAGE_KEY, translations }

package/src/components/TicketConversation/index.tsx

@@ -21,14 +21,14 @@ import { useTicketActions } from './hooks/useTicketActions'
 import { useReply } from './hooks/useReply'
 import { useAI } from './hooks/useAI'
 import { useDocumentIdFromUrl } from './hooks/useDocumentIdFromUrl'
-import { getFeatures, type TicketingFeatures } from './config'
+import { useFeatures } from './hooks/useFeatures'
 import { SkeletonText } from './SkeletonText'
 import { RewriteDropdown } from './RewriteDropdown'
 import '../../styles/theme.css'
 
 const TicketConversation: React.FC = () => {
   const { id } = useDocumentIdFromUrl()
-  const [features] = useState<TicketingFeatures>(() => getFeatures())
+  const { features } = useFeatures()
   const [messages, setMessages] = useState<Message[]>([])
   const [timeEntries, setTimeEntries] = useState<TimeEntry[]>([])
   const [client, setClient] = useState<ClientInfo | null>(null)

package/src/endpoints/ai.ts

@@ -3,12 +3,13 @@ import type { CollectionSlugs } from '../utils/slugs'
 import { requireAdmin, handleAuthError } from '../utils/auth'
 import { readSupportSettings, type SupportSettings } from '../utils/readSettings'
 import { RateLimiter, type RateLimitStore } from '../utils/rateLimiter'
+import { resolveOllamaBaseUrl } from '../utils/aiProvider'
 
 async function getClient(aiSettings: SupportSettings['ai']) {
   const moduleName = '@anthropic-ai/sdk'
   const { default: Anthropic } = await import(moduleName)
   if (aiSettings.provider === 'ollama') {
-    const baseURL = process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1'
+    const baseURL = resolveOllamaBaseUrl()
     return new Anthropic({ apiKey: 'ollama', baseURL })
   }
   return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

package/src/endpoints/client-intelligence.ts

@@ -3,12 +3,13 @@ import type { CollectionSlugs } from '../utils/slugs'
 import { requireAdmin, handleAuthError } from '../utils/auth'
 import { readSupportSettings, type SupportSettings } from '../utils/readSettings'
 import { RateLimiter, type RateLimitStore } from '../utils/rateLimiter'
+import { resolveOllamaBaseUrl } from '../utils/aiProvider'
 
 async function getClient(aiSettings: SupportSettings['ai']) {
   const moduleName = '@anthropic-ai/sdk'
   const { default: Anthropic } = await import(moduleName)
   if (aiSettings.provider === 'ollama') {
-    const baseURL = process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1'
+    const baseURL = resolveOllamaBaseUrl()
     return new Anthropic({ apiKey: 'ollama', baseURL })
   }
   return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

package/src/endpoints/process-scheduled.ts

@@ -1,7 +1,7 @@
 import type { Endpoint } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
 import { escapeHtml } from '../utils/emailTemplate'
-import { fireWebhooks } from '../utils/fireWebhooks'
+import { dispatchWebhook } from '../utils/webhookDispatcher'
 import { readSupportSettings } from '../utils/readSettings'
 import { dbFind, dbFindByID, dbUpdate } from '../utils/db'
 import { verifySecret } from '../utils/webhookSecurity'
@@ -112,13 +112,18 @@ export function createProcessScheduledEndpoint(slugs: CollectionSlugs): Endpoint
             }
 
             // Fire webhook for the now-sent reply
-            fireWebhooks(payload, slugs, 'ticket_replied', {
-              ticketId,
-              messageId: msg.id,
-              authorType: msg.authorType,
-              scheduled: true,
-              body: msg.body?.length > 500 ? msg.body.slice(0, 500) + '...' : msg.body,
-            })
+            dispatchWebhook(
+              {
+                ticketId,
+                messageId: msg.id,
+                authorType: msg.authorType,
+                scheduled: true,
+                body: msg.body?.length > 500 ? msg.body.slice(0, 500) + '...' : msg.body,
+              },
+              'ticket_replied',
+              payload,
+              slugs,
+            )
 
             results.processed++
           } catch (err) {

package/src/endpoints/round-robin-config.ts

@@ -1,9 +1,24 @@
 import type { Endpoint } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
 import { requireAdmin, handleAuthError } from '../utils/auth'
-import { dbFind } from '../utils/db'
+import {
+  SUPPORT_SETTINGS_PREF_KEY as PREF_KEY,
+  invalidateSupportSettingsCache,
+  mergeSupportSettings,
+  readSupportSettingsState,
+} from '../utils/readSettings'
+import { stripProjectedFeatures } from '../utils/features'
 
-const PREF_KEY = 'support-round-robin'
+/**
+ * Round-robin used to live in its own `support-round-robin` preference row,
+ * while the admin UI toggled a `roundRobin` flag in `localStorage` — the two
+ * never met, so the toggle had no effect on assignment.
+ *
+ * Both endpoints below now read and write `settings.features.roundRobin`, the
+ * same value `/api/support/settings` exposes and `Tickets`' auto-assign hook
+ * reads. The legacy row is still honoured on read until the first save (see
+ * `readSupportSettingsState`), so an install that had it enabled keeps it.
+ */
 
 /**
  * GET /api/support/round-robin-config — Get round-robin enabled status
@@ -18,18 +33,9 @@ export function createRoundRobinConfigGetEndpoint(slugs: CollectionSlugs): Endpo
 
         requireAdmin(req, slugs)
 
-        const prefs = await dbFind(payload, 'payload-preferences', {
-          where: { key: { equals: PREF_KEY } },
-          limit: 1,
-          depth: 0,
-          overrideAccess: true,
-        })
-
-        const enabled = prefs.docs.length > 0
-          ? (prefs.docs[0].value as { enabled?: boolean })?.enabled === true
-          : false
+        const { settings } = await readSupportSettingsState(payload)
 
-        return Response.json({ enabled })
+        return Response.json({ enabled: settings.features.roundRobin })
       } catch (error) {
         const authResponse = handleAuthError(error)
         if (authResponse) return authResponse
@@ -55,19 +61,21 @@ export function createRoundRobinConfigPostEndpoint(slugs: CollectionSlugs): Endp
 
         const { enabled } = (await req.json!()) as { enabled: boolean }
 
-        const existing = await dbFind(payload, 'payload-preferences', {
-          where: { key: { equals: PREF_KEY } },
-          limit: 1,
-          depth: 0,
-          overrideAccess: true,
-        })
+        const { settings: current } = await readSupportSettingsState(payload)
+        const merged = mergeSupportSettings(
+          { features: { ...current.features, roundRobin: !!enabled } },
+          current,
+        )
 
         await payload.db.upsert({
           collection: 'payload-preferences',
           data: {
             key: PREF_KEY,
             user: { relationTo: req.user!.collection, value: req.user!.id },
-            value: { enabled: !!enabled },
+            value: {
+              ...merged,
+              features: stripProjectedFeatures(merged.features),
+            } as unknown as Record<string, unknown>,
           },
           req: { payload, user: req.user } as any,
           where: {
@@ -79,6 +87,8 @@ export function createRoundRobinConfigPostEndpoint(slugs: CollectionSlugs): Endp
           },
         })
 
+        invalidateSupportSettingsCache()
+
         return Response.json({ enabled: !!enabled })
       } catch (error) {
         const authResponse = handleAuthError(error)