@startsimpli/funnels 0.4.6 → 0.4.7

package/src/core/evaluator.ts

@@ -26,13 +26,13 @@ import { applyOperator } from './operators';
  * const investor = { name: 'John', firm: { stage: 'Series A' } };
  *
  * evaluateRule(investor, {
- *   field_path: 'firm.stage',
+ *   fieldPath: 'firm.stage',
  *   operator: 'eq',
  *   value: 'Series A'
  * }); // true
  *
  * evaluateRule(investor, {
- *   field_path: 'firm.stage',
+ *   fieldPath: 'firm.stage',
  *   operator: 'eq',
  *   value: 'Seed',
  *   negate: true
@@ -41,7 +41,7 @@ import { applyOperator } from './operators';
  */
 export function evaluateRule<T>(entity: T, rule: FilterRule): boolean {
   // Resolve field value from entity
-  const actualValue = resolveField(entity, rule.field_path);
+  const actualValue = resolveField(entity, rule.fieldPath);
 
   // Apply operator
   const result = applyOperator(rule.operator, actualValue, rule.value);
@@ -60,15 +60,15 @@ export function evaluateRule<T>(entity: T, rule: FilterRule): boolean {
  * @example
  * ```typescript
  * const result = evaluateRuleWithResult(investor, {
- *   field_path: 'firm.stage',
+ *   fieldPath: 'firm.stage',
  *   operator: 'eq',
  *   value: 'Series A'
  * });
  * // {
- * //   field_path: 'firm.stage',
+ * //   fieldPath: 'firm.stage',
  * //   operator: 'eq',
  * //   value: 'Series A',
- * //   actual_value: 'Series A',
+ * //   actualValue: 'Series A',
  * //   matched: true
  * // }
  * ```
@@ -79,7 +79,7 @@ export function evaluateRuleWithResult<T>(
 ): RuleResult {
   try {
     // Resolve field value
-    const actualValue = resolveField(entity, rule.field_path);
+    const actualValue = resolveField(entity, rule.fieldPath);
 
     // Apply operator
     const operatorResult = applyOperator(rule.operator, actualValue, rule.value);
@@ -88,19 +88,19 @@ export function evaluateRuleWithResult<T>(
     const matched = rule.negate ? !operatorResult : operatorResult;
 
     return {
-      field_path: rule.field_path,
+      fieldPath: rule.fieldPath,
       operator: rule.operator,
       value: rule.value,
-      actual_value: actualValue,
+      actualValue: actualValue,
       matched,
     };
   } catch (error) {
     // Handle evaluation errors gracefully
     return {
-      field_path: rule.field_path,
+      fieldPath: rule.fieldPath,
       operator: rule.operator,
       value: rule.value,
-      actual_value: undefined,
+      actualValue: undefined,
       matched: false,
       error: error instanceof Error ? error.message : String(error),
     };
@@ -119,8 +119,8 @@ export function evaluateRuleWithResult<T>(
  * const investor = { name: 'John', firm: { stage: 'Series A', aum: 100000000 } };
  *
  * evaluateRulesAND(investor, [
- *   { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
- *   { field_path: 'firm.aum', operator: 'gte', value: 50000000 }
+ *   { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
+ *   { fieldPath: 'firm.aum', operator: 'gte', value: 50000000 }
  * ]); // true (both rules match)
  * ```
  */
@@ -142,8 +142,8 @@ export function evaluateRulesAND<T>(entity: T, rules: FilterRule[]): boolean {
  * const investor = { name: 'John', firm: { stage: 'Seed' } };
  *
  * evaluateRulesOR(investor, [
- *   { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
- *   { field_path: 'firm.stage', operator: 'eq', value: 'Seed' }
+ *   { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
+ *   { fieldPath: 'firm.stage', operator: 'eq', value: 'Seed' }
  * ]); // true (second rule matches)
  * ```
  */
@@ -188,15 +188,15 @@ export function evaluateRules<T>(
  * @example
  * ```typescript
  * const result = evaluateRulesWithResults(investor, [
- *   { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
- *   { field_path: 'firm.aum', operator: 'gte', value: 50000000 }
+ *   { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' },
+ *   { fieldPath: 'firm.aum', operator: 'gte', value: 50000000 }
  * ], 'AND');
  * // {
  * //   matched: true,
  * //   logic: 'AND',
- * //   rule_results: [
- * //     { field_path: 'firm.stage', operator: 'eq', value: 'Series A', actual_value: 'Series A', matched: true },
- * //     { field_path: 'firm.aum', operator: 'gte', value: 50000000, actual_value: 100000000, matched: true }
+ * //   ruleResults: [
+ * //     { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A', actualValue: 'Series A', matched: true },
+ * //     { fieldPath: 'firm.aum', operator: 'gte', value: 50000000, actualValue: 100000000, matched: true }
  * //   ]
  * // }
  * ```
@@ -208,7 +208,7 @@ export function evaluateRulesWithResults<T>(
 ): {
   matched: boolean;
   logic: 'AND' | 'OR';
-  rule_results: RuleResult[];
+  ruleResults: RuleResult[];
 } {
   const ruleResults = rules.map(rule => evaluateRuleWithResult(entity, rule));
 
@@ -220,7 +220,7 @@ export function evaluateRulesWithResults<T>(
   return {
     matched,
     logic,
-    rule_results: ruleResults,
+    ruleResults: ruleResults,
   };
 }
 
@@ -241,7 +241,7 @@ export function evaluateRulesWithResults<T>(
  * ];
  *
  * filterEntities(investors, [
- *   { field_path: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] }
+ *   { fieldPath: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] }
  * ]);
  * // [
  * //   { name: 'Jane', firm: { stage: 'Series A' } },

package/src/core/field-resolver.example.ts

@@ -27,7 +27,7 @@ const investor = {
     response_rate: 0.85,
     deal_count: 12,
   },
-  created_at: new Date('2024-01-01'),
+  createdAt: new Date('2024-01-01'),
 };
 
 // Resolve simple fields

package/src/core/field-resolver.test.ts

@@ -31,8 +31,8 @@ describe('resolveField', () => {
 
     it('resolves top-level date field', () => {
       const date = new Date('2024-01-01');
-      const entity = { created_at: date };
-      expect(resolveField(entity, 'created_at')).toBe(date);
+      const entity = { createdAt: date };
+      expect(resolveField(entity, 'createdAt')).toBe(date);
     });
 
     it('resolves top-level null field', () => {
@@ -228,7 +228,7 @@ describe('resolveField', () => {
           response_rate: 0.85,
           deal_count: 12,
         },
-        created_at: new Date('2024-01-01'),
+        createdAt: new Date('2024-01-01'),
       };
 
       expect(resolveField(investor, 'name')).toBe('John Doe');
@@ -237,7 +237,7 @@ describe('resolveField', () => {
       expect(resolveField(investor, 'tags[0]')).toBe('active');
       expect(resolveField(investor, 'profile.linkedin_url')).toBe('https://linkedin.com/in/johndoe');
       expect(resolveField(investor, 'metrics.response_rate')).toBe(0.85);
-      expect(resolveField(investor, 'created_at')).toBeInstanceOf(Date);
+      expect(resolveField(investor, 'createdAt')).toBeInstanceOf(Date);
     });
 
     it('resolves recipe entity fields', () => {

package/src/store/create-funnel-store.test.ts

@@ -54,53 +54,53 @@ const mockFunnel: Funnel = {
   name: 'Test Funnel',
   description: 'Test description',
   status: 'active',
-  input_type: 'contacts',
+  inputType: 'contacts',
   stages: [
     {
       id: 'stage-1',
       order: 0,
       name: 'Stage 1',
-      filter_logic: 'AND',
+      filterLogic: 'AND',
       rules: [],
-      match_action: 'continue',
-      no_match_action: 'exclude',
+      matchAction: 'continue',
+      noMatchAction: 'exclude',
     },
     {
       id: 'stage-2',
       order: 1,
       name: 'Stage 2',
-      filter_logic: 'OR',
+      filterLogic: 'OR',
       rules: [],
-      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 mockFunnel2: Funnel = {
   id: 'funnel-2',
   name: 'Test Funnel 2',
   status: 'draft',
-  input_type: 'organizations',
+  inputType: 'organizations',
   stages: [],
-  created_at: new Date().toISOString(),
-  updated_at: new Date().toISOString(),
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
 };
 
 const mockRun: FunnelRun = {
   id: 'run-1',
-  funnel_id: 'funnel-1',
+  funnelId: 'funnel-1',
   status: 'completed',
-  trigger_type: 'manual',
-  started_at: new Date().toISOString(),
-  completed_at: new Date().toISOString(),
-  total_input: 100,
-  total_matched: 75,
-  total_excluded: 25,
-  total_tagged: 50,
-  stage_stats: {},
+  triggerType: 'manual',
+  startedAt: new Date().toISOString(),
+  completedAt: new Date().toISOString(),
+  totalInput: 100,
+  totalMatched: 75,
+  totalExcluded: 25,
+  totalTagged: 50,
+  stageStats: {},
 };
 
 // ============================================================================
@@ -175,12 +175,12 @@ describe('createFunnelStore', () => {
       vi.mocked(apiClient.listFunnels).mockResolvedValue(mockResponse);
 
       const { loadFunnels } = useFunnelStore.getState();
-      await loadFunnels({ status: 'active', page: 2, page_size: 10 });
+      await loadFunnels({ status: 'active', page: 2, pageSize: 10 });
 
       expect(apiClient.listFunnels).toHaveBeenCalledWith({
         status: 'active',
         page: 2,
-        page_size: 10,
+        pageSize: 10,
       });
 
       const state = useFunnelStore.getState();
@@ -249,7 +249,7 @@ describe('createFunnelStore', () => {
       const input: CreateFunnelInput = {
         name: 'Test Funnel',
         status: 'active',
-        input_type: 'contacts',
+        inputType: 'contacts',
         stages: [],
       };
 
@@ -268,7 +268,7 @@ describe('createFunnelStore', () => {
       const input: CreateFunnelInput = {
         name: '',
         status: 'active',
-        input_type: 'contacts',
+        inputType: 'contacts',
         stages: [],
       };
 
@@ -505,10 +505,10 @@ describe('createFunnelStore', () => {
         id: 'stage-3',
         order: 2,
         name: 'Stage 3',
-        filter_logic: 'AND',
+        filterLogic: 'AND',
         rules: [],
-        match_action: 'continue',
-        no_match_action: 'exclude',
+        matchAction: 'continue',
+        noMatchAction: 'exclude',
       };
 
       vi.mocked(apiClient.createStage).mockResolvedValue(newStage);
@@ -517,10 +517,10 @@ describe('createFunnelStore', () => {
       await createStage('funnel-1', {
         order: 2,
         name: 'Stage 3',
-        filter_logic: 'AND',
+        filterLogic: 'AND',
         rules: [],
-        match_action: 'continue',
-        no_match_action: 'exclude',
+        matchAction: 'continue',
+        noMatchAction: 'exclude',
       });
 
       const state = useFunnelStore.getState();
@@ -574,7 +574,7 @@ describe('createFunnelStore', () => {
       vi.mocked(apiClient.runFunnel).mockResolvedValue(mockRun);
 
       const { runFunnel } = useFunnelStore.getState();
-      const result = await runFunnel('funnel-1', { trigger_type: 'manual' });
+      const result = await runFunnel('funnel-1', { triggerType: 'manual' });
 
       expect(result).toEqual(mockRun);
       expect(useFunnelStore.getState().runs).toHaveLength(1);

package/src/store/create-funnel-store.ts

@@ -74,7 +74,7 @@ export function createFunnelStore<TEntity = any>(
             next: response.next,
             previous: response.previous,
             currentPage: filters?.page || 1,
-            pageSize: filters?.page_size || 20,
+            pageSize: filters?.pageSize || 20,
           },
           isLoading: false,
         });
@@ -204,12 +204,12 @@ export function createFunnelStore<TEntity = any>(
         name: `${funnel.name} (Copy)`,
         description: funnel.description,
         status: 'draft', // Always create as draft
-        input_type: funnel.input_type,
+        inputType: funnel.inputType,
         stages: funnel.stages.map((stage, index) => ({
           ...stage,
           order: index, // Preserve order
         })),
-        completion_tags: funnel.completion_tags,
+        completionTags: funnel.completionTags,
         metadata: funnel.metadata,
       };
 

package/src/store/types.ts

@@ -190,7 +190,7 @@ export interface FunnelStore<TEntity = any> {
   runFunnel: (
     id: string,
     options?: {
-      trigger_type?: 'manual' | 'scheduled' | 'webhook' | 'api';
+      triggerType?: 'manual' | 'scheduled' | 'webhook' | 'api';
       metadata?: Record<string, any>;
     }
   ) => Promise<FunnelRun>;
@@ -206,7 +206,7 @@ export interface FunnelStore<TEntity = any> {
     filters?: {
       status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
       page?: number;
-      page_size?: number;
+      pageSize?: number;
     }
   ) => Promise<void>;