@startsimpli/funnels 0.4.6 → 0.4.8

package/src/components/FunnelCard/FunnelCard.test.tsx

@@ -22,37 +22,37 @@ function createFunnel(overrides?: Partial<Funnel>): Funnel {
     name: 'Test Funnel',
     description: 'Test funnel description',
     status: 'active',
-    input_type: 'any',
+    inputType: 'any',
     stages: [
       {
         id: 'stage-1',
         order: 0,
         name: 'Stage 1',
         description: 'First stage',
-        filter_logic: 'AND',
+        filterLogic: 'AND',
         rules: [
-          { field_path: 'name', operator: 'eq', value: 'test' }
+          { fieldPath: 'name', operator: 'eq', value: 'test' }
         ],
-        match_action: 'continue',
-        no_match_action: 'exclude',
+        matchAction: 'continue',
+        noMatchAction: 'exclude',
       },
       {
         id: 'stage-2',
         order: 1,
         name: 'Stage 2',
         description: 'Second stage',
-        filter_logic: 'OR',
+        filterLogic: 'OR',
         rules: [
-          { field_path: 'value', operator: 'gt', value: 100 },
-          { field_path: 'type', operator: 'in', value: ['A', 'B'] },
-          { field_path: 'active', operator: 'is_true', value: null },
+          { fieldPath: 'value', operator: 'gt', value: 100 },
+          { fieldPath: 'type', operator: 'in', value: ['A', 'B'] },
+          { fieldPath: 'active', operator: 'is_true', value: null },
         ],
-        match_action: 'output',
-        no_match_action: 'exclude',
+        matchAction: 'output',
+        noMatchAction: 'exclude',
       },
     ],
-    created_at: '2024-01-01T00:00:00Z',
-    updated_at: '2024-01-01T00:00:00Z',
+    createdAt: '2024-01-01T00:00:00Z',
+    updatedAt: '2024-01-01T00:00:00Z',
     ...overrides,
   };
 }
@@ -60,17 +60,17 @@ function createFunnel(overrides?: Partial<Funnel>): Funnel {
 function createFunnelRun(overrides?: Partial<FunnelRun>): FunnelRun {
   return {
     id: 'run-1',
-    funnel_id: 'funnel-1',
+    funnelId: 'funnel-1',
     status: 'completed',
-    trigger_type: 'manual',
-    started_at: '2024-01-01T00:00:00Z',
-    completed_at: '2024-01-01T00:01:00Z',
-    duration_ms: 60000,
-    total_input: 83061,
-    total_matched: 235,
-    total_excluded: 82826,
-    total_tagged: 235,
-    stage_stats: {},
+    triggerType: 'manual',
+    startedAt: '2024-01-01T00:00:00Z',
+    completedAt: '2024-01-01T00:01:00Z',
+    durationMs: 60000,
+    totalInput: 83061,
+    totalMatched: 235,
+    totalExcluded: 82826,
+    totalTagged: 235,
+    stageStats: {},
     ...overrides,
   };
 }
@@ -167,10 +167,10 @@ describe('FunnelCard', () => {
             id: 'stage-1',
             order: 0,
             name: 'Only Stage',
-            filter_logic: 'AND',
-            rules: [{ field_path: 'x', operator: 'eq', value: 1 }],
-            match_action: 'output',
-            no_match_action: 'exclude',
+            filterLogic: 'AND',
+            rules: [{ fieldPath: 'x', operator: 'eq', value: 1 }],
+            matchAction: 'output',
+            noMatchAction: 'exclude',
           },
         ],
       });
@@ -185,10 +185,10 @@ describe('FunnelCard', () => {
         id: `stage-${i}`,
         order: i,
         name: `Stage ${i + 1}`,
-        filter_logic: 'AND' as const,
-        rules: [{ field_path: 'x', operator: 'eq' as const, value: i }],
-        match_action: 'continue' as const,
-        no_match_action: 'exclude' as const,
+        filterLogic: 'AND' as const,
+        rules: [{ fieldPath: 'x', operator: 'eq' as const, value: i }],
+        matchAction: 'continue' as const,
+        noMatchAction: 'exclude' as const,
       }));
       const funnel = createFunnel({ stages });
       render(<FunnelCard funnel={funnel} />);
