@flowuent-org/diagramming-core 1.0.5

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

@@ -0,0 +1,105 @@
+import { Edge } from '@xyflow/react';
+import { ICardNode } from '../types/card-node';
+
+export const getPreviousNodes = (
+  node: ICardNode,
+  edges: Edge[],
+  nodes: ICardNode[],
+) => {
+  const nodeIds = edges
+    .filter((e) => e.target === node.id)
+    .map((e) => e.source);
+  if (nodeIds) {
+    return nodes.filter((n) => nodeIds.includes(n.id));
+  }
+  return [];
+};
+
+export const getMinX = (nodes: ICardNode[]) =>
+  nodes.length === 0
+    ? Infinity
+    : Math.min(...nodes.map((node) => getNodePositionX(node)));
+export const getMaxX = (nodes: ICardNode[]) =>
+  nodes.length === 0
+    ? -Infinity
+    : Math.max(
+        ...nodes.map((node) => getNodePositionX(node) + getNodeWidth(node)),
+      );
+
+const getLevelExtremes = (
+  previousNode: ICardNode,
+  yLevel: number,
+  nodes: ICardNode[],
+  edges: Edge[],
+) => {
+  const eligibleNodes = nodes.filter(
+    (n) =>
+      n.position.y === yLevel &&
+      previousNode.id === getPreviousNodes(n, edges, nodes)[0]?.id,
+  );
+
+  return {
+    minX: getMinX(eligibleNodes),
+    maxX: getMaxX(eligibleNodes),
+  };
+};
+
+const recursivelyGetLevelExtremes = (
+  finalNodeId: string | undefined,
+  currentExtremes: { minX: number; maxX: number; maxWidth: number },
+  node: ICardNode,
+  nodes: ICardNode[],
+  edges: Edge[],
+  type: 'branch' | 'parallel',
+): { minX: number; maxX: number; maxWidth: number } => {
+  const nextNode = getNextNodes(node.id, nodes, edges)[0];
+  let returnValue = {
+    minX: Math.min(currentExtremes.minX, node.position.x),
+    maxX: Math.max(currentExtremes.maxX, node.position.x + getNodeWidth(node)),
+    maxWidth: Math.max(currentExtremes.maxWidth, getNodeWidth(node)),
+  };
+  if (nextNode && nextNode.id !== finalNodeId && returnValue.minX !== 0) {
+    // Calculate the extremes of the current level
+    const levelExtremes = getLevelExtremes(
+      node,
+      nextNode.position.y,
+      nodes,
+      edges,
+    );
+    const newWidth = levelExtremes.maxX - levelExtremes.minX;
+    // Update the current extremes if the current level's extremes are greater or lesser
+    const newExtremes = {
+      minX: Math.min(currentExtremes.minX, levelExtremes.minX),
+      maxX: Math.max(currentExtremes.maxX, levelExtremes.maxX),
+      maxWidth: Math.max(currentExtremes.maxWidth, newWidth),
+    };
+    // Recursively call the function for the next node
+    returnValue = recursivelyGetLevelExtremes(
+      finalNodeId,
+      newExtremes,
+      nextNode,
+      nodes,
+      edges,
+      type,
+    );
+  } else {
+  }
+
+  return returnValue;
+};
+
+export const getNextNodes = (
+  nodeId: string,
+  nodes: ICardNode[],
+  edges: Edge[],
+): ICardNode[] => {
+  const ids = edges.filter((e) => e.source === nodeId).map((e) => e.target);
+  return nodes.filter((n) => ids.includes(n.id));
+};
+
+const defaultStyle = { width: 0, height: 0 };
+export const getNodeWidth = (node: ICardNode) =>
+  typeof node.width === 'number' ? node.width : defaultStyle.width;
+export const getNodeHeight = (node: ICardNode) =>
+  typeof node.height === 'number' ? node.height : defaultStyle.height;
+export const getNodePositionX = (node: ICardNode) => node.position.x;

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

@@ -0,0 +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();