@ram_28/kf-ai-sdk 1.0.5 → 1.0.8

package/sdk/components/hooks/useFilter/payloadBuilder.utils.ts

@@ -1,298 +0,0 @@
-import type { Filter, FilterCondition, FilterLogical, LogicalOperator } from "../../../types/common";
-import type { FilterConditionWithId, FilterState } from "../useFilter";
-
-// ============================================================
-// PAYLOAD BUILDING UTILITIES
-// ============================================================
-
-/**
- * Helper to check if operator is a logical operator
- */
-const isLogicalOperator = (operator: string): operator is LogicalOperator => {
-  return operator === 'And' || operator === 'Or' || operator === 'Not';
-};
-
-/**
- * Convert a single FilterConditionWithId to API format (FilterCondition or FilterLogical)
- */
-const buildCondition = (condition: FilterConditionWithId): FilterCondition | FilterLogical => {
-  // Check if this is a logical operator (nested group)
-  if (isLogicalOperator(condition.operator)) {
-    // Build nested logical filter
-    return {
-      Operator: condition.operator,
-      Condition: (condition.children || [])
-        .filter(child => child.isValid)
-        .map(child => buildCondition(child))
-    };
-  } else {
-    // Build simple condition
-    return {
-      Operator: condition.operator,
-      LHSField: condition.lhsField!,
-      RHSValue: condition.rhsValue,
-      RHSType: condition.rhsType || "Constant"
-    };
-  }
-};
-
-/**
- * Build SDK Filter payload from filter state
- * Returns undefined if no valid conditions exist
- * Supports both flat and nested filter structures
- */
-export const buildFilterPayload = (
-  conditions: FilterConditionWithId[],
-  logicalOperator: LogicalOperator
-): Filter | undefined => {
-  // Return undefined if no conditions
-  if (conditions.length === 0) {
-    return undefined;
-  }
-
-  // Filter out invalid conditions
-  const validConditions = conditions.filter(condition => condition.isValid);
-
-  // Return undefined if no valid conditions
-  if (validConditions.length === 0) {
-    return undefined;
-  }
-
-  // Build the filter payload
-  return {
-    Operator: logicalOperator,
-    Condition: validConditions.map(buildCondition)
-  };
-};
-
-/**
- * Build filter payload from complete filter state
- */
-export const buildFilterPayloadFromState = (state: FilterState): Filter | undefined => {
-  return buildFilterPayload(state.conditions, state.logicalOperator);
-};
-
-/**
- * Validate that a filter payload is well-formed (supports nested filters)
- */
-export const validateFilterPayload = (filter: Filter | undefined): boolean => {
-  if (!filter) {
-    return true; // undefined filter is valid (no filtering)
-  }
-
-  // Check operator
-  if (!filter.Operator || !['And', 'Or', 'Not'].includes(filter.Operator)) {
-    return false;
-  }
-
-  // Check conditions array
-  if (!Array.isArray(filter.Condition) || filter.Condition.length === 0) {
-    return false;
-  }
-
-  // Not operator can only have one child
-  if (filter.Operator === 'Not' && filter.Condition.length !== 1) {
-    return false;
-  }
-
-  // Validate each condition recursively
-  return filter.Condition.every(condition => {
-    if (!condition.Operator) {
-      return false;
-    }
-
-    // Check if this is a logical operator (nested)
-    if (isLogicalOperator(condition.Operator)) {
-      // Recursively validate nested filter
-      return validateFilterPayload(condition as FilterLogical);
-    } else {
-      // Validate simple condition
-      const simpleCondition = condition as FilterCondition;
-      return (
-        simpleCondition.LHSField !== undefined &&
-        simpleCondition.RHSValue !== undefined &&
-        (simpleCondition.RHSType === undefined || ['Constant', 'BOField', 'AppVariable'].includes(simpleCondition.RHSType))
-      );
-    }
-  });
-};
-
-/**
- * Deep clone a filter condition (supports nested filters)
- */
-const cloneCondition = (condition: FilterCondition | FilterLogical): FilterCondition | FilterLogical => {
-  if (isLogicalOperator(condition.Operator)) {
-    // Clone logical filter recursively
-    return {
-      Operator: condition.Operator,
-      Condition: (condition as FilterLogical).Condition.map(cloneCondition)
-    };
-  } else {
-    // Clone simple condition
-    const simpleCondition = condition as FilterCondition;
-    return {
-      Operator: simpleCondition.Operator,
-      LHSField: simpleCondition.LHSField,
-      RHSValue: simpleCondition.RHSValue,
-      RHSType: simpleCondition.RHSType
-    };
-  }
-};
-
-/**
- * Deep clone a filter payload (supports nested filters)
- */
-export const cloneFilterPayload = (filter: Filter | undefined): Filter | undefined => {
-  if (!filter) {
-    return undefined;
-  }
-
-  return {
-    Operator: filter.Operator,
-    Condition: filter.Condition.map(cloneCondition)
-  };
-};
-
-/**
- * Merge multiple filter payloads with a logical operator
- */
-export const mergeFilterPayloads = (
-  filters: (Filter | undefined)[],
-  operator: LogicalOperator
-): Filter | undefined => {
-  const validFilters = filters.filter((filter): filter is Filter =>
-    filter !== undefined && validateFilterPayload(filter)
-  );
-
-  if (validFilters.length === 0) {
-    return undefined;
-  }
-
-  if (validFilters.length === 1) {
-    return cloneFilterPayload(validFilters[0]);
-  }
-
-  // Flatten all conditions
-  const allConditions = validFilters.flatMap(filter => filter.Condition);
-
-  return {
-    Operator: operator,
-    Condition: allConditions
-  };
-};
-
-/**
- * Convert filter condition to a human-readable string (supports nested filters)
- */
-const conditionToString = (condition: FilterCondition | FilterLogical): string => {
-  if (isLogicalOperator(condition.Operator)) {
-    // Handle logical filter
-    const logicalFilter = condition as FilterLogical;
-    const childStrings = logicalFilter.Condition.map(conditionToString);
-
-    if (childStrings.length === 1) {
-      return condition.Operator === 'Not'
-        ? `NOT (${childStrings[0]})`
-        : childStrings[0];
-    }
-
-    return `(${childStrings.join(` ${condition.Operator} `)})`;
-  } else {
-    // Handle simple condition
-    const simpleCondition = condition as FilterCondition;
-    const rhsDisplay = Array.isArray(simpleCondition.RHSValue)
-      ? `[${simpleCondition.RHSValue.join(', ')}]`
-      : String(simpleCondition.RHSValue);
-
-    return `${simpleCondition.LHSField} ${simpleCondition.Operator} ${rhsDisplay}`;
-  }
-};
-
-/**
- * Convert filter payload to a human-readable string for debugging (supports nested filters)
- */
-export const filterPayloadToString = (filter: Filter | undefined): string => {
-  if (!filter) {
-    return "No filters";
-  }
-
-  const conditionStrings = filter.Condition.map(conditionToString);
-
-  if (conditionStrings.length === 1) {
-    return conditionStrings[0];
-  }
-
-  return `(${conditionStrings.join(` ${filter.Operator} `)})`;
-};
-
-/**
- * Check if two conditions are equivalent (supports nested filters)
- */
-const areConditionsEqual = (
-  condition1: FilterCondition | FilterLogical,
-  condition2: FilterCondition | FilterLogical
-): boolean => {
-  // Different operators
-  if (condition1.Operator !== condition2.Operator) {
-    return false;
-  }
-
-  // Check if logical operators
-  if (isLogicalOperator(condition1.Operator)) {
-    const logical1 = condition1 as FilterLogical;
-    const logical2 = condition2 as FilterLogical;
-
-    // Different number of children
-    if (logical1.Condition.length !== logical2.Condition.length) {
-      return false;
-    }
-
-    // Recursively compare all children
-    return logical1.Condition.every((child1, index) =>
-      areConditionsEqual(child1, logical2.Condition[index])
-    );
-  } else {
-    // Compare simple conditions
-    const simple1 = condition1 as FilterCondition;
-    const simple2 = condition2 as FilterCondition;
-
-    return (
-      simple1.LHSField === simple2.LHSField &&
-      JSON.stringify(simple1.RHSValue) === JSON.stringify(simple2.RHSValue) &&
-      simple1.RHSType === simple2.RHSType
-    );
-  }
-};
-
-/**
- * Check if two filter payloads are equivalent (supports nested filters)
- */
-export const areFilterPayloadsEqual = (
-  filter1: Filter | undefined,
-  filter2: Filter | undefined
-): boolean => {
-  // Both undefined
-  if (!filter1 && !filter2) {
-    return true;
-  }
-
-  // One undefined, one defined
-  if (!filter1 || !filter2) {
-    return false;
-  }
-
-  // Different operators
-  if (filter1.Operator !== filter2.Operator) {
-    return false;
-  }
-
-  // Different number of conditions
-  if (filter1.Condition.length !== filter2.Condition.length) {
-    return false;
-  }
-
-  // Compare each condition recursively
-  return filter1.Condition.every((condition1, index) =>
-    areConditionsEqual(condition1, filter2.Condition[index])
-  );
-};

