@reachy/audience-module 1.0.12 → 1.0.14

package/src/engine/V2AudienceEngine.ts

@@ -7,6 +7,247 @@ type Logger = {
   error: (...args: any[]) => void
 }
 
+const getByPath = (obj: any, dottedPath: string): any => {
+  if (!obj || !dottedPath) return undefined
+  const parts = dottedPath.split('.').filter(Boolean)
+  let cur: any = obj
+  for (const p of parts) {
+    if (cur == null) return undefined
+    cur = cur[p]
+  }
+  return cur
+}
+
+const getEventPropertyValue = (eventData: any, keyRaw: any): any => {
+  const key = String(keyRaw || '').trim()
+  if (!key) return undefined
+  const ed = eventData || {}
+
+  if (key.startsWith('event_data.')) return getByPath(ed, key.replace(/^event_data\./, ''))
+  if (key.startsWith('custom_data.')) return getByPath(ed?.custom_data, key.replace(/^custom_data\./, ''))
+  if (key.startsWith('utm_data.')) return getByPath(ed?.utm_data, key.replace(/^utm_data\./, ''))
+  if (key.startsWith('url_data.')) return getByPath(ed?.url_data, key.replace(/^url_data\./, ''))
+  if (key.startsWith('session_data.')) return getByPath(ed?.session_data, key.replace(/^session_data\./, ''))
+
+  // fallback: tentar direto e depois dentro de custom_data
+  return getByPath(ed, key) ?? getByPath(ed?.custom_data, key)
+}
+
+const isValidIanaTimezone = (tzRaw: any): boolean => {
+  const tz = String(tzRaw || '').trim()
+  if (!tz) return false
+  try {
+    // eslint-disable-next-line no-new
+    new Intl.DateTimeFormat('en-US', { timeZone: tz })
+    return true
+  } catch {
+    return false
+  }
+}
+
+const parseTimeToMinutes = (raw: any): number | null => {
+  const s = String(raw || '').trim()
+  if (!s) return null
+  const m = s.match(/^(\d{1,2}):(\d{2})\s*(AM|PM)?$/i)
+  if (!m) return null
+  let hh = Number(m[1])
+  const mm = Number(m[2])
+  const ampm = m[3] ? String(m[3]).toUpperCase() : null
+  if (!Number.isFinite(hh) || !Number.isFinite(mm)) return null
+  if (mm < 0 || mm > 59) return null
+
+  if (ampm) {
+    if (hh < 1 || hh > 12) return null
+    if (ampm === 'AM') hh = hh === 12 ? 0 : hh
+    if (ampm === 'PM') hh = hh === 12 ? 12 : hh + 12
+  } else {
+    if (hh < 0 || hh > 23) return null
+  }
+  return hh * 60 + mm
+}
+
+const getLocalTimeParts = (iso: any, tz: string): { minutes: number; weekday: number; dayOfMonth: number } | null => {
+  const d = new Date(String(iso || ''))
+  if (Number.isNaN(d.getTime())) return null
+
+  const dtf = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+    weekday: 'short',
+    day: '2-digit',
+  })
+
+  const parts = dtf.formatToParts(d)
+  let hourStr = ''
+  let minStr = ''
+  let weekdayStr = ''
+  let dayStr = ''
+  for (const p of parts) {
+    if (p.type === 'hour') hourStr = p.value
+    if (p.type === 'minute') minStr = p.value
+    if (p.type === 'weekday') weekdayStr = p.value
+    if (p.type === 'day') dayStr = p.value
+  }
+
+  const hour = Number(hourStr)
+  const minute = Number(minStr)
+  const dayOfMonth = Number(dayStr)
+  if (!Number.isFinite(hour) || !Number.isFinite(minute) || !Number.isFinite(dayOfMonth)) return null
+  const minutes = hour * 60 + minute
+
+  // 0=Sunday ... 6=Saturday
+  const weekdayMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 }
+  const weekday = weekdayMap[weekdayStr] ?? -1
+  if (weekday < 0) return null
+
+  return { minutes, weekday, dayOfMonth }
+}
+
+const parseWeekdayToIndex = (raw: any): number | null => {
+  const s = String(raw || '').trim().toLowerCase()
+  if (!s) return null
+  const map: Record<string, number> = {
+    sunday: 0, sun: 0,
+    monday: 1, mon: 1,
+    tuesday: 2, tue: 2, tues: 2,
+    wednesday: 3, wed: 3,
+    thursday: 4, thu: 4, thurs: 4,
+    friday: 5, fri: 5,
+    saturday: 6, sat: 6,
+  }
+  return map[s] ?? null
+}
+
+const matchesInterest = (raw: any, op: string, expected: any): boolean => {
+  if (raw === null || raw === undefined) return false
+  const a = String(raw).trim()
+  const b = String(expected ?? '').trim()
+  if (!b) return false
+  const nOp = String(op || 'equals').trim()
+  if (nOp === 'equals') return a === b
+  if (nOp === 'contains') return a.toLowerCase().includes(b.toLowerCase())
+  if (nOp === 'starts_with') return a.toLowerCase().startsWith(b.toLowerCase())
+  if (nOp === 'ends_with') return a.toLowerCase().endsWith(b.toLowerCase())
+  if (nOp === 'not_equals') return a !== b
+  return a.toLowerCase().includes(b.toLowerCase())
+}
+
+const normalizeEventPropertyOp = (opRaw: any): string => {
+  const op = String(opRaw ?? '').trim()
+  if (op === '=' || op === '==' || op === 'eq' || op === 'equals') return 'equals'
+  if (op === '!=' || op === '<>' || op === 'neq' || op === 'not_equals') return 'not_equals'
+  if (op === 'contains') return 'contains'
+  if (op === 'not_contains') return 'not_contains'
+  if (op === 'starts_with') return 'starts_with'
+  if (op === 'ends_with') return 'ends_with'
+  if (op === 'is_empty') return 'is_empty'
+  if (op === 'is_not_empty') return 'is_not_empty'
+  if (op === '>' || op === 'gt') return 'gt'
+  if (op === '>=' || op === 'gte') return 'gte'
+  if (op === '<' || op === 'lt') return 'lt'
+  if (op === '<=' || op === 'lte') return 'lte'
+  return op
+}
+
+const matchesEventPropertyFilter = (raw: any, opRaw: any, expected: any): boolean => {
+  const op = normalizeEventPropertyOp(opRaw)
+
+  if (op === 'is_empty') {
+    return raw === null || raw === undefined || String(raw).trim() === ''
+  }
+  if (op === 'is_not_empty') {
+    return raw !== null && raw !== undefined && String(raw).trim() !== ''
+  }
+
+  if (raw === null || raw === undefined) return false
+  const a = String(raw)
+  const b = String(expected ?? '')
+
+  if (op === 'equals') return a === b
+  if (op === 'not_equals') return a !== b
+  if (op === 'contains') return a.toLowerCase().includes(b.toLowerCase())
+  if (op === 'not_contains') return !a.toLowerCase().includes(b.toLowerCase())
+  if (op === 'starts_with') return a.toLowerCase().startsWith(b.toLowerCase())
+  if (op === 'ends_with') return a.toLowerCase().endsWith(b.toLowerCase())
+
+  if (op === 'gt' || op === 'gte' || op === 'lt' || op === 'lte') {
+    const aNum = Number(raw)
+    const bNum = Number(expected)
+    if (!Number.isFinite(aNum) || !Number.isFinite(bNum)) return false
+    if (op === 'gt') return aNum > bNum
+    if (op === 'gte') return aNum >= bNum
+    if (op === 'lt') return aNum < bNum
+    return aNum <= bNum
+  }
+
+  return false
+}
+
+const applyEventRuleFilters = (
+  rows: any[],
+  filters: any[],
+  opts?: { timezone?: string }
+): any[] => {
+  let out = rows
+  const tz = String(opts?.timezone || '').trim()
+  for (const f of filters) {
+    const type = String(f?.type || '').trim()
+    if (type === 'event_property') {
+      const key = String(f?.key || '').trim()
+      if (!key) continue
+      const op = f?.op
+      const value = f?.value
+      out = out.filter((row) => matchesEventPropertyFilter(getEventPropertyValue(row?.event_data, key), op, value))
+    } else if (type === 'time_of_day') {
+      if (!tz) continue
+      const startMin = parseTimeToMinutes(f?.timeStart)
+      const endMin = parseTimeToMinutes(f?.timeEnd)
+      if (startMin == null || endMin == null) continue
+      // compatível com between: se start > end, não casa
+      if (startMin > endMin) {
+        out = []
+        continue
+      }
+      out = out.filter((row) => {
+        const parts = getLocalTimeParts(row?.event_timestamp, tz)
+        if (!parts) return false
+        return parts.minutes >= startMin && parts.minutes <= endMin
+      })
+    } else if (type === 'day_of_week') {
+      if (!tz) continue
+      const days = Array.isArray(f?.days) ? f.days : []
+      const allowed = new Set<number>()
+      for (const d of days) {
+        const idx = parseWeekdayToIndex(d)
+        if (idx != null) allowed.add(idx)
+      }
+      if (allowed.size === 0) continue
+      out = out.filter((row) => {
+        const parts = getLocalTimeParts(row?.event_timestamp, tz)
+        if (!parts) return false
+        return allowed.has(parts.weekday)
+      })
+    } else if (type === 'day_of_month') {
+      if (!tz) continue
+      const days = Array.isArray(f?.days) ? f.days : []
+      const allowed = new Set<number>()
+      for (const d of days) {
+        const n = Number(d)
+        if (Number.isFinite(n) && n >= 1 && n <= 31) allowed.add(Math.floor(n))
+      }
+      if (allowed.size === 0) continue
+      out = out.filter((row) => {
+        const parts = getLocalTimeParts(row?.event_timestamp, tz)
+        if (!parts) return false
+        return allowed.has(parts.dayOfMonth)
+      })
+    }
+  }
+  return out
+}
+
 /**
  * Engine V2 (groups/rules) portado do reachy-api para o audience-module.
  *
@@ -31,6 +272,24 @@ export class V2AudienceEngine {
   ): Promise<Set<string>> {
     let criteria: AudienceCriteria = CriteriaParser.parse(criteriaRaw as any) as any
 
+    // Timezone do projeto: usado em filtros de tempo (time_of_day/day_of_week/day_of_month)
+    // Fonte: projects.settings.timezone (mesma tela de Settings > Project no frontend)
+    let projectTimezone = 'UTC'
+    try {
+      const { data } = await this.supabase
+        .from('projects')
+        .select('settings')
+        .eq('organization_id', organizationId)
+        .eq('id', projectId)
+        .single()
+      const tzCandidate = (data as any)?.settings?.timezone
+      if (typeof tzCandidate === 'string' && isValidIanaTimezone(tzCandidate)) {
+        projectTimezone = tzCandidate.trim()
+      }
+    } catch {
+      // fallback silencioso
+    }
+
     // Compat: permitir critérios legados (filters/conditions) sem groups,
     // convertendo para groups V2 para que o engine avalie sozinho.
     if (
@@ -63,12 +322,16 @@ export class V2AudienceEngine {
 
     const allContactIds = new Set<string>((allContacts || []).map((c: any) => c.id as string))
     const reachyIdToContactId = new Map<string, string>()
+    const contactIdToReachyId = new Map<string, string>()
     const emailToContactId = new Map<string, string>()
 
     for (const c of allContacts || []) {
       const rid = c?.reachy_id ? String(c.reachy_id).trim() : ''
       const cid = c?.id ? String(c.id).trim() : ''
-      if (rid && cid) reachyIdToContactId.set(rid, cid)
+      if (rid && cid) {
+        reachyIdToContactId.set(rid, cid)
+        contactIdToReachyId.set(cid, rid)
+      }
       const email = c?.email ? String(c.email).trim().toLowerCase() : ''
       if (email && cid) emailToContactId.set(email, cid)
     }
@@ -206,8 +469,15 @@ export class V2AudienceEngine {
       }
 
       // Event attributes: attributes: [{ key, op, value }]
+      const interest = (rule as any)?.interest
       try {
-        const attributes = Array.isArray(rule.attributes) ? rule.attributes : (rule.attributes ? [rule.attributes] : [])
+        let attributes = Array.isArray(rule.attributes) ? rule.attributes : (rule.attributes ? [rule.attributes] : [])
+        // Se houver "interest", não podemos pré-filtrar o dataset pelo atributo do interesse,
+        // senão o cálculo de % sempre vira 100% (porque só sobram eventos que já casam).
+        const interestKey = interest?.key ? String(interest.key).trim() : ''
+        if (interestKey) {
+          attributes = attributes.filter((a: any) => String(a?.key || '').trim() !== interestKey)
+        }
 
         const trackerEvents = new Set([
           'click',
@@ -290,26 +560,256 @@ export class V2AudienceEngine {
       const { data, error } = await query
       if (error) return new Set<string>()
 
+      // Event advanced filters (ex.: event_property dentro do DID)
+      let rows = (data || []) as any[]
+      const ruleFiltersAll = Array.isArray((rule as any).filters) ? (rule as any).filters : []
+      const hasFirstTime = ruleFiltersAll.some((f: any) => String(f?.type || '').trim() === 'first_time')
+      const hasLastTime = ruleFiltersAll.some((f: any) => String(f?.type || '').trim() === 'last_time')
+      const ruleFilters = ruleFiltersAll.filter((f: any) => {
+        const t = String(f?.type || '').trim()
+        return t && t !== 'first_time' && t !== 'last_time'
+      })
+
+      if (ruleFilters.length > 0) {
+        rows = applyEventRuleFilters(rows, ruleFilters, { timezone: projectTimezone })
+      }
+
+      // First Time / Last Time (CleverTap-like): avaliar pelo histórico do evento (vida inteira),
+      // e só depois aplicar a janela temporal (rule.time).
+      // Implementação eficiente:
+      // - candidatos = contatos que têm pelo menos 1 evento na janela atual
+      // - first_time: excluir candidatos que já tinham o evento ANTES do início da janela
+      // - last_time: excluir candidatos que têm o evento DEPOIS do fim da janela
+      if ((hasFirstTime || hasLastTime) && rows.length > 0) {
+        const now = new Date()
+        let windowStartIso: string | undefined
+        let windowEndIso: string | undefined
+
+        // Preferir rule.time; fallback em cfg.timeFrame (paridade)
+        if (rule.time) {
+          if (rule.time.unit && rule.time.value != null) {
+            type TimeUnit = 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
+            const unit = String(rule.time.unit) as TimeUnit
+            const valueNum = Number(rule.time.value)
+            const units: Record<TimeUnit, number> = {
+              minutes: 60 * 1000,
+              hours: 60 * 60 * 1000,
+              days: 24 * 60 * 60 * 1000,
+              weeks: 7 * 24 * 60 * 60 * 1000,
+              months: 30 * 24 * 60 * 60 * 1000,
+            }
+            const ms = units[unit] ?? units['days']
+            if (Number.isFinite(valueNum) && valueNum >= 0) {
+              windowStartIso = new Date(now.getTime() - valueNum * ms).toISOString()
+              windowEndIso = now.toISOString()
+            }
+          } else {
+            if (rule.time.from) windowStartIso = String(rule.time.from)
+            if (rule.time.to) windowEndIso = String(rule.time.to)
+          }
+        } else if (cfg && cfg.timeFrame) {
+          const tf = String(cfg.timeFrame).trim()
+          let unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' = 'days'
+          let value = 7
+          if (/^\d+$/.test(tf)) { value = Number(tf); unit = 'days' }
+          else if (/^\d+\s*m$/.test(tf)) { value = Number(tf.replace(/m$/, '')); unit = 'minutes' }
+          else if (/^\d+\s*h$/.test(tf)) { value = Number(tf.replace(/h$/, '')); unit = 'hours' }
+          else if (/^\d+\s*d$/.test(tf)) { value = Number(tf.replace(/d$/, '')); unit = 'days' }
+          else if (/^\d+\s*w$/.test(tf)) { value = Number(tf.replace(/w$/, '')); unit = 'weeks' }
+          else if (/^\d+\s*mo$/.test(tf)) { value = Number(tf.replace(/mo$/, '')); unit = 'months' }
+          const units: Record<typeof unit, number> = {
+            minutes: 60 * 1000,
+            hours: 60 * 60 * 1000,
+            days: 24 * 60 * 60 * 1000,
+            weeks: 7 * 24 * 60 * 60 * 1000,
+            months: 30 * 24 * 60 * 60 * 1000,
+          }
+          if (Number.isFinite(value) && value >= 0) {
+            const from = new Date(now.getTime() - value * units[unit])
+            windowStartIso = from.toISOString()
+            windowEndIso = now.toISOString()
+          }
+        }
+
+        if (!windowEndIso) windowEndIso = now.toISOString()
+
+        const candidateIds = new Set<string>()
+        for (const row of rows) {
+          const id = resolveEventContactId(row)
+          if (id) candidateIds.add(id)
+        }
+
+        if (candidateIds.size === 0) {
+          return new Set<string>()
+        }
+
+        const candidateArr = Array.from(candidateIds)
+        const CHUNK = 500
+        const PAGE = 1000
+
+        const fetchOutside = async (dir: 'before' | 'after', boundaryIso: string): Promise<Set<string>> => {
+          const outIds = new Set<string>()
+          for (let i = 0; i < candidateArr.length; i += CHUNK) {
+            const chunkIds = candidateArr.slice(i, i + CHUNK)
+            const chunkReachyIds = chunkIds.map((cid) => contactIdToReachyId.get(cid)).filter(Boolean) as string[]
+
+            const runPaged = async (queryBuilderFactory: (rangeFrom: number, rangeTo: number) => any) => {
+              let offset = 0
+              while (true) {
+                const query = queryBuilderFactory(offset, offset + PAGE - 1)
+                const { data: rowsPage, error: pageError } = await query
+                if (pageError || !rowsPage || rowsPage.length === 0) break
+                for (const r of rowsPage as any[]) {
+                  const cid = resolveEventContactId(r)
+                  if (cid) outIds.add(cid)
+                }
+                if (outIds.size >= candidateIds.size) return
+                if (rowsPage.length < PAGE) break
+                offset += PAGE
+                if (offset > 50_000) break
+              }
+            }
+
+            // Query por contact_id
+            await runPaged((from: number, to: number) => {
+              let q = this.supabase
+                .from('contact_events')
+                .select('contact_id, reachy_id, event_timestamp')
+                .eq('organization_id', organizationId)
+                .eq('project_id', projectId)
+                .eq('event_name', effectiveEventName)
+              q = dir === 'before' ? q.lt('event_timestamp', boundaryIso) : q.gt('event_timestamp', boundaryIso)
+              q = q.in('contact_id', chunkIds)
+              return q.range(from, to)
+            })
+
+            if (outIds.size >= candidateIds.size) break
+
+            // Query por reachy_id (para casos em que contact_id é null)
+            if (chunkReachyIds.length > 0) {
+              await runPaged((from: number, to: number) => {
+                let q = this.supabase
+                  .from('contact_events')
+                  .select('contact_id, reachy_id, event_timestamp')
+                  .eq('organization_id', organizationId)
+                  .eq('project_id', projectId)
+                  .eq('event_name', effectiveEventName)
+                q = dir === 'before' ? q.lt('event_timestamp', boundaryIso) : q.gt('event_timestamp', boundaryIso)
+                q = q.in('reachy_id', chunkReachyIds)
+                return q.range(from, to)
+              })
+            }
+
+            if (outIds.size >= candidateIds.size) break
+          }
+          return outIds
+        }
+
+        let allowed = new Set<string>(candidateIds)
+        if (hasFirstTime && windowStartIso) {
+          const hadBefore = await fetchOutside('before', windowStartIso)
+          allowed = diff(allowed, hadBefore)
+        }
+        if (hasLastTime && windowEndIso) {
+          const hadAfter = await fetchOutside('after', windowEndIso)
+          allowed = diff(allowed, hadAfter)
+        }
+
+        if (allowed.size === 0) {
+          return new Set<string>()
+        }
+
+        rows = rows.filter((row) => {
+          const id = resolveEventContactId(row)
+          return id ? allowed.has(id) : false
+        })
+      }
+
+      // User Interests: predominantly / at least X% of the time
+      // rule.interest?: { key, op, value, occurrenceType, occurrencePercentage }
+      if (interest && interest.key) {
+        const key = String(interest.key || '').trim()
+        const op = String(interest.op || 'equals').trim()
+        const expected = interest.value
+        const occType = String(interest.occurrenceType || 'predominantly').trim()
+        const pct = Number(interest.occurrencePercentage ?? 0)
+        const threshold = Number.isFinite(pct) ? Math.max(0, Math.min(100, pct)) / 100 : 0
+
+        // total events por contato dentro da janela (já filtrada por time/event_name)
+        const totals = new Map<string, number>()
+        // matches (para at_least) e counts por valor (para predominantly)
+        const matchCounts = new Map<string, number>()
+        const valueCounts = new Map<string, Map<string, number>>()
+
+        for (const row of rows) {
+          const id = resolveEventContactId(row)
+          if (!id) continue
+          totals.set(id, (totals.get(id) || 0) + 1)
+
+          const rawVal = getEventPropertyValue(row?.event_data, key)
+          const strVal = rawVal === null || rawVal === undefined ? '' : String(rawVal)
+
+          // para predominantemente: contar por valor bruto
+          if (!valueCounts.has(id)) valueCounts.set(id, new Map<string, number>())
+          const per = valueCounts.get(id)!
+          per.set(strVal, (per.get(strVal) || 0) + 1)
+
+          if (matchesInterest(rawVal, op === 'contains' ? 'contains' : op, expected)) {
+            matchCounts.set(id, (matchCounts.get(id) || 0) + 1)
+          }
+        }
+
+        const res = new Set<string>()
+        totals.forEach((total, id) => {
+          if (total <= 0) return
+
+          const match = matchCounts.get(id) || 0
+          if (occType === 'at_least') {
+            if (match > 0 && match / total >= threshold) res.add(id)
+            return
+          }
+
+          // predominantly
+          const per = valueCounts.get(id)
+          if (!per) return
+          let maxOther = 0
+          // "predominantly": o grupo que casa o operador/valor deve ser >= qualquer outro valor individual.
+          per.forEach((cnt, valStr) => {
+            if (!matchesInterest(valStr, op, expected)) {
+              if (cnt > maxOther) maxOther = cnt
+            }
+          })
+
+          if (match > 0 && match >= maxOther) res.add(id)
+        })
+
+        return res
+      }
+
       // Frequência / agregação
       if (rule.frequency && rule.frequency.value != null) {
-        const { op, value, type = 'count', field = 'value' } = rule.frequency
+        const { op, value, value2, type = 'count', field = 'value' } = rule.frequency
         const counts = new Map<string, number>()
+        const denoms = new Map<string, number>() // usado para avg (ignora eventos sem número)
 
-        for (const row of data || []) {
+        for (const row of rows) {
           const id = resolveEventContactId(row)
           if (!id) continue
 
           if (type === 'count') {
             counts.set(id, (counts.get(id) || 0) + 1)
           } else if (type === 'sum' || type === 'avg') {
-            let numVal = 0
             const eventData = row.event_data || {}
-            if (eventData[field] !== undefined) numVal = Number(eventData[field])
-            else if (eventData['value'] !== undefined) numVal = Number(eventData['value'])
-            else if (eventData['amount'] !== undefined) numVal = Number(eventData['amount'])
-
-            if (!Number.isNaN(numVal)) {
+            const raw =
+              getEventPropertyValue(eventData, field) ??
+              (eventData?.[field] !== undefined ? eventData[field] : undefined) ??
+              eventData?.value ??
+              eventData?.amount
+            const numVal = Number(raw)
+
+            if (Number.isFinite(numVal)) {
               counts.set(id, (counts.get(id) || 0) + numVal)
+              if (type === 'avg') denoms.set(id, (denoms.get(id) || 0) + 1)
             }
           }
         }
@@ -318,21 +818,28 @@ export class V2AudienceEngine {
         counts.forEach((aggregatedValue, id) => {
           let finalValue = aggregatedValue
           if (type === 'avg') {
-            let eventCount = 0
-            for (const row of data || []) {
-              const rid = resolveEventContactId(row)
-              if (rid === id) eventCount++
-            }
-            finalValue = eventCount > 0 ? aggregatedValue / eventCount : 0
+            const denom = denoms.get(id) || 0
+            finalValue = denom > 0 ? aggregatedValue / denom : 0
           }
 
+          const betweenOk = (() => {
+            if (op !== 'between') return false
+            const a = Number(value)
+            const b = Number(value2)
+            if (!Number.isFinite(a) || !Number.isFinite(b)) return false
+            // Compatível com CleverTap: se o usuário inverter (min > max), não deve casar.
+            if (a > b) return false
+            return finalValue >= a && finalValue <= b
+          })()
+
           if (
             (op === '>=' && finalValue >= value) ||
             (op === '>' && finalValue > value) ||
             (op === '=' && finalValue === value) ||
             (op === '!=' && finalValue !== value) ||
             (op === '<=' && finalValue <= value) ||
-            (op === '<' && finalValue < value)
+            (op === '<' && finalValue < value) ||
+            betweenOk
           ) {
             res.add(id)
           }
@@ -344,7 +851,7 @@ export class V2AudienceEngine {
       if (typeId === 'live-page-count' && cfg && cfg.pageCount != null) {
         const threshold = Number(cfg.pageCount)
         const counts = new Map<string, number>()
-        for (const row of data || []) {
+        for (const row of rows) {
           const id = resolveEventContactId(row)
           if (!id) continue
           counts.set(id, (counts.get(id) || 0) + 1)
@@ -355,7 +862,7 @@ export class V2AudienceEngine {
       }
 
       const res = new Set<string>()
-      for (const row of data || []) {
+      for (const row of rows) {
         const id = resolveEventContactId(row)
         if (id) res.add(id)
       }
@@ -614,6 +1121,23 @@ export class V2AudienceEngine {
 
     const typeId = String((criteria as any)?.type || '')
 
+    // Timezone do projeto (para filtros de tempo em eventos)
+    let projectTimezone = 'UTC'
+    try {
+      const { data } = await this.supabase
+        .from('projects')
+        .select('settings')
+        .eq('organization_id', organizationId)
+        .eq('id', projectId)
+        .single()
+      const tzCandidate = (data as any)?.settings?.timezone
+      if (typeof tzCandidate === 'string' && isValidIanaTimezone(tzCandidate)) {
+        projectTimezone = tzCandidate.trim()
+      }
+    } catch {
+      // fallback silencioso
+    }
+
     // Carregar identidade do contato (para reachy_id)
     const { data: contactRow } = await this.supabase
       .from('contacts')
@@ -737,8 +1261,13 @@ export class V2AudienceEngine {
       }
 
       // Event attributes
+      const interest = (rule as any)?.interest
       try {
-        const attributes = Array.isArray(rule.attributes) ? rule.attributes : (rule.attributes ? [rule.attributes] : [])
+        let attributes = Array.isArray(rule.attributes) ? rule.attributes : (rule.attributes ? [rule.attributes] : [])
+        const interestKey = interest?.key ? String(interest.key).trim() : ''
+        if (interestKey) {
+          attributes = attributes.filter((a: any) => String(a?.key || '').trim() !== interestKey)
+        }
         const resolveDbFieldForAttrKey = (keyRaw: string) => {
           const key = String(keyRaw || '').trim()
           if (!key) return null
@@ -801,23 +1330,180 @@ export class V2AudienceEngine {
       const { data, error } = await query
       if (error) return false
 
+      // Event advanced filters (ex.: event_property dentro do DID)
+      let rows = (data || []) as any[]
+      const ruleFiltersAll = Array.isArray((rule as any).filters) ? (rule as any).filters : []
+      const hasFirstTime = ruleFiltersAll.some((f: any) => String(f?.type || '').trim() === 'first_time')
+      const hasLastTime = ruleFiltersAll.some((f: any) => String(f?.type || '').trim() === 'last_time')
+      const ruleFilters = ruleFiltersAll.filter((f: any) => {
+        const t = String(f?.type || '').trim()
+        return t && t !== 'first_time' && t !== 'last_time'
+      })
+
+      if (ruleFilters.length > 0) {
+        rows = applyEventRuleFilters(rows, ruleFilters, { timezone: projectTimezone })
+      }
+
+      if ((hasFirstTime || hasLastTime) && rows.length > 0) {
+        const now = new Date()
+        let windowStartIso: string | undefined
+        let windowEndIso: string | undefined
+
+        if (rule.time) {
+          if (rule.time.unit && rule.time.value != null) {
+            type TimeUnit = 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
+            const unit = String(rule.time.unit) as TimeUnit
+            const valueNum = Number(rule.time.value)
+            const units: Record<TimeUnit, number> = {
+              minutes: 60 * 1000,
+              hours: 60 * 60 * 1000,
+              days: 24 * 60 * 60 * 1000,
+              weeks: 7 * 24 * 60 * 60 * 1000,
+              months: 30 * 24 * 60 * 60 * 1000,
+            }
+            const ms = units[unit] ?? units['days']
+            if (Number.isFinite(valueNum) && valueNum >= 0) {
+              windowStartIso = new Date(now.getTime() - valueNum * ms).toISOString()
+              windowEndIso = now.toISOString()
+            }
+          } else {
+            if (rule.time.from) windowStartIso = String(rule.time.from)
+            if (rule.time.to) windowEndIso = String(rule.time.to)
+          }
+        } else if (cfg && cfg.timeFrame) {
+          const tf = String(cfg.timeFrame).trim()
+          let unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' = 'days'
+          let value = 7
+          if (/^\d+$/.test(tf)) { value = Number(tf); unit = 'days' }
+          else if (/^\d+\s*m$/.test(tf)) { value = Number(tf.replace(/m$/, '')); unit = 'minutes' }
+          else if (/^\d+\s*h$/.test(tf)) { value = Number(tf.replace(/h$/, '')); unit = 'hours' }
+          else if (/^\d+\s*d$/.test(tf)) { value = Number(tf.replace(/d$/, '')); unit = 'days' }
+          else if (/^\d+\s*w$/.test(tf)) { value = Number(tf.replace(/w$/, '')); unit = 'weeks' }
+          else if (/^\d+\s*mo$/.test(tf)) { value = Number(tf.replace(/mo$/, '')); unit = 'months' }
+          const units: Record<typeof unit, number> = {
+            minutes: 60 * 1000,
+            hours: 60 * 60 * 1000,
+            days: 24 * 60 * 60 * 1000,
+            weeks: 7 * 24 * 60 * 60 * 1000,
+            months: 30 * 24 * 60 * 60 * 1000,
+          }
+          if (Number.isFinite(value) && value >= 0) {
+            const from = new Date(now.getTime() - value * units[unit])
+            windowStartIso = from.toISOString()
+            windowEndIso = now.toISOString()
+          }
+        }
+
+        if (!windowEndIso) windowEndIso = now.toISOString()
+
+        if (hasFirstTime && windowStartIso) {
+          let q = this.supabase
+            .from('contact_events')
+            .select('id')
+            .eq('organization_id', organizationId)
+            .eq('project_id', projectId)
+            .eq('event_name', effectiveEventName)
+            .lt('event_timestamp', windowStartIso)
+            .limit(1)
+
+          // mesmo narrow de identidade que usamos acima
+          const ors2: string[] = []
+          if (contactId) ors2.push(`contact_id.eq.${contactId}`)
+          if (reachyId) ors2.push(`reachy_id.eq.${reachyId}`)
+          if (ors2.length > 0) q = q.or(ors2.join(','))
+
+          const { data: beforeRows } = await q
+          if (Array.isArray(beforeRows) && beforeRows.length > 0) return false
+        }
+
+        if (hasLastTime && windowEndIso) {
+          let q = this.supabase
+            .from('contact_events')
+            .select('id')
+            .eq('organization_id', organizationId)
+            .eq('project_id', projectId)
+            .eq('event_name', effectiveEventName)
+            .gt('event_timestamp', windowEndIso)
+            .limit(1)
+
+          const ors2: string[] = []
+          if (contactId) ors2.push(`contact_id.eq.${contactId}`)
+          if (reachyId) ors2.push(`reachy_id.eq.${reachyId}`)
+          if (ors2.length > 0) q = q.or(ors2.join(','))
+
+          const { data: afterRows } = await q
+          if (Array.isArray(afterRows) && afterRows.length > 0) return false
+        }
+      }
+
+      // User Interests: predominantly / at least X% of the time (para 1 contato)
+      if (interest && interest.key) {
+        const key = String(interest.key || '').trim()
+        const op = String(interest.op || 'equals').trim()
+        const expected = interest.value
+        const occType = String(interest.occurrenceType || 'predominantly').trim()
+        const pct = Number(interest.occurrencePercentage ?? 0)
+        const threshold = Number.isFinite(pct) ? Math.max(0, Math.min(100, pct)) / 100 : 0
+
+        if (rows.length === 0) return false
+
+        let total = 0
+        let match = 0
+        const counts = new Map<string, number>()
+
+        for (const row of rows) {
+          total++
+          const rawVal = getEventPropertyValue(row?.event_data, key)
+          const strVal = rawVal === null || rawVal === undefined ? '' : String(rawVal)
+          counts.set(strVal, (counts.get(strVal) || 0) + 1)
+          if (matchesInterest(rawVal, op === 'contains' ? 'contains' : op, expected)) match++
+        }
+
+        if (occType === 'at_least') {
+          return match > 0 && match / total >= threshold
+        }
+
+        let maxOther = 0
+        counts.forEach((cnt, valStr) => {
+          if (!matchesInterest(valStr, op, expected)) {
+            if (cnt > maxOther) maxOther = cnt
+          }
+        })
+
+        return match > 0 && match >= maxOther
+      }
+
       // Frequência / agregação (para 1 contato)
-      const rows = data || []
       if (rule.frequency && rule.frequency.value != null) {
-        const { op, value, type = 'count', field = 'value' } = rule.frequency
+        const { op, value, value2, type = 'count', field = 'value' } = rule.frequency
         let aggregatedValue = 0
+        let denom = 0
         if (type === 'count') {
           aggregatedValue = rows.length
         } else {
           for (const row of rows) {
             const eventData = row.event_data || {}
-            let numVal = 0
-            if (eventData[field] !== undefined) numVal = Number(eventData[field])
-            else if (eventData['value'] !== undefined) numVal = Number(eventData['value'])
-            else if (eventData['amount'] !== undefined) numVal = Number(eventData['amount'])
-            if (!Number.isNaN(numVal)) aggregatedValue += numVal
+            const raw =
+              getEventPropertyValue(eventData, field) ??
+              (eventData?.[field] !== undefined ? eventData[field] : undefined) ??
+              eventData?.value ??
+              eventData?.amount
+            const numVal = Number(raw)
+            if (Number.isFinite(numVal)) {
+              aggregatedValue += numVal
+              denom += 1
+            }
           }
-          if (type === 'avg') aggregatedValue = rows.length > 0 ? aggregatedValue / rows.length : 0
+          if (type === 'avg') aggregatedValue = denom > 0 ? aggregatedValue / denom : 0
+        }
+
+        if (op === 'between') {
+          const a = Number(value)
+          const b = Number(value2)
+          if (!Number.isFinite(a) || !Number.isFinite(b)) return false
+          // Compatível com CleverTap: se o usuário inverter (min > max), não deve casar.
+          if (a > b) return false
+          return aggregatedValue >= a && aggregatedValue <= b
         }
 
         return (