@reachy/audience-module 1.0.19 → 1.0.21

package/src/__tests__/StaticAudienceExecutor.test.ts

@@ -0,0 +1,134 @@
+import { StaticAudienceExecutor } from '../executors/StaticAudienceExecutor'
+import { AudienceCriteria } from '../types'
+
+const validCriteria: AudienceCriteria = {
+  groups: [{ operator: 'AND', rules: [{ kind: 'property', field: 'email', op: 'contains', value: '@' }] }]
+}
+
+function mockRepo(ids: string[] = ['c1', 'c2', 'c3']) {
+  return {
+    getContactIdsByAudienceCriteriaV2: jest.fn().mockResolvedValue(new Set(ids)),
+    findByIds: jest.fn().mockResolvedValue({
+      data: ids.map(id => ({ id, email: `${id}@test.com` })),
+      error: null,
+    }),
+  }
+}
+
+describe('StaticAudienceExecutor', () => {
+  describe('execute', () => {
+    it('returns contactIds and count', async () => {
+      const executor = new StaticAudienceExecutor(mockRepo())
+      const result = await executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(result.contactIds).toBeInstanceOf(Set)
+      expect(result.contactIds.size).toBe(3)
+      expect(result.count).toBe(3)
+      expect(result.metadata?.criteriaType).toBe('static')
+      expect(result.metadata?.executionTime).toBeGreaterThanOrEqual(0)
+    })
+
+    it('fetches contact details when pagination is set', async () => {
+      const repo = mockRepo(['c1', 'c2', 'c3', 'c4', 'c5'])
+      const executor = new StaticAudienceExecutor(repo)
+
+      await executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+        pagination: { page: 1, limit: 2 },
+      })
+
+      expect(repo.findByIds).toHaveBeenCalled()
+      // Should request only first 2 ids
+      const calledIds = repo.findByIds.mock.calls[0][2]
+      expect(calledIds).toHaveLength(2)
+    })
+
+    it('fetches contact details when includeCount is true', async () => {
+      const repo = mockRepo()
+      const executor = new StaticAudienceExecutor(repo)
+
+      const result = await executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+        includeCount: true,
+      })
+
+      expect(repo.findByIds).toHaveBeenCalled()
+      expect(result.contacts).toBeDefined()
+    })
+
+    it('does not fetch contact details without pagination or includeCount', async () => {
+      const repo = mockRepo()
+      const executor = new StaticAudienceExecutor(repo)
+
+      const result = await executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(repo.findByIds).not.toHaveBeenCalled()
+      expect(result.contacts).toBeUndefined()
+    })
+
+    it('returns empty result for invalid criteria', async () => {
+      const executor = new StaticAudienceExecutor(mockRepo())
+      const result = await executor.execute({ type: 'static' }, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(result.contactIds.size).toBe(0)
+      expect(result.count).toBe(0)
+    })
+
+    it('throws when contactRepository not set', async () => {
+      const executor = new StaticAudienceExecutor()
+      await expect(executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })).rejects.toThrow('ContactRepository não foi configurado')
+    })
+
+    it('paginates correctly for page 2', async () => {
+      const repo = mockRepo(['c1', 'c2', 'c3', 'c4', 'c5'])
+      const executor = new StaticAudienceExecutor(repo)
+
+      await executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+        pagination: { page: 2, limit: 2 },
+      })
+
+      const calledIds = repo.findByIds.mock.calls[0][2]
+      expect(calledIds).toEqual(['c3', 'c4'])
+    })
+  })
+
+  describe('executeCount', () => {
+    it('returns count only', async () => {
+      const executor = new StaticAudienceExecutor(mockRepo(['c1', 'c2']))
+      const count = await executor.executeCount(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+      expect(count).toBe(2)
+    })
+  })
+
+  describe('setContactRepository', () => {
+    it('allows setting repository after construction', async () => {
+      const executor = new StaticAudienceExecutor()
+      executor.setContactRepository(mockRepo())
+
+      const result = await executor.execute(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+      expect(result.count).toBe(3)
+    })
+  })
+})

package/src/__tests__/SupabaseContactRepository.test.ts

