@startsimpli/funnels 0.4.6 → 0.4.8

package/src/types/index.ts

@@ -74,17 +74,17 @@ export type FieldType =
  * A single filter rule
  *
  * Examples:
- * - { field_path: 'firm.stage', operator: 'eq', value: 'Series A' }
- * - { field_path: 'recipe.cuisine', operator: 'in', value: ['Italian', 'French'] }
- * - { field_path: 'contact.email', operator: 'isnotnull', value: null }
- * - { field_path: 'organization.tags', operator: 'has_tag', value: 'enterprise' }
+ * - { fieldPath: 'firm.stage', operator: 'eq', value: 'Series A' }
+ * - { fieldPath: 'recipe.cuisine', operator: 'in', value: ['Italian', 'French'] }
+ * - { fieldPath: 'contact.email', operator: 'isnotnull', value: null }
+ * - { fieldPath: 'organization.tags', operator: 'has_tag', value: 'enterprise' }
  */
 export interface FilterRule {
   /**
    * Dot-notation path to field
    * Examples: 'name', 'firm.stage', 'profile.linkedin_url', 'tags', 'metrics.arr_usd'
    */
-  field_path: string;
+  fieldPath: string;
 
   /** Comparison operator */
   operator: Operator;
@@ -156,22 +156,22 @@ export interface FunnelStage<TEntity = any> {
    * - AND: All rules must match
    * - OR: At least one rule must match
    */
-  filter_logic: FilterLogic;
+  filterLogic: FilterLogic;
 
   /** Filter rules to evaluate */
   rules: FilterRule[];
 
   /** Action when rules match */
-  match_action: MatchAction;
+  matchAction: MatchAction;
 
   /** Action when rules don't match */
-  no_match_action: NoMatchAction;
+  noMatchAction: NoMatchAction;
 
   /** Tags to add when rules match */
-  match_tags?: string[];
+  matchTags?: string[];
 
   /** Tags to add when rules don't match */
-  no_match_tags?: string[];
+  noMatchTags?: string[];
 
   /**
    * Context to add to entity when rules match
@@ -180,13 +180,13 @@ export interface FunnelStage<TEntity = any> {
    * - { stage: 'qualified_leads', reason: 'high_fit_score' }
    * - { tier: 'premium', discount: 0.2 }
    */
-  match_context?: Record<string, any>;
+  matchContext?: Record<string, any>;
 
   /**
    * Optional: Custom evaluation function
    * For complex logic that can't be expressed with rules
    */
-  custom_evaluator?: (entity: TEntity) => boolean;
+  customEvaluator?: (entity: TEntity) => boolean;
 }
 
 // ============================================================================
@@ -225,28 +225,28 @@ export interface Funnel<TEntity = any> {
    * Type of entities this funnel processes
    * Used for field registry lookup
    */
-  input_type: InputType;
+  inputType: InputType;
 
   /** Ordered stages */
   stages: FunnelStage<TEntity>[];
 
   /** Created timestamp */
-  created_at: Date | string;
+  createdAt: Date | string;
 
   /** Last updated timestamp */
-  updated_at: Date | string;
+  updatedAt: Date | string;
 
   /** Owner user ID */
-  owner_id?: string;
+  ownerId?: string;
 
   /** Team/company ID for multi-tenancy */
-  team_id?: string;
+  teamId?: string;
 
   /**
    * Optional: Tags to automatically add to all entities
    * that complete the funnel
    */
-  completion_tags?: string[];
+  completionTags?: string[];
 
   /**
    * Optional: Metadata for custom integrations
@@ -282,34 +282,34 @@ export type TriggerType =
  */
 export interface StageStats {
   /** Stage ID */
-  stage_id: string;
+  stageId: string;
 
   /** Stage name */
-  stage_name: string;
+  stageName: string;
 
   /** Entities that entered this stage */
-  input_count: number;
+  inputCount: number;
 
   /** Entities that matched rules */
-  matched_count: number;
+  matchedCount: number;
 
   /** Entities that didn't match rules */
-  not_matched_count: number;
+  notMatchedCount: number;
 
   /** Entities excluded at this stage */
-  excluded_count: number;
+  excludedCount: number;
 
   /** Entities tagged at this stage */
-  tagged_count: number;
+  taggedCount: number;
 
   /** Entities that continued to next stage */
-  continued_count: number;
+  continuedCount: number;
 
   /** Execution time in milliseconds */
-  duration_ms?: number;
+  durationMs?: number;
 
   /** Error count */
-  error_count?: number;
+  errorCount?: number;
 }
 
 /**
@@ -320,7 +320,7 @@ export interface FunnelRun {
   id: string;
 
   /** Funnel ID */
-  funnel_id: string;
+  funnelId: string;
 
   /** Funnel snapshot (copy of funnel at run time) */
   funnel?: Funnel;
@@ -329,40 +329,40 @@ export interface FunnelRun {
   status: FunnelRunStatus;
 
   /** How run was triggered */
-  trigger_type: TriggerType;
+  triggerType: TriggerType;
 
   /** User who triggered (if manual) */
-  triggered_by?: string;
+  triggeredBy?: string;
 
   /** Started timestamp */
-  started_at: Date | string;
+  startedAt: Date | string;
 
   /** Completed timestamp */
-  completed_at?: Date | string;
+  completedAt?: Date | string;
 
   /** Duration in milliseconds */
-  duration_ms?: number;
+  durationMs?: number;
 
   /** Total entities input */
-  total_input: number;
+  totalInput: number;
 
   /** Total entities matched (in output) */
-  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>;
 
   /** Error message (if failed) */
   error?: string;
 
   /** Stack trace (if failed) */
-  stack_trace?: string;
+  stackTrace?: string;
 
   /** Metadata */
   metadata?: Record<string, any>;
@@ -379,16 +379,16 @@ export interface FunnelResult<TEntity = any> {
   matched: boolean;
 
   /** Stage where entity was excluded (if excluded) */
-  excluded_at_stage?: string;
+  excludedAtStage?: string;
 
   /** Tags accumulated during processing */
-  accumulated_tags: string[];
+  accumulatedTags: string[];
 
   /** Context accumulated during processing */
   context: Record<string, any>;
 
   /** Stage-by-stage results */
-  stage_results?: StageResult[];
+  stageResults?: StageResult[];
 }
 
 /**
@@ -396,25 +396,25 @@ export interface FunnelResult<TEntity = any> {
  */
 export interface StageResult {
   /** Stage ID */
-  stage_id: string;
+  stageId: string;
 
   /** Stage name */
-  stage_name: string;
+  stageName: string;
 
   /** Whether rules matched */
   matched: boolean;
 
   /** Rule evaluation results */
-  rule_results?: RuleResult[];
+  ruleResults?: RuleResult[];
 
   /** Action taken */
   action: MatchAction | NoMatchAction;
 
   /** Tags added */
-  tags_added?: string[];
+  tagsAdded?: string[];
 
   /** Context added */
-  context_added?: Record<string, any>;
+  contextAdded?: Record<string, any>;
 
   /** Whether entity was excluded */
   excluded: boolean;
@@ -428,7 +428,7 @@ export interface StageResult {
  */
 export interface RuleResult {
   /** Rule field path */
-  field_path: string;
+  fieldPath: string;
 
   /** Rule operator */
   operator: Operator;
@@ -437,7 +437,7 @@ export interface RuleResult {
   value: any;
 
   /** Actual value from entity */
-  actual_value: any;
+  actualValue: any;
 
   /** Whether rule matched */
   matched: boolean;
@@ -460,10 +460,10 @@ export type ValidOperators = Operator[];
  */
 export interface FieldConstraints {
   /** Minimum value (numbers, dates) */
-  min_value?: number | string;
+  minValue?: number | string;
 
   /** Maximum value (numbers, dates) */
-  max_value?: number | string;
+  maxValue?: number | string;
 
   /** Allowed values (enums) */
   choices?: any[];
@@ -513,7 +513,7 @@ export interface FieldDefinition {
   examples?: any[];
 
   /** Related fields (for UI suggestions) */
-  related_fields?: string[];
+  relatedFields?: string[];
 }
 
 /**
@@ -523,13 +523,13 @@ export interface FieldDefinition {
  */
 export interface FieldRegistry {
   /** Entity type this registry is for */
-  entity_type: string;
+  entityType: string;
 
   /** Available fields */
   fields: FieldDefinition[];
 
   /** Field lookup by name */
-  field_map?: Map<string, FieldDefinition>;
+  fieldMap?: Map<string, FieldDefinition>;
 
   /** Categories (for UI grouping) */
   categories?: string[];
@@ -573,7 +573,7 @@ export type FieldPath<T, Prefix extends string = ''> = {
  */
 export type CreateFunnelInput<TEntity = any> = Omit<
   Funnel<TEntity>,
-  'id' | 'created_at' | 'updated_at'
+  'id' | 'createdAt' | 'updatedAt'
 >;
 
 /**
@@ -625,7 +625,7 @@ export function isStage<TEntity = any>(value: unknown): value is FunnelStage<TEn
     typeof s.id === 'string' &&
     typeof s.name === 'string' &&
     typeof s.order === 'number' &&
-    ['AND', 'OR'].includes(s.filter_logic) &&
+    ['AND', 'OR'].includes(s.filterLogic) &&
     Array.isArray(s.rules)
   );
 }
@@ -638,7 +638,7 @@ export function isFilterRule(value: unknown): value is FilterRule {
   return (
     typeof r === 'object' &&
     r !== null &&
-    typeof r.field_path === 'string' &&
+    typeof r.fieldPath === 'string' &&
     typeof r.operator === 'string' &&
     r.value !== undefined
   );
@@ -653,7 +653,7 @@ export function isFunnelRun(value: unknown): value is FunnelRun {
     typeof r === 'object' &&
     r !== null &&
     typeof r.id === 'string' &&
-    typeof r.funnel_id === 'string' &&
+    typeof r.funnelId === 'string' &&
     ['pending', 'running', 'completed', 'failed', 'cancelled'].includes(r.status)
   );
 }
@@ -670,7 +670,7 @@ export function isFunnelResult<TEntity = any>(
     r !== null &&
     r.entity !== undefined &&
     typeof r.matched === 'boolean' &&
-    Array.isArray(r.accumulated_tags)
+    Array.isArray(r.accumulatedTags)
   );
 }
 
@@ -758,8 +758,8 @@ export function isValidOperator(
 export function validateFilterRule(rule: FilterRule): string[] {
   const errors: string[] = [];
 
-  if (!rule.field_path) {
-    errors.push('field_path is required');
+  if (!rule.fieldPath) {
+    errors.push('fieldPath is required');
   }
 
   if (!rule.operator) {
@@ -791,8 +791,8 @@ export function validateStage<TEntity = any>(
     errors.push('order must be a number');
   }
 
-  if (!['AND', 'OR'].includes(stage.filter_logic)) {
-    errors.push('filter_logic must be AND or OR');
+  if (!['AND', 'OR'].includes(stage.filterLogic)) {
+    errors.push('filterLogic must be AND or OR');
   }
 
   if (!Array.isArray(stage.rules)) {