@ram_28/kf-ai-sdk 1.0.11 → 1.0.12

package/sdk/components/hooks/useForm/optimizedExpressionValidator.utils.ts

@@ -4,9 +4,9 @@
 // Enhanced expression evaluator with caching, dependency tracking, and performance optimizations
 
 import type {
-  ExpressionTree,
-  FieldValidationResult,
-  SchemaValidationRule,
+  ExpressionTreeType,
+  FieldValidationResultType,
+  SchemaValidationRuleType,
 } from "./types";
 
 // ============================================================
@@ -58,11 +58,11 @@ class LRUCache<T> {
  * Analyze expression dependencies for optimized watching
  */
 export function analyzeExpressionDependencies(
-  expression: ExpressionTree
+  expression: ExpressionTreeType
 ): Set<string> {
   const dependencies = new Set<string>();
 
-  function traverse(node: ExpressionTree): void {
+  function traverse(node: ExpressionTreeType): void {
     switch (node.Type) {
       case "Identifier":
         if (node.Name && !node.Name.startsWith("$")) {
@@ -94,7 +94,7 @@ export function analyzeExpressionDependencies(
  * Build dependency graph for multiple expressions
  */
 export function buildDependencyGraph(
-  rules: Record<string, SchemaValidationRule>
+  rules: Record<string, SchemaValidationRuleType>
 ): Map<string, Set<string>> {
   const graph = new Map<string, Set<string>>();
 
@@ -122,7 +122,7 @@ export class OptimizedExpressionEvaluator {
    * Create cache key from expression and context
    */
   private createCacheKey(
-    expression: ExpressionTree,
+    expression: ExpressionTreeType,
     context: Record<string, any>
   ): string {
     const expressionHash = JSON.stringify(expression);
@@ -133,7 +133,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Get expression dependencies (cached)
    */
-  getDependencies(expression: ExpressionTree): Set<string> {
+  getDependencies(expression: ExpressionTreeType): Set<string> {
     const expressionKey = JSON.stringify(expression);
     
     let dependencies = this.dependencyCache.get(expressionKey);
@@ -149,7 +149,7 @@ export class OptimizedExpressionEvaluator {
    * Check if expression result is cached and context hasn't changed
    */
   private getCachedResult(
-    expression: ExpressionTree,
+    expression: ExpressionTreeType,
     context: Record<string, any>,
     lastContext?: Record<string, any>
   ): any | undefined {
@@ -173,7 +173,7 @@ export class OptimizedExpressionEvaluator {
    * Evaluate expression with caching
    */
   evaluate(
-    expression: ExpressionTree,
+    expression: ExpressionTreeType,
     context: Record<string, any>,
     lastContext?: Record<string, any>
   ): any {
@@ -194,7 +194,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Core expression evaluation logic
    */
-  private evaluateNode(node: ExpressionTree, context: Record<string, any>): any {
+  private evaluateNode(node: ExpressionTreeType, context: Record<string, any>): any {
     switch (node.Type) {
       case "Literal":
         return node.Value;
@@ -222,7 +222,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Get identifier value with system context support
    */
-  private getIdentifierValue(node: ExpressionTree, context: Record<string, any>): any {
+  private getIdentifierValue(node: ExpressionTreeType, context: Record<string, any>): any {
     if (!node.Name) return undefined;
 
     // System identifiers
@@ -249,7 +249,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Evaluate binary expressions with type coercion
    */
-  private evaluateBinaryExpression(node: ExpressionTree, context: Record<string, any>): any {
+  private evaluateBinaryExpression(node: ExpressionTreeType, context: Record<string, any>): any {
     if (!node.Arguments || node.Arguments.length !== 2) {
       throw new Error("Binary expression requires exactly 2 arguments");
     }
@@ -279,7 +279,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Evaluate logical expressions with short-circuiting
    */
-  private evaluateLogicalExpression(node: ExpressionTree, context: Record<string, any>): any {
+  private evaluateLogicalExpression(node: ExpressionTreeType, context: Record<string, any>): any {
     if (!node.Arguments || node.Arguments.length < 2) {
       throw new Error("Logical expression requires at least 2 arguments");
     }
@@ -309,7 +309,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Evaluate function calls with built-in functions
    */
-  private evaluateCallExpression(node: ExpressionTree, context: Record<string, any>): any {
+  private evaluateCallExpression(node: ExpressionTreeType, context: Record<string, any>): any {
     if (!node.Callee) {
       throw new Error("Call expression requires a function name");
     }
@@ -360,7 +360,7 @@ export class OptimizedExpressionEvaluator {
   /**
    * Evaluate member expressions
    */
-  private evaluateMemberExpression(node: ExpressionTree, context: Record<string, any>): any {
+  private evaluateMemberExpression(node: ExpressionTreeType, context: Record<string, any>): any {
     if (!node.Arguments || node.Arguments.length === 0) {
       throw new Error("Member expression requires arguments");
     }
@@ -398,10 +398,10 @@ const globalEvaluator = new OptimizedExpressionEvaluator();
 export function validateFieldOptimized<T = Record<string, any>>(
   fieldName: string,
   fieldValue: any,
-  validationRules: SchemaValidationRule[],
+  validationRules: SchemaValidationRuleType[],
   formValues: T,
   lastFormValues?: T
-): FieldValidationResult<T> {
+): FieldValidationResultType<T> {
   if (!validationRules || validationRules.length === 0) {
     return { isValid: true };
   }
@@ -435,7 +435,7 @@ export function validateFieldOptimized<T = Record<string, any>>(
  * Optimized computed value calculation
  */
 export function calculateComputedValueOptimized(
-  expression: ExpressionTree,
+  expression: ExpressionTreeType,
   formValues: Record<string, any>,
   lastFormValues?: Record<string, any>
 ): any {
@@ -450,7 +450,7 @@ export function calculateComputedValueOptimized(
 /**
  * Get field dependencies for optimized watching
  */
-export function getFieldDependencies(expression: ExpressionTree): string[] {
+export function getFieldDependencies(expression: ExpressionTreeType): string[] {
   return Array.from(globalEvaluator.getDependencies(expression));
 }
 
@@ -461,11 +461,11 @@ export function batchValidateFields<T = Record<string, any>>(
   validations: Array<{
     fieldName: string;
     fieldValue: any;
-    rules: SchemaValidationRule[];
+    rules: SchemaValidationRuleType[];
   }>,
   formValues: T,
   lastFormValues?: T
-): Array<FieldValidationResult<T>> {
+): Array<FieldValidationResultType<T>> {
   return validations.map(({ fieldName, fieldValue, rules }) =>
     validateFieldOptimized(fieldName, fieldValue, rules, formValues, lastFormValues)
   );

package/sdk/components/hooks/useForm/ruleClassifier.utils.ts

@@ -4,12 +4,11 @@
 // Classifies rules by type and determines execution strategy
 
 import type {
-  BDOSchema,
-  BDOFieldDefinition,
-  FormSchemaConfig,
-  SchemaValidationRule,
-  RuleType,
-  FieldPermission,
+  BDOSchemaType,
+  FormSchemaConfigType,
+  SchemaValidationRuleType,
+  RuleTypeType,
+  FieldPermissionType,
 } from "./types";
 
 // ============================================================
@@ -20,7 +19,7 @@ import type {
  * Check if a validation rule represents a "required" validation
  * Detects patterns like: field != null, TRIM(field) != '', etc.
  */
-function isRequiredSchemaValidationRule(rule: SchemaValidationRule, fieldName: string): boolean {
+function isRequiredSchemaValidationRule(rule: SchemaValidationRuleType, fieldName: string): boolean {
   const expression = rule.Expression?.toLowerCase() || '';
   const ruleName = rule.Name?.toLowerCase() || '';
   const ruleId = rule.Id?.toLowerCase() || '';
@@ -48,7 +47,7 @@ function isRequiredSchemaValidationRule(rule: SchemaValidationRule, fieldName: s
  * Normalize BDO schema to ensure validation rules are in centralized format
  * Extracts inline validation rules from fields and adds them to Rules.Validation
  */
-export function normalizeBDOSchema(schema: BDOSchema): BDOSchema {
+export function normalizeBDOSchema(schema: BDOSchemaType): BDOSchemaType {
   const normalizedSchema = { ...schema };
 
   // Initialize Rules section if it doesn't exist
@@ -84,7 +83,7 @@ export function normalizeBDOSchema(schema: BDOSchema): BDOSchema {
         // Extract inline validation rules
         const ruleIds: string[] = [];
 
-        (field.Validation as SchemaValidationRule[]).forEach((rule) => {
+        (field.Validation as SchemaValidationRuleType[]).forEach((rule) => {
           // Add rule to centralized Rules.Validation
           normalizedSchema.Rules.Validation![rule.Id] = rule;
           ruleIds.push(rule.Id);
@@ -146,11 +145,11 @@ export function normalizeBDOSchema(schema: BDOSchema): BDOSchema {
 /**
  * Classify rules by type from BDO schema
  */
-export function classifyRules(schema: BDOSchema): FormSchemaConfig["rules"] {
+export function classifyRules(schema: BDOSchemaType): FormSchemaConfigType["rules"] {
   const rules = {
-    validation: {} as Record<string, SchemaValidationRule>,
-    computation: {} as Record<string, SchemaValidationRule>,
-    businessLogic: {} as Record<string, SchemaValidationRule>,
+    validation: {} as Record<string, SchemaValidationRuleType>,
+    computation: {} as Record<string, SchemaValidationRuleType>,
+    businessLogic: {} as Record<string, SchemaValidationRuleType>,
   };
 
   // Extract rules from BDO Rules section
@@ -178,7 +177,7 @@ export function classifyRules(schema: BDOSchema): FormSchemaConfig["rules"] {
  * by analyzing the rule's target field from its name/description
  */
 function inferComputationRuleTargets(
-  schema: BDOSchema
+  schema: BDOSchemaType
 ): Record<string, string> {
   const ruleToField: Record<string, string> = {};
 
@@ -222,10 +221,10 @@ function inferComputationRuleTargets(
 }
 
 export function createFieldRuleMapping(
-  schema: BDOSchema,
-  classifiedRules: FormSchemaConfig["rules"]
-): FormSchemaConfig["fieldRules"] {
-  const fieldRules: FormSchemaConfig["fieldRules"] = {};
+  schema: BDOSchemaType,
+  classifiedRules: FormSchemaConfigType["rules"]
+): FormSchemaConfigType["fieldRules"] {
+  const fieldRules: FormSchemaConfigType["fieldRules"] = {};
 
   // Initialize all fields
   Object.keys(schema.Fields).forEach((fieldName) => {
@@ -288,13 +287,13 @@ export function createFieldRuleMapping(
  * Calculate field permissions based on user role
  */
 export function calculateFieldPermissions(
-  schema: BDOSchema,
+  schema: BDOSchemaType,
   userRole?: string
-): Record<string, FieldPermission> {
-  const fieldPermissions: Record<string, FieldPermission> = {};
+): Record<string, FieldPermissionType> {
+  const fieldPermissions: Record<string, FieldPermissionType> = {};
 
   // Default permissions (no role specified)
-  const defaultPermission: FieldPermission = {
+  const defaultPermission: FieldPermissionType = {
     editable: true,
     readable: true,
     hidden: false,
@@ -338,7 +337,7 @@ export function calculateFieldPermissions(
  * Determine if rule should execute client-side or server-side
  */
 export function getRuleExecutionStrategy(
-  ruleType: RuleType
+  ruleType: RuleTypeType
 ): "client" | "server" {
   switch (ruleType) {
     case "Validation":
@@ -356,11 +355,11 @@ export function getRuleExecutionStrategy(
  */
 export function getRulesForField(
   fieldName: string,
-  fieldRules: FormSchemaConfig["fieldRules"],
-  classifiedRules: FormSchemaConfig["rules"],
+  fieldRules: FormSchemaConfigType["fieldRules"],
+  classifiedRules: FormSchemaConfigType["rules"],
   executionType: "client" | "server"
-): SchemaValidationRule[] {
-  const rules: SchemaValidationRule[] = [];
+): SchemaValidationRuleType[] {
+  const rules: SchemaValidationRuleType[] = [];
   const fieldRuleMap = fieldRules[fieldName];
 
   if (!fieldRuleMap) return rules;
@@ -388,38 +387,3 @@ export function getRulesForField(
 
   return rules;
 }
-
-// ============================================================
-// LEGACY SCHEMA SUPPORT
-// ============================================================
-
-/**
- * Convert legacy schema format to BDO format
- * @deprecated Legacy schema format is no longer supported
- */
-export function convertLegacySchema(legacySchema: Record<string, BDOFieldDefinition>): BDOSchema {
-  return {
-    Id: "legacy_schema",
-    Name: "Legacy Schema",
-    Kind: "BusinessObject",
-    Description: "Converted from legacy schema format",
-    Rules: {
-      Validation: {},
-      Computation: {},
-      BusinessLogic: {},
-    },
-    Fields: Object.fromEntries(
-      Object.entries(legacySchema).map(([fieldName, field]) => [
-        fieldName,
-        {
-          ...field,
-          Id: fieldName,
-          Name: field.Description || fieldName,
-          Validation: [], // Legacy format needs to be processed separately
-        },
-      ])
-    ),
-    RolePermission: {},
-    Roles: {},
-  };
-}

package/sdk/components/hooks/useForm/schemaParser.utils.ts

@@ -4,12 +4,12 @@
 // Converts backend field schemas to react-hook-form validation rules
 
 import type {
-  BDOSchema,
-  BDOFieldDefinition,
-  FormFieldConfig,
-  FormSchemaConfig,
-  SchemaValidationRule,
-  FieldPermission,
+  BDOSchemaType,
+  BDOFieldDefinitionType,
+  FormFieldConfigType,
+  FormSchemaConfigType,
+  SchemaValidationRuleType,
+  FieldPermissionType,
 } from "./types";
 import {
   calculateDefaultValue,
@@ -85,8 +85,8 @@ function generateLabel(fieldName: string): string {
  */
 function convertSchemaValidationRules(
   fieldName: string,
-  fieldDef: BDOFieldDefinition,
-  _allFields: Record<string, BDOFieldDefinition>
+  fieldDef: BDOFieldDefinitionType,
+  _allFields: Record<string, BDOFieldDefinitionType>
 ): any {
   const validation: any = {};
 
@@ -130,7 +130,7 @@ function convertSchemaValidationRules(
  * Process field options for select/reference fields
  */
 function processFieldOptions(
-  fieldDef: BDOFieldDefinition
+  fieldDef: BDOFieldDefinitionType
 ): Array<{ value: any; label: string }> {
   if (!fieldDef.Values) {
     return [];
@@ -161,7 +161,7 @@ function processFieldOptions(
  * Calculate default value for a field
  */
 function processDefaultValue(
-  fieldDef: BDOFieldDefinition,
+  fieldDef: BDOFieldDefinitionType,
   formValues: Record<string, any> = {}
 ): any {
   if (!fieldDef.DefaultValue) {
@@ -197,17 +197,17 @@ function processDefaultValue(
  */
 function processField(
   fieldName: string,
-  fieldDef: BDOFieldDefinition,
-  allFields: Record<string, BDOFieldDefinition>,
+  fieldDef: BDOFieldDefinitionType,
+  allFields: Record<string, BDOFieldDefinitionType>,
   formValues: Record<string, any> = {},
-  permission?: FieldPermission,
+  permission?: FieldPermissionType,
   rules?: {
     validation: string[];
     computation: string[];
     businessLogic: string[];
   }
-): FormFieldConfig {
-  const defaultPermission: FieldPermission = {
+): FormFieldConfigType {
+  const defaultPermission: FieldPermissionType = {
     editable: true,
     readable: true,
     hidden: false,
@@ -256,21 +256,21 @@ function processField(
  * Process complete BDO schema
  */
 export function processSchema(
-  schema: BDOSchema,
+  schema: BDOSchemaType,
   formValues: Record<string, any> = {},
   userRole?: string
-): FormSchemaConfig {
+): FormSchemaConfigType {
   // Ensure schema is in BDO format
   let bdoSchema = schema;
 
   // Normalize BDO schema to ensure inline validation rules are centralized
   bdoSchema = normalizeBDOSchema(bdoSchema);
 
-  const fields: Record<string, FormFieldConfig> = {};
+  const fields: Record<string, FormFieldConfigType> = {};
   const fieldOrder: string[] = [];
   const computedFields: string[] = [];
   const requiredFields: string[] = [];
-  const crossFieldValidation: SchemaValidationRule[] = [];
+  const crossFieldValidation: SchemaValidationRuleType[] = [];
 
   // Classify rules by type
   const classifiedRules = classifyRules(bdoSchema);
@@ -339,7 +339,7 @@ export function processSchema(
  * Update computed field values based on current form values
  */
 export function updateComputedFields(
-  processedSchema: FormSchemaConfig,
+  processedSchema: FormSchemaConfigType,
   currentValues: Record<string, any>
 ): Record<string, any> {
   const computedValues: Record<string, any> = {};
@@ -401,7 +401,7 @@ function extractFieldDependencies(expressionTree: any): string[] {
  * Build field dependency map
  */
 export function buildDependencyMap(
-  processedSchema: FormSchemaConfig
+  processedSchema: FormSchemaConfigType
 ): Record<string, string[]> {
   const dependencyMap: Record<string, string[]> = {};
 
@@ -445,7 +445,7 @@ export function buildDependencyMap(
 /**
  * Validate processed schema
  */
-export function validateSchema(processedSchema: FormSchemaConfig): {
+export function validateSchema(processedSchema: FormSchemaConfigType): {
   isValid: boolean;
   errors: string[];
 } {
@@ -478,7 +478,7 @@ export function validateSchema(processedSchema: FormSchemaConfig): {
 /**
  * Build reference field configuration for API calls
  */
-export function buildReferenceFieldConfig(field: FormFieldConfig): any {
+export function buildReferenceFieldConfig(field: FormFieldConfigType): any {
   if (field.type !== "reference" || !field._bdoField.Values?.Reference) {
     return null;
   }
@@ -497,7 +497,7 @@ export function buildReferenceFieldConfig(field: FormFieldConfig): any {
  * Extract all reference field configurations from schema
  */
 export function extractReferenceFields(
-  processedSchema: FormSchemaConfig
+  processedSchema: FormSchemaConfigType
 ): Record<string, any> {
   const referenceFields: Record<string, any> = {};