@flowuent-org/diagramming-core 1.3.10 → 1.4.1

package/packages/diagrams/src/lib/utils/validationEngine.ts

@@ -1,610 +1,610 @@
-import {
-  ValidationSchema,
-  ValidationResult,
-  ValidationRule,
-  SeverityLevel,
-} from '../types/validation-types';
-
-export class ValidationEngine {
-  private schema: ValidationSchema | null = null;
-  private cache: Map<string, any> = new Map();
-
-  constructor() {
-    this.loadSchema();
-  }
-
-  /**
-   * Load the validation schema from the JSON file
-   */
-  private async loadSchema(): Promise<void> {
-    try {
-      // In a real implementation, this would load from a config endpoint
-      // For now, we'll import the schema directly
-      const schemaModule = await import('../templates/validationSchema.json');
-      // Cast to ValidationSchema to handle JSON string literal types
-      this.schema = schemaModule.default as ValidationSchema;
-    } catch (error) {
-      console.warn(
-        'Failed to load validation schema, using default validation:',
-        error,
-      );
-      this.schema = this.getDefaultSchema();
-    }
-  }
-
-  /**
-   * Get the current validation schema
-   */
-  getSchema(): ValidationSchema | null {
-    return this.schema;
-  }
-
-  /**
-   * Validate a primitive value based on data type
-   */
-  validatePrimitiveValue(value: string, dataType: string): ValidationResult[] {
-    if (!this.schema) {
-      return this.fallbackValidation(value, dataType);
-    }
-
-    const results: ValidationResult[] = [];
-    const dataTypeConfig = this.schema.dataTypes[dataType];
-
-    if (!dataTypeConfig) {
-      return results; // No validation rules for this data type
-    }
-
-    const rules = dataTypeConfig.validation;
-
-    // Required validation
-    if (rules.required?.enabled) {
-      if (!value || value.trim() === '') {
-        results.push({
-          field: 'value',
-          message: this.interpolateMessage(rules.required.message, {
-            dataType,
-          }),
-          severity: rules.required.severity || 'error',
-          rule: 'required',
-        });
-      }
-    }
-
-    // Type-specific validation
-    switch (dataType) {
-      case 'Number':
-      case 'INT':
-      case 'FLOAT':
-        if (rules.numeric?.enabled && value && value.trim() !== '') {
-          if (isNaN(Number(value.trim()))) {
-            results.push({
-              field: 'value',
-              message: this.interpolateMessage(rules.numeric.message, {
-                dataType,
-              }),
-              severity: rules.numeric.severity || 'error',
-              rule: 'numeric',
-            });
-          }
-        }
-
-        // Integer validation for INT type
-        if (
-          dataType === 'INT' &&
-          rules.integer?.enabled &&
-          value &&
-          value.trim() !== ''
-        ) {
-          const num = Number(value.trim());
-          if (!Number.isInteger(num)) {
-            results.push({
-              field: 'value',
-              message: this.interpolateMessage(rules.integer.message, {
-                dataType,
-              }),
-              severity: rules.integer.severity || 'error',
-              rule: 'integer',
-            });
-          }
-        }
-        break;
-
-      case 'Boolean':
-      case 'BOOLEAN':
-        if (rules.boolean?.enabled && value && value.trim() !== '') {
-          const validBooleans = ['true', 'false', '0', '1'];
-          if (!validBooleans.includes(value.trim().toLowerCase())) {
-            results.push({
-              field: 'value',
-              message: this.interpolateMessage(rules.boolean.message, {
-                dataType,
-              }),
-              severity: rules.boolean.severity || 'error',
-              rule: 'boolean',
-            });
-          }
-        }
-        break;
-
-      case 'Object':
-      case 'Array':
-        if (rules.json?.enabled && value && value.trim() !== '') {
-          try {
-            JSON.parse(value.trim());
-          } catch {
-            results.push({
-              field: 'value',
-              message: this.interpolateMessage(rules.json.message, {
-                dataType,
-              }),
-              severity: rules.json.severity || 'error',
-              rule: 'json',
-            });
-          }
-        }
-        break;
-    }
-
-    // Length validation for strings
-    if (dataType === 'String' && value) {
-      if (rules.minLength?.enabled && value.length < rules.minLength.value) {
-        results.push({
-          field: 'value',
-          message: this.interpolateMessage(rules.minLength.message, {
-            minLength: rules.minLength.value,
-          }),
-          severity: rules.minLength.severity || 'warning',
-          rule: 'minLength',
-        });
-      }
-
-      if (rules.maxLength?.enabled && value.length > rules.maxLength.value) {
-        results.push({
-          field: 'value',
-          message: this.interpolateMessage(rules.maxLength.message, {
-            maxLength: rules.maxLength.value,
-          }),
-          severity: rules.maxLength.severity || 'warning',
-          rule: 'maxLength',
-        });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Validate operation operands
-   */
-  validateOperationOperands(
-    operands: string[],
-    dataType: string,
-  ): ValidationResult[] {
-    if (!this.schema) {
-      return this.fallbackOperationValidation(operands, dataType);
-    }
-
-    const results: ValidationResult[] = [];
-    const operationConfig = this.schema.expressions.operation;
-
-    if (!operationConfig) {
-      return results;
-    }
-
-    operands.forEach((operand, index) => {
-      // Required validation
-      if (operationConfig.validation.operands.required?.enabled) {
-        if (!operand || operand.trim() === '') {
-          results.push({
-            field: `operand${index + 1}`,
-            message: this.interpolateMessage(
-              operationConfig.validation.operands.required.message,
-              { index: index + 1 },
-            ),
-            severity:
-              operationConfig.validation.operands.required.severity || 'error',
-            rule: 'required',
-          });
-        }
-      }
-
-      // Type mismatch validation (warning level)
-      if (
-        operationConfig.validation.operands.typeMismatch?.enabled &&
-        operand &&
-        operand.trim() !== ''
-      ) {
-        const typeValidation = this.validatePrimitiveValue(operand, dataType);
-        if (typeValidation.length > 0) {
-          // Convert to warnings for type mismatches in operations
-          typeValidation.forEach((validation) => {
-            const typeMismatchRule =
-              operationConfig.validation.operands.typeMismatch;
-            if (typeMismatchRule) {
-              results.push({
-                ...validation,
-                field: `operand${index + 1}`,
-                message: this.interpolateMessage(typeMismatchRule.message, {
-                  index: index + 1,
-                  dataType,
-                }),
-                severity: 'warning', // Always warning for type mismatches in operations
-                rule: 'typeMismatch',
-              });
-            }
-          });
-        }
-      }
-    });
-
-    return results;
-  }
-
-  /**
-   * Validate identifier (variable names, function names, etc.)
-   */
-  validateIdentifier(
-    value: string,
-    context: string = 'identifier',
-  ): ValidationResult[] {
-    if (!this.schema) {
-      return this.fallbackIdentifierValidation(value);
-    }
-
-    const results: ValidationResult[] = [];
-    const identifierConfig = this.schema.identifiers.validation;
-
-    // Required validation
-    if (identifierConfig.required?.enabled) {
-      if (!value || value.trim() === '') {
-        results.push({
-          field: context,
-          message: identifierConfig.required.message,
-          severity: identifierConfig.required.severity || 'error',
-          rule: 'required',
-        });
-      }
-    }
-
-    // Format validation
-    if (
-      identifierConfig.format?.enabled &&
-      value &&
-      value.trim() !== '' &&
-      identifierConfig.format.pattern
-    ) {
-      const pattern = new RegExp(identifierConfig.format.pattern);
-      if (!pattern.test(value.trim())) {
-        results.push({
-          field: context,
-          message: identifierConfig.format.message,
-          severity: identifierConfig.format.severity || 'error',
-          rule: 'format',
-        });
-      }
-    }
-
-    // No spaces validation
-    if (identifierConfig.noSpaces?.enabled && value && value.includes(' ')) {
-      results.push({
-        field: context,
-        message: identifierConfig.noSpaces.message,
-        severity: identifierConfig.noSpaces.severity || 'error',
-        rule: 'noSpaces',
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Validate a specific node type
-   */
-  validateNodeType(nodeType: string, data: any): ValidationResult[] {
-    if (!this.schema || !this.schema.nodeTypes[nodeType]) {
-      return [];
-    }
-
-    const results: ValidationResult[] = [];
-    const nodeConfig = this.schema.nodeTypes[nodeType];
-
-    // Validate based on node type
-    switch (nodeType) {
-      case 'function':
-        if (data.name) {
-          results.push(...this.validateIdentifier(data.name, 'functionName'));
-        }
-        if (data.parameters) {
-          data.parameters.forEach((param: string, index: number) => {
-            results.push(
-              ...this.validateIdentifier(param, `parameter${index + 1}`),
-            );
-          });
-        }
-        break;
-
-      case 'if':
-        if (data.condition && nodeConfig.condition?.required) {
-          // Validate condition expression
-          if (
-            typeof data.condition === 'string' &&
-            data.condition.trim() === ''
-          ) {
-            results.push({
-              field: 'condition',
-              message: nodeConfig.condition.required.message,
-              severity: nodeConfig.condition.required.severity || 'error',
-              rule: 'required',
-            });
-          }
-        }
-        break;
-
-      case 'let':
-        if (data.bindings) {
-          data.bindings.forEach((binding: [string, any], index: number) => {
-            const [name, value] = binding;
-            results.push(
-              ...this.validateIdentifier(name, `bindingName${index + 1}`),
-            );
-            if (!value || (typeof value === 'string' && value.trim() === '')) {
-              results.push({
-                field: `bindingValue${index + 1}`,
-                message: 'Binding value cannot be empty',
-                severity: 'error',
-                rule: 'required',
-              });
-            }
-          });
-        }
-        break;
-
-      case 'set':
-        if (data.variable) {
-          results.push(...this.validateIdentifier(data.variable, 'variable'));
-        }
-        if (data.value) {
-          if (typeof data.value === 'string' && data.value.trim() === '') {
-            results.push({
-              field: 'value',
-              message: 'Value cannot be empty',
-              severity: 'error',
-              rule: 'required',
-            });
-          }
-        }
-        break;
-    }
-
-    return results;
-  }
-
-  /**
-   * Interpolate message with variables
-   */
-  private interpolateMessage(
-    message: string,
-    variables: Record<string, any>,
-  ): string {
-    return message.replace(/\{(\w+)\}/g, (match, key) => {
-      return variables[key] !== undefined ? String(variables[key]) : match;
-    });
-  }
-
-  /**
-   * Fallback validation when schema is not available
-   */
-  private fallbackValidation(
-    value: string,
-    dataType: string,
-  ): ValidationResult[] {
-    const results: ValidationResult[] = [];
-
-    if (!value || value.trim() === '') {
-      results.push({
-        field: 'value',
-        message: 'Value cannot be empty',
-        severity: 'error',
-        rule: 'required',
-      });
-      return results;
-    }
-
-    switch (dataType) {
-      case 'Number':
-      case 'INT':
-      case 'FLOAT':
-        if (isNaN(Number(value))) {
-          results.push({
-            field: 'value',
-            message: `Value must be a valid number for ${dataType} type`,
-            severity: 'error',
-            rule: 'numeric',
-          });
-        }
-        break;
-
-      case 'Boolean':
-      case 'BOOLEAN':
-        const validBooleans = ['true', 'false', '0', '1'];
-        if (!validBooleans.includes(value.toLowerCase())) {
-          results.push({
-            field: 'value',
-            message: `Value must be a valid boolean for ${dataType} type`,
-            severity: 'error',
-            rule: 'boolean',
-          });
-        }
-        break;
-
-      case 'Object':
-      case 'Array':
-        try {
-          JSON.parse(value);
-        } catch {
-          results.push({
-            field: 'value',
-            message: `Value must be valid JSON for ${dataType} type`,
-            severity: 'error',
-            rule: 'json',
-          });
-        }
-        break;
-    }
-
-    return results;
-  }
-
-  /**
-   * Fallback operation validation
-   */
-  private fallbackOperationValidation(
-    operands: string[],
-    dataType: string,
-  ): ValidationResult[] {
-    const results: ValidationResult[] = [];
-
-    operands.forEach((operand, index) => {
-      if (!operand || operand.trim() === '') {
-        results.push({
-          field: `operand${index + 1}`,
-          message: `Operand ${index + 1} cannot be empty`,
-          severity: 'error',
-          rule: 'required',
-        });
-      }
-    });
-
-    return results;
-  }
-
-  /**
-   * Fallback identifier validation
-   */
-  private fallbackIdentifierValidation(value: string): ValidationResult[] {
-    const results: ValidationResult[] = [];
-
-    if (!value || value.trim() === '') {
-      results.push({
-        field: 'identifier',
-        message: 'Identifier cannot be empty',
-        severity: 'error',
-        rule: 'required',
-      });
-      return results;
-    }
-
-    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value)) {
-      results.push({
-        field: 'identifier',
-        message:
-          'Identifier must start with a letter or underscore and contain only letters, numbers, and underscores',
-        severity: 'error',
-        rule: 'format',
-      });
-    }
-
-    if (value.includes(' ')) {
-      results.push({
-        field: 'identifier',
-        message: 'Identifier cannot contain spaces',
-        severity: 'error',
-        rule: 'noSpaces',
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Get default schema for fallback
-   */
-  private getDefaultSchema(): ValidationSchema {
-    return {
-      version: '1.0.0',
-      description: 'Default validation schema',
-      globalSettings: {
-        defaultSeverity: 'error',
-        showWarnings: true,
-        strictMode: false,
-      },
-      dataTypes: {},
-      expressions: {
-        primitive: {
-          validation: {
-            required: {
-              enabled: true,
-              message: 'Value cannot be empty',
-              severity: 'error',
-            },
-          },
-        },
-        operation: {
-          validation: {
-            operands: {
-              required: {
-                enabled: true,
-                message: 'Operand {index} cannot be empty',
-                severity: 'error',
-              },
-            },
-          },
-        },
-      },
-      nodeTypes: {},
-      identifiers: {
-        validation: {
-          required: {
-            enabled: true,
-            message: 'Identifier cannot be empty',
-            severity: 'error',
-          },
-          format: {
-            enabled: true,
-            message: 'Invalid identifier format',
-            severity: 'error',
-          },
-        },
-      },
-      messages: {
-        custom: {
-          emptyValue: 'This field cannot be empty',
-          invalidFormat: 'Invalid format for this field',
-          typeMismatch: 'Value type does not match expected type',
-          validationFailed: 'Validation failed for this field',
-        },
-      },
-    };
-  }
-
-  /**
-   * Check if validation results contain errors
-   */
-  hasErrors(results: ValidationResult[]): boolean {
-    return results.some((result) => result.severity === 'error');
-  }
-
-  /**
-   * Check if validation results contain warnings
-   */
-  hasWarnings(results: ValidationResult[]): boolean {
-    return results.some((result) => result.severity === 'warning');
-  }
-
-  /**
-   * Get only error results
-   */
-  getErrors(results: ValidationResult[]): ValidationResult[] {
-    return results.filter((result) => result.severity === 'error');
-  }
-
-  /**
-   * Get only warning results
-   */
-  getWarnings(results: ValidationResult[]): ValidationResult[] {
-    return results.filter((result) => result.severity === 'warning');
-  }
-}
-
-// Export singleton instance
-export const validationEngine = new ValidationEngine();
+import {
+  ValidationSchema,
+  ValidationResult,
+  ValidationRule,
+  SeverityLevel,
+} from '../types/validation-types';
+
+export class ValidationEngine {
+  private schema: ValidationSchema | null = null;
+  private cache: Map<string, any> = new Map();
+
+  constructor() {
+    this.loadSchema();
+  }
+
+  /**
+   * Load the validation schema from the JSON file
+   */
+  private async loadSchema(): Promise<void> {
+    try {
+      // In a real implementation, this would load from a config endpoint
+      // For now, we'll import the schema directly
+      const schemaModule = await import('../templates/validationSchema.json');
+      // Cast to ValidationSchema to handle JSON string literal types
+      this.schema = schemaModule.default as ValidationSchema;
+    } catch (error) {
+      console.warn(
+        'Failed to load validation schema, using default validation:',
+        error,
+      );
+      this.schema = this.getDefaultSchema();
+    }
+  }
+
+  /**
+   * Get the current validation schema
+   */
+  getSchema(): ValidationSchema | null {
+    return this.schema;
+  }
+
+  /**
+   * Validate a primitive value based on data type
+   */
+  validatePrimitiveValue(value: string, dataType: string): ValidationResult[] {
+    if (!this.schema) {
+      return this.fallbackValidation(value, dataType);
+    }
+
+    const results: ValidationResult[] = [];
+    const dataTypeConfig = this.schema.dataTypes[dataType];
+
+    if (!dataTypeConfig) {
+      return results; // No validation rules for this data type
+    }
+
+    const rules = dataTypeConfig.validation;
+
+    // Required validation
+    if (rules.required?.enabled) {
+      if (!value || value.trim() === '') {
+        results.push({
+          field: 'value',
+          message: this.interpolateMessage(rules.required.message, {
+            dataType,
+          }),
+          severity: rules.required.severity || 'error',
+          rule: 'required',
+        });
+      }
+    }
+
+    // Type-specific validation
+    switch (dataType) {
+      case 'Number':
+      case 'INT':
+      case 'FLOAT':
+        if (rules.numeric?.enabled && value && value.trim() !== '') {
+          if (isNaN(Number(value.trim()))) {
+            results.push({
+              field: 'value',
+              message: this.interpolateMessage(rules.numeric.message, {
+                dataType,
+              }),
+              severity: rules.numeric.severity || 'error',
+              rule: 'numeric',
+            });
+          }
+        }
+
+        // Integer validation for INT type
+        if (
+          dataType === 'INT' &&
+          rules.integer?.enabled &&
+          value &&
+          value.trim() !== ''
+        ) {
+          const num = Number(value.trim());
+          if (!Number.isInteger(num)) {
+            results.push({
+              field: 'value',
+              message: this.interpolateMessage(rules.integer.message, {
+                dataType,
+              }),
+              severity: rules.integer.severity || 'error',
+              rule: 'integer',
+            });
+          }
+        }
+        break;
+
+      case 'Boolean':
+      case 'BOOLEAN':
+        if (rules.boolean?.enabled && value && value.trim() !== '') {
+          const validBooleans = ['true', 'false', '0', '1'];
+          if (!validBooleans.includes(value.trim().toLowerCase())) {
+            results.push({
+              field: 'value',
+              message: this.interpolateMessage(rules.boolean.message, {
+                dataType,
+              }),
+              severity: rules.boolean.severity || 'error',
+              rule: 'boolean',
+            });
+          }
+        }
+        break;
+
+      case 'Object':
+      case 'Array':
+        if (rules.json?.enabled && value && value.trim() !== '') {
+          try {
+            JSON.parse(value.trim());
+          } catch {
+            results.push({
+              field: 'value',
+              message: this.interpolateMessage(rules.json.message, {
+                dataType,
+              }),
+              severity: rules.json.severity || 'error',
+              rule: 'json',
+            });
+          }
+        }
+        break;
+    }
+
+    // Length validation for strings
+    if (dataType === 'String' && value) {
+      if (rules.minLength?.enabled && value.length < rules.minLength.value) {
+        results.push({
+          field: 'value',
+          message: this.interpolateMessage(rules.minLength.message, {
+            minLength: rules.minLength.value,
+          }),
+          severity: rules.minLength.severity || 'warning',
+          rule: 'minLength',
+        });
+      }
+
+      if (rules.maxLength?.enabled && value.length > rules.maxLength.value) {
+        results.push({
+          field: 'value',
+          message: this.interpolateMessage(rules.maxLength.message, {
+            maxLength: rules.maxLength.value,
+          }),
+          severity: rules.maxLength.severity || 'warning',
+          rule: 'maxLength',
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate operation operands
+   */
+  validateOperationOperands(
+    operands: string[],
+    dataType: string,
+  ): ValidationResult[] {
+    if (!this.schema) {
+      return this.fallbackOperationValidation(operands, dataType);
+    }
+
+    const results: ValidationResult[] = [];
+    const operationConfig = this.schema.expressions.operation;
+
+    if (!operationConfig) {
+      return results;
+    }
+
+    operands.forEach((operand, index) => {
+      // Required validation
+      if (operationConfig.validation.operands.required?.enabled) {
+        if (!operand || operand.trim() === '') {
+          results.push({
+            field: `operand${index + 1}`,
+            message: this.interpolateMessage(
+              operationConfig.validation.operands.required.message,
+              { index: index + 1 },
+            ),
+            severity:
+              operationConfig.validation.operands.required.severity || 'error',
+            rule: 'required',
+          });
+        }
+      }
+
+      // Type mismatch validation (warning level)
+      if (
+        operationConfig.validation.operands.typeMismatch?.enabled &&
+        operand &&
+        operand.trim() !== ''
+      ) {
+        const typeValidation = this.validatePrimitiveValue(operand, dataType);
+        if (typeValidation.length > 0) {
+          // Convert to warnings for type mismatches in operations
+          typeValidation.forEach((validation) => {
+            const typeMismatchRule =
+              operationConfig.validation.operands.typeMismatch;
+            if (typeMismatchRule) {
+              results.push({
+                ...validation,
+                field: `operand${index + 1}`,
+                message: this.interpolateMessage(typeMismatchRule.message, {
+                  index: index + 1,
+                  dataType,
+                }),
+                severity: 'warning', // Always warning for type mismatches in operations
+                rule: 'typeMismatch',
+              });
+            }
+          });
+        }
+      }
+    });
+
+    return results;
+  }
+
+  /**
+   * Validate identifier (variable names, function names, etc.)
+   */
+  validateIdentifier(
+    value: string,
+    context: string = 'identifier',
+  ): ValidationResult[] {
+    if (!this.schema) {
+      return this.fallbackIdentifierValidation(value);
+    }
+
+    const results: ValidationResult[] = [];
+    const identifierConfig = this.schema.identifiers.validation;
+
+    // Required validation
+    if (identifierConfig.required?.enabled) {
+      if (!value || value.trim() === '') {
+        results.push({
+          field: context,
+          message: identifierConfig.required.message,
+          severity: identifierConfig.required.severity || 'error',
+          rule: 'required',
+        });
+      }
+    }
+
+    // Format validation
+    if (
+      identifierConfig.format?.enabled &&
+      value &&
+      value.trim() !== '' &&
+      identifierConfig.format.pattern
+    ) {
+      const pattern = new RegExp(identifierConfig.format.pattern);
+      if (!pattern.test(value.trim())) {
+        results.push({
+          field: context,
+          message: identifierConfig.format.message,
+          severity: identifierConfig.format.severity || 'error',
+          rule: 'format',
+        });
+      }
+    }
+
+    // No spaces validation
+    if (identifierConfig.noSpaces?.enabled && value && value.includes(' ')) {
+      results.push({
+        field: context,
+        message: identifierConfig.noSpaces.message,
+        severity: identifierConfig.noSpaces.severity || 'error',
+        rule: 'noSpaces',
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate a specific node type
+   */
+  validateNodeType(nodeType: string, data: any): ValidationResult[] {
+    if (!this.schema || !this.schema.nodeTypes[nodeType]) {
+      return [];
+    }
+
+    const results: ValidationResult[] = [];
+    const nodeConfig = this.schema.nodeTypes[nodeType];
+
+    // Validate based on node type
+    switch (nodeType) {
+      case 'function':
+        if (data.name) {
+          results.push(...this.validateIdentifier(data.name, 'functionName'));
+        }
+        if (data.parameters) {
+          data.parameters.forEach((param: string, index: number) => {
+            results.push(
+              ...this.validateIdentifier(param, `parameter${index + 1}`),
+            );
+          });
+        }
+        break;
+
+      case 'if':
+        if (data.condition && nodeConfig.condition?.required) {
+          // Validate condition expression
+          if (
+            typeof data.condition === 'string' &&
+            data.condition.trim() === ''
+          ) {
+            results.push({
+              field: 'condition',
+              message: nodeConfig.condition.required.message,
+              severity: nodeConfig.condition.required.severity || 'error',
+              rule: 'required',
+            });
+          }
+        }
+        break;
+
+      case 'let':
+        if (data.bindings) {
+          data.bindings.forEach((binding: [string, any], index: number) => {
+            const [name, value] = binding;
+            results.push(
+              ...this.validateIdentifier(name, `bindingName${index + 1}`),
+            );
+            if (!value || (typeof value === 'string' && value.trim() === '')) {
+              results.push({
+                field: `bindingValue${index + 1}`,
+                message: 'Binding value cannot be empty',
+                severity: 'error',
+                rule: 'required',
+              });
+            }
+          });
+        }
+        break;
+
+      case 'set':
+        if (data.variable) {
+          results.push(...this.validateIdentifier(data.variable, 'variable'));
+        }
+        if (data.value) {
+          if (typeof data.value === 'string' && data.value.trim() === '') {
+            results.push({
+              field: 'value',
+              message: 'Value cannot be empty',
+              severity: 'error',
+              rule: 'required',
+            });
+          }
+        }
+        break;
+    }
+
+    return results;
+  }
+
+  /**
+   * Interpolate message with variables
+   */
+  private interpolateMessage(
+    message: string,
+    variables: Record<string, any>,
+  ): string {
+    return message.replace(/\{(\w+)\}/g, (match, key) => {
+      return variables[key] !== undefined ? String(variables[key]) : match;
+    });
+  }
+
+  /**
+   * Fallback validation when schema is not available
+   */
+  private fallbackValidation(
+    value: string,
+    dataType: string,
+  ): ValidationResult[] {
+    const results: ValidationResult[] = [];
+
+    if (!value || value.trim() === '') {
+      results.push({
+        field: 'value',
+        message: 'Value cannot be empty',
+        severity: 'error',
+        rule: 'required',
+      });
+      return results;
+    }
+
+    switch (dataType) {
+      case 'Number':
+      case 'INT':
+      case 'FLOAT':
+        if (isNaN(Number(value))) {
+          results.push({
+            field: 'value',
+            message: `Value must be a valid number for ${dataType} type`,
+            severity: 'error',
+            rule: 'numeric',
+          });
+        }
+        break;
+
+      case 'Boolean':
+      case 'BOOLEAN':
+        const validBooleans = ['true', 'false', '0', '1'];
+        if (!validBooleans.includes(value.toLowerCase())) {
+          results.push({
+            field: 'value',
+            message: `Value must be a valid boolean for ${dataType} type`,
+            severity: 'error',
+            rule: 'boolean',
+          });
+        }
+        break;
+
+      case 'Object':
+      case 'Array':
+        try {
+          JSON.parse(value);
+        } catch {
+          results.push({
+            field: 'value',
+            message: `Value must be valid JSON for ${dataType} type`,
+            severity: 'error',
+            rule: 'json',
+          });
+        }
+        break;
+    }
+
+    return results;
+  }
+
+  /**
+   * Fallback operation validation
+   */
+  private fallbackOperationValidation(
+    operands: string[],
+    dataType: string,
+  ): ValidationResult[] {
+    const results: ValidationResult[] = [];
+
+    operands.forEach((operand, index) => {
+      if (!operand || operand.trim() === '') {
+        results.push({
+          field: `operand${index + 1}`,
+          message: `Operand ${index + 1} cannot be empty`,
+          severity: 'error',
+          rule: 'required',
+        });
+      }
+    });
+
+    return results;
+  }
+
+  /**
+   * Fallback identifier validation
+   */
+  private fallbackIdentifierValidation(value: string): ValidationResult[] {
+    const results: ValidationResult[] = [];
+
+    if (!value || value.trim() === '') {
+      results.push({
+        field: 'identifier',
+        message: 'Identifier cannot be empty',
+        severity: 'error',
+        rule: 'required',
+      });
+      return results;
+    }
+
+    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value)) {
+      results.push({
+        field: 'identifier',
+        message:
+          'Identifier must start with a letter or underscore and contain only letters, numbers, and underscores',
+        severity: 'error',
+        rule: 'format',
+      });
+    }
+
+    if (value.includes(' ')) {
+      results.push({
+        field: 'identifier',
+        message: 'Identifier cannot contain spaces',
+        severity: 'error',
+        rule: 'noSpaces',
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Get default schema for fallback
+   */
+  private getDefaultSchema(): ValidationSchema {
+    return {
+      version: '1.0.0',
+      description: 'Default validation schema',
+      globalSettings: {
+        defaultSeverity: 'error',
+        showWarnings: true,
+        strictMode: false,
+      },
+      dataTypes: {},
+      expressions: {
+        primitive: {
+          validation: {
+            required: {
+              enabled: true,
+              message: 'Value cannot be empty',
+              severity: 'error',
+            },
+          },
+        },
+        operation: {
+          validation: {
+            operands: {
+              required: {
+                enabled: true,
+                message: 'Operand {index} cannot be empty',
+                severity: 'error',
+              },
+            },
+          },
+        },
+      },
+      nodeTypes: {},
+      identifiers: {
+        validation: {
+          required: {
+            enabled: true,
+            message: 'Identifier cannot be empty',
+            severity: 'error',
+          },
+          format: {
+            enabled: true,
+            message: 'Invalid identifier format',
+            severity: 'error',
+          },
+        },
+      },
+      messages: {
+        custom: {
+          emptyValue: 'This field cannot be empty',
+          invalidFormat: 'Invalid format for this field',
+          typeMismatch: 'Value type does not match expected type',
+          validationFailed: 'Validation failed for this field',
+        },
+      },
+    };
+  }
+
+  /**
+   * Check if validation results contain errors
+   */
+  hasErrors(results: ValidationResult[]): boolean {
+    return results.some((result) => result.severity === 'error');
+  }
+
+  /**
+   * Check if validation results contain warnings
+   */
+  hasWarnings(results: ValidationResult[]): boolean {
+    return results.some((result) => result.severity === 'warning');
+  }
+
+  /**
+   * Get only error results
+   */
+  getErrors(results: ValidationResult[]): ValidationResult[] {
+    return results.filter((result) => result.severity === 'error');
+  }
+
+  /**
+   * Get only warning results
+   */
+  getWarnings(results: ValidationResult[]): ValidationResult[] {
+    return results.filter((result) => result.severity === 'warning');
+  }
+}
+
+// Export singleton instance
+export const validationEngine = new ValidationEngine();