@@ -0,0 +1,81 @@
+import { SupabaseContactRepository } from '../repositories/SupabaseContactRepository'
+
+// Mock V2AudienceEngine since it requires real Supabase
+jest.mock('../engine/V2AudienceEngine', () => ({
+  V2AudienceEngine: jest.fn().mockImplementation(() => ({
+    getContactIdsByAudienceCriteriaV2: jest.fn().mockResolvedValue(new Set(['c1', 'c2'])),
+    matchesContactByAudienceCriteriaV2: jest.fn().mockResolvedValue(true),
+  })),
+}))
+
+function mockSupabase() {
+  const chainable = {
+    select: jest.fn().mockReturnThis(),
+    eq: jest.fn().mockReturnThis(),
+    in: jest.fn().mockResolvedValue({
+      data: [{ id: 'c1', email: 'a@b.com' }, { id: 'c2', email: 'c@d.com' }],
+      error: null,
+    }),
+  }
+  return {
+    from: jest.fn().mockReturnValue(chainable),
+    _chainable: chainable,
+  }
+}
+
+describe('SupabaseContactRepository', () => {
+  it('creates instance with supabase and clickhouse clients', () => {
+    const repo = new SupabaseContactRepository({
+      supabaseClient: mockSupabase(),
+      clickhouseClient: {},
+      debug: false,
+    })
+    expect(repo).toBeDefined()
+  })
+
+  describe('getContactIdsByAudienceCriteriaV2', () => {
+    it('delegates to V2AudienceEngine', async () => {
+      const repo = new SupabaseContactRepository({ supabaseClient: mockSupabase() })
+      const result = await repo.getContactIdsByAudienceCriteriaV2('org-1', 'proj-1', { groups: [] })
+
+      expect(result).toBeInstanceOf(Set)
+      expect(result.size).toBe(2)
+    })
+  })
+
+  describe('matchesContactByAudienceCriteriaV2', () => {
+    it('delegates to V2AudienceEngine', async () => {
+      const repo = new SupabaseContactRepository({ supabaseClient: mockSupabase() })
+      const result = await repo.matchesContactByAudienceCriteriaV2('org-1', 'proj-1', { groups: [] }, 'c1')
+
+      expect(result).toBe(true)
+    })
+  })
+
+  describe('findByIds', () => {
+    it('queries Supabase for contacts by IDs', async () => {
+      const supabase = mockSupabase()
+      const repo = new SupabaseContactRepository({ supabaseClient: supabase })
+
+      const { data } = await repo.findByIds('org-1', 'proj-1', ['c1', 'c2'])
+
+      expect(supabase.from).toHaveBeenCalledWith('contacts')
+      expect(supabase._chainable.select).toHaveBeenCalledWith('*')
+      expect(supabase._chainable.eq).toHaveBeenCalledWith('organization_id', 'org-1')
+      expect(supabase._chainable.eq).toHaveBeenCalledWith('project_id', 'proj-1')
+      expect(supabase._chainable.in).toHaveBeenCalledWith('id', ['c1', 'c2'])
+      expect(data).toHaveLength(2)
+    })
+
+    it('throws when Supabase returns an error', async () => {
+      const supabase = mockSupabase()
+      supabase._chainable.in = jest.fn().mockResolvedValue({
+        data: null,
+        error: new Error('DB error'),
+      })
+      const repo = new SupabaseContactRepository({ supabaseClient: supabase })
+
+      await expect(repo.findByIds('org-1', 'proj-1', ['c1'])).rejects.toThrow('DB error')
+    })
+  })
+})

package/src/builders/QueryBuilder.ts

