@ram_28/kf-ai-sdk 1.0.8 → 1.0.9

package/package.json

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

package/sdk/components/hooks/index.ts

@@ -9,15 +9,35 @@ export type {
 // Form hook
 export { useForm } from "./useForm";
 export type {
+  // Core types
   UseFormOptions,
   UseFormReturn,
-  BackendFieldDefinition,
-  ProcessedField,
-  ProcessedSchema,
   FormOperation,
   FormMode,
-  ValidationResult,
+
+  // Form field configuration
+  FormFieldConfig,
+  FormSchemaConfig,
+  FormFieldType,
+  SelectOption,
+  FieldPermission,
+
+  // Result types
+  FieldValidationResult,
   SubmissionResult,
+
+  // BDO Schema types (advanced)
+  BDOSchema,
+  BDOFieldDefinition,
+  SchemaValidationRule,
+} from "./useForm";
+
+// Error utilities
+export {
+  parseApiError,
+  isNetworkError,
+  isValidationError,
+  clearFormCache,
 } from "./useForm";
 
 // Kanban hook

package/sdk/components/hooks/useForm/apiClient.ts

@@ -4,7 +4,7 @@
 // Handles schema fetching and form submissions
 
 import { api, getBdoSchema } from "../../../api";
-import type { BackendSchema, FormOperation, SubmissionResult } from "./types";
+import type { BDOSchema, FormOperation, SubmissionResult } from "./types";
 
 // ============================================================
 // SCHEMA FETCHING
@@ -13,7 +13,7 @@ import type { BackendSchema, FormOperation, SubmissionResult } from "./types";
 /**
  * Fetch BDO schema from backend metadata endpoint
  */
-export async function fetchFormSchema(source: string): Promise<BackendSchema> {
+export async function fetchFormSchema(source: string): Promise<BDOSchema> {
   try {
     // Use the new metadata API client to fetch BDO schema
     const bdoResp = await getBdoSchema(source);
@@ -25,7 +25,7 @@ export async function fetchFormSchema(source: string): Promise<BackendSchema> {
     }
 
     // Return the full BDO schema - the form processor will extract what it needs
-    return bdoSchema as BackendSchema;
+    return bdoSchema as BDOSchema;
   } catch (error) {
     console.error(`Schema fetch error for ${source}:`, error);
     throw new Error(
@@ -40,7 +40,7 @@ export async function fetchFormSchema(source: string): Promise<BackendSchema> {
 export async function fetchFormSchemaWithRetry(
   source: string,
   maxRetries: number = 3
-): Promise<BackendSchema> {
+): Promise<BDOSchema> {
   let lastError: Error;
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -404,7 +404,7 @@ export function clearCache(keyPrefix?: string): void {
  */
 export async function fetchFormSchemaWithCache(
   source: string
-): Promise<BackendSchema> {
+): Promise<BDOSchema> {
   const cacheKey = `schema:${source}`;
   const cached = getCacheData(cacheKey);
 

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

@@ -5,9 +5,9 @@
 
 import type {
   ExpressionTree,
-  EvaluationContext,
-  ValidationResult,
-  ValidationRule,
+  ExpressionContext,
+  FieldValidationResult,
+  SchemaValidationRule,
 } from "./types";
 
 // ============================================================
@@ -137,7 +137,7 @@ const FUNCTIONS = {
 /**
  * Evaluate an expression tree node
  */
-function evaluateNode(node: ExpressionTree, context: EvaluationContext): any {
+function evaluateNode(node: ExpressionTree, context: ExpressionContext): any {
   switch (node.Type) {
     case "Literal":
       return node.Value;
@@ -218,7 +218,7 @@ function evaluateNode(node: ExpressionTree, context: EvaluationContext): any {
  */
 function getIdentifierValue(
   node: ExpressionTree,
-  context: EvaluationContext
+  context: ExpressionContext
 ): any {
   const { Name, Source } = node;
 
@@ -293,7 +293,7 @@ function evaluateBinaryOperation(operator: string, left: any, right: any): any {
 function evaluateLogicalOperation(
   operator: string,
   args: ExpressionTree[],
-  context: EvaluationContext
+  context: ExpressionContext
 ): boolean {
   switch (operator) {
     case "AND":
@@ -317,7 +317,7 @@ export function evaluateExpression(
   formValues: Record<string, any>,
   referenceData: Record<string, any> = {}
 ): any {
-  const context: EvaluationContext = {
+  const context: ExpressionContext = {
     formValues,
     systemValues: getSystemValues(),
     referenceData,
@@ -337,10 +337,10 @@ export function evaluateExpression(
 export function validateField<T = Record<string, any>>(
   fieldName: string,
   fieldValue: any,
-  validationRules: ValidationRule[],
+  validationRules: SchemaValidationRule[],
   formValues: T,
   referenceData: Record<string, any> = {}
-): ValidationResult<T> {
+): FieldValidationResult<T> {
   // If no validation rules, field is valid
   if (!validationRules || validationRules.length === 0) {
     return { isValid: true };
@@ -385,8 +385,8 @@ export function validateCrossField<T = Record<string, any>>(
   }>,
   formValues: T,
   referenceData: Record<string, any> = {}
-): ValidationResult<T>[] {
-  const results: ValidationResult<T>[] = [];
+): FieldValidationResult<T>[] {
+  const results: FieldValidationResult<T>[] = [];
 
   for (const rule of validationRules) {
     try {

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

@@ -1,64 +1,60 @@
 // ============================================================
-// USE FORM HOOK - MAIN EXPORT
+// useForm Hook - Public API
 // ============================================================
 
-// Main hook
+// === MAIN HOOK ===
 export { useForm } from './useForm';
 
-// Types
+// === TYPES: Core (Always needed) ===
 export type {
   UseFormOptions,
   UseFormReturn,
-  BackendSchema,
-  BackendFieldDefinition,
-  ProcessedField,
-  ProcessedSchema,
   FormOperation,
   FormMode,
-  ValidationResult,
+} from './types';
+
+// === TYPES: Form Field Configuration (For dynamic form rendering) ===
+export type {
+  FormFieldConfig,
+  FormSchemaConfig,
+  FormFieldType,
+  SelectOption,
+  FieldPermission,
+  FieldRuleIds,
+} from './types';
+
+// === TYPES: Result Types ===
+export type {
+  FieldValidationResult,
   SubmissionResult,
-  ExpressionTree,
-  ValidationRule,
-  Formula,
-  DefaultValue,
-  ReferenceField,
-  FieldValues,
-  EvaluationContext
 } from './types';
 
-// Utilities
-export {
-  processSchema,
-  updateComputedFields,
-  buildDependencyMap,
-  extractReferenceFields,
-  validateSchema,
-  buildReferenceFieldConfig
-} from './schemaParser.utils';
+// === TYPES: BDO Schema (For advanced schema manipulation) ===
+export type {
+  BDOSchema,
+  BDOFieldDefinition,
+  SchemaValidationRule,
+  ComputedFieldFormula,
+  DefaultValueExpression,
+  ReferenceFieldConfig,
+  FieldOptionsConfig,
+  ExpressionTree,
+  BusinessObjectRules,
+  RolePermission,
+  RuleType,
+} from './types';
 
-export {
-  evaluateExpression,
-  validateField,
-  validateCrossField,
-  calculateComputedValue,
-  calculateDefaultValue
-} from './expressionValidator.utils';
+// === TYPES: Expression Evaluation (For custom expression handling) ===
+export type {
+  ExpressionContext,
+} from './types';
 
+// === UTILITIES: Error Handling ===
 export {
-  fetchFormSchema,
-  fetchFormSchemaWithRetry,
-  fetchRecord,
-  submitFormData,
-  fetchReferenceData,
-  fetchAllReferenceData,
-  validateFormData,
-  cleanFormData,
   parseApiError,
   isNetworkError,
   isValidationError,
-  setCacheData,
-  getCacheData,
-  clearCache,
-  fetchFormSchemaWithCache,
-  fetchReferenceDataWithCache
-} from './apiClient';
+} from './apiClient';
+
+// === UTILITIES: Cache Control ===
+export { clearCache as clearFormCache } from './apiClient';

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

@@ -5,8 +5,8 @@
 
 import type {
   ExpressionTree,
-  ValidationResult,
-  ValidationRule,
+  FieldValidationResult,
+  SchemaValidationRule,
 } from "./types";
 
 // ============================================================
@@ -94,7 +94,7 @@ export function analyzeExpressionDependencies(
  * Build dependency graph for multiple expressions
  */
 export function buildDependencyGraph(
-  rules: Record<string, ValidationRule>
+  rules: Record<string, SchemaValidationRule>
 ): Map<string, Set<string>> {
   const graph = new Map<string, Set<string>>();
 
@@ -398,10 +398,10 @@ const globalEvaluator = new OptimizedExpressionEvaluator();
 export function validateFieldOptimized<T = Record<string, any>>(
   fieldName: string,
   fieldValue: any,
-  validationRules: ValidationRule[],
+  validationRules: SchemaValidationRule[],
   formValues: T,
   lastFormValues?: T
-): ValidationResult<T> {
+): FieldValidationResult<T> {
   if (!validationRules || validationRules.length === 0) {
     return { isValid: true };
   }
@@ -461,11 +461,11 @@ export function batchValidateFields<T = Record<string, any>>(
   validations: Array<{
     fieldName: string;
     fieldValue: any;
-    rules: ValidationRule[];
+    rules: SchemaValidationRule[];
   }>,
   formValues: T,
   lastFormValues?: T
-): Array<ValidationResult<T>> {
+): Array<FieldValidationResult<T>> {
   return validations.map(({ fieldName, fieldValue, rules }) =>
     validateFieldOptimized(fieldName, fieldValue, rules, formValues, lastFormValues)
   );

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

@@ -5,9 +5,9 @@
 
 import type {
   BDOSchema,
-  BackendSchema,
-  ProcessedSchema,
-  ValidationRule,
+  BDOFieldDefinition,
+  FormSchemaConfig,
+  SchemaValidationRule,
   RuleType,
   FieldPermission,
 } from "./types";
@@ -20,7 +20,7 @@ import type {
  * Check if a validation rule represents a "required" validation
  * Detects patterns like: field != null, TRIM(field) != '', etc.
  */
-function isRequiredValidationRule(rule: ValidationRule, fieldName: string): boolean {
+function isRequiredSchemaValidationRule(rule: SchemaValidationRule, fieldName: string): boolean {
   const expression = rule.Expression?.toLowerCase() || '';
   const ruleName = rule.Name?.toLowerCase() || '';
   const ruleId = rule.Id?.toLowerCase() || '';
@@ -84,13 +84,13 @@ export function normalizeBDOSchema(schema: BDOSchema): BDOSchema {
         // Extract inline validation rules
         const ruleIds: string[] = [];
 
-        (field.Validation as ValidationRule[]).forEach((rule) => {
+        (field.Validation as SchemaValidationRule[]).forEach((rule) => {
           // Add rule to centralized Rules.Validation
           normalizedSchema.Rules.Validation![rule.Id] = rule;
           ruleIds.push(rule.Id);
 
           // Check if this is a required validation rule
-          if (isRequiredValidationRule(rule, fieldName)) {
+          if (isRequiredSchemaValidationRule(rule, fieldName)) {
             isRequired = true;
           }
         });
@@ -106,7 +106,7 @@ export function normalizeBDOSchema(schema: BDOSchema): BDOSchema {
         const validationRuleIds = field.Validation as string[];
         validationRuleIds.forEach((ruleId) => {
           const rule = normalizedSchema.Rules.Validation?.[ruleId];
-          if (rule && isRequiredValidationRule(rule, fieldName)) {
+          if (rule && isRequiredSchemaValidationRule(rule, fieldName)) {
             isRequired = true;
           }
         });
@@ -146,11 +146,11 @@ export function normalizeBDOSchema(schema: BDOSchema): BDOSchema {
 /**
  * Classify rules by type from BDO schema
  */
-export function classifyRules(schema: BDOSchema): ProcessedSchema["rules"] {
+export function classifyRules(schema: BDOSchema): FormSchemaConfig["rules"] {
   const rules = {
-    validation: {} as Record<string, ValidationRule>,
-    computation: {} as Record<string, ValidationRule>,
-    businessLogic: {} as Record<string, ValidationRule>,
+    validation: {} as Record<string, SchemaValidationRule>,
+    computation: {} as Record<string, SchemaValidationRule>,
+    businessLogic: {} as Record<string, SchemaValidationRule>,
   };
 
   // Extract rules from BDO Rules section
@@ -223,9 +223,9 @@ function inferComputationRuleTargets(
 
 export function createFieldRuleMapping(
   schema: BDOSchema,
-  classifiedRules: ProcessedSchema["rules"]
-): ProcessedSchema["fieldRules"] {
-  const fieldRules: ProcessedSchema["fieldRules"] = {};
+  classifiedRules: FormSchemaConfig["rules"]
+): FormSchemaConfig["fieldRules"] {
+  const fieldRules: FormSchemaConfig["fieldRules"] = {};
 
   // Initialize all fields
   Object.keys(schema.Fields).forEach((fieldName) => {
@@ -356,11 +356,11 @@ export function getRuleExecutionStrategy(
  */
 export function getRulesForField(
   fieldName: string,
-  fieldRules: ProcessedSchema["fieldRules"],
-  classifiedRules: ProcessedSchema["rules"],
+  fieldRules: FormSchemaConfig["fieldRules"],
+  classifiedRules: FormSchemaConfig["rules"],
   executionType: "client" | "server"
-): ValidationRule[] {
-  const rules: ValidationRule[] = [];
+): SchemaValidationRule[] {
+  const rules: SchemaValidationRule[] = [];
   const fieldRuleMap = fieldRules[fieldName];
 
   if (!fieldRuleMap) return rules;
@@ -394,9 +394,10 @@ export function getRulesForField(
 // ============================================================
 
 /**
- * Convert legacy BackendSchema to BDO format
+ * Convert legacy schema format to BDO format
+ * @deprecated Legacy schema format is no longer supported
  */
-export function convertLegacySchema(legacySchema: BackendSchema): BDOSchema {
+export function convertLegacySchema(legacySchema: Record<string, BDOFieldDefinition>): BDOSchema {
   return {
     Id: "legacy_schema",
     Name: "Legacy Schema",

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

@@ -4,12 +4,11 @@
 // Converts backend field schemas to react-hook-form validation rules
 
 import type {
-  BackendSchema,
   BDOSchema,
-  BackendFieldDefinition,
-  ProcessedField,
-  ProcessedSchema,
-  ValidationRule,
+  BDOFieldDefinition,
+  FormFieldConfig,
+  FormSchemaConfig,
+  SchemaValidationRule,
   FieldPermission,
 } from "./types";
 import {
@@ -20,7 +19,6 @@ import {
   classifyRules,
   createFieldRuleMapping,
   calculateFieldPermissions,
-  convertLegacySchema,
   normalizeBDOSchema,
 } from "./ruleClassifier.utils";
 
@@ -85,10 +83,10 @@ function generateLabel(fieldName: string): string {
 /**
  * Convert backend validation rules to react-hook-form validation
  */
-function convertValidationRules(
+function convertSchemaValidationRules(
   fieldName: string,
-  fieldDef: BackendFieldDefinition,
-  _allFields: Record<string, BackendFieldDefinition>
+  fieldDef: BDOFieldDefinition,
+  _allFields: Record<string, BDOFieldDefinition>
 ): any {
   const validation: any = {};
 
@@ -113,7 +111,7 @@ function convertValidationRules(
   }
 
   // Custom validation using expression trees
-  // Note: fieldDef.Validation contains rule IDs (string[]), not ValidationRule[]
+  // Note: fieldDef.Validation contains rule IDs (string[]), not SchemaValidationRule[]
   // Validation is handled by the form hook which has access to the full schema rules
   if (fieldDef.Validation && fieldDef.Validation.length > 0) {
     // Validation rules will be applied by the form hook
@@ -132,7 +130,7 @@ function convertValidationRules(
  * Process field options for select/reference fields
  */
 function processFieldOptions(
-  fieldDef: BackendFieldDefinition
+  fieldDef: BDOFieldDefinition
 ): Array<{ value: any; label: string }> {
   if (!fieldDef.Values) {
     return [];
@@ -163,7 +161,7 @@ function processFieldOptions(
  * Calculate default value for a field
  */
 function processDefaultValue(
-  fieldDef: BackendFieldDefinition,
+  fieldDef: BDOFieldDefinition,
   formValues: Record<string, any> = {}
 ): any {
   if (!fieldDef.DefaultValue) {
@@ -199,8 +197,8 @@ function processDefaultValue(
  */
 function processField(
   fieldName: string,
-  fieldDef: BackendFieldDefinition,
-  allFields: Record<string, BackendFieldDefinition>,
+  fieldDef: BDOFieldDefinition,
+  allFields: Record<string, BDOFieldDefinition>,
   formValues: Record<string, any> = {},
   permission?: FieldPermission,
   rules?: {
@@ -208,7 +206,7 @@ function processField(
     computation: string[];
     businessLogic: string[];
   }
-): ProcessedField {
+): FormFieldConfig {
   const defaultPermission: FieldPermission = {
     editable: true,
     readable: true,
@@ -227,7 +225,7 @@ function processField(
     !!fieldDef.Formula ||
     fieldRules.computation.length > 0;
 
-  const validation = convertValidationRules(fieldName, fieldDef, allFields);
+  const validation = convertSchemaValidationRules(fieldName, fieldDef, allFields);
 
   // Mark computed fields as disabled so they cannot be manually edited
   if (isComputed) {
@@ -244,7 +242,7 @@ function processField(
     options: processFieldOptions(fieldDef),
     validation,
     description: fieldDef.Description,
-    backendField: fieldDef,
+    _bdoField: fieldDef,
     permission: permission || defaultPermission,
     rules: fieldRules,
   };
@@ -255,27 +253,24 @@ function processField(
 // ============================================================
 
 /**
- * Process complete backend schema
+ * Process complete BDO schema
  */
 export function processSchema(
-  schema: BackendSchema | BDOSchema,
+  schema: BDOSchema,
   formValues: Record<string, any> = {},
   userRole?: string
-): ProcessedSchema {
-  // Convert legacy schema to BDO format if needed
-  let bdoSchema =
-    "Kind" in schema && schema.Kind === "BusinessObject"
-      ? (schema as BDOSchema)
-      : convertLegacySchema(schema as BackendSchema);
+): FormSchemaConfig {
+  // 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, ProcessedField> = {};
+  const fields: Record<string, FormFieldConfig> = {};
   const fieldOrder: string[] = [];
   const computedFields: string[] = [];
   const requiredFields: string[] = [];
-  const crossFieldValidation: ValidationRule[] = [];
+  const crossFieldValidation: SchemaValidationRule[] = [];
 
   // Classify rules by type
   const classifiedRules = classifyRules(bdoSchema);
@@ -344,14 +339,14 @@ export function processSchema(
  * Update computed field values based on current form values
  */
 export function updateComputedFields(
-  processedSchema: ProcessedSchema,
+  processedSchema: FormSchemaConfig,
   currentValues: Record<string, any>
 ): Record<string, any> {
   const computedValues: Record<string, any> = {};
 
   for (const fieldName of processedSchema.computedFields) {
     const field = processedSchema.fields[fieldName];
-    const backendField = field.backendField;
+    const backendField = field._bdoField;
 
     if (backendField.Formula) {
       try {
@@ -406,7 +401,7 @@ function extractFieldDependencies(expressionTree: any): string[] {
  * Build field dependency map
  */
 export function buildDependencyMap(
-  processedSchema: ProcessedSchema
+  processedSchema: FormSchemaConfig
 ): Record<string, string[]> {
   const dependencyMap: Record<string, string[]> = {};
 
@@ -414,25 +409,25 @@ export function buildDependencyMap(
     const dependencies: Set<string> = new Set();
 
     // Check formula dependencies
-    if (field.backendField.Formula) {
+    if (field._bdoField.Formula) {
       const formulaDeps = extractFieldDependencies(
-        field.backendField.Formula.ExpressionTree
+        field._bdoField.Formula.ExpressionTree
       );
       formulaDeps.forEach((dep) => dependencies.add(dep));
     }
 
     // Check validation dependencies
-    // Note: field.backendField.Validation contains rule IDs (string[])
+    // Note: field._bdoField.Validation contains rule IDs (string[])
     // To extract validation dependencies, we would need access to the full schema rules
     // This is skipped for now as validation dependencies are tracked separately
-    if (field.backendField.Validation) {
+    if (field._bdoField.Validation) {
       // Validation rule dependencies would be extracted here if we had access to the rules
     }
 
     // Check default value dependencies
-    if (field.backendField.DefaultValue) {
+    if (field._bdoField.DefaultValue) {
       const defaultDeps = extractFieldDependencies(
-        field.backendField.DefaultValue.ExpressionTree
+        field._bdoField.DefaultValue.ExpressionTree
       );
       defaultDeps.forEach((dep) => dependencies.add(dep));
     }
@@ -450,7 +445,7 @@ export function buildDependencyMap(
 /**
  * Validate processed schema
  */
-export function validateSchema(processedSchema: ProcessedSchema): {
+export function validateSchema(processedSchema: FormSchemaConfig): {
   isValid: boolean;
   errors: string[];
 } {
@@ -483,12 +478,12 @@ export function validateSchema(processedSchema: ProcessedSchema): {
 /**
  * Build reference field configuration for API calls
  */
-export function buildReferenceFieldConfig(field: ProcessedField): any {
-  if (field.type !== "reference" || !field.backendField.Values?.Reference) {
+export function buildReferenceFieldConfig(field: FormFieldConfig): any {
+  if (field.type !== "reference" || !field._bdoField.Values?.Reference) {
     return null;
   }
 
-  const ref = field.backendField.Values.Reference;
+  const ref = field._bdoField.Values.Reference;
 
   return {
     businessObject: ref.BusinessObject,
@@ -502,7 +497,7 @@ export function buildReferenceFieldConfig(field: ProcessedField): any {
  * Extract all reference field configurations from schema
  */
 export function extractReferenceFields(
-  processedSchema: ProcessedSchema
+  processedSchema: FormSchemaConfig
 ): Record<string, any> {
   const referenceFields: Record<string, any> = {};