@reachy/audience-module 1.0.19 → 1.0.21

package/src/__tests__/AudienceModule.test.ts

@@ -0,0 +1,382 @@
+import { AudienceModule } from '../AudienceModule'
+import { AudienceCriteria } from '../types'
+
+function mockContactRepository(contactIds: Set<string> = new Set(['c1', 'c2'])) {
+  return {
+    getContactIdsByAudienceCriteriaV2: jest.fn().mockResolvedValue(contactIds),
+    matchesContactByAudienceCriteriaV2: jest.fn().mockImplementation(
+      (_org: string, _proj: string, _criteria: any, contactId: string) =>
+        Promise.resolve(contactIds.has(contactId))
+    ),
+    findByIds: jest.fn().mockResolvedValue({
+      data: Array.from(contactIds).map(id => ({ id, email: `${id}@test.com` })),
+      error: null,
+    }),
+  }
+}
+
+function mockAudienceRepository() {
+  return {
+    create: jest.fn().mockResolvedValue({ data: { id: 'aud-1', name: 'Test', count: 0 }, error: null }),
+    update: jest.fn().mockResolvedValue({ data: { id: 'aud-1', name: 'Updated' }, error: null }),
+    updateCount: jest.fn().mockResolvedValue(undefined),
+    findById: jest.fn().mockResolvedValue({ data: { id: 'aud-1' }, error: null }),
+    delete: jest.fn().mockResolvedValue({ data: null, error: null }),
+  }
+}
+
+function mockMemberRepository() {
+  return {
+    bulkUpsert: jest.fn().mockResolvedValue({ data: [], error: null }),
+    listMembers: jest.fn().mockResolvedValue({ data: [{ id: 'c1' }], count: 1 }),
+  }
+}
+
+const validCriteria: AudienceCriteria = {
+  groups: [{ operator: 'AND', rules: [{ kind: 'property', field: 'email', op: 'contains', value: '@' }] }]
+}
+
+describe('AudienceModule', () => {
+  describe('constructor', () => {
+    it('creates instance without config', () => {
+      const mod = new AudienceModule()
+      expect(mod).toBeInstanceOf(AudienceModule)
+    })
+
+    it('creates instance with supabaseClient and sets up internal repo', () => {
+      // Just verifying no throw — actual Supabase calls are mocked in integration tests
+      expect(() => new AudienceModule({ supabaseClient: {} })).not.toThrow()
+    })
+  })
+
+  describe('setRepositories', () => {
+    it('accepts contactRepository', () => {
+      const mod = new AudienceModule()
+      const repo = mockContactRepository()
+      mod.setRepositories({ contactRepository: repo })
+      // No error = success
+    })
+
+    it('accepts all repositories', () => {
+      const mod = new AudienceModule()
+      mod.setRepositories({
+        contactRepository: mockContactRepository(),
+        audienceRepository: mockAudienceRepository(),
+        memberRepository: mockMemberRepository(),
+      })
+    })
+  })
+
+  describe('executeQuery', () => {
+    it('executes static query and returns contactIds', async () => {
+      const mod = new AudienceModule()
+      const repo = mockContactRepository(new Set(['c1', 'c2', 'c3']))
+      mod.setRepositories({ contactRepository: repo })
+
+      const result = await mod.executeQuery(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(result.contactIds.size).toBe(3)
+      expect(result.count).toBe(3)
+      expect(result.metadata?.criteriaType).toBe('static')
+    })
+
+    it('parses JSON string criteria', async () => {
+      const mod = new AudienceModule()
+      const repo = mockContactRepository()
+      mod.setRepositories({ contactRepository: repo })
+
+      const result = await mod.executeQuery(JSON.stringify(validCriteria), {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(result.contactIds.size).toBe(2)
+    })
+
+    it('executes live query using memberRepository', async () => {
+      const mod = new AudienceModule()
+      const memberRepo = mockMemberRepository()
+      mod.setRepositories({ memberRepository: memberRepo })
+
+      const liveCriteria: AudienceCriteria = {
+        type: 'live-actions',
+        groups: [{ rules: [{ kind: 'event', eventName: 'click' }] }]
+      }
+
+      const result = await mod.executeQuery(liveCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(result.metadata?.criteriaType).toBe('live')
+      expect(memberRepo.listMembers).toHaveBeenCalled()
+    })
+
+    it('throws when memberRepository is not set for live query', async () => {
+      const mod = new AudienceModule()
+      const liveCriteria: AudienceCriteria = { type: 'live-page-visit', groups: [] }
+
+      await expect(mod.executeQuery(liveCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })).rejects.toThrow('MemberRepository não configurado')
+    })
+  })
+
+  describe('getContactCount', () => {
+    it('returns count of matching contacts', async () => {
+      const mod = new AudienceModule()
+      mod.setRepositories({ contactRepository: mockContactRepository(new Set(['c1', 'c2'])) })
+
+      const count = await mod.getContactCount(validCriteria, {
+        organizationId: 'org-1',
+        projectId: 'proj-1',
+      })
+
+      expect(count).toBe(2)
+    })
+  })
+
+  describe('getContactIds', () => {
+    it('returns Set of contact IDs', async () => {
+      const mod = new AudienceModule()
+      const repo = mockContactRepository(new Set(['c1', 'c2']))
+      mod.setRepositories({ contactRepository: repo })
+
+      const ids = await mod.getContactIds(validCriteria, 'org-1', 'proj-1')
+      expect(ids).toBeInstanceOf(Set)
+      expect(ids.size).toBe(2)
+      expect(repo.getContactIdsByAudienceCriteriaV2).toHaveBeenCalledWith('org-1', 'proj-1', expect.any(Object))
+    })
+
+    it('throws when contactRepository not configured', async () => {
+      const mod = new AudienceModule()
+      await expect(mod.getContactIds(validCriteria, 'org-1', 'proj-1'))
+        .rejects.toThrow('ContactRepository não configurado')
+    })
+  })
+
+  describe('matchesContact', () => {
+    it('returns true for matching contact', async () => {
+      const mod = new AudienceModule()
+      mod.setRepositories({ contactRepository: mockContactRepository(new Set(['c1', 'c2'])) })
+
+      const result = await mod.matchesContact(validCriteria, 'org-1', 'proj-1', 'c1')
+      expect(result).toBe(true)
+    })
+
+    it('returns false for non-matching contact', async () => {
+      const mod = new AudienceModule()
+      mod.setRepositories({ contactRepository: mockContactRepository(new Set(['c1'])) })
+
+      const result = await mod.matchesContact(validCriteria, 'org-1', 'proj-1', 'c99')
+      expect(result).toBe(false)
+    })
+
+    it('falls back to getContactIds when matchesContactByAudienceCriteriaV2 is missing', async () => {
+      const mod = new AudienceModule()
+      const repo = {
+        getContactIdsByAudienceCriteriaV2: jest.fn().mockResolvedValue(new Set(['c1'])),
+        findByIds: jest.fn(),
+      }
+      mod.setRepositories({ contactRepository: repo })
+
+      const result = await mod.matchesContact(validCriteria, 'org-1', 'proj-1', 'c1')
+      expect(result).toBe(true)
+      expect(repo.getContactIdsByAudienceCriteriaV2).toHaveBeenCalled()
+    })
+
+    it('throws when contactRepository not configured', async () => {
+      const mod = new AudienceModule()
+      await expect(mod.matchesContact(validCriteria, 'org-1', 'proj-1', 'c1'))
+        .rejects.toThrow('ContactRepository não configurado')
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('createAudience validates and creates', async () => {
+      const mod = new AudienceModule()
+      const audienceRepo = mockAudienceRepository()
+      const contactRepo = mockContactRepository()
+      mod.setRepositories({ contactRepository: contactRepo, audienceRepository: audienceRepo })
+
+      const result = await mod.createAudience({
+        name: 'Test Audience',
+        criteria: validCriteria,
+        organization_id: 'org-1',
+        project_id: 'proj-1',
+        user_id: 'user-1',
+      })
+
+      expect(result.data).toBeDefined()
+      expect(audienceRepo.create).toHaveBeenCalled()
+      expect(audienceRepo.updateCount).toHaveBeenCalled()
+    })
+
+    it('createAudience throws on invalid criteria', async () => {
+      const mod = new AudienceModule()
+      mod.setRepositories({ audienceRepository: mockAudienceRepository() })
+
+      await expect(mod.createAudience({
+        name: 'Bad',
+        criteria: {} as AudienceCriteria,
+        organization_id: 'org-1',
+        project_id: 'proj-1',
+        user_id: 'user-1',
+      })).rejects.toThrow('Critérios inválidos')
+    })
+
+    it('createAudience throws when audienceRepository not set', async () => {
+      const mod = new AudienceModule()
+      await expect(mod.createAudience({
+        name: 'Test',
+        criteria: validCriteria,
+        organization_id: 'org-1',
+        project_id: 'proj-1',
+        user_id: 'user-1',
+      })).rejects.toThrow('AudienceRepository não configurado')
+    })
+
+    it('updateAudience updates and recounts', async () => {
+      const mod = new AudienceModule()
+      const audienceRepo = mockAudienceRepository()
+      const contactRepo = mockContactRepository()
+      mod.setRepositories({ contactRepository: contactRepo, audienceRepository: audienceRepo })
+
+      const result = await mod.updateAudience('aud-1', { criteria: validCriteria }, 'org-1', 'proj-1')
+      expect(result.data).toBeDefined()
+      expect(audienceRepo.update).toHaveBeenCalled()
+      expect(audienceRepo.updateCount).toHaveBeenCalled()
+    })
+
+    it('getAudienceById delegates to repository', async () => {
+      const mod = new AudienceModule()
+      const audienceRepo = mockAudienceRepository()
+      mod.setRepositories({ audienceRepository: audienceRepo })
+
+      await mod.getAudienceById('aud-1', 'org-1', 'proj-1')
+      expect(audienceRepo.findById).toHaveBeenCalledWith('aud-1', 'org-1', 'proj-1')
+    })
+
+    it('deleteAudience delegates to repository', async () => {
+      const mod = new AudienceModule()
+      const audienceRepo = mockAudienceRepository()
+      mod.setRepositories({ audienceRepository: audienceRepo })
+
+      await mod.deleteAudience('aud-1')
+      expect(audienceRepo.delete).toHaveBeenCalledWith('aud-1')
+    })
+  })
+
+  describe('hasEventRule', () => {
+    it('returns true when event rule matches', () => {
+      const mod = new AudienceModule()
+      const criteria = {
+        groups: [{ rules: [{ kind: 'event', eventName: 'purchase' }] }]
+      }
+      expect(mod.hasEventRule(criteria, 'purchase')).toBe(true)
+    })
+
+    it('returns false when event name does not match', () => {
+      const mod = new AudienceModule()
+      const criteria = {
+        groups: [{ rules: [{ kind: 'event', eventName: 'click' }] }]
+      }
+      expect(mod.hasEventRule(criteria, 'purchase')).toBe(false)
+    })
+
+    it('returns false when no event rules exist', () => {
+      const mod = new AudienceModule()
+      const criteria = {
+        groups: [{ rules: [{ kind: 'property', field: 'email', op: 'equals', value: 'x' }] }]
+      }
+      expect(mod.hasEventRule(criteria, 'purchase')).toBe(false)
+    })
+
+    it('handles JSON string input', () => {
+      const mod = new AudienceModule()
+      const criteria = JSON.stringify({
+        groups: [{ rules: [{ kind: 'event', eventName: 'signup' }] }]
+      })
+      expect(mod.hasEventRule(criteria, 'signup')).toBe(true)
+    })
+
+    it('returns false for invalid JSON', () => {
+      const mod = new AudienceModule()
+      expect(mod.hasEventRule('invalid-json', 'signup')).toBe(false)
+    })
+
+    it('returns false for empty criteria', () => {
+      const mod = new AudienceModule()
+      expect(mod.hasEventRule({}, 'signup')).toBe(false)
+    })
+  })
+
+  describe('members management', () => {
+    it('addMembers delegates to memberRepository', async () => {
+      const mod = new AudienceModule()
+      const memberRepo = mockMemberRepository()
+      mod.setRepositories({ memberRepository: memberRepo })
+
+      await mod.addMembers('aud-1', ['c1', 'c2'], 'org-1', 'proj-1', 'realtime')
+      expect(memberRepo.bulkUpsert).toHaveBeenCalledWith('aud-1', 'org-1', 'proj-1', ['c1', 'c2'], 'realtime')
+    })
+
+    it('addMembers defaults origin to "backfill"', async () => {
+      const mod = new AudienceModule()
+      const memberRepo = mockMemberRepository()
+      mod.setRepositories({ memberRepository: memberRepo })
+
+      await mod.addMembers('aud-1', ['c1'], 'org-1', 'proj-1')
+      expect(memberRepo.bulkUpsert).toHaveBeenCalledWith('aud-1', 'org-1', 'proj-1', ['c1'], 'backfill')
+    })
+
+    it('addMembers throws when memberRepository not set', async () => {
+      const mod = new AudienceModule()
+      await expect(mod.addMembers('aud-1', ['c1'], 'org-1', 'proj-1'))
+        .rejects.toThrow('MemberRepository não configurado')
+    })
+
+    it('getMembers delegates to memberRepository', async () => {
+      const mod = new AudienceModule()
+      const memberRepo = mockMemberRepository()
+      mod.setRepositories({ memberRepository: memberRepo })
+
+      await mod.getMembers('aud-1', 'org-1', 'proj-1', { page: 1, limit: 10 })
+      expect(memberRepo.listMembers).toHaveBeenCalledWith('aud-1', 'org-1', 'proj-1', { page: 1, limit: 10 })
+    })
+  })
+
+  describe('utilities', () => {
+    it('validateCriteria returns valid for good criteria', () => {
+      const mod = new AudienceModule()
+      const result = mod.validateCriteria(validCriteria)
+      expect(result.valid).toBe(true)
+    })
+
+    it('validateCriteria returns invalid for empty criteria', () => {
+      const mod = new AudienceModule()
+      const result = mod.validateCriteria({ type: 'static' })
+      expect(result.valid).toBe(false)
+    })
+
+    it('validateCriteria parses JSON string', () => {
+      const mod = new AudienceModule()
+      const result = mod.validateCriteria(JSON.stringify(validCriteria))
+      expect(result.valid).toBe(true)
+    })
+
+    it('getAudienceType returns "static" for property criteria', () => {
+      const mod = new AudienceModule()
+      expect(mod.getAudienceType(validCriteria)).toBe('static')
+    })
+
+    it('getAudienceType returns "live" for live criteria', () => {
+      const mod = new AudienceModule()
+      expect(mod.getAudienceType({ type: 'live-actions', groups: [] })).toBe('live')
+    })
+  })
+})

package/src/__tests__/CriteriaParser.test.ts

@@ -0,0 +1,130 @@
+import { CriteriaParser } from '../builders/CriteriaParser'
+import { AudienceCriteria } from '../types'
+
+describe('CriteriaParser', () => {
+  describe('parse', () => {
+    it('parses a valid JSON string into criteria object', () => {
+      const json = JSON.stringify({ groups: [{ rules: [{ field: 'email', op: 'equals', value: 'a@b.com' }] }] })
+      const result = CriteriaParser.parse(json)
+      expect(result.groups).toBeDefined()
+      expect(result.groups![0].rules![0].value).toBe('a@b.com')
+    })
+
+    it('throws on invalid JSON string', () => {
+      expect(() => CriteriaParser.parse('not-json')).toThrow('Critérios inválidos')
+    })
+
+    it('passes through an object unchanged if it has groups', () => {
+      const criteria: AudienceCriteria = {
+        groups: [{ operator: 'AND', rules: [{ kind: 'property', field: 'email', op: 'equals', value: 'x' }] }]
+      }
+      const result = CriteriaParser.parse(criteria)
+      expect(result).toEqual(criteria)
+    })
+
+    it('normalizes filters format into conditions', () => {
+      const criteria: AudienceCriteria = {
+        filters: [
+          {
+            id: 'f1',
+            operator: 'AND',
+            conditions: [
+              { id: 'c1', field: 'email', operator: 'equals', value: 'test@x.com', logicalOperator: 'AND' }
+            ]
+          }
+        ]
+      }
+      const result = CriteriaParser.parse(criteria)
+      expect(result.conditions).toBeDefined()
+      expect(result.conditions!.length).toBe(1)
+      expect(result.conditions![0].groupId).toBe('f1')
+      expect(result.conditions![0].operator).toBe('AND')
+      expect(result.conditions![0].conditions![0].field).toBe('email')
+    })
+
+    it('normalizes filter conditions with customFieldKey', () => {
+      const criteria: AudienceCriteria = {
+        filters: [{
+          id: 'f1',
+          operator: 'OR',
+          conditions: [{
+            id: 'c1',
+            field: 'custom_field',
+            operator: 'contains',
+            value: 'vip',
+            logicalOperator: 'OR',
+            customFieldKey: 'plan_type'
+          }]
+        }]
+      }
+      const result = CriteriaParser.parse(criteria)
+      expect(result.conditions![0].conditions![0].customFieldKey).toBe('plan_type')
+    })
+
+    it('passes through conditions format unchanged', () => {
+      const criteria: AudienceCriteria = {
+        conditions: [{ groupId: 'g1', operator: 'AND', conditions: [{ field: 'name', operator: 'equals', value: 'John' }] }]
+      }
+      const result = CriteriaParser.parse(criteria)
+      expect(result.conditions).toEqual(criteria.conditions)
+    })
+  })
+
+  describe('getAudienceType', () => {
+    it('returns "static" for criteria without type', () => {
+      expect(CriteriaParser.getAudienceType({})).toBe('static')
+    })
+
+    it('returns "static" for unknown type', () => {
+      expect(CriteriaParser.getAudienceType({ type: 'past-behavior' })).toBe('static')
+    })
+
+    it.each([
+      'live-actions',
+      'live-page-visit',
+      'live-referrer',
+      'live-page-count',
+    ])('returns "live" for type "%s"', (type) => {
+      expect(CriteriaParser.getAudienceType({ type })).toBe('live')
+    })
+  })
+
+  describe('validate', () => {
+    it('returns valid for criteria with groups', () => {
+      const result = CriteriaParser.validate({ groups: [] })
+      expect(result.valid).toBe(true)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('returns valid for criteria with filters', () => {
+      const result = CriteriaParser.validate({
+        filters: [{ id: '1', operator: 'AND', conditions: [] }]
+      } as AudienceCriteria)
+      expect(result.valid).toBe(true)
+    })
+
+    it('returns valid for criteria with conditions', () => {
+      const result = CriteriaParser.validate({
+        conditions: [{ groupId: 'g1', operator: 'AND', conditions: [] }]
+      })
+      expect(result.valid).toBe(true)
+    })
+
+    it('returns invalid when no conditions, filters, or groups exist', () => {
+      const result = CriteriaParser.validate({ type: 'static' })
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Critérios devem conter conditions, filters ou groups')
+    })
+
+    it('returns invalid for null-ish input', () => {
+      const result = CriteriaParser.validate(null as any)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Critérios devem ser um objeto')
+    })
+
+    it('returns invalid for non-object input', () => {
+      const result = CriteriaParser.validate('string' as any)
+      expect(result.valid).toBe(false)
+    })
+  })
+})