@startsimpli/funnels 0.4.6 → 0.4.8

package/src/core/evaluator.test.ts

@@ -29,7 +29,7 @@ interface TestEntity {
   score?: number;
   active?: boolean;
   tags?: string[];
-  created_at?: Date | string;
+  createdAt?: Date | string;
   firm?: {
     name?: string;
     stage?: string;
@@ -53,7 +53,7 @@ const sampleEntity: TestEntity = {
   score: 85.5,
   active: true,
   tags: ['qualified', 'active', 'premium'],
-  created_at: new Date('2024-01-15'),
+  createdAt: new Date('2024-01-15'),
   firm: {
     name: 'Acme Ventures',
     stage: 'Series A',
@@ -75,32 +75,32 @@ const sampleEntity: TestEntity = {
 
 describe('Equality Operators', () => {
   it('eq: should match equal values', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'eq', value: 'John Doe' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'eq', value: 'John Doe' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('eq: should not match different values', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'eq', value: 'Jane Doe' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'eq', value: 'Jane Doe' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('eq: should match numbers', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'eq', value: 35 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'eq', value: 35 };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('eq: should match nested fields', () => {
-    const rule: FilterRule = { field_path: 'firm.stage', operator: 'eq', value: 'Series A' };
+    const rule: FilterRule = { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('ne: should match different values', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'ne', value: 'Jane Doe' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'ne', value: 'Jane Doe' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('ne: should not match equal values', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'ne', value: 'John Doe' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'ne', value: 'John Doe' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 });
@@ -111,56 +111,56 @@ describe('Equality Operators', () => {
 
 describe('Comparison Operators', () => {
   it('gt: should match greater values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'gt', value: 30 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'gt', value: 30 };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('gt: should not match equal or lesser values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'gt', value: 35 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'gt', value: 35 };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('lt: should match lesser values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'lt', value: 40 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'lt', value: 40 };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('lt: should not match equal or greater values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'lt', value: 35 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'lt', value: 35 };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('gte: should match greater or equal values', () => {
-    const rule1: FilterRule = { field_path: 'age', operator: 'gte', value: 35 };
-    const rule2: FilterRule = { field_path: 'age', operator: 'gte', value: 30 };
+    const rule1: FilterRule = { fieldPath: 'age', operator: 'gte', value: 35 };
+    const rule2: FilterRule = { fieldPath: 'age', operator: 'gte', value: 30 };
     expect(evaluateRule(sampleEntity, rule1)).toBe(true);
     expect(evaluateRule(sampleEntity, rule2)).toBe(true);
   });
 
   it('gte: should not match lesser values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'gte', value: 40 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'gte', value: 40 };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('lte: should match lesser or equal values', () => {
-    const rule1: FilterRule = { field_path: 'age', operator: 'lte', value: 35 };
-    const rule2: FilterRule = { field_path: 'age', operator: 'lte', value: 40 };
+    const rule1: FilterRule = { fieldPath: 'age', operator: 'lte', value: 35 };
+    const rule2: FilterRule = { fieldPath: 'age', operator: 'lte', value: 40 };
     expect(evaluateRule(sampleEntity, rule1)).toBe(true);
     expect(evaluateRule(sampleEntity, rule2)).toBe(true);
   });
 
   it('lte: should not match greater values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'lte', value: 30 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'lte', value: 30 };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('should compare decimal numbers', () => {
-    const rule: FilterRule = { field_path: 'score', operator: 'gt', value: 85 };
+    const rule: FilterRule = { fieldPath: 'score', operator: 'gt', value: 85 };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('should compare nested numbers', () => {
-    const rule: FilterRule = { field_path: 'firm.aum', operator: 'gte', value: 100000000 };
+    const rule: FilterRule = { fieldPath: 'firm.aum', operator: 'gte', value: 100000000 };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 });
@@ -171,57 +171,57 @@ describe('Comparison Operators', () => {
 
 describe('String Operators', () => {
   it('contains: should match substring (case-insensitive)', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'contains', value: 'john' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'contains', value: 'john' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('contains: should not match non-existent substring', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'contains', value: 'jane' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'contains', value: 'jane' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('contains: should match nested string', () => {
-    const rule: FilterRule = { field_path: 'firm.name', operator: 'contains', value: 'acme' };
+    const rule: FilterRule = { fieldPath: 'firm.name', operator: 'contains', value: 'acme' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('not_contains: should match when substring absent', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'not_contains', value: 'jane' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'not_contains', value: 'jane' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('not_contains: should not match when substring present', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'not_contains', value: 'john' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'not_contains', value: 'john' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('startswith: should match prefix (case-insensitive)', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'startswith', value: 'john' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'startswith', value: 'john' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('startswith: should not match non-prefix', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'startswith', value: 'doe' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'startswith', value: 'doe' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('endswith: should match suffix (case-insensitive)', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'endswith', value: 'doe' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'endswith', value: 'doe' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('endswith: should not match non-suffix', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'endswith', value: 'john' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'endswith', value: 'john' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('matches: should match regex pattern', () => {
-    const rule: FilterRule = { field_path: 'email', operator: 'matches', value: '^[a-z]+@example\\.com$' };
+    const rule: FilterRule = { fieldPath: 'email', operator: 'matches', value: '^[a-z]+@example\\.com$' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('matches: should not match non-matching pattern', () => {
-    const rule: FilterRule = { field_path: 'email', operator: 'matches', value: '^[0-9]+@' };
+    const rule: FilterRule = { fieldPath: 'email', operator: 'matches', value: '^[0-9]+@' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 });
@@ -232,42 +232,42 @@ describe('String Operators', () => {
 
 describe('Array Operators', () => {
   it('in: should match value in array', () => {
-    const rule: FilterRule = { field_path: 'firm.stage', operator: 'in', value: ['Seed', 'Series A', 'Series B'] };
+    const rule: FilterRule = { fieldPath: 'firm.stage', operator: 'in', value: ['Seed', 'Series A', 'Series B'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('in: should not match value not in array', () => {
-    const rule: FilterRule = { field_path: 'firm.stage', operator: 'in', value: ['Seed', 'Series B'] };
+    const rule: FilterRule = { fieldPath: 'firm.stage', operator: 'in', value: ['Seed', 'Series B'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('not_in: should match value not in array', () => {
-    const rule: FilterRule = { field_path: 'firm.stage', operator: 'not_in', value: ['Seed', 'Series B'] };
+    const rule: FilterRule = { fieldPath: 'firm.stage', operator: 'not_in', value: ['Seed', 'Series B'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('not_in: should not match value in array', () => {
-    const rule: FilterRule = { field_path: 'firm.stage', operator: 'not_in', value: ['Series A', 'Series B'] };
+    const rule: FilterRule = { fieldPath: 'firm.stage', operator: 'not_in', value: ['Series A', 'Series B'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('has_any: should match when array has any value', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_any', value: ['qualified', 'inactive'] };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_any', value: ['qualified', 'inactive'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('has_any: should not match when array has no values', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_any', value: ['inactive', 'suspended'] };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_any', value: ['inactive', 'suspended'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('has_all: should match when array has all values', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_all', value: ['qualified', 'active'] };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_all', value: ['qualified', 'active'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('has_all: should not match when array missing some values', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_all', value: ['qualified', 'inactive'] };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_all', value: ['qualified', 'inactive'] };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 });
@@ -286,37 +286,37 @@ describe('Null Operators', () => {
   };
 
   it('isnull: should match null values', () => {
-    const rule: FilterRule = { field_path: 'email', operator: 'isnull', value: null };
+    const rule: FilterRule = { fieldPath: 'email', operator: 'isnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(true);
   });
 
   it('isnull: should match undefined values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'isnull', value: null };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'isnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(true);
   });
 
   it('isnull: should not match defined values', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'isnull', value: null };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'isnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(false);
   });
 
   it('isnull: should match nested null', () => {
-    const rule: FilterRule = { field_path: 'profile.linkedin_url', operator: 'isnull', value: null };
+    const rule: FilterRule = { fieldPath: 'profile.linkedin_url', operator: 'isnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(true);
   });
 
   it('isnotnull: should match defined values', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'isnotnull', value: null };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'isnotnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(true);
   });
 
   it('isnotnull: should not match null values', () => {
-    const rule: FilterRule = { field_path: 'email', operator: 'isnotnull', value: null };
+    const rule: FilterRule = { fieldPath: 'email', operator: 'isnotnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(false);
   });
 
   it('isnotnull: should not match undefined values', () => {
-    const rule: FilterRule = { field_path: 'age', operator: 'isnotnull', value: null };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'isnotnull', value: null };
     expect(evaluateRule(entityWithNulls, rule)).toBe(false);
   });
 });
@@ -327,22 +327,22 @@ describe('Null Operators', () => {
 
 describe('Tag Operators', () => {
   it('has_tag: should match tag in array (case-insensitive)', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_tag', value: 'QUALIFIED' };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_tag', value: 'QUALIFIED' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('has_tag: should not match missing tag', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_tag', value: 'inactive' };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_tag', value: 'inactive' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('not_has_tag: should match when tag absent', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'not_has_tag', value: 'inactive' };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'not_has_tag', value: 'inactive' };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('not_has_tag: should not match when tag present', () => {
-    const rule: FilterRule = { field_path: 'tags', operator: 'not_has_tag', value: 'qualified' };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'not_has_tag', value: 'qualified' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 });
@@ -353,24 +353,24 @@ describe('Tag Operators', () => {
 
 describe('Boolean Operators', () => {
   it('is_true: should match true values', () => {
-    const rule: FilterRule = { field_path: 'active', operator: 'is_true', value: null };
+    const rule: FilterRule = { fieldPath: 'active', operator: 'is_true', value: null };
     expect(evaluateRule(sampleEntity, rule)).toBe(true);
   });
 
   it('is_true: should not match false values', () => {
     const entity = { ...sampleEntity, active: false };
-    const rule: FilterRule = { field_path: 'active', operator: 'is_true', value: null };
+    const rule: FilterRule = { fieldPath: 'active', operator: 'is_true', value: null };
     expect(evaluateRule(entity, rule)).toBe(false);
   });
 
   it('is_false: should match false values', () => {
     const entity = { ...sampleEntity, active: false };
-    const rule: FilterRule = { field_path: 'active', operator: 'is_false', value: null };
+    const rule: FilterRule = { fieldPath: 'active', operator: 'is_false', value: null };
     expect(evaluateRule(entity, rule)).toBe(true);
   });
 
   it('is_false: should not match true values', () => {
-    const rule: FilterRule = { field_path: 'active', operator: 'is_false', value: null };
+    const rule: FilterRule = { fieldPath: 'active', operator: 'is_false', value: null };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 });
@@ -382,7 +382,7 @@ describe('Boolean Operators', () => {
 describe('Date Operators', () => {
   it('should compare Date objects', () => {
     const rule: FilterRule = {
-      field_path: 'created_at',
+      fieldPath: 'createdAt',
       operator: 'gt',
       value: new Date('2024-01-01'),
     };
@@ -390,9 +390,9 @@ describe('Date Operators', () => {
   });
 
   it('should compare date strings', () => {
-    const entity = { ...sampleEntity, created_at: '2024-01-15' };
+    const entity = { ...sampleEntity, createdAt: '2024-01-15' };
     const rule: FilterRule = {
-      field_path: 'created_at',
+      fieldPath: 'createdAt',
       operator: 'gte',
       value: '2024-01-15',
     };
@@ -400,9 +400,9 @@ describe('Date Operators', () => {
   });
 
   it('should handle date equality', () => {
-    const entity = { ...sampleEntity, created_at: '2024-01-15' };
+    const entity = { ...sampleEntity, createdAt: '2024-01-15' };
     const rule: FilterRule = {
-      field_path: 'created_at',
+      fieldPath: 'createdAt',
       operator: 'eq',
       value: new Date('2024-01-15'),
     };
@@ -417,7 +417,7 @@ describe('Date Operators', () => {
 describe('Negate Flag', () => {
   it('should negate equality', () => {
     const rule: FilterRule = {
-      field_path: 'name',
+      fieldPath: 'name',
       operator: 'eq',
       value: 'John Doe',
       negate: true,
@@ -427,7 +427,7 @@ describe('Negate Flag', () => {
 
   it('should negate inequality', () => {
     const rule: FilterRule = {
-      field_path: 'name',
+      fieldPath: 'name',
       operator: 'ne',
       value: 'John Doe',
       negate: true,
@@ -437,7 +437,7 @@ describe('Negate Flag', () => {
 
   it('should negate contains', () => {
     const rule: FilterRule = {
-      field_path: 'name',
+      fieldPath: 'name',
       operator: 'contains',
       value: 'john',
       negate: true,
@@ -452,31 +452,31 @@ describe('Negate Flag', () => {
 
 describe('Edge Cases', () => {
   it('should handle missing nested paths', () => {
-    const rule: FilterRule = { field_path: 'firm.missing.field', operator: 'eq', value: 'test' };
+    const rule: FilterRule = { fieldPath: 'firm.missing.field', operator: 'eq', value: 'test' };
     expect(evaluateRule(sampleEntity, rule)).toBe(false);
   });
 
   it('should handle empty strings', () => {
     const entity = { name: '' };
-    const rule: FilterRule = { field_path: 'name', operator: 'eq', value: '' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'eq', value: '' };
     expect(evaluateRule(entity, rule)).toBe(true);
   });
 
   it('should handle empty arrays', () => {
     const entity = { tags: [] };
-    const rule: FilterRule = { field_path: 'tags', operator: 'has_tag', value: 'test' };
+    const rule: FilterRule = { fieldPath: 'tags', operator: 'has_tag', value: 'test' };
     expect(evaluateRule(entity, rule)).toBe(false);
   });
 
   it('should handle zero values', () => {
     const entity = { score: 0 };
-    const rule: FilterRule = { field_path: 'score', operator: 'eq', value: 0 };
+    const rule: FilterRule = { fieldPath: 'score', operator: 'eq', value: 0 };
     expect(evaluateRule(entity, rule)).toBe(true);
   });
 
   it('should handle numeric strings in comparisons', () => {
     const entity = { age: '35' };
-    const rule: FilterRule = { field_path: 'age', operator: 'gt', value: 30 };
+    const rule: FilterRule = { fieldPath: 'age', operator: 'gt', value: 30 };
     expect(evaluateRule(entity, rule)).toBe(true);
   });
 });
@@ -487,9 +487,9 @@ describe('Edge Cases', () => {
 
 describe('Multiple Rules', () => {
   const rules: FilterRule[] = [
-    { field_path: 'age', operator: 'gte', value: 30 },
-    { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
-    { field_path: 'tags', operator: 'has_tag', value: 'qualified' },
+    { fieldPath: 'age', operator: 'gte', value: 30 },
+    { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
+    { fieldPath: 'tags', operator: 'has_tag', value: 'qualified' },
   ];
 
   it('AND: should match when all rules pass', () => {
@@ -499,23 +499,23 @@ describe('Multiple Rules', () => {
   it('AND: should not match when any rule fails', () => {
     const failingRules = [
       ...rules,
-      { field_path: 'age', operator: 'lt', value: 30 } as FilterRule,
+      { fieldPath: 'age', operator: 'lt', value: 30 } as FilterRule,
     ];
     expect(evaluateRulesAND(sampleEntity, failingRules)).toBe(false);
   });
 
   it('OR: should match when any rule passes', () => {
     const orRules: FilterRule[] = [
-      { field_path: 'age', operator: 'lt', value: 30 }, // false
-      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' }, // true
+      { fieldPath: 'age', operator: 'lt', value: 30 }, // false
+      { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' }, // true
     ];
     expect(evaluateRulesOR(sampleEntity, orRules)).toBe(true);
   });
 
   it('OR: should not match when all rules fail', () => {
     const orRules: FilterRule[] = [
-      { field_path: 'age', operator: 'lt', value: 30 },
-      { field_path: 'firm.stage', operator: 'eq', value: 'Seed' },
+      { fieldPath: 'age', operator: 'lt', value: 30 },
+      { fieldPath: 'firm.stage', operator: 'eq', value: 'Seed' },
     ];
     expect(evaluateRulesOR(sampleEntity, orRules)).toBe(false);
   });
@@ -526,8 +526,8 @@ describe('Multiple Rules', () => {
 
   it('evaluateRules: should use specified logic', () => {
     const orRules: FilterRule[] = [
-      { field_path: 'age', operator: 'lt', value: 30 },
-      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+      { fieldPath: 'age', operator: 'lt', value: 30 },
+      { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
     ];
     expect(evaluateRules(sampleEntity, orRules, 'OR')).toBe(true);
   });
@@ -544,35 +544,35 @@ describe('Multiple Rules', () => {
 
 describe('Detailed Results', () => {
   it('should return detailed rule result', () => {
-    const rule: FilterRule = { field_path: 'firm.stage', operator: 'eq', value: 'Series A' };
+    const rule: FilterRule = { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' };
     const result = evaluateRuleWithResult(sampleEntity, rule);
 
     expect(result).toEqual({
-      field_path: 'firm.stage',
+      fieldPath: 'firm.stage',
       operator: 'eq',
       value: 'Series A',
-      actual_value: 'Series A',
+      actualValue: 'Series A',
       matched: true,
     });
   });
 
   it('should return detailed results for multiple rules', () => {
     const rules: FilterRule[] = [
-      { field_path: 'age', operator: 'gte', value: 30 },
-      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+      { fieldPath: 'age', operator: 'gte', value: 30 },
+      { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
     ];
 
     const result = evaluateRulesWithResults(sampleEntity, rules, 'AND');
 
     expect(result.matched).toBe(true);
     expect(result.logic).toBe('AND');
-    expect(result.rule_results).toHaveLength(2);
-    expect(result.rule_results[0].matched).toBe(true);
-    expect(result.rule_results[1].matched).toBe(true);
+    expect(result.ruleResults).toHaveLength(2);
+    expect(result.ruleResults[0].matched).toBe(true);
+    expect(result.ruleResults[1].matched).toBe(true);
   });
 
   it('should handle errors in rule evaluation', () => {
-    const rule: FilterRule = { field_path: 'name', operator: 'matches' as any, value: '[invalid-regex' };
+    const rule: FilterRule = { fieldPath: 'name', operator: 'matches' as any, value: '[invalid-regex' };
     const result = evaluateRuleWithResult(sampleEntity, rule);
 
     expect(result.matched).toBe(false);
@@ -593,7 +593,7 @@ describe('Filter Entities', () => {
 
   it('should filter entities with single rule', () => {
     const rules: FilterRule[] = [
-      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+      { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
     ];
 
     const result = filterEntities(entities, rules);
@@ -603,8 +603,8 @@ describe('Filter Entities', () => {
 
   it('should filter entities with multiple AND rules', () => {
     const rules: FilterRule[] = [
-      { field_path: 'age', operator: 'gte', value: 30 },
-      { field_path: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] },
+      { fieldPath: 'age', operator: 'gte', value: 30 },
+      { fieldPath: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] },
     ];
 
     const result = filterEntities(entities, rules, 'AND');
@@ -614,8 +614,8 @@ describe('Filter Entities', () => {
 
   it('should filter entities with OR rules', () => {
     const rules: FilterRule[] = [
-      { field_path: 'age', operator: 'lt', value: 30 },
-      { field_path: 'firm.stage', operator: 'eq', value: 'Series B' },
+      { fieldPath: 'age', operator: 'lt', value: 30 },
+      { fieldPath: 'firm.stage', operator: 'eq', value: 'Series B' },
     ];
 
     const result = filterEntities(entities, rules, 'OR');
@@ -630,7 +630,7 @@ describe('Filter Entities', () => {
 
   it('should return empty array for no matches', () => {
     const rules: FilterRule[] = [
-      { field_path: 'age', operator: 'gt', value: 100 },
+      { fieldPath: 'age', operator: 'gt', value: 100 },
     ];
 
     const result = filterEntities(entities, rules);