package/sdk/components/hooks/useFilter/validation.utils.ts

@@ -1,401 +0,0 @@
-import type { FilterOperator } from "../../../types/common";
-import type { FieldDefinition, ValidationResult } from "../useFilter";
-
-// ============================================================
-// FIELD TYPE VALIDATION HELPERS
-// ============================================================
-
-/**
- * Validate number values based on operator
- */
-export const validateNumberValue = (value: any, operator: FilterOperator): ValidationResult => {
-  const errors: string[] = [];
-
-  switch (operator) {
-    case 'Between':
-    case 'NotBetween':
-      if (!Array.isArray(value) || value.length !== 2) {
-        errors.push('Between operators require exactly two numeric values');
-      } else {
-        const [min, max] = value;
-        if (typeof min !== 'number' || typeof max !== 'number') {
-          errors.push('Between values must be numbers');
-        } else if (min >= max) {
-          errors.push('First value must be less than second value');
-        }
-      }
-      break;
-    case 'IN':
-    case 'NIN':
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push('IN/NIN operators require a non-empty array of numbers');
-      } else if (!value.every((v: any) => typeof v === 'number')) {
-        errors.push('All values in array must be numbers');
-      }
-      break;
-    case 'Empty':
-    case 'NotEmpty':
-      // No validation needed for these operators
-      break;
-    default:
-      if (typeof value !== 'number' || isNaN(value)) {
-        errors.push('Value must be a valid number');
-      }
-      break;
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-};
-
-/**
- * Validate date values based on operator
- */
-export const validateDateValue = (value: any, operator: FilterOperator): ValidationResult => {
-  const errors: string[] = [];
-
-  const isValidDate = (date: any): boolean => {
-    return date instanceof Date && !isNaN(date.getTime());
-  };
-
-  const parseDate = (val: any): Date | null => {
-    if (val instanceof Date) return val;
-    if (typeof val === 'string' || typeof val === 'number') {
-      const parsed = new Date(val);
-      return isValidDate(parsed) ? parsed : null;
-    }
-    return null;
-  };
-
-  switch (operator) {
-    case 'Between':
-    case 'NotBetween':
-      if (!Array.isArray(value) || value.length !== 2) {
-        errors.push('Between operators require exactly two date values');
-      } else {
-        const [start, end] = value.map(parseDate);
-        if (!start || !end) {
-          errors.push('Between values must be valid dates');
-        } else if (start >= end) {
-          errors.push('Start date must be before end date');
-        }
-      }
-      break;
-    case 'IN':
-    case 'NIN':
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push('IN/NIN operators require a non-empty array of dates');
-      } else if (!value.every((v: any) => parseDate(v))) {
-        errors.push('All values in array must be valid dates');
-      }
-      break;
-    case 'Empty':
-    case 'NotEmpty':
-      // No validation needed for these operators
-      break;
-    default:
-      if (!parseDate(value)) {
-        errors.push('Value must be a valid date');
-      }
-      break;
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-};
-
-/**
- * Validate currency values based on operator
- */
-export const validateCurrencyValue = (value: any, operator: FilterOperator): ValidationResult => {
-  const errors: string[] = [];
-
-  const isValidCurrencyObject = (val: any): boolean => {
-    return val && 
-           typeof val === 'object' &&
-           typeof val.value === 'number' &&
-           typeof val.currency === 'string' &&
-           val.currency.length === 3; // Standard currency codes are 3 letters
-  };
-
-  const isValidCurrencyString = (val: any): boolean => {
-    return typeof val === 'string' && /^\d+(\.\d{2})?\s[A-Z]{3}$/.test(val);
-  };
-
-  const isValidCurrency = (val: any): boolean => {
-    return isValidCurrencyObject(val) || isValidCurrencyString(val) || typeof val === 'number';
-  };
-
-  switch (operator) {
-    case 'Between':
-    case 'NotBetween':
-      if (!Array.isArray(value) || value.length !== 2) {
-        errors.push('Between operators require exactly two currency values');
-      } else if (!value.every(isValidCurrency)) {
-        errors.push('Between values must be valid currency amounts');
-      }
-      break;
-    case 'IN':
-    case 'NIN':
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push('IN/NIN operators require a non-empty array of currency values');
-      } else if (!value.every(isValidCurrency)) {
-        errors.push('All values in array must be valid currency amounts');
-      }
-      break;
-    case 'Empty':
-    case 'NotEmpty':
-      // No validation needed for these operators
-      break;
-    default:
-      if (!isValidCurrency(value)) {
-        errors.push('Value must be a valid currency amount');
-      }
-      break;
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-};
-
-/**
- * Validate string values based on operator
- */
-export const validateStringValue = (value: any, operator: FilterOperator): ValidationResult => {
-  const errors: string[] = [];
-
-  switch (operator) {
-    case 'Between':
-    case 'NotBetween':
-      errors.push('Between operators are not supported for string fields');
-      break;
-    case 'GT':
-    case 'GTE':
-    case 'LT':
-    case 'LTE':
-      errors.push('Comparison operators are not supported for string fields');
-      break;
-    case 'IN':
-    case 'NIN':
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push('IN/NIN operators require a non-empty array of strings');
-      } else if (!value.every((v: any) => typeof v === 'string')) {
-        errors.push('All values in array must be strings');
-      }
-      break;
-    case 'MinLength':
-      if (typeof value !== 'number' || value < 0) {
-        errors.push('MinLength value must be a non-negative number');
-      }
-      break;
-    case 'MaxLength':
-      if (typeof value !== 'number' || value < 0) {
-        errors.push('MaxLength value must be a non-negative number');
-      }
-      break;
-    case 'Empty':
-    case 'NotEmpty':
-      // No validation needed for these operators
-      break;
-    default:
-      if (typeof value !== 'string') {
-        errors.push('Value must be a string');
-      }
-      break;
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-};
-
-/**
- * Validate boolean values based on operator
- */
-export const validateBooleanValue = (value: any, operator: FilterOperator): ValidationResult => {
-  const errors: string[] = [];
-
-  const supportedOperators: FilterOperator[] = ['EQ', 'NE', 'IN', 'NIN', 'Empty', 'NotEmpty'];
-
-  if (!supportedOperators.includes(operator)) {
-    errors.push(`Operator ${operator} is not supported for boolean fields`);
-    return { isValid: false, errors };
-  }
-
-  switch (operator) {
-    case 'IN':
-    case 'NIN':
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push('IN/NIN operators require a non-empty array of boolean values');
-      } else if (!value.every((v: any) => typeof v === 'boolean')) {
-        errors.push('All values in array must be boolean');
-      }
-      break;
-    case 'Empty':
-    case 'NotEmpty':
-      // No validation needed for these operators
-      break;
-    default:
-      if (typeof value !== 'boolean') {
-        errors.push('Value must be a boolean (true or false)');
-      }
-      break;
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-};
-
-/**
- * Validate select field values based on operator and available options
- */
-export const validateSelectValue = (
-  value: any, 
-  operator: FilterOperator, 
-  selectOptions?: Array<{ label: string; value: any }>
-): ValidationResult => {
-  const errors: string[] = [];
-
-  if (!selectOptions || selectOptions.length === 0) {
-    errors.push('No select options defined for this field');
-    return { isValid: false, errors };
-  }
-
-  const validValues = selectOptions.map(option => option.value);
-  const isValidOption = (val: any) => validValues.includes(val);
-
-  switch (operator) {
-    case 'Between':
-    case 'NotBetween':
-    case 'GT':
-    case 'GTE':
-    case 'LT':
-    case 'LTE':
-      errors.push(`Operator ${operator} is not supported for select fields`);
-      break;
-    case 'IN':
-    case 'NIN':
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push('IN/NIN operators require a non-empty array of values');
-      } else if (!value.every(isValidOption)) {
-        errors.push('All values must be from the available options');
-      }
-      break;
-    case 'Empty':
-    case 'NotEmpty':
-      // No validation needed for these operators
-      break;
-    default:
-      if (!isValidOption(value)) {
-        errors.push('Value must be one of the available options');
-      }
-      break;
-  }
-
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-};
-
-// ============================================================
-// FIELD DEFINITION HELPERS
-// ============================================================
-
-/**
- * Get default field definition based on field type
- */
-export const getDefaultFieldDefinition = (fieldType: FieldDefinition['type']): FieldDefinition => {
-  switch (fieldType) {
-    case 'string':
-      return {
-        type: 'string',
-        allowedOperators: ['EQ', 'NE', 'Contains', 'NotContains', 'IN', 'NIN', 'Empty', 'NotEmpty', 'MinLength', 'MaxLength'],
-        validateValue: validateStringValue
-      };
-    
-    case 'number':
-      return {
-        type: 'number',
-        allowedOperators: ['EQ', 'NE', 'GT', 'GTE', 'LT', 'LTE', 'Between', 'NotBetween', 'IN', 'NIN', 'Empty', 'NotEmpty'],
-        validateValue: validateNumberValue
-      };
-    
-    case 'date':
-      return {
-        type: 'date',
-        allowedOperators: ['EQ', 'NE', 'GT', 'GTE', 'LT', 'LTE', 'Between', 'NotBetween', 'IN', 'NIN', 'Empty', 'NotEmpty'],
-        validateValue: validateDateValue
-      };
-    
-    case 'boolean':
-      return {
-        type: 'boolean',
-        allowedOperators: ['EQ', 'NE', 'IN', 'NIN', 'Empty', 'NotEmpty'],
-        validateValue: validateBooleanValue
-      };
-    
-    case 'currency':
-      return {
-        type: 'currency',
-        allowedOperators: ['EQ', 'NE', 'GT', 'GTE', 'LT', 'LTE', 'Between', 'NotBetween', 'IN', 'NIN', 'Empty', 'NotEmpty'],
-        validateValue: validateCurrencyValue
-      };
-    
-    case 'select':
-      const selectFieldDef: FieldDefinition = {
-        type: 'select',
-        allowedOperators: ['EQ', 'NE', 'IN', 'NIN', 'Empty', 'NotEmpty'],
-        selectOptions: []
-      };
-      selectFieldDef.validateValue = (value: any, operator: FilterOperator) =>
-        validateSelectValue(value, operator, selectFieldDef.selectOptions);
-      return selectFieldDef;
-    
-    default:
-      // Default to string type
-      return getDefaultFieldDefinition('string');
-  }
-};
-
-/**
- * Create field definitions from sample data
- */
-export const createFieldDefinitionsFromSample = <T>(sampleData: T): Record<keyof T, FieldDefinition> => {
-  const fieldDefinitions = {} as Record<keyof T, FieldDefinition>;
-
-  if (!sampleData || typeof sampleData !== 'object') {
-    return fieldDefinitions;
-  }
-
-  Object.keys(sampleData).forEach(key => {
-    const value = (sampleData as any)[key];
-    const fieldKey = key as keyof T;
-
-    if (typeof value === 'string') {
-      fieldDefinitions[fieldKey] = getDefaultFieldDefinition('string');
-    } else if (typeof value === 'number') {
-      fieldDefinitions[fieldKey] = getDefaultFieldDefinition('number');
-    } else if (typeof value === 'boolean') {
-      fieldDefinitions[fieldKey] = getDefaultFieldDefinition('boolean');
-    } else if (value instanceof Date) {
-      fieldDefinitions[fieldKey] = getDefaultFieldDefinition('date');
-    } else if (value && typeof value === 'object' && 'value' in value && 'currency' in value) {
-      fieldDefinitions[fieldKey] = getDefaultFieldDefinition('currency');
-    } else {
-      // Default to string for complex types
-      fieldDefinitions[fieldKey] = getDefaultFieldDefinition('string');
-    }
-  });
-
-  return fieldDefinitions;
-};