feat: automações de tickets e testes de regressão

convex/automations.ts

@@ -0,0 +1,516 @@
+import { ConvexError, v } from "convex/values"
+
+import { api } from "./_generated/api"
+import type { Doc, Id } from "./_generated/dataModel"
+import type { MutationCtx } from "./_generated/server"
+import { mutation, query } from "./_generated/server"
+import { requireInternal } from "./rbac"
+import {
+  evaluateAutomationConditions,
+  type AutomationConditionGroup,
+  type AutomationTrigger,
+  type TicketForAutomation,
+} from "./automationsEngine"
+import { getTemplateByKey, normalizeFormTemplateKey } from "./ticketFormTemplates"
+import { TICKET_FORM_CONFIG } from "./ticketForms.config"
+
+type AutomationAction =
+  | { type: "SET_PRIORITY"; priority: string }
+  | { type: "MOVE_QUEUE"; queueId: Id<"queues"> }
+  | { type: "ASSIGN_TO"; assigneeId: Id<"users"> }
+  | { type: "SET_FORM_TEMPLATE"; formTemplate: string | null }
+  | { type: "SET_CHAT_ENABLED"; enabled: boolean }
+  | { type: "ADD_INTERNAL_COMMENT"; body: string }
+
+const TRIGGERS: AutomationTrigger[] = ["TICKET_CREATED", "STATUS_CHANGED", "COMMENT_ADDED", "TICKET_RESOLVED"]
+const TIMINGS = ["IMMEDIATE", "DELAYED"] as const
+
+const VISIT_QUEUE_KEYWORDS = ["visita", "visitas", "in loco", "laboratório", "laboratorio", "lab"]
+
+function normalizeTrigger(input: string): AutomationTrigger {
+  const normalized = input.trim().toUpperCase()
+  const trigger = TRIGGERS.find((t) => t === normalized)
+  if (!trigger) {
+    throw new ConvexError("Gatilho inválido")
+  }
+  return trigger
+}
+
+function normalizeTiming(input: string): (typeof TIMINGS)[number] {
+  const normalized = input.trim().toUpperCase()
+  if (!TIMINGS.includes(normalized as (typeof TIMINGS)[number])) {
+    throw new ConvexError("Agendamento inválido")
+  }
+  return normalized as (typeof TIMINGS)[number]
+}
+
+function parseConditions(raw: unknown): AutomationConditionGroup | null {
+  if (!raw) return null
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new ConvexError("Condições inválidas")
+  }
+  const group = raw as Partial<AutomationConditionGroup>
+  if (!group.op || (group.op !== "AND" && group.op !== "OR")) {
+    throw new ConvexError("Operador de condição inválido")
+  }
+  if (!Array.isArray(group.conditions)) {
+    throw new ConvexError("Condições inválidas")
+  }
+  return {
+    op: group.op,
+    conditions: group.conditions as AutomationConditionGroup["conditions"],
+  }
+}
+
+function parseActions(raw: unknown): AutomationAction[] {
+  if (!Array.isArray(raw)) {
+    throw new ConvexError("Ações inválidas")
+  }
+  if (raw.length === 0) {
+    throw new ConvexError("Adicione pelo menos uma ação")
+  }
+  return raw as AutomationAction[]
+}
+
+function mapAutomation(doc: Doc<"ticketAutomations">) {
+  return {
+    id: doc._id,
+    name: doc.name,
+    enabled: doc.enabled,
+    trigger: doc.trigger,
+    timing: doc.timing,
+    delayMs: doc.delayMs ?? null,
+    conditions: (doc.conditions ?? null) as AutomationConditionGroup | null,
+    actions: doc.actions as AutomationAction[],
+    runCount: doc.runCount ?? 0,
+    lastRunAt: doc.lastRunAt ?? null,
+    createdAt: doc.createdAt,
+    updatedAt: doc.updatedAt,
+  }
+}
+
+export const list = query({
+  args: { tenantId: v.string(), viewerId: v.id("users") },
+  handler: async (ctx, { tenantId, viewerId }) => {
+    await requireInternal(ctx, viewerId, tenantId)
+    const docs = await ctx.db
+      .query("ticketAutomations")
+      .withIndex("by_tenant", (q) => q.eq("tenantId", tenantId))
+      .take(200)
+    return docs.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)).map(mapAutomation)
+  },
+})
+
+export const getById = query({
+  args: { tenantId: v.string(), viewerId: v.id("users"), automationId: v.id("ticketAutomations") },
+  handler: async (ctx, { tenantId, viewerId, automationId }) => {
+    await requireInternal(ctx, viewerId, tenantId)
+    const doc = await ctx.db.get(automationId)
+    if (!doc || doc.tenantId !== tenantId) return null
+    return mapAutomation(doc)
+  },
+})
+
+export const create = mutation({
+  args: {
+    tenantId: v.string(),
+    viewerId: v.id("users"),
+    name: v.string(),
+    enabled: v.boolean(),
+    trigger: v.string(),
+    timing: v.string(),
+    delayMs: v.optional(v.number()),
+    conditions: v.optional(v.any()),
+    actions: v.any(),
+  },
+  handler: async (ctx, args) => {
+    await requireInternal(ctx, args.viewerId, args.tenantId)
+
+    const name = args.name.trim()
+    if (!name) throw new ConvexError("Nome inválido")
+
+    const trigger = normalizeTrigger(args.trigger)
+    const timing = normalizeTiming(args.timing)
+    const delayMs = timing === "DELAYED" ? Math.max(0, args.delayMs ?? 0) : 0
+    if (timing === "DELAYED" && delayMs < 1_000) {
+      throw new ConvexError("Agendamento precisa ser de pelo menos 1 segundo")
+    }
+
+    const conditions = parseConditions(args.conditions)
+    const actions = parseActions(args.actions)
+
+    const now = Date.now()
+    const id = await ctx.db.insert("ticketAutomations", {
+      tenantId: args.tenantId,
+      name,
+      enabled: Boolean(args.enabled),
+      trigger,
+      timing,
+      delayMs: timing === "DELAYED" ? delayMs : undefined,
+      conditions: conditions ?? undefined,
+      actions,
+      createdBy: args.viewerId,
+      updatedBy: undefined,
+      createdAt: now,
+      updatedAt: now,
+      runCount: 0,
+      lastRunAt: undefined,
+    })
+    return { id }
+  },
+})
+
+export const update = mutation({
+  args: {
+    tenantId: v.string(),
+    viewerId: v.id("users"),
+    automationId: v.id("ticketAutomations"),
+    name: v.string(),
+    enabled: v.boolean(),
+    trigger: v.string(),
+    timing: v.string(),
+    delayMs: v.optional(v.number()),
+    conditions: v.optional(v.any()),
+    actions: v.any(),
+  },
+  handler: async (ctx, args) => {
+    await requireInternal(ctx, args.viewerId, args.tenantId)
+    const existing = await ctx.db.get(args.automationId)
+    if (!existing || existing.tenantId !== args.tenantId) {
+      throw new ConvexError("Automação não encontrada")
+    }
+
+    const name = args.name.trim()
+    if (!name) throw new ConvexError("Nome inválido")
+
+    const trigger = normalizeTrigger(args.trigger)
+    const timing = normalizeTiming(args.timing)
+    const delayMs = timing === "DELAYED" ? Math.max(0, args.delayMs ?? 0) : 0
+    if (timing === "DELAYED" && delayMs < 1_000) {
+      throw new ConvexError("Agendamento precisa ser de pelo menos 1 segundo")
+    }
+
+    const conditions = parseConditions(args.conditions)
+    const actions = parseActions(args.actions)
+
+    const now = Date.now()
+    await ctx.db.patch(args.automationId, {
+      name,
+      enabled: Boolean(args.enabled),
+      trigger,
+      timing,
+      delayMs: timing === "DELAYED" ? delayMs : undefined,
+      conditions: conditions ?? undefined,
+      actions,
+      updatedBy: args.viewerId,
+      updatedAt: now,
+    })
+    return { ok: true }
+  },
+})
+
+export const remove = mutation({
+  args: { tenantId: v.string(), viewerId: v.id("users"), automationId: v.id("ticketAutomations") },
+  handler: async (ctx, { tenantId, viewerId, automationId }) => {
+    await requireInternal(ctx, viewerId, tenantId)
+    const existing = await ctx.db.get(automationId)
+    if (!existing || existing.tenantId !== tenantId) {
+      throw new ConvexError("Automação não encontrada")
+    }
+    await ctx.db.delete(automationId)
+    return { ok: true }
+  },
+})
+
+export const toggleEnabled = mutation({
+  args: { tenantId: v.string(), viewerId: v.id("users"), automationId: v.id("ticketAutomations"), enabled: v.boolean() },
+  handler: async (ctx, { tenantId, viewerId, automationId, enabled }) => {
+    await requireInternal(ctx, viewerId, tenantId)
+    const existing = await ctx.db.get(automationId)
+    if (!existing || existing.tenantId !== tenantId) {
+      throw new ConvexError("Automação não encontrada")
+    }
+    await ctx.db.patch(automationId, { enabled: Boolean(enabled), updatedBy: viewerId, updatedAt: Date.now() })
+    return { ok: true }
+  },
+})
+
+export async function runTicketAutomationsForEvent(
+  ctx: MutationCtx,
+  params: { tenantId: string; ticketId: Id<"tickets">; eventType: AutomationTrigger }
+) {
+  try {
+    const { tenantId, ticketId, eventType } = params
+
+    const ticket = await ctx.db.get(ticketId)
+    if (!ticket || ticket.tenantId !== tenantId) return
+
+    const automations = await ctx.db
+      .query("ticketAutomations")
+      .withIndex("by_tenant_trigger", (q) => q.eq("tenantId", tenantId).eq("trigger", eventType))
+      .filter((q) => q.eq(q.field("enabled"), true))
+      .take(200)
+
+    if (automations.length === 0) return
+
+    for (const automation of automations) {
+      const conditions = (automation.conditions ?? null) as AutomationConditionGroup | null
+      const matches = evaluateAutomationConditions(ticket as unknown as TicketForAutomation, conditions)
+      if (!matches) continue
+
+      const timing = (automation.timing ?? "IMMEDIATE").toUpperCase()
+      const delayMs = timing === "DELAYED" ? Math.max(0, automation.delayMs ?? 0) : 0
+
+      const schedulerRunAfter = ctx.scheduler?.runAfter
+      if (timing === "DELAYED" && delayMs > 0 && typeof schedulerRunAfter === "function") {
+        await schedulerRunAfter(delayMs, api.automations.execute, {
+          automationId: automation._id,
+          ticketId,
+          eventType,
+        })
+        continue
+      }
+
+      await executeAutomationInternal(ctx, automation, ticket, eventType)
+    }
+  } catch (error) {
+    if (process.env.NODE_ENV !== "test") {
+      console.error("[automations] Falha ao processar automações", error)
+    }
+  }
+}
+
+export const execute = mutation({
+  args: {
+    automationId: v.id("ticketAutomations"),
+    ticketId: v.id("tickets"),
+    eventType: v.string(),
+  },
+  handler: async (ctx, { automationId, ticketId, eventType }) => {
+    const automation = await ctx.db.get(automationId)
+    if (!automation || automation.enabled !== true) return { ok: true, skipped: true }
+
+    const ticket = await ctx.db.get(ticketId)
+    if (!ticket || ticket.tenantId !== automation.tenantId) return { ok: true, skipped: true }
+
+    await executeAutomationInternal(ctx, automation, ticket, eventType)
+    return { ok: true }
+  },
+})
+
+async function executeAutomationInternal(
+  ctx: MutationCtx,
+  automation: Doc<"ticketAutomations">,
+  ticket: Doc<"tickets">,
+  eventType: string
+) {
+  const now = Date.now()
+
+  const conditions = (automation.conditions ?? null) as AutomationConditionGroup | null
+  const matched = evaluateAutomationConditions(ticket as unknown as TicketForAutomation, conditions)
+  if (!matched) {
+    await ctx.db.insert("ticketAutomationRuns", {
+      tenantId: automation.tenantId,
+      automationId: automation._id,
+      ticketId: ticket._id,
+      eventType,
+      status: "SKIPPED",
+      matched: false,
+      createdAt: now,
+    })
+    return
+  }
+
+  try {
+    const applied = await applyActions(ctx, automation, ticket, now)
+    await ctx.db.patch(automation._id, {
+      runCount: (automation.runCount ?? 0) + 1,
+      lastRunAt: now,
+      updatedAt: now,
+    })
+    await ctx.db.insert("ticketAutomationRuns", {
+      tenantId: automation.tenantId,
+      automationId: automation._id,
+      ticketId: ticket._id,
+      eventType,
+      status: "SUCCESS",
+      matched: true,
+      actionsApplied: applied,
+      createdAt: now,
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    await ctx.db.insert("ticketAutomationRuns", {
+      tenantId: automation.tenantId,
+      automationId: automation._id,
+      ticketId: ticket._id,
+      eventType,
+      status: "ERROR",
+      matched: true,
+      error: message,
+      createdAt: now,
+    })
+  }
+}
+
+async function applyActions(
+  ctx: MutationCtx,
+  automation: Doc<"ticketAutomations">,
+  ticket: Doc<"tickets">,
+  now: number
+) {
+  const actions = parseActions(automation.actions)
+
+  const patch: Partial<Doc<"tickets">> = {}
+  const applied: Array<{ type: string; details?: Record<string, unknown> }> = []
+
+  for (const action of actions) {
+    if (action.type === "SET_PRIORITY") {
+      const next = action.priority.trim().toUpperCase()
+      if (!next) continue
+      if (ticket.priority !== next) {
+        patch.priority = next
+        applied.push({ type: action.type, details: { priority: next } })
+        const pt: Record<string, string> = { LOW: "Baixa", MEDIUM: "Média", HIGH: "Alta", URGENT: "Urgente" }
+        await ctx.db.insert("ticketEvents", {
+          ticketId: ticket._id,
+          type: "PRIORITY_CHANGED",
+          payload: { to: next, toLabel: pt[next] ?? next },
+          createdAt: now,
+        })
+      }
+      continue
+    }
+
+    if (action.type === "MOVE_QUEUE") {
+      const queue = (await ctx.db.get(action.queueId)) as Doc<"queues"> | null
+      if (!queue || queue.tenantId !== ticket.tenantId) {
+        throw new ConvexError("Fila inválida na automação")
+      }
+      if (ticket.queueId !== action.queueId) {
+        patch.queueId = action.queueId
+        const queueName = queue.name ?? ""
+        const normalizedQueueLabel = queueName.toLowerCase()
+        const isVisitQueueTarget = VISIT_QUEUE_KEYWORDS.some((keyword) => normalizedQueueLabel.includes(keyword))
+        if (!isVisitQueueTarget) {
+          patch.dueAt = ticket.slaSolutionDueAt ?? undefined
+        }
+        applied.push({ type: action.type, details: { queueId: String(action.queueId), queueName } })
+        await ctx.db.insert("ticketEvents", {
+          ticketId: ticket._id,
+          type: "QUEUE_CHANGED",
+          payload: { queueId: action.queueId, queueName },
+          createdAt: now,
+        })
+      }
+      continue
+    }
+
+    if (action.type === "ASSIGN_TO") {
+      const assignee = (await ctx.db.get(action.assigneeId)) as Doc<"users"> | null
+      if (!assignee || assignee.tenantId !== ticket.tenantId) {
+        throw new ConvexError("Responsável inválido na automação")
+      }
+      if (ticket.assigneeId !== action.assigneeId) {
+        patch.assigneeId = action.assigneeId
+        patch.assigneeSnapshot = {
+          name: assignee.name,
+          email: assignee.email,
+          avatarUrl: assignee.avatarUrl ?? undefined,
+          teams: assignee.teams ?? undefined,
+        }
+        applied.push({ type: action.type, details: { assigneeId: String(action.assigneeId), assigneeName: assignee.name } })
+
+        const previousAssigneeName =
+          ((ticket.assigneeSnapshot as { name?: string } | null)?.name as string | undefined) ?? "Não atribuído"
+        await ctx.db.insert("ticketEvents", {
+          ticketId: ticket._id,
+          type: "ASSIGNEE_CHANGED",
+          payload: {
+            assigneeId: action.assigneeId,
+            assigneeName: assignee.name,
+            previousAssigneeId: ticket.assigneeId ?? null,
+            previousAssigneeName,
+            viaAutomation: true,
+            automationId: automation._id,
+            automationName: automation.name,
+          },
+          createdAt: now,
+        })
+      }
+      continue
+    }
+
+    if (action.type === "SET_FORM_TEMPLATE") {
+      const normalizedKey = normalizeFormTemplateKey(action.formTemplate ?? null)
+      let label: string | null = null
+      if (normalizedKey) {
+        const templateDoc = await getTemplateByKey(ctx, ticket.tenantId, normalizedKey)
+        if (templateDoc && templateDoc.isArchived !== true) {
+          label = templateDoc.label
+        } else {
+          const fallback = TICKET_FORM_CONFIG.find((tpl) => tpl.key === normalizedKey) ?? null
+          if (fallback) label = fallback.label
+        }
+      }
+      if ((ticket.formTemplate ?? null) !== normalizedKey || (ticket.formTemplateLabel ?? null) !== label) {
+        patch.formTemplate = normalizedKey ?? undefined
+        patch.formTemplateLabel = label ?? undefined
+        applied.push({ type: action.type, details: { formTemplate: normalizedKey, formTemplateLabel: label } })
+      }
+      continue
+    }
+
+    if (action.type === "SET_CHAT_ENABLED") {
+      const next = Boolean(action.enabled)
+      if (Boolean(ticket.chatEnabled) !== next) {
+        patch.chatEnabled = next
+        applied.push({ type: action.type, details: { enabled: next } })
+      }
+      continue
+    }
+
+    if (action.type === "ADD_INTERNAL_COMMENT") {
+      const body = action.body.replace(/\r\n/g, "\n").trim()
+      if (!body) continue
+      if (body.length > 4000) {
+        throw new ConvexError("Comentário interno muito longo (máx. 4000 caracteres)")
+      }
+      const author = (await ctx.db.get(automation.createdBy)) as Doc<"users"> | null
+      if (!author || author.tenantId !== ticket.tenantId) {
+        throw new ConvexError("Autor da automação inválido")
+      }
+      const authorSnapshot = {
+        name: author.name,
+        email: author.email,
+        avatarUrl: author.avatarUrl ?? undefined,
+        teams: author.teams ?? undefined,
+      }
+      await ctx.db.insert("ticketComments", {
+        ticketId: ticket._id,
+        authorId: automation.createdBy,
+        visibility: "INTERNAL",
+        body,
+        authorSnapshot,
+        attachments: [],
+        createdAt: now,
+        updatedAt: now,
+      })
+      await ctx.db.insert("ticketEvents", {
+        ticketId: ticket._id,
+        type: "COMMENT_ADDED",
+        payload: { authorId: automation.createdBy, authorName: author.name, viaAutomation: true, automationId: automation._id },
+        createdAt: now,
+      })
+      applied.push({ type: action.type })
+      continue
+    }
+  }
+
+  if (Object.keys(patch).length > 0) {
+    patch.updatedAt = now
+    await ctx.db.patch(ticket._id, patch)
+  }
+
+  return applied
+}