@startsimpli/funnels 0.4.6 → 0.4.8

package/src/core/engine.ts

@@ -38,22 +38,22 @@ export interface ExecutionResult<T = any> {
   excluded: FunnelResult<T>[];
 
   /** Total entities processed */
-  total_input: number;
+  totalInput: number;
 
   /** Total entities that matched */
-  total_matched: number;
+  totalMatched: number;
 
   /** Total entities excluded */
-  total_excluded: number;
+  totalExcluded: number;
 
   /** Total entities tagged */
-  total_tagged: number;
+  totalTagged: number;
 
   /** Per-stage statistics */
-  stage_stats: Record<string, StageStats>;
+  stageStats: Record<string, StageStats>;
 
   /** Execution duration in milliseconds */
-  duration_ms: number;
+  durationMs: number;
 
   /** Errors encountered (non-fatal) */
   errors?: string[];
@@ -68,10 +68,10 @@ export interface ExecutionResult<T = any> {
 function evaluateRule<T>(_entity: T, _rule: FilterRule): RuleResult {
   throw new Error('Not implemented - BEAD: fund-your-startup-a0b8. evaluateRule must import from rule evaluator.');
   // return {
-  //   field_path: _rule.field_path,
+  //   fieldPath: _rule.fieldPath,
   //   operator: _rule.operator,
   //   value: _rule.value,
-  //   actual_value: undefined,
+  //   actualValue: undefined,
   //   matched: false,
   //   error: 'Evaluator not implemented yet',
   // };
@@ -115,9 +115,9 @@ export class FunnelEngine<T = any> {
     const results: FunnelResult<T>[] = entities.map(entity => ({
       entity,
       matched: true, // Start as matched, exclude as needed
-      accumulated_tags: [],
+      accumulatedTags: [],
       context: {},
-      stage_results: [],
+      stageResults: [],
     }));
 
     const stageStats: Record<string, StageStats> = {};
@@ -131,18 +131,18 @@ export class FunnelEngine<T = any> {
       const stageStartTime = Date.now();
 
       // Track entities entering this stage
-      const inputEntities = results.filter(r => r.matched && !r.excluded_at_stage);
+      const inputEntities = results.filter(r => r.matched && !r.excludedAtStage);
 
       const stats: StageStats = {
-        stage_id: stage.id,
-        stage_name: stage.name,
-        input_count: inputEntities.length,
-        matched_count: 0,
-        not_matched_count: 0,
-        excluded_count: 0,
-        tagged_count: 0,
-        continued_count: 0,
-        error_count: 0,
+        stageId: stage.id,
+        stageName: stage.name,
+        inputCount: inputEntities.length,
+        matchedCount: 0,
+        notMatchedCount: 0,
+        excludedCount: 0,
+        taggedCount: 0,
+        continuedCount: 0,
+        errorCount: 0,
       };
 
       // Process each entity through this stage
@@ -151,46 +151,46 @@ export class FunnelEngine<T = any> {
           const stageResult = this.processStage(stage, result.entity);
 
           // Update entity result
-          result.stage_results!.push(stageResult);
+          result.stageResults!.push(stageResult);
 
           // Apply stage result to entity
           if (stageResult.matched) {
-            stats.matched_count++;
+            stats.matchedCount++;
           } else {
-            stats.not_matched_count++;
+            stats.notMatchedCount++;
           }
 
-          if (stageResult.tags_added && stageResult.tags_added.length > 0) {
-            result.accumulated_tags.push(...stageResult.tags_added);
-            stats.tagged_count++;
+          if (stageResult.tagsAdded && stageResult.tagsAdded.length > 0) {
+            result.accumulatedTags.push(...stageResult.tagsAdded);
+            stats.taggedCount++;
           }
 
-          if (stageResult.context_added) {
-            result.context = { ...result.context, ...stageResult.context_added };
+          if (stageResult.contextAdded) {
+            result.context = { ...result.context, ...stageResult.contextAdded };
           }
 
           if (stageResult.excluded) {
             result.matched = false;
-            result.excluded_at_stage = stage.id;
-            stats.excluded_count++;
+            result.excludedAtStage = stage.id;
+            stats.excludedCount++;
           } else if (stageResult.continued) {
-            stats.continued_count++;
+            stats.continuedCount++;
           }
         } catch (error) {
-          stats.error_count!++;
+          stats.errorCount!++;
           errors.push(`Stage ${stage.name}: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
 
-      stats.duration_ms = Date.now() - stageStartTime;
+      stats.durationMs = Date.now() - stageStartTime;
       stageStats[stage.id] = stats;
     }
 
     // Apply completion tags to matched entities
-    if (funnel.completion_tags && funnel.completion_tags.length > 0) {
+    if (funnel.completionTags && funnel.completionTags.length > 0) {
       for (const result of results) {
         if (result.matched) {
-          result.accumulated_tags.push(...funnel.completion_tags);
+          result.accumulatedTags.push(...funnel.completionTags);
         }
       }
     }
@@ -200,17 +200,17 @@ export class FunnelEngine<T = any> {
     const excluded = results.filter(r => !r.matched);
 
     // Count unique tagged entities
-    const totalTagged = results.filter(r => r.accumulated_tags.length > 0).length;
+    const totalTagged = results.filter(r => r.accumulatedTags.length > 0).length;
 
     return {
       matched,
       excluded,
-      total_input: entities.length,
-      total_matched: matched.length,
-      total_excluded: excluded.length,
-      total_tagged: totalTagged,
-      stage_stats: stageStats,
-      duration_ms: Date.now() - startTime,
+      totalInput: entities.length,
+      totalMatched: matched.length,
+      totalExcluded: excluded.length,
+      totalTagged: totalTagged,
+      stageStats: stageStats,
+      durationMs: Date.now() - startTime,
       errors: errors.length > 0 ? errors : undefined,
     };
   }
@@ -227,10 +227,10 @@ export class FunnelEngine<T = any> {
     const ruleResults: RuleResult[] = [];
     let matched = false;
 
-    if (stage.custom_evaluator) {
+    if (stage.customEvaluator) {
       // Use custom evaluator if provided (highest priority)
       try {
-        matched = stage.custom_evaluator(entity);
+        matched = stage.customEvaluator(entity);
       } catch (error) {
         matched = false;
       }
@@ -245,7 +245,7 @@ export class FunnelEngine<T = any> {
       }
 
       // Apply filter logic (AND/OR)
-      if (stage.filter_logic === 'AND') {
+      if (stage.filterLogic === 'AND') {
         // All rules must match
         matched = ruleResults.every(r => r.matched);
       } else {
@@ -262,20 +262,20 @@ export class FunnelEngine<T = any> {
     let continued = false;
 
     if (matched) {
-      action = stage.match_action;
+      action = stage.matchAction;
 
       // Add match tags
-      if (stage.match_tags && stage.match_tags.length > 0) {
-        tagsAdded = [...stage.match_tags];
+      if (stage.matchTags && stage.matchTags.length > 0) {
+        tagsAdded = [...stage.matchTags];
       }
 
       // Add match context
-      if (stage.match_context) {
-        contextAdded = stage.match_context;
+      if (stage.matchContext) {
+        contextAdded = stage.matchContext;
       }
 
       // Apply match action
-      switch (stage.match_action) {
+      switch (stage.matchAction) {
         case 'continue':
           continued = true;
           break;
@@ -293,15 +293,15 @@ export class FunnelEngine<T = any> {
           break;
       }
     } else {
-      action = stage.no_match_action;
+      action = stage.noMatchAction;
 
       // Add no-match tags
-      if (stage.no_match_tags && stage.no_match_tags.length > 0) {
-        tagsAdded = [...stage.no_match_tags];
+      if (stage.noMatchTags && stage.noMatchTags.length > 0) {
+        tagsAdded = [...stage.noMatchTags];
       }
 
       // Apply no-match action
-      switch (stage.no_match_action) {
+      switch (stage.noMatchAction) {
         case 'continue':
           continued = true;
           break;
@@ -315,13 +315,13 @@ export class FunnelEngine<T = any> {
     }
 
     return {
-      stage_id: stage.id,
-      stage_name: stage.name,
+      stageId: stage.id,
+      stageName: stage.name,
       matched,
-      rule_results: ruleResults.length > 0 ? ruleResults : undefined,
+      ruleResults: ruleResults.length > 0 ? ruleResults : undefined,
       action,
-      tags_added: tagsAdded.length > 0 ? tagsAdded : undefined,
-      context_added: contextAdded,
+      tagsAdded: tagsAdded.length > 0 ? tagsAdded : undefined,
+      contextAdded: contextAdded,
       excluded,
       continued,
     };

package/src/core/evaluator.example.ts

@@ -27,7 +27,7 @@ interface Investor {
     geography: string[];
   };
   tags: string[];
-  created_at: Date;
+  createdAt: Date;
 }
 
 const investors: Investor[] = [
@@ -41,7 +41,7 @@ const investors: Investor[] = [
       geography: ['US', 'Canada'],
     },
     tags: ['qualified', 'active'],
-    created_at: new Date('2024-01-15'),
+    createdAt: new Date('2024-01-15'),
   },
   {
     name: 'Jane Smith',
@@ -53,7 +53,7 @@ const investors: Investor[] = [
       geography: ['US'],
     },
     tags: ['active'],
-    created_at: new Date('2024-02-01'),
+    createdAt: new Date('2024-02-01'),
   },
   {
     name: 'Bob Johnson',
@@ -65,14 +65,14 @@ const investors: Investor[] = [
       geography: ['US', 'Europe', 'Asia'],
     },
     tags: ['qualified', 'premium'],
-    created_at: new Date('2024-01-20'),
+    createdAt: new Date('2024-01-20'),
   },
 ];
 
 // Example 1a: Single rule evaluation
 console.log('=== Example 1a: Single Rule ===');
 const rule1: FilterRule = {
-  field_path: 'firm.aum',
+  fieldPath: 'firm.aum',
   operator: 'gte',
   value: 100000000,
 };
@@ -85,9 +85,9 @@ investors.forEach(investor => {
 // Example 1b: Multiple rules with AND logic
 console.log('\n=== Example 1b: Multiple Rules (AND) ===');
 const rules1: FilterRule[] = [
-  { field_path: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] },
-  { field_path: 'firm.aum', operator: 'gte', value: 100000000 },
-  { field_path: 'tags', operator: 'has_tag', value: 'qualified' },
+  { fieldPath: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] },
+  { fieldPath: 'firm.aum', operator: 'gte', value: 100000000 },
+  { fieldPath: 'tags', operator: 'has_tag', value: 'qualified' },
 ];
 
 const qualified = filterEntities(investors, rules1, 'AND');
@@ -99,9 +99,9 @@ const result1 = evaluateRulesWithResults(investors[0], rules1, 'AND');
 console.log('Evaluation for John Doe:');
 console.log('Overall match:', result1.matched);
 console.log('Rule results:');
-result1.rule_results.forEach(r => {
-  console.log(`  - ${r.field_path} ${r.operator} ${JSON.stringify(r.value)}`);
-  console.log(`    Actual: ${JSON.stringify(r.actual_value)}, Matched: ${r.matched}`);
+result1.ruleResults.forEach(r => {
+  console.log(`  - ${r.fieldPath} ${r.operator} ${JSON.stringify(r.value)}`);
+  console.log(`    Actual: ${JSON.stringify(r.actualValue)}, Matched: ${r.matched}`);
 });
 
 // ============================================================================
@@ -151,7 +151,7 @@ const recipes: Recipe[] = [
 // Example 2a: Filter by dietary restrictions
 console.log('\n=== Example 2: Recipe Filtering ===');
 const veganRules: FilterRule[] = [
-  { field_path: 'dietary', operator: 'has_tag', value: 'vegan' },
+  { fieldPath: 'dietary', operator: 'has_tag', value: 'vegan' },
 ];
 
 const veganRecipes = filterEntities(recipes, veganRules);
@@ -159,9 +159,9 @@ console.log('Vegan recipes:', veganRecipes.map(r => r.name));
 
 // Example 2b: Filter by multiple criteria (quick meals)
 const quickMealRules: FilterRule[] = [
-  { field_path: 'prep_time_minutes', operator: 'lte', value: 30 },
-  { field_path: 'difficulty', operator: 'in', value: ['easy', 'medium'] },
-  { field_path: 'rating', operator: 'gte', value: 4.0 },
+  { fieldPath: 'prep_time_minutes', operator: 'lte', value: 30 },
+  { fieldPath: 'difficulty', operator: 'in', value: ['easy', 'medium'] },
+  { fieldPath: 'rating', operator: 'gte', value: 4.0 },
 ];
 
 const quickMeals = filterEntities(recipes, quickMealRules, 'AND');
@@ -222,9 +222,9 @@ const repos: GitHubRepo[] = [
 // Example 3a: Find popular active repos
 console.log('\n=== Example 3: GitHub Repos ===');
 const popularRepoRules: FilterRule[] = [
-  { field_path: 'stars', operator: 'gte', value: 100 },
-  { field_path: 'is_archived', operator: 'is_false', value: null },
-  { field_path: 'last_updated', operator: 'gte', value: new Date('2024-01-01') },
+  { fieldPath: 'stars', operator: 'gte', value: 100 },
+  { fieldPath: 'is_archived', operator: 'is_false', value: null },
+  { fieldPath: 'last_updated', operator: 'gte', value: new Date('2024-01-01') },
 ];
 
 const popularRepos = filterEntities(repos, popularRepoRules, 'AND');
@@ -232,8 +232,8 @@ console.log('Popular active repos:', popularRepos.map(r => r.name));
 
 // Example 3b: Find TypeScript projects with React
 const tsReactRules: FilterRule[] = [
-  { field_path: 'language', operator: 'eq', value: 'TypeScript' },
-  { field_path: 'topics', operator: 'has_tag', value: 'react' },
+  { fieldPath: 'language', operator: 'eq', value: 'TypeScript' },
+  { fieldPath: 'topics', operator: 'has_tag', value: 'react' },
 ];
 
 const tsReactRepos = filterEntities(repos, tsReactRules, 'AND');
@@ -247,7 +247,7 @@ console.log('\n=== Example 4: Advanced Patterns ===');
 
 // Pattern 1: Negation
 const notArchivedRule: FilterRule = {
-  field_path: 'is_archived',
+  fieldPath: 'is_archived',
   operator: 'is_true',
   value: null,
   negate: true, // Negate the result
@@ -258,7 +258,7 @@ console.log('Active repos (using negate):', activeRepos.map(r => r.name));
 
 // Pattern 2: Complex string matching
 const emailDomainRule: FilterRule = {
-  field_path: 'email',
+  fieldPath: 'email',
   operator: 'matches',
   value: '@acme\\.vc$', // Matches emails ending with @acme.vc
 };
@@ -268,8 +268,8 @@ console.log('Acme VC investors:', acmeInvestors.map(i => i.name));
 
 // Pattern 3: OR logic (match any condition)
 const flexibleStageRules: FilterRule[] = [
-  { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
-  { field_path: 'firm.aum', operator: 'gte', value: 500000000 }, // OR very large fund
+  { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
+  { fieldPath: 'firm.aum', operator: 'gte', value: 500000000 }, // OR very large fund
 ];
 
 const flexibleMatch = filterEntities(investors, flexibleStageRules, 'OR');
@@ -282,11 +282,11 @@ investorsWithoutEmail.push({
   email: null as any,
   firm: { name: 'Test', stage: 'Seed', aum: 0, geography: [] },
   tags: [],
-  created_at: new Date(),
+  createdAt: new Date(),
 });
 
 const hasEmailRule: FilterRule = {
-  field_path: 'email',
+  fieldPath: 'email',
   operator: 'isnotnull',
   value: null,
 };
@@ -296,7 +296,7 @@ console.log('Investors with email:', withEmail.map(i => i.name));
 
 // Pattern 5: Array operations
 const multiGeographyRule: FilterRule = {
-  field_path: 'firm.geography',
+  fieldPath: 'firm.geography',
   operator: 'has_all',
   value: ['US', 'Europe'],
 };
@@ -329,22 +329,22 @@ function simulateFunnel<T>(entities: T[], stages: Array<{ name: string; rules: F
 const investorFunnelStages = [
   {
     name: 'Active & Not Archived',
-    rules: [{ field_path: 'tags', operator: 'has_tag', value: 'active' } as FilterRule],
+    rules: [{ fieldPath: 'tags', operator: 'has_tag', value: 'active' } as FilterRule],
     logic: 'AND' as const,
   },
   {
     name: 'Series A+ Stage',
-    rules: [{ field_path: 'firm.stage', operator: 'in', value: ['Series A', 'Series B', 'Series C'] } as FilterRule],
+    rules: [{ fieldPath: 'firm.stage', operator: 'in', value: ['Series A', 'Series B', 'Series C'] } as FilterRule],
     logic: 'AND' as const,
   },
   {
     name: 'Minimum AUM $100M',
-    rules: [{ field_path: 'firm.aum', operator: 'gte', value: 100000000 } as FilterRule],
+    rules: [{ fieldPath: 'firm.aum', operator: 'gte', value: 100000000 } as FilterRule],
     logic: 'AND' as const,
   },
   {
     name: 'Qualified Tag',
-    rules: [{ field_path: 'tags', operator: 'has_tag', value: 'qualified' } as FilterRule],
+    rules: [{ fieldPath: 'tags', operator: 'has_tag', value: 'qualified' } as FilterRule],
     logic: 'AND' as const,
   },
 ];