@@ -131,6 +131,10 @@ export class QueryBuilder {
 
     const dbField = this.mapFieldToColumn(field, condition.customFieldKey)
 
+    if (dbField === 'tags') {
+      return this.applyTagCondition(query, operator, value)
+    }
+
     switch (operator) {
       case 'equals':
       case 'eq':
@@ -163,6 +167,39 @@ export class QueryBuilder {
     }
   }
 
+  private static applyTagCondition(query: any, operator: string, value: any): any {
+    const op = String(operator || '').trim().toLowerCase()
+    const values = QueryBuilder.normalizeTagValues(value)
+
+    if (op === 'has_all' || op === 'equals' || op === 'eq' || op === '=') {
+      if (values.length === 0) return query.eq('id', '__never__')
+      return query.contains('tags', values)
+    }
+    if (op === 'has_any' || op === 'contains' || op === 'in') {
+      if (values.length === 0) return query.eq('id', '__never__')
+      return query.overlaps('tags', values)
+    }
+    if (op === 'is_empty') {
+      return query.or('tags.is.null,tags.eq.{}')
+    }
+    if (op === 'is_not_empty') {
+      return query.not('tags', 'is', null).neq('tags', '{}')
+    }
+    console.warn(`⚠️ Operador de tag desconhecido: ${operator}`)
+    return query.eq('id', '__never__')
+  }
+
+  private static normalizeTagValues(value: any): string[] {
+    if (value === null || value === undefined) return []
+    const raw = Array.isArray(value) ? value : String(value).split(',')
+    const out: string[] = []
+    for (const item of raw) {
+      const v = String(item ?? '').trim()
+      if (v.length > 0) out.push(v)
+    }
+    return out
+  }
+
   /**
    * Constrói string de condição para uso em .or()
    */
@@ -173,6 +210,10 @@ export class QueryBuilder {
 
     const dbField = this.mapFieldToColumn(field, condition.customFieldKey)
 
+    if (dbField === 'tags') {
+      return QueryBuilder.buildTagConditionString(operator, value)
+    }
+
     switch (operator) {
       case 'equals':
       case 'eq':
@@ -204,6 +245,24 @@ export class QueryBuilder {
     }
   }
 
+  private static buildTagConditionString(operator: string, value: any): string | null {
+    const op = String(operator || '').trim().toLowerCase()
+    const values = QueryBuilder.normalizeTagValues(value)
+    const arrLiteral = `{${values.map((v) => v.includes(',') ? `"${v.replace(/"/g, '\\"')}"` : v).join(',')}}`
+
+    if (op === 'has_all' || op === 'equals' || op === 'eq' || op === '=') {
+      if (values.length === 0) return null
+      return `tags.cs.${arrLiteral}`
+    }
+    if (op === 'has_any' || op === 'contains' || op === 'in') {
+      if (values.length === 0) return null
+      return `tags.ov.${arrLiteral}`
+    }
+    if (op === 'is_empty') return `tags.is.null`
+    if (op === 'is_not_empty') return `tags.not.is.null`
+    return null
+  }
+
   /**
    * Mapeia campo da audiência para coluna do banco
    */

package/src/engine/V2AudienceEngine.ts

@@ -163,6 +163,31 @@ const normalizePropertyOp = (opRaw: any): string => {
   return op
 }
 
