@consilioweb/payload-support 2.0.1 → 3.0.0

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)

package/src/endpoints/settings.ts

@@ -1,59 +1,21 @@
 import type { Endpoint } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
 import { requireAdmin, handleAuthError } from '../utils/auth'
-import { invalidateSupportSettingsCache } from '../utils/readSettings'
-import { dbFind } from '../utils/db'
-
-const PREF_KEY = 'support-settings'
-
-interface SupportSettings {
-  email: {
-    fromAddress: string
-    fromName: string
-    replyToAddress: string
-  }
-  ai: {
-    provider: 'anthropic' | 'openai' | 'gemini' | 'ollama'
-    model: string
-    enableSentiment: boolean
-    enableSynthesis: boolean
-    enableSuggestion: boolean
-    enableRewrite: boolean
-  }
-  sla: {
-    firstResponseMinutes: number
-    resolutionMinutes: number
-    businessHoursOnly: boolean
-    escalationEmail: string
-  }
-  autoClose: {
-    enabled: boolean
-    daysBeforeClose: number
-    reminderDaysBefore: number
-  }
-}
-
-const DEFAULT_SUPPORT_SETTINGS: SupportSettings = {
-  email: { fromAddress: '', fromName: 'Support', replyToAddress: '' },
-  ai: {
-    provider: 'anthropic',
-    model: 'claude-haiku-4-5-20251001',
-    enableSentiment: true,
-    enableSynthesis: true,
-    enableSuggestion: true,
-    enableRewrite: true,
-  },
-  sla: {
-    firstResponseMinutes: 120,
-    resolutionMinutes: 1440,
-    businessHoursOnly: true,
-    escalationEmail: '',
-  },
-  autoClose: { enabled: true, daysBeforeClose: 7, reminderDaysBefore: 2 },
-}
+import {
+  SUPPORT_SETTINGS_PREF_KEY as PREF_KEY,
+  invalidateSupportSettingsCache,
+  mergeSupportSettings,
+  readSupportSettingsState,
+  type SupportSettings,
+} from '../utils/readSettings'
+import { stripProjectedFeatures } from '../utils/features'
 
 /**
  * GET /api/support/settings — Read support settings
+ *
+ * `featuresConfigured` tells the admin UI whether the server has ever had
+ * feature flags saved; a client still holding pre-2.1 `localStorage` flags uses
+ * it to seed the server once instead of losing its configuration.
  */
 export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
   return {
@@ -65,25 +27,9 @@ export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
 
         requireAdmin(req, slugs)
 
-        const prefs = await dbFind(payload, 'payload-preferences', {
-          where: { key: { equals: PREF_KEY } },
-          limit: 1,
-          depth: 0,
-          overrideAccess: true,
-        })
-
-        let settings = { ...DEFAULT_SUPPORT_SETTINGS }
-        if (prefs.docs.length > 0) {
-          const stored = prefs.docs[0].value as Partial<SupportSettings>
-          settings = {
-            email: { ...DEFAULT_SUPPORT_SETTINGS.email, ...stored.email },
-            ai: { ...DEFAULT_SUPPORT_SETTINGS.ai, ...stored.ai },
-            sla: { ...DEFAULT_SUPPORT_SETTINGS.sla, ...stored.sla },
-            autoClose: { ...DEFAULT_SUPPORT_SETTINGS.autoClose, ...stored.autoClose },
-          }
-        }
+        const { settings, featuresConfigured } = await readSupportSettingsState(payload)
 
-        return Response.json(settings)
+        return Response.json({ ...settings, featuresConfigured })
       } catch (error) {
         const authResponse = handleAuthError(error)
         if (authResponse) return authResponse
@@ -95,7 +41,11 @@ export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
 }
 
 /**
- * POST /api/support/settings — Save all support settings (admin-only)
+ * POST /api/support/settings — Save support settings (admin-only)
+ *
+ * The body is merged onto the CURRENT settings, not onto the defaults: the
+ * feature-flag screen posts `{ features }` alone, and that must not reset the
+ * email / AI / SLA blocks.
  */
 export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
   return {
@@ -109,19 +59,20 @@ export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
 
         const body = (await req.json!()) as Partial<SupportSettings>
 
-        const merged: SupportSettings = {
-          email: { ...DEFAULT_SUPPORT_SETTINGS.email, ...body.email },
-          ai: { ...DEFAULT_SUPPORT_SETTINGS.ai, ...body.ai },
-          sla: { ...DEFAULT_SUPPORT_SETTINGS.sla, ...body.sla },
-          autoClose: { ...DEFAULT_SUPPORT_SETTINGS.autoClose, ...body.autoClose },
-        }
+        const { settings: current } = await readSupportSettingsState(payload)
+        const merged = mergeSupportSettings(body, current)
 
         await payload.db.upsert({
           collection: 'payload-preferences',
           data: {
             key: PREF_KEY,
             user: { relationTo: req.user!.collection, value: req.user!.id },
-            value: merged as unknown as Record<string, unknown>,
+            value: {
+              ...merged,
+              // Persist the flags without the two projected ones, so `features`
+              // and the `autoClose` block can never drift apart.
+              features: stripProjectedFeatures(merged.features),
+            } as unknown as Record<string, unknown>,
           },
           req: { payload, user: req.user } as any,
           where: {
@@ -135,7 +86,7 @@ export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
 
         invalidateSupportSettingsCache()
 
-        return Response.json(merged)
+        return Response.json({ ...merged, featuresConfigured: true })
       } catch (error) {
         const authResponse = handleAuthError(error)
         if (authResponse) return authResponse

package/src/index.ts

@@ -21,8 +21,12 @@ export { DEFAULT_FEATURES } from './types'
 // Utils
 export { resolveSlugs, DEFAULT_SLUGS } from './utils/slugs'
 export type { CollectionSlugs } from './utils/slugs'
-export { readSupportSettings, readUserPrefs, DEFAULT_SETTINGS, DEFAULT_USER_PREFS } from './utils/readSettings'
-export type { SupportSettings, UserPrefs } from './utils/readSettings'
+export { readSupportSettings, readSupportSettingsState, readUserPrefs, DEFAULT_SETTINGS, DEFAULT_USER_PREFS } from './utils/readSettings'
+export type { SupportSettings, SupportSettingsState, UserPrefs } from './utils/readSettings'
+// Runtime feature flags (server-authoritative, see utils/features.ts). Distinct
+// from the build-time `SupportFeatures` passed to `supportPlugin()`.
+export { DEFAULT_TICKETING_FEATURES, normalizeFeatures, projectAutoClose, stripProjectedFeatures } from './utils/features'
+export type { TicketingFeatures } from './utils/features'
 export { MemoryRateLimitStore, PayloadRateLimitStore, RateLimiter } from './utils/rateLimiter'
 export type { RateLimitEntry, RateLimitStore } from './utils/rateLimiter'
 export { DEFAULT_INBOUND_EMAIL_LIMITS, validateInboundEmailPayload, verifySecret } from './utils/webhookSecurity'

package/src/portal/LiveChat.tsx

@@ -29,6 +29,13 @@ export function LiveChat() {
   const lastFetchRef = useRef<string | null>(null)
   const inputRef = useRef<HTMLInputElement>(null)
   const pollIntervalRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  // Mirror of `messages`. The poll decision (and the unread badge) MUST be taken
+  // outside the setMessages updater: React skips the updater on the eager-state
+  // path, so a flag assigned inside it is only ever written on the very first
+  // update — after which `hasNewMessages` stays false, the adaptive backoff climbs
+  // to its 30 s ceiling and never comes back down, mid-conversation. Same pattern
+  // as ChatWidget.tsx.
+  const messagesRef = useRef<ChatMessage[]>([])
 
   // Load session from localStorage on mount
   useEffect(() => {
@@ -42,6 +49,7 @@ export function LiveChat() {
 
   // Auto-scroll to bottom when messages change
   useEffect(() => {
+    messagesRef.current = messages
     messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
   }, [messages])
 
@@ -61,31 +69,32 @@ export function LiveChat() {
 
       const data = await res.json()
       if (data.messages?.length > 0) {
-        let hadNewMessages = false
-        setMessages((prev) => {
-          const existingIds = new Set(prev.map((m) => String(m.id)))
-          const newMsgs = data.messages.filter(
-            (m: ChatMessage) => !existingIds.has(String(m.id)),
-          )
-          if (newMsgs.length === 0) return prev
-
-          hadNewMessages = true
-
-          // Count agent messages as unread if chat panel is closed
-          if (screen === 'closed') {
-            const agentNewMsgs = newMsgs.filter(
-              (m: ChatMessage) => m.senderType === 'agent',
-            )
-            if (agentNewMsgs.length > 0) {
-              setUnreadCount((prev) => prev + agentNewMsgs.length)
-            }
+        const existingIds = new Set(messagesRef.current.map((m) => String(m.id)))
+        const newMsgs: ChatMessage[] = data.messages.filter(
+          (m: ChatMessage) => !existingIds.has(String(m.id)),
+        )
+        lastFetchRef.current = data.messages[data.messages.length - 1].createdAt
+        if (newMsgs.length === 0) return false
+
+        // Count agent messages as unread if chat panel is closed. Kept OUT of the
+        // updater: nesting a setState there also double-counted the badge under
+        // StrictMode's double invocation in dev.
+        if (screen === 'closed') {
+          const agentNewMsgs = newMsgs.filter((m) => m.senderType === 'agent')
+          if (agentNewMsgs.length > 0) {
+            setUnreadCount((prev) => prev + agentNewMsgs.length)
           }
+        }
 
-          return [...prev, ...newMsgs]
+        setMessages((prev) => {
+          // Re-dedupe against the authoritative state: the mirror can lag by one
+          // commit if a message was appended optimistically in the meantime.
+          const prevIds = new Set(prev.map((m) => String(m.id)))
+          const trulyNew = newMsgs.filter((m) => !prevIds.has(String(m.id)))
+          if (trulyNew.length === 0) return prev
+          return [...prev, ...trulyNew]
         })
-        lastFetchRef.current =
-          data.messages[data.messages.length - 1].createdAt
-        return hadNewMessages
+        return true
       }
       return false
     } catch {
@@ -127,6 +136,8 @@ export function LiveChat() {
       // If we have a session, fetch messages
       if (session.sessionId) {
         lastFetchRef.current = null
+        // Synchronous too: pollMessages() runs before the mirroring effect commits.
+        messagesRef.current = []
         setMessages([])
         pollMessages()
       }

package/src/portal/auth/tickets/detail/TicketPolling.tsx

@@ -30,8 +30,12 @@ export function TicketPolling({
 
     const interval = setInterval(async () => {
       try {
+        // `/count` returns a single number. The previous limit=0 idiom did NOT return
+        // zero documents — Payload disables pagination for limit=0 and derives
+        // totalDocs from the rows it materialised, so every open portal tab used to
+        // re-download its whole conversation every 30 s to read one counter.
         const res = await fetch(
-          `/api/ticket-messages?where[ticket][equals]=${ticketId}&limit=0&depth=0`,
+          `/api/ticket-messages/count?where[ticket][equals]=${ticketId}`,
           { credentials: 'include' },
         )
         if (res.status === 401 || res.status === 403) {

package/src/types/lucide-react.d.ts

@@ -1,7 +1,15 @@
 /**
  * Ambient stub for 'lucide-react'.
- * lucide-react is an optional peer dependency — the host application installs it.
- * This stub satisfies TypeScript when the plugin is type-checked in isolation.
+ *
+ * lucide-react is a REQUIRED peer dependency — three unconditionally registered
+ * components import it statically, so a host without it fails at build time.
+ * It is deliberately not a devDependency here; this stub is what lets the plugin
+ * type-check in isolation without pulling the icon set into the repo.
+ *
+ * Keep the icon list below in sync with the actual imports:
+ *   src/portal/LiveChat.tsx
+ *   src/views/PendingEmailsView/client.tsx
+ *   src/views/TicketingSettingsView/client.tsx
  */
 declare module 'lucide-react' {
   import type { FC, SVGProps } from 'react'

package/src/utils/aiAgent.ts

@@ -2,6 +2,7 @@ import type { Payload } from 'payload'
 import type { CollectionSlugs } from './slugs'
 import { readSupportSettings, type SupportSettings } from './readSettings'
 import { dbFind, dbFindByID, dbCreate, dbUpdate } from './db'
+import { resolveOllamaBaseUrl } from './aiProvider'
 
 export interface AgentDecision {
   action: 'reply' | 'escalate'
@@ -61,7 +62,7 @@ export async function applyAgentDecision(
 function getClient(aiSettings: SupportSettings['ai']) {
   const Anthropic = require('@anthropic-ai/sdk').default
   if (aiSettings.provider === 'ollama') {
-    return new Anthropic({ apiKey: 'ollama', baseURL: process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1' })
+    return new Anthropic({ apiKey: 'ollama', baseURL: resolveOllamaBaseUrl() })
   }
   return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
 }

package/src/utils/aiProvider.ts

@@ -0,0 +1,21 @@
+import { APIError } from 'payload'
+
+/**
+ * Resolve the base URL of the OpenAI-compatible gateway used by the `ollama`
+ * provider.
+ *
+ * There is deliberately NO default here. An integrator who selects `ollama` does
+ * so precisely to keep ticket content off third-party infrastructure; a silent
+ * fallback to any hosted endpoint would ship the whole conversation — subject,
+ * message bodies, client name and company — to a server the operator never chose,
+ * and would do so invisibly because the AI answer still comes back normally.
+ *
+ * Fail loudly instead: a missing `OLLAMA_API_URL` is a configuration error.
+ */
+export function resolveOllamaBaseUrl(): string {
+  const baseURL = process.env.OLLAMA_API_URL
+  if (!baseURL) {
+    throw new APIError("provider 'ollama' requires OLLAMA_API_URL", 500)
+  }
+  return baseURL
+}