@@ -203,10 +203,10 @@ describe('FunnelCard', () => {
         id: `stage-${i}`,
         order: i,
         name: `Stage ${i + 1}`,
-        filter_logic: 'AND' as const,
-        rules: [{ field_path: 'x', operator: 'eq' as const, value: i }],
-        match_action: 'continue' as const,
-        no_match_action: 'exclude' as const,
+        filterLogic: 'AND' as const,
+        rules: [{ fieldPath: 'x', operator: 'eq' as const, value: i }],
+        matchAction: 'continue' as const,
+        noMatchAction: 'exclude' as const,
       }));
       const funnel = createFunnel({ stages });
       render(<FunnelCard funnel={funnel} />);
@@ -289,8 +289,8 @@ describe('FunnelCard', () => {
     it('handles zero matched entities', () => {
       const funnel = createFunnel();
       const latestRun = createFunnelRun({
-        total_matched: 0,
-        total_excluded: 100,
+        totalMatched: 0,
+        totalExcluded: 100,
       });
       render(<FunnelCard funnel={funnel} latestRun={latestRun} />);
 
@@ -301,9 +301,9 @@ describe('FunnelCard', () => {
     it('handles zero input entities', () => {
       const funnel = createFunnel();
       const latestRun = createFunnelRun({
-        total_input: 0,
-        total_matched: 0,
-        total_excluded: 0,
+        totalInput: 0,
+        totalMatched: 0,
+        totalExcluded: 0,
       });
       render(<FunnelCard funnel={funnel} latestRun={latestRun} />);
 

package/src/components/FunnelCard/FunnelCard.tsx

@@ -73,9 +73,9 @@ export function FunnelCard({
 }: FunnelCardProps) {
   // Extract stats from latest run or use zeros
   const stats = latestRun ? {
-    input: latestRun.total_input,
-    matched: latestRun.total_matched,
-    excluded: latestRun.total_excluded,
+    input: latestRun.totalInput,
+    matched: latestRun.totalMatched,
+    excluded: latestRun.totalExcluded,
   } : {
     input: 0,
     matched: 0,

package/src/components/FunnelPreview/FunnelPreview.test.tsx

@@ -20,46 +20,46 @@ const mockFunnel: Funnel = {
   name: 'Test Funnel',
   description: 'A test funnel',
   status: 'active',
-  input_type: 'contacts',
+  inputType: 'contacts',
   stages: [
     {
       id: 'stage-1',
       order: 0,
       name: 'High Score',
-      filter_logic: 'AND',
+      filterLogic: 'AND',
       rules: [
         {
-          field_path: 'score',
+          fieldPath: 'score',
           operator: 'gte',
           value: 80,
         },
       ],
-      match_action: 'continue',
-      no_match_action: 'exclude',
+      matchAction: 'continue',
+      noMatchAction: 'exclude',
     },
     {
       id: 'stage-2',
       order: 1,
       name: 'Series A or Seed',
-      filter_logic: 'OR',
+      filterLogic: 'OR',
       rules: [
         {
-          field_path: 'firm.stage',
+          fieldPath: 'firm.stage',
           operator: 'eq',
           value: 'Series A',
         },
         {
-          field_path: 'firm.stage',
+          fieldPath: 'firm.stage',
           operator: 'eq',
           value: 'Seed',
         },
       ],
-      match_action: 'output',
-      no_match_action: 'exclude',
+      matchAction: 'output',
+      noMatchAction: 'exclude',
     },
   ],
-  created_at: new Date().toISOString(),
-  updated_at: new Date().toISOString(),
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
 };
 
 describe('FunnelPreview', () => {
@@ -69,10 +69,10 @@ describe('FunnelPreview', () => {
       const engine = new FunnelEngine();
       const result = engine.execute(mockFunnel, mockEntities);
 
-      expect(result.total_input).toBe(5);
-      expect(result.total_matched).toBeGreaterThan(0);
-      expect(result.total_excluded).toBeGreaterThan(0);
-      expect(result.matched.length).toBe(result.total_matched);
+      expect(result.totalInput).toBe(5);
+      expect(result.totalMatched).toBeGreaterThan(0);
+      expect(result.totalExcluded).toBeGreaterThan(0);
+      expect(result.matched.length).toBe(result.totalMatched);
     });
 
     it('should handle empty entities', async () => {
@@ -80,9 +80,9 @@ describe('FunnelPreview', () => {
       const engine = new FunnelEngine();
       const result = engine.execute(mockFunnel, []);
 
-      expect(result.total_input).toBe(0);
-      expect(result.total_matched).toBe(0);
-      expect(result.total_excluded).toBe(0);
+      expect(result.totalInput).toBe(0);
+      expect(result.totalMatched).toBe(0);
+      expect(result.totalExcluded).toBe(0);
       expect(result.matched).toEqual([]);
     });
 
@@ -97,8 +97,8 @@ describe('FunnelPreview', () => {
       const result = engine.execute(emptyFunnel, mockEntities);
 
       // With no stages, all entities should match
-      expect(result.total_matched).toBe(5);
-      expect(result.total_excluded).toBe(0);
+      expect(result.totalMatched).toBe(5);
+      expect(result.totalExcluded).toBe(0);
     });
   });
 
@@ -109,11 +109,11 @@ describe('FunnelPreview', () => {
       const result = engine.execute(mockFunnel, mockEntities);
 
       // Should have stats for both stages
-      expect(result.stage_stats['stage-1']).toBeDefined();
-      expect(result.stage_stats['stage-2']).toBeDefined();
+      expect(result.stageStats['stage-1']).toBeDefined();
+      expect(result.stageStats['stage-2']).toBeDefined();
 
       // Stage 1 should process all entities
-      expect(result.stage_stats['stage-1'].input_count).toBe(5);
+      expect(result.stageStats['stage-1'].inputCount).toBe(5);
     });
 
     it('should count exclusions per stage', async () => {
@@ -122,12 +122,12 @@ describe('FunnelPreview', () => {
       const result = engine.execute(mockFunnel, mockEntities);
 
       // Sum of excluded across all stages should equal total excluded
-      const totalExcludedAcrossStages = Object.values(result.stage_stats).reduce(
-        (sum, stats) => sum + stats.excluded_count,
+      const totalExcludedAcrossStages = Object.values(result.stageStats).reduce(
+        (sum, stats) => sum + stats.excludedCount,
         0
       );
 
-      expect(totalExcludedAcrossStages).toBeLessThanOrEqual(result.total_excluded);
+      expect(totalExcludedAcrossStages).toBeLessThanOrEqual(result.totalExcluded);
     });
   });
 
@@ -137,9 +137,9 @@ describe('FunnelPreview', () => {
       const engine = new FunnelEngine();
       const result = engine.execute(mockFunnel, mockEntities);
 
-      const total = result.total_matched + result.total_excluded;
+      const total = result.totalMatched + result.totalExcluded;
       const expectedPercentage =
-        total > 0 ? Math.round((result.total_matched / total) * 100) : 0;
+        total > 0 ? Math.round((result.totalMatched / total) * 100) : 0;
 
       expect(expectedPercentage).toBeGreaterThanOrEqual(0);
       expect(expectedPercentage).toBeLessThanOrEqual(100);
@@ -166,28 +166,28 @@ describe('FunnelPreview', () => {
             id: 'stage-1',
             order: 0,
             name: 'Stage 1',
-            filter_logic: 'AND',
-            rules: [{ field_path: 'score', operator: 'gte', value: 80 }],
-            match_action: 'continue',
-            no_match_action: 'exclude',
+            filterLogic: 'AND',
+            rules: [{ fieldPath: 'score', operator: 'gte', value: 80 }],
+            matchAction: 'continue',
+            noMatchAction: 'exclude',
           },
           {
             id: 'stage-2',
             order: 1,
             name: 'Stage 2',
-            filter_logic: 'AND',
-            rules: [{ field_path: 'score', operator: 'lte', value: 90 }],
-            match_action: 'continue',
-            no_match_action: 'exclude',
+            filterLogic: 'AND',
+            rules: [{ fieldPath: 'score', operator: 'lte', value: 90 }],
+            matchAction: 'continue',
+            noMatchAction: 'exclude',
           },
           {
             id: 'stage-3',
             order: 2,
             name: 'Stage 3',
-            filter_logic: 'AND',
-            rules: [{ field_path: 'firm.stage', operator: 'eq', value: 'Series A' }],
-            match_action: 'output',
-            no_match_action: 'exclude',
+            filterLogic: 'AND',
+            rules: [{ fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' }],
+            matchAction: 'output',
+            noMatchAction: 'exclude',
           },
         ],
       };
@@ -197,10 +197,10 @@ describe('FunnelPreview', () => {
       const result = engine.execute(multiFunnel, mockEntities);
 
       // Should have stats for all 3 stages
-      expect(Object.keys(result.stage_stats).length).toBe(3);
-      expect(result.stage_stats['stage-1']).toBeDefined();
-      expect(result.stage_stats['stage-2']).toBeDefined();
-      expect(result.stage_stats['stage-3']).toBeDefined();
+      expect(Object.keys(result.stageStats).length).toBe(3);
+      expect(result.stageStats['stage-1']).toBeDefined();
+      expect(result.stageStats['stage-2']).toBeDefined();
+      expect(result.stageStats['stage-3']).toBeDefined();
     });
 
     it('should track remaining entities correctly', async () => {
@@ -209,10 +209,10 @@ describe('FunnelPreview', () => {
       const result = engine.execute(mockFunnel, mockEntities);
 
       // For each stage, remaining = input - excluded
-      Object.values(result.stage_stats).forEach((stats) => {
-        const remaining = stats.input_count - stats.excluded_count;
+      Object.values(result.stageStats).forEach((stats) => {
+        const remaining = stats.inputCount - stats.excludedCount;
         expect(remaining).toBeGreaterThanOrEqual(0);
-        expect(remaining).toBeLessThanOrEqual(stats.input_count);
+        expect(remaining).toBeLessThanOrEqual(stats.inputCount);
       });
     });
   });
@@ -223,9 +223,9 @@ describe('FunnelPreview', () => {
       const engine = new FunnelEngine();
       const result = engine.execute(mockFunnel, []);
 
-      expect(result.total_input).toBe(0);
-      expect(result.total_matched).toBe(0);
-      expect(result.total_excluded).toBe(0);
+      expect(result.totalInput).toBe(0);
+      expect(result.totalMatched).toBe(0);
+      expect(result.totalExcluded).toBe(0);
     });
 
     it('should handle 100 entities', async () => {
@@ -239,8 +239,8 @@ describe('FunnelPreview', () => {
       const engine = new FunnelEngine();
       const result = engine.execute(mockFunnel, largeEntities);
 
-      expect(result.total_input).toBe(100);
-      expect(result.total_matched + result.total_excluded).toBe(100);
+      expect(result.totalInput).toBe(100);
+      expect(result.totalMatched + result.totalExcluded).toBe(100);
     });
 
     it('should handle funnel with no rules', async () => {
@@ -251,10 +251,10 @@ describe('FunnelPreview', () => {
             id: 'stage-1',
             order: 0,
             name: 'Pass All',
-            filter_logic: 'AND',
+            filterLogic: 'AND',
             rules: [],
-            match_action: 'output',
-            no_match_action: 'exclude',
+            matchAction: 'output',
+            noMatchAction: 'exclude',
           },
         ],
       };
@@ -264,8 +264,8 @@ describe('FunnelPreview', () => {
       const result = engine.execute(noRulesFunnel, mockEntities);
 
       // With no rules, all entities should match
-      expect(result.total_matched).toBe(5);
-      expect(result.total_excluded).toBe(0);
+      expect(result.totalMatched).toBe(5);
+      expect(result.totalExcluded).toBe(0);
     });
 
     it('should handle custom evaluator', async () => {
@@ -276,11 +276,11 @@ describe('FunnelPreview', () => {
             id: 'stage-1',
             order: 0,
             name: 'Custom',
-            filter_logic: 'AND',
+            filterLogic: 'AND',
             rules: [],
-            match_action: 'output',
-            no_match_action: 'exclude',
-            custom_evaluator: (entity: any) => entity.score > 85,
+            matchAction: 'output',
+            noMatchAction: 'exclude',
+            customEvaluator: (entity: any) => entity.score > 85,
           },
         ],
       };
@@ -290,7 +290,7 @@ describe('FunnelPreview', () => {
       const result = engine.execute(customFunnel, mockEntities);
 
       // Should match entities with score > 85
-      expect(result.total_matched).toBe(3); // Jane(92), Alice(88), Charlie(95)
+      expect(result.totalMatched).toBe(3); // Jane(92), Alice(88), Charlie(95)
     });
   });
 

package/src/components/FunnelPreview/FunnelPreview.tsx

@@ -76,12 +76,12 @@ function convertToPreviewResult(
   execResult: ExecutionResult,
   maxEntities: number = 10
 ): PreviewResult {
-  const { matched, total_matched, total_excluded, stage_stats } = execResult;
+  const { matched, totalMatched, totalExcluded, stageStats } = execResult;
 
   // Calculate match percentage
-  const total = total_matched + total_excluded;
+  const total = totalMatched + totalExcluded;
   const matchPercentage =
-    total > 0 ? Math.round((total_matched / total) * 100) : 0;
+    total > 0 ? Math.round((totalMatched / total) * 100) : 0;
 
   // Get preview entities (first N matched)
   const previewEntities = matched.slice(0, maxEntities).map((r) => r.entity);
@@ -89,19 +89,19 @@ function convertToPreviewResult(
   // Convert stage stats to preview format
   const previewStageStats: Record<string, StagePreviewStats> = {};
 
-  Object.entries(stage_stats).forEach(([stageId, stats]) => {
+  Object.entries(stageStats).forEach(([stageId, stats]) => {
     previewStageStats[stageId] = {
-      stage_id: stats.stage_id,
-      stage_name: stats.stage_name,
-      input_count: stats.input_count,
-      excluded_count: stats.excluded_count,
-      remaining_count: stats.input_count - stats.excluded_count,
+      stageId: stats.stageId,
+      stageName: stats.stageName,
+      inputCount: stats.inputCount,
+      excludedCount: stats.excludedCount,
+      remaining_count: stats.inputCount - stats.excludedCount,
     };
   });
 
   return {
-    totalMatched: total_matched,
-    totalExcluded: total_excluded,
+    totalMatched: totalMatched,
+    totalExcluded: totalExcluded,
     matchPercentage,
     previewEntities,
     stageStats: previewStageStats,

package/src/components/FunnelPreview/StageBreakdown.tsx

@@ -19,10 +19,10 @@
 import type { StageStats } from '../../types';
 
 export interface StagePreviewStats {
-  stage_id: string;
-  stage_name: string;
-  input_count: number;
-  excluded_count: number;
+  stageId: string;
+  stageName: string;
+  inputCount: number;
+  excludedCount: number;
   remaining_count: number;
 }
 
@@ -52,7 +52,7 @@ export function StageBreakdown({
           if (!stats) return null;
 
           const isLast = index === sortedStages.length - 1;
-          const excludedCount = stats.excluded_count;
+          const excludedCount = stats.excludedCount;
           const remainingCount = stats.remaining_count;
 
           return (

package/src/components/FunnelPreview/example.tsx

@@ -17,33 +17,33 @@ const investorFunnel: Funnel = {
   name: 'Investor Qualification',
   description: 'Filter investors by firm stage and check size',
   status: 'active',
-  input_type: 'contacts',
+  inputType: 'contacts',
   stages: [
     {
       id: 'stage-1',
       order: 0,
       name: 'Series A or Later',
-      filter_logic: 'OR',
+      filterLogic: 'OR',
       rules: [
-        { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
-        { field_path: 'firm.stage', operator: 'eq', value: 'Series B' },
-        { field_path: 'firm.stage', operator: 'eq', value: 'Series C' },
+        { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
+        { fieldPath: 'firm.stage', operator: 'eq', value: 'Series B' },
+        { fieldPath: 'firm.stage', operator: 'eq', value: 'Series C' },
       ],
-      match_action: 'continue',
-      no_match_action: 'exclude',
+      matchAction: 'continue',
+      noMatchAction: 'exclude',
     },
     {
       id: 'stage-2',
       order: 1,
       name: 'High ICP Score',
-      filter_logic: 'AND',
-      rules: [{ field_path: 'icp_score', operator: 'gte', value: 80 }],
-      match_action: 'output',
-      no_match_action: 'exclude',
+      filterLogic: 'AND',
+      rules: [{ fieldPath: 'icp_score', operator: 'gte', value: 80 }],
+      matchAction: 'output',
+      noMatchAction: 'exclude',
     },
   ],
-  created_at: new Date().toISOString(),
-  updated_at: new Date().toISOString(),
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
 };
 
 const sampleInvestors = [
@@ -112,32 +112,32 @@ const recipeFunnel: Funnel = {
   name: 'Recipe Recommendations',
   description: 'Filter recipes by dietary restrictions and difficulty',
   status: 'active',
-  input_type: 'any',
+  inputType: 'any',
   stages: [
     {
       id: 'dietary',
       order: 0,
       name: 'Vegetarian',
-      filter_logic: 'AND',
-      rules: [{ field_path: 'tags', operator: 'has_tag', value: 'vegetarian' }],
-      match_action: 'continue',
-      no_match_action: 'exclude',
+      filterLogic: 'AND',
+      rules: [{ fieldPath: 'tags', operator: 'has_tag', value: 'vegetarian' }],
+      matchAction: 'continue',
+      noMatchAction: 'exclude',
     },
     {
       id: 'difficulty',
       order: 1,
       name: 'Easy to Moderate',
-      filter_logic: 'OR',
+      filterLogic: 'OR',
       rules: [
-        { field_path: 'difficulty', operator: 'eq', value: 'easy' },
-        { field_path: 'difficulty', operator: 'eq', value: 'moderate' },
+        { fieldPath: 'difficulty', operator: 'eq', value: 'easy' },
+        { fieldPath: 'difficulty', operator: 'eq', value: 'moderate' },
       ],
-      match_action: 'output',
-      no_match_action: 'exclude',
+      matchAction: 'output',
+      noMatchAction: 'exclude',
     },
   ],
-  created_at: new Date().toISOString(),
-  updated_at: new Date().toISOString(),
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
 };
 
 const sampleRecipes = [
@@ -198,43 +198,43 @@ const leadFunnel: Funnel = {
   name: 'Qualified Leads',
   description: 'Score and filter leads based on company size and engagement',
   status: 'active',
-  input_type: 'any',
+  inputType: 'any',
   stages: [
     {
       id: 'company-size',
       order: 0,
       name: 'Mid-Market and Above',
-      filter_logic: 'AND',
-      rules: [{ field_path: 'company.employees', operator: 'gte', value: 50 }],
-      match_action: 'continue',
-      no_match_action: 'exclude',
+      filterLogic: 'AND',
+      rules: [{ fieldPath: 'company.employees', operator: 'gte', value: 50 }],
+      matchAction: 'continue',
+      noMatchAction: 'exclude',
     },
     {
       id: 'engagement',
       order: 1,
       name: 'High Engagement',
-      filter_logic: 'AND',
-      rules: [{ field_path: 'engagement_score', operator: 'gte', value: 7 }],
-      match_action: 'tag_continue',
-      no_match_action: 'continue',
-      match_tags: ['high-engagement'],
+      filterLogic: 'AND',
+      rules: [{ fieldPath: 'engagement_score', operator: 'gte', value: 7 }],
+      matchAction: 'tag_continue',
+      noMatchAction: 'continue',
+      matchTags: ['high-engagement'],
     },
     {
       id: 'industry',
       order: 2,
       name: 'Target Industries',
-      filter_logic: 'OR',
+      filterLogic: 'OR',
       rules: [
-        { field_path: 'company.industry', operator: 'eq', value: 'Technology' },
-        { field_path: 'company.industry', operator: 'eq', value: 'SaaS' },
-        { field_path: 'company.industry', operator: 'eq', value: 'FinTech' },
+        { fieldPath: 'company.industry', operator: 'eq', value: 'Technology' },
+        { fieldPath: 'company.industry', operator: 'eq', value: 'SaaS' },
+        { fieldPath: 'company.industry', operator: 'eq', value: 'FinTech' },
       ],
-      match_action: 'output',
-      no_match_action: 'exclude',
+      matchAction: 'output',
+      noMatchAction: 'exclude',
     },
   ],
-  created_at: new Date().toISOString(),
-  updated_at: new Date().toISOString(),
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
 };
 
 const sampleLeads = [