@ram_28/kf-ai-sdk 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ram_28/kf-ai-sdk",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Type-safe, AI-driven SDK for building modern web applications with role-based access control",
   "author": "Ramprasad",
   "license": "MIT",

package/sdk/components/hooks/useFilter/index.ts

@@ -6,25 +6,12 @@ export type {
   FilterConditionWithId,
   TypedFilterConditionInput,
   FilterState,
-  FieldDefinition,
   ValidationResult,
   ValidationError,
   UseFilterOptions,
   UseFilterReturn
 } from './types';
 
-// Validation utilities
-export {
-  validateNumberValue,
-  validateDateValue,
-  validateCurrencyValue,
-  validateStringValue,
-  validateBooleanValue,
-  validateSelectValue,
-  getDefaultFieldDefinition,
-  createFieldDefinitionsFromSample
-} from './validation.utils';
-
 // Payload building utilities
 export {
   buildFilterPayload,

package/sdk/components/hooks/useFilter/types.ts

@@ -51,19 +51,6 @@ export interface FilterState {
   conditions: FilterConditionWithId[];
 }
 
-export interface FieldDefinition {
-  /** Field data type */
-  type: 'string' | 'number' | 'date' | 'boolean' | 'currency' | 'select';
-  /** Operators allowed for this field type */
-  allowedOperators: FilterOperator[];
-  /** Custom value validation function */
-  validateValue?: (value: any, operator: FilterOperator) => ValidationResult;
-  /** Value transformation function */
-  transformValue?: (value: any) => any;
-  /** Options for select fields */
-  selectOptions?: Array<{ label: string; value: any }>;
-}
-
 export interface ValidationResult {
   /** Whether the validation passed */
   isValid: boolean;
@@ -80,13 +67,11 @@ export interface ValidationError {
   message: string;
 }
 
-export interface UseFilterOptions<T = any> {
+export interface UseFilterOptions {
   /** Initial filter conditions */
   initialConditions?: FilterConditionWithId[];
   /** Initial logical operator */
   initialLogicalOperator?: LogicalOperator;
-  /** Field definitions for validation */
-  fieldDefinitions?: Record<keyof T, FieldDefinition>;
   /** Whether to validate conditions on change */
   validateOnChange?: boolean;
   /** Callback when condition is added */

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

@@ -3,7 +3,6 @@ import type { Filter, LogicalOperator } from "../../../types/common";
 import type {
   FilterConditionWithId,
   TypedFilterConditionInput,
-  FieldDefinition,
   ValidationResult,
   ValidationError,
   FilterState,
@@ -32,9 +31,8 @@ const isLogicalOperator = (operator: string): operator is LogicalOperator => {
 /**
  * Validate a filter condition (supports both simple conditions and nested logical groups)
  */
-const validateFilterCondition = <T>(
-  condition: Partial<FilterConditionWithId>,
-  fieldDefinitions?: Record<keyof T, FieldDefinition>
+const validateFilterCondition = (
+  condition: Partial<FilterConditionWithId>
 ): ValidationResult => {
   const errors: string[] = [];
 
@@ -57,7 +55,7 @@ const validateFilterCondition = <T>(
     // Recursively validate children
     if (condition.children && Array.isArray(condition.children)) {
       condition.children.forEach((child, index) => {
-        const childValidation = validateFilterCondition(child, fieldDefinitions);
+        const childValidation = validateFilterCondition(child);
         if (!childValidation.isValid) {
           errors.push(...childValidation.errors.map(err => `Child ${index + 1}: ${err}`));
         }
@@ -104,25 +102,6 @@ const validateFilterCondition = <T>(
       }
     }
 
-    // Field-specific validation
-    if (fieldDefinitions && condition.lhsField && condition.operator) {
-      const fieldDef = fieldDefinitions[condition.lhsField as keyof T];
-      if (fieldDef) {
-        // Check if operator is allowed for this field
-        if (!fieldDef.allowedOperators.includes(condition.operator as any)) {
-          errors.push(`Operator ${condition.operator} is not allowed for field ${condition.lhsField}`);
-        }
-
-        // Custom field validation
-        if (fieldDef.validateValue && condition.rhsValue !== undefined) {
-          const fieldValidation = fieldDef.validateValue(condition.rhsValue, condition.operator as any);
-          if (!fieldValidation.isValid) {
-            errors.push(...fieldValidation.errors);
-          }
-        }
-      }
-    }
-
     // Simple conditions should not have children
     if (condition.children && condition.children.length > 0) {
       errors.push('Condition operators should not have children');
@@ -187,7 +166,7 @@ const buildFilterPayload = (
 // ============================================================
 
 export function useFilter<T = any>(
-  options: UseFilterOptions<T> = {}
+  options: UseFilterOptions = {}
 ): UseFilterReturn<T> {
   // ============================================================
   // STATE MANAGEMENT
@@ -209,8 +188,8 @@ export function useFilter<T = any>(
   // ============================================================
 
   const validateCondition = useCallback((condition: Partial<FilterConditionWithId>): ValidationResult => {
-    return validateFilterCondition(condition, options.fieldDefinitions);
-  }, [options.fieldDefinitions]);
+    return validateFilterCondition(condition);
+  }, []);
 
   const validateAllConditions = useCallback((): ValidationResult => {
     const allErrors: string[] = [];

package/sdk/components/hooks/useKanban/types.ts

@@ -7,7 +7,6 @@
 import type {
   FilterConditionWithId,
   ValidationError,
-  FieldDefinition,
 } from "../useFilter";
 import type { LogicalOperator } from "../../../types/common";
 
@@ -199,9 +198,6 @@ export interface UseKanbanOptions<T> {
   /** Enable search functionality */
   enableSearch?: boolean;
 
-  /** Field definitions for card validation */
-  cardFieldDefinitions?: Record<keyof T, FieldDefinition>;
-
   /** Initial state */
   initialState?: {
     /** Initial filter conditions */
@@ -537,7 +533,6 @@ export interface CardValidationContext<T> {
   card: Partial<KanbanCard<T>>;
   column?: KanbanColumn<T>;
   allColumns: KanbanColumn<T>[];
-  fieldDefinitions?: Record<keyof T, FieldDefinition>;
 }
 
 /**

package/sdk/components/hooks/useKanban/useKanban.ts

@@ -28,7 +28,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     cardSource,
     source,
     enableDragDrop = true,
-    cardFieldDefinitions,
     initialState,
     onCardMove,
     onCardCreate,
@@ -93,7 +92,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
   const filterHook = useFilter<T>({
     initialConditions: initialState?.filters,
     initialLogicalOperator: initialState?.filterOperator || "And",
-    fieldDefinitions: cardFieldDefinitions,
     validateOnChange: true,
     onValidationError: onFilterError,
   });

package/sdk/components/hooks/useTable/types.ts

@@ -3,7 +3,6 @@ import type {
   FilterConditionWithId,
   TypedFilterConditionInput,
   ValidationError,
-  FieldDefinition,
 } from "../useFilter";
 
 // ============================================================
@@ -34,8 +33,6 @@ export interface UseTableOptions<T> {
   enableFiltering?: boolean;
   /** Enable pagination */
   enablePagination?: boolean;
-  /** Field definitions for filter validation */
-  fieldDefinitions?: Record<keyof T, FieldDefinition>;
   /** Initial state */
   initialState?: {
     pagination?: {

package/sdk/components/hooks/useTable/useTable.ts

@@ -92,7 +92,6 @@ export function useTable<T = any>(
   const filterHook = useFilter<T>({
     initialConditions: options.initialState?.filters,
     initialLogicalOperator: options.initialState?.filterOperator || "And",
-    fieldDefinitions: options.fieldDefinitions,
     validateOnChange: true,
     onValidationError: options.onFilterError,
     onConditionAdd: () => {

package/dist/components/hooks/useFilter/validation.utils.d.ts

@@ -1,38 +0,0 @@
-import type { FilterOperator } from "../../../types/common";
-import type { FieldDefinition, ValidationResult } from "../useFilter";
-/**
- * Validate number values based on operator
- */
-export declare const validateNumberValue: (value: any, operator: FilterOperator) => ValidationResult;
-/**
- * Validate date values based on operator
- */
-export declare const validateDateValue: (value: any, operator: FilterOperator) => ValidationResult;
-/**
- * Validate currency values based on operator
- */
-export declare const validateCurrencyValue: (value: any, operator: FilterOperator) => ValidationResult;
-/**
- * Validate string values based on operator
- */
-export declare const validateStringValue: (value: any, operator: FilterOperator) => ValidationResult;
-/**
- * Validate boolean values based on operator
- */
-export declare const validateBooleanValue: (value: any, operator: FilterOperator) => ValidationResult;
-/**
- * Validate select field values based on operator and available options
- */
-export declare const validateSelectValue: (value: any, operator: FilterOperator, selectOptions?: Array<{
-    label: string;
-    value: any;
-}>) => ValidationResult;
-/**
- * Get default field definition based on field type
- */
-export declare const getDefaultFieldDefinition: (fieldType: FieldDefinition["type"]) => FieldDefinition;
-/**
- * Create field definitions from sample data
- */
-export declare const createFieldDefinitionsFromSample: <T>(sampleData: T) => Record<keyof T, FieldDefinition>;
-//# sourceMappingURL=validation.utils.d.ts.map

package/dist/components/hooks/useFilter/validation.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation.utils.d.ts","sourceRoot":"","sources":["../../../../sdk/components/hooks/useFilter/validation.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMtE;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,GAAG,EAAE,UAAU,cAAc,KAAG,gBAwC1E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,GAAG,EAAE,UAAU,cAAc,KAAG,gBAqDxE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,GAAG,EAAE,UAAU,cAAc,KAAG,gBAmD5E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,GAAG,EAAE,UAAU,cAAc,KAAG,gBA+C1E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,GAAG,EAAE,UAAU,cAAc,KAAG,gBAkC3E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,GAAG,EACV,UAAU,cAAc,EACxB,gBAAgB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,KACnD,gBA2CF,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,yBAAyB,GAAI,WAAW,eAAe,CAAC,MAAM,CAAC,KAAG,eAmD9E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gCAAgC,GAAI,CAAC,EAAE,YAAY,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,EAAE,eAAe,CA4BlG,CAAC"}

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;
-};