+const normalizeTagValues = (value: any): string[] => {
+  if (value === null || value === undefined) return []
+  const raw = Array.isArray(value) ? value : String(value).split(',')
+  const out: string[] = []
+  for (const item of raw) {
+    const v = String(item ?? '').trim()
+    if (v.length > 0) out.push(v)
+  }
+  return out
+}
+
+const normalizeTagOp = (opRaw: any): string => {
+  const op = String(opRaw ?? '').trim().toLowerCase()
+  // UI principal: espelha os operadores dos campos texto.
+  if (op === 'equals' || op === 'eq' || op === '=' || op === 'has_all' || op === 'has') return 'equals'
+  if (op === 'not_equals' || op === 'neq' || op === '!=' || op === '<>') return 'not_equals'
+  if (op === 'contains') return 'contains'
+  if (op === 'not_contains') return 'not_contains'
+  // Array-specific (forward-compat / API direta)
+  if (op === 'has_any' || op === 'in') return 'has_any'
+  if (op === 'is_empty') return 'is_empty'
+  if (op === 'is_not_empty') return 'is_not_empty'
+  return op
+}
+
 const isNumericLike = (value: any): boolean => {
   if (typeof value === 'number') return Number.isFinite(value)
   if (typeof value !== 'string') return false
@@ -1034,6 +1059,63 @@ export class V2AudienceEngine {
       }
 
       const mappedField = mapAudienceFieldToContactField(field)
+
+      if (field === 'tags' || mappedField === 'tags') {
+        const tagOp = normalizeTagOp(opRaw)
+
+        if (tagOp === 'contains' || tagOp === 'not_contains') {
+          const expected = String(value ?? '').trim().toLowerCase()
+          if (!expected) return new Set<string>()
+          const fetchQuery = this.supabase
+            .from('contacts')
+            .select('id, tags')
+            .eq('organization_id', organizationId)
+            .eq('project_id', projectId)
+          const data = await fetchAll(fetchQuery, 1000)
+          if (!data || data.length === 0) return new Set<string>()
+          const result = new Set<string>()
+          for (const row of data as any[]) {
+            const id = row?.id as string | undefined
+            if (!id) continue
+            const tags = Array.isArray(row.tags) ? row.tags : []
+            const hasMatch = tags.some((t: any) => String(t ?? '').toLowerCase().includes(expected))
+            if (tagOp === 'contains' && hasMatch) result.add(id)
+            else if (tagOp === 'not_contains' && !hasMatch) result.add(id)
+          }
+          return result
+        }
+
+        const tagValues = normalizeTagValues(value)
+        let tagQuery = this.supabase
+          .from('contacts')
+          .select('id')
+          .eq('organization_id', organizationId)
+          .eq('project_id', projectId)
+
+        if (tagOp === 'equals') {
+          if (tagValues.length === 0) return new Set<string>()
+          tagQuery = tagQuery.contains('tags', tagValues)
+        } else if (tagOp === 'not_equals') {
+          if (tagValues.length === 0) return new Set<string>()
+          const arrLiteral = `{${tagValues.join(',')}}`
+          tagQuery = tagQuery.or(`tags.is.null,tags.not.cs.${arrLiteral}`)
+        } else if (tagOp === 'has_any') {
+          if (tagValues.length === 0) return new Set<string>()
+          tagQuery = tagQuery.overlaps('tags', tagValues)
+        } else if (tagOp === 'is_empty') {
+          tagQuery = tagQuery.or('tags.is.null,tags.eq.{}')
+        } else if (tagOp === 'is_not_empty') {
+          tagQuery = tagQuery.not('tags', 'is', null).neq('tags', '{}')
+        } else {
+          this.dlog('tags rule with unsupported op, returning empty', { opRaw, tagOp })
+          return new Set<string>()
+        }
+
+        const tagData = await fetchAll(tagQuery, 1000)
+        if (!tagData || tagData.length === 0) return new Set<string>()
+        return new Set<string>(tagData.map((r: any) => r.id as string))
+      }
+
       const known = ['email', 'first_name', 'last_name', 'phone', 'is_subscribed', 'created_at', 'updated_at', 'name']
       const isJsonb = !(known.includes(field) || known.includes(mappedField))
       const dbField = isJsonb ? `properties->>${field}` : mappedField
@@ -1816,6 +1898,59 @@ export class V2AudienceEngine {
       }
 
       const mappedField = mapAudienceFieldToContactField(field)
+
+      // Coluna `tags` é text[] — desvia para operadores de array antes do path scalar/JSONB.
+      if (field === 'tags' || mappedField === 'tags') {
+        const tagOp = normalizeTagOp(opRaw)
+
+        // contains/not_contains: substring — fetch + filtro em memória.
+        if (tagOp === 'contains' || tagOp === 'not_contains') {
+          const expected = String(value ?? '').trim().toLowerCase()
+          if (!expected) return false
+          const { data: tagsRow, error: tagsErr } = await this.supabase
+            .from('contacts')
+            .select('tags')
+            .eq('organization_id', organizationId)
+            .eq('project_id', projectId)
+            .eq('id', contactId)
+            .maybeSingle()
+          if (tagsErr) return false
+          const tags = Array.isArray((tagsRow as any)?.tags) ? (tagsRow as any).tags : []
+          const hasMatch = tags.some((t: any) => String(t ?? '').toLowerCase().includes(expected))
+          return tagOp === 'contains' ? hasMatch : !hasMatch
+        }
+
+        const tagValues = normalizeTagValues(value)
+        let tagQuery = this.supabase
+          .from('contacts')
+          .select('id')
+          .eq('organization_id', organizationId)
+          .eq('project_id', projectId)
+          .eq('id', contactId)
+
+        if (tagOp === 'equals') {
+          if (tagValues.length === 0) return false
+          tagQuery = tagQuery.contains('tags', tagValues)
+        } else if (tagOp === 'not_equals') {
+          if (tagValues.length === 0) return false
+          const arrLiteral = `{${tagValues.join(',')}}`
+          tagQuery = tagQuery.or(`tags.is.null,tags.not.cs.${arrLiteral}`)
+        } else if (tagOp === 'has_any') {
+          if (tagValues.length === 0) return false
+          tagQuery = tagQuery.overlaps('tags', tagValues)
+        } else if (tagOp === 'is_empty') {
+          tagQuery = tagQuery.or('tags.is.null,tags.eq.{}')
+        } else if (tagOp === 'is_not_empty') {
+          tagQuery = tagQuery.not('tags', 'is', null).neq('tags', '{}')
+        } else {
+          return false
+        }
+
+        const { data: tagData, error: tagErr } = await tagQuery
+        if (tagErr) return false
+        return Array.isArray(tagData) && tagData.length > 0
+      }
+
       const known = ['email', 'first_name', 'last_name', 'phone', 'is_subscribed', 'created_at', 'updated_at', 'name']
       const isJsonb = !(known.includes(field) || known.includes(mappedField))
       const dbField = isJsonb ? `properties->>${field}` : mappedField