@flowuent-org/diagramming-core 1.3.9 → 1.4.0

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

@@ -1,105 +0,0 @@
-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

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