@flowuent-org/diagramming-core 1.3.10 → 1.4.1

package/packages/diagrams/src/lib/templates/cloud-arch/utils/restrictionValidator.ts

@@ -1,401 +1,401 @@
-// Smart Restriction Validator
-// Handles both legacy string arrays and new structured RestrictionRule objects
-
-import { Node } from 'reactflow';
-import { ResourceRestrictions, RestrictionRule } from '../types/validation';
-import { localizationManager } from './localizationManager';
-
-export interface ValidationResult {
-  isValid: boolean;
-  message?: string;
-  severity?: 'error' | 'warning' | 'info';
-  metadata?: {
-    limit?: number;
-    current?: number;
-    category?: string;
-    helpUrl?: string;
-  };
-}
-
-export interface ContainmentValidation {
-  canContain: boolean;
-  violations: ValidationResult[];
-  warnings: ValidationResult[];
-  limits: {
-    hasLimits: boolean;
-    withinLimits: boolean;
-    details: Array<{
-      resourceType: string;
-      max?: number;
-      current: number;
-      message: string;
-    }>;
-  };
-}
-
-export class RestrictionValidator {
-  
-  /**
-   * Validate if a parent can contain a specific child resource
-   */
-  validateContainment(
-    parentNode: Node,
-    childResourceType: string,
-    allNodes: Node[],
-    restrictions: ResourceRestrictions
-  ): ValidationResult {
-    const { canContain } = restrictions;
-    
-    // Handle simple string array format (legacy)
-    if (Array.isArray(canContain)) {
-      return {
-        isValid: canContain.includes(childResourceType),
-        message: canContain.includes(childResourceType) 
-          ? undefined 
-          : `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`
-      };
-    }
-    
-    // Handle structured RestrictionRule format (new)
-    const rule = canContain[childResourceType];
-    if (!rule) {
-      return {
-        isValid: false,
-        message: `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`,
-        severity: 'error'
-      };
-    }
-    
-    // Check conditions first
-    if (!this.evaluateConditions(rule.condition, parentNode, allNodes)) {
-      return {
-        isValid: false,
-        message: this.resolveMessage(rule.validationMessage) || `Conditions not met for ${childResourceType}`,
-        severity: rule.metadata?.severity || 'error'
-      };
-    }
-    
-    // Check limits
-    const currentCount = this.countChildrenOfType(parentNode, childResourceType, allNodes);
-    
-    if (rule.max !== undefined && currentCount >= rule.max) {
-      return {
-        isValid: false,
-        message: this.resolveMessage(rule.validationMessage) || `Maximum ${rule.max} ${childResourceType} allowed`,
-        severity: rule.metadata?.severity || 'error',
-        metadata: {
-          limit: rule.max,
-          current: currentCount,
-          category: rule.metadata?.category,
-          helpUrl: rule.metadata?.helpUrl
-        }
-      };
-    }
-    
-    return {
-      isValid: true,
-      message: this.resolveMessage(rule.validationMessage),
-      severity: rule.metadata?.severity || 'info'
-    };
-  }
-  
-  /**
-   * Validate if a parent cannot contain a specific child resource
-   */
-  validateNonContainment(
-    parentNode: Node,
-    childResourceType: string,
-    allNodes: Node[],
-    restrictions: ResourceRestrictions
-  ): ValidationResult {
-    const { cannotContain } = restrictions;
-    
-    // Handle simple string array format (legacy)
-    if (Array.isArray(cannotContain)) {
-      return {
-        isValid: !cannotContain.includes(childResourceType),
-        message: cannotContain.includes(childResourceType) 
-          ? `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`
-          : undefined
-      };
-    }
-    
-    // Handle structured RestrictionRule format (new)
-    const rule = cannotContain[childResourceType];
-    if (!rule) {
-      return { isValid: true }; // No restriction found, so it's allowed
-    }
-    
-    // Check conditions - if conditions apply, then the restriction is active
-    const conditionsApply = this.evaluateConditions(rule.condition, parentNode, allNodes);
-    
-    if (conditionsApply) {
-      return {
-        isValid: false,
-        message: this.resolveMessage(rule.validationMessage) || `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`,
-        severity: rule.metadata?.severity || 'error',
-        metadata: {
-          category: rule.metadata?.category,
-          helpUrl: rule.metadata?.helpUrl
-        }
-      };
-    }
-    
-    return { isValid: true };
-  }
-  
-  /**
-   * Get comprehensive containment validation for a parent node
-   */
-  validateAllContainment(
-    parentNode: Node,
-    allNodes: Node[],
-    restrictions: ResourceRestrictions
-  ): ContainmentValidation {
-    const violations: ValidationResult[] = [];
-    const warnings: ValidationResult[] = [];
-    const limitDetails: Array<{
-      resourceType: string;
-      max?: number;
-      current: number;
-      message: string;
-    }> = [];
-    
-    let hasLimits = false;
-    let withinLimits = true;
-    
-    const { canContain } = restrictions;
-    
-    // Handle structured format
-    if (!Array.isArray(canContain)) {
-      Object.entries(canContain).forEach(([resourceType, rule]) => {
-        const currentCount = this.countChildrenOfType(parentNode, resourceType, allNodes);
-        
-        if (rule.max !== undefined) {
-          hasLimits = true;
-          
-          const detail = {
-            resourceType,
-            max: rule.max,
-            current: currentCount,
-            message: this.resolveMessage(rule.validationMessage) || `${currentCount}/${rule.max} ${resourceType}`
-          };
-          limitDetails.push(detail);
-          
-          if (currentCount > rule.max) {
-            withinLimits = false;
-            violations.push({
-              isValid: false,
-              message: detail.message,
-              severity: 'error',
-              metadata: {
-                limit: rule.max,
-                current: currentCount
-              }
-            });
-          } else if (currentCount === rule.max) {
-            warnings.push({
-              isValid: true,
-              message: `At limit: ${detail.message}`,
-              severity: 'warning',
-              metadata: {
-                limit: rule.max,
-                current: currentCount
-              }
-            });
-          }
-        }
-      });
-    }
-    
-    return {
-      canContain: violations.length === 0,
-      violations,
-      warnings,
-      limits: {
-        hasLimits,
-        withinLimits,
-        details: limitDetails
-      }
-    };
-  }
-  
-  /**
-   * Count children of a specific type for a parent node
-   */
-  private countChildrenOfType(parentNode: Node, resourceType: string, allNodes: Node[]): number {
-    return allNodes.filter(node => 
-      node.parentNode === parentNode.id && 
-      node.data?.service === resourceType
-    ).length;
-  }
-  
-  /**
-   * Evaluate conditional logic for restriction rules
-   */
-  private evaluateConditions(
-    condition: RestrictionRule['condition'],
-    parentNode: Node,
-    allNodes: Node[]
-  ): boolean {
-    if (!condition) return true; // No conditions mean rule always applies
-    
-    // Check "unless" conditions - if any are true, rule doesn't apply
-    if (condition.unless) {
-      const unlessConditionsMet = condition.unless.some(cond => 
-        this.evaluateSingleCondition(cond, parentNode, allNodes)
-      );
-      if (unlessConditionsMet) return false;
-    }
-    
-    // Check "onlyIf" conditions - all must be true for rule to apply
-    if (condition.onlyIf) {
-      const onlyIfConditionsMet = condition.onlyIf.every(cond => 
-        this.evaluateSingleCondition(cond, parentNode, allNodes)
-      );
-      if (!onlyIfConditionsMet) return false;
-    }
-    
-    // Check region conditions
-    if (condition.regions) {
-      const nodeRegion = parentNode.data?.region;
-      if (nodeRegion && !condition.regions.includes(nodeRegion)) {
-        return false;
-      }
-    }
-    
-    // Check tag conditions
-    if (condition.tags) {
-      const nodeTags = parentNode.data?.tags || {};
-      const allTagsMatch = Object.entries(condition.tags).every(([key, value]) => 
-        nodeTags[key] === value
-      );
-      if (!allTagsMatch) return false;
-    }
-    
-    return true;
-  }
-  
-  /**
-   * Evaluate a single condition string
-   */
-  private evaluateSingleCondition(condition: string, parentNode: Node, allNodes: Node[]): boolean {
-    // Simple condition evaluation - can be extended
-    switch (condition) {
-      case 'has-internet-gateway':
-        return allNodes.some(node => 
-          node.parentNode === parentNode.id && 
-          node.data?.service === 'internet-gateway'
-        );
-      case 'is-public-subnet':
-        return parentNode.data?.subnetType === 'public';
-      case 'is-private-subnet':
-        return parentNode.data?.subnetType === 'private';
-      case 'multi-az-enabled':
-        return parentNode.data?.multiAZ === true;
-      default:
-        return false;
-    }
-  }
-  
-  /**
-   * Resolve validation message using localization manager
-   */
-  private resolveMessage(messageKey?: string): string | undefined {
-    if (!messageKey) return undefined;
-    
-    // Check if it's a localization key
-    if (messageKey.includes('.')) {
-      return localizationManager.getMessage(messageKey, {}, messageKey);
-    }
-    
-    return messageKey;
-  }
-  
-  /**
-   * Get summary of all restrictions for a resource type
-   */
-  getRestrictionSummary(restrictions: ResourceRestrictions): {
-    containmentRules: Array<{
-      resourceType: string;
-      canContain: boolean;
-      limits?: { max?: number; min?: number };
-      message?: string;
-    }>;
-    limits: {
-      maxChildren?: number;
-      quotas?: Record<string, number>;
-    };
-  } {
-    const containmentRules: Array<{
-      resourceType: string;
-      canContain: boolean;
-      limits?: { max?: number; min?: number };
-      message?: string;
-    }> = [];
-    
-    // Process canContain rules
-    if (!Array.isArray(restrictions.canContain)) {
-      Object.entries(restrictions.canContain).forEach(([resourceType, rule]) => {
-        containmentRules.push({
-          resourceType,
-          canContain: true,
-          limits: {
-            max: rule.max,
-            min: rule.min
-          },
-          message: this.resolveMessage(rule.validationMessage)
-        });
-      });
-    }
-    
-    // Process cannotContain rules
-    if (!Array.isArray(restrictions.cannotContain)) {
-      Object.entries(restrictions.cannotContain).forEach(([resourceType, rule]) => {
-        containmentRules.push({
-          resourceType,
-          canContain: false,
-          message: this.resolveMessage(rule.validationMessage)
-        });
-      });
-    }
-    
-    return {
-      containmentRules,
-      limits: {
-        maxChildren: restrictions.limits?.maxChildren,
-        quotas: restrictions.limits?.quotas
-      }
-    };
-  }
-}
-
-// Default instance
-export const restrictionValidator = new RestrictionValidator();
-
-// Utility functions
-export const validateNodeContainment = (
-  parentNode: Node,
-  childResourceType: string,
-  allNodes: Node[],
-  restrictions: ResourceRestrictions
-): ValidationResult => {
-  return restrictionValidator.validateContainment(parentNode, childResourceType, allNodes, restrictions);
-};
-
-export const validateNodeNonContainment = (
-  parentNode: Node,
-  childResourceType: string,
-  allNodes: Node[],
-  restrictions: ResourceRestrictions
-): ValidationResult => {
-  return restrictionValidator.validateNonContainment(parentNode, childResourceType, allNodes, restrictions);
-};
-
-export const getNodeContainmentSummary = (
-  parentNode: Node,
-  allNodes: Node[],
-  restrictions: ResourceRestrictions
-): ContainmentValidation => {
-  return restrictionValidator.validateAllContainment(parentNode, allNodes, restrictions);
+// Smart Restriction Validator
+// Handles both legacy string arrays and new structured RestrictionRule objects
+
+import { Node } from 'reactflow';
+import { ResourceRestrictions, RestrictionRule } from '../types/validation';
+import { localizationManager } from './localizationManager';
+
+export interface ValidationResult {
+  isValid: boolean;
+  message?: string;
+  severity?: 'error' | 'warning' | 'info';
+  metadata?: {
+    limit?: number;
+    current?: number;
+    category?: string;
+    helpUrl?: string;
+  };
+}
+
+export interface ContainmentValidation {
+  canContain: boolean;
+  violations: ValidationResult[];
+  warnings: ValidationResult[];
+  limits: {
+    hasLimits: boolean;
+    withinLimits: boolean;
+    details: Array<{
+      resourceType: string;
+      max?: number;
+      current: number;
+      message: string;
+    }>;
+  };
+}
+
+export class RestrictionValidator {
+  
+  /**
+   * Validate if a parent can contain a specific child resource
+   */
+  validateContainment(
+    parentNode: Node,
+    childResourceType: string,
+    allNodes: Node[],
+    restrictions: ResourceRestrictions
+  ): ValidationResult {
+    const { canContain } = restrictions;
+    
+    // Handle simple string array format (legacy)
+    if (Array.isArray(canContain)) {
+      return {
+        isValid: canContain.includes(childResourceType),
+        message: canContain.includes(childResourceType) 
+          ? undefined 
+          : `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`
+      };
+    }
+    
+    // Handle structured RestrictionRule format (new)
+    const rule = canContain[childResourceType];
+    if (!rule) {
+      return {
+        isValid: false,
+        message: `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`,
+        severity: 'error'
+      };
+    }
+    
+    // Check conditions first
+    if (!this.evaluateConditions(rule.condition, parentNode, allNodes)) {
+      return {
+        isValid: false,
+        message: this.resolveMessage(rule.validationMessage) || `Conditions not met for ${childResourceType}`,
+        severity: rule.metadata?.severity || 'error'
+      };
+    }
+    
+    // Check limits
+    const currentCount = this.countChildrenOfType(parentNode, childResourceType, allNodes);
+    
+    if (rule.max !== undefined && currentCount >= rule.max) {
+      return {
+        isValid: false,
+        message: this.resolveMessage(rule.validationMessage) || `Maximum ${rule.max} ${childResourceType} allowed`,
+        severity: rule.metadata?.severity || 'error',
+        metadata: {
+          limit: rule.max,
+          current: currentCount,
+          category: rule.metadata?.category,
+          helpUrl: rule.metadata?.helpUrl
+        }
+      };
+    }
+    
+    return {
+      isValid: true,
+      message: this.resolveMessage(rule.validationMessage),
+      severity: rule.metadata?.severity || 'info'
+    };
+  }
+  
+  /**
+   * Validate if a parent cannot contain a specific child resource
+   */
+  validateNonContainment(
+    parentNode: Node,
+    childResourceType: string,
+    allNodes: Node[],
+    restrictions: ResourceRestrictions
+  ): ValidationResult {
+    const { cannotContain } = restrictions;
+    
+    // Handle simple string array format (legacy)
+    if (Array.isArray(cannotContain)) {
+      return {
+        isValid: !cannotContain.includes(childResourceType),
+        message: cannotContain.includes(childResourceType) 
+          ? `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`
+          : undefined
+      };
+    }
+    
+    // Handle structured RestrictionRule format (new)
+    const rule = cannotContain[childResourceType];
+    if (!rule) {
+      return { isValid: true }; // No restriction found, so it's allowed
+    }
+    
+    // Check conditions - if conditions apply, then the restriction is active
+    const conditionsApply = this.evaluateConditions(rule.condition, parentNode, allNodes);
+    
+    if (conditionsApply) {
+      return {
+        isValid: false,
+        message: this.resolveMessage(rule.validationMessage) || `${parentNode.data?.service || 'Resource'} cannot contain ${childResourceType}`,
+        severity: rule.metadata?.severity || 'error',
+        metadata: {
+          category: rule.metadata?.category,
+          helpUrl: rule.metadata?.helpUrl
+        }
+      };
+    }
+    
+    return { isValid: true };
+  }
+  
+  /**
+   * Get comprehensive containment validation for a parent node
+   */
+  validateAllContainment(
+    parentNode: Node,
+    allNodes: Node[],
+    restrictions: ResourceRestrictions
+  ): ContainmentValidation {
+    const violations: ValidationResult[] = [];
+    const warnings: ValidationResult[] = [];
+    const limitDetails: Array<{
+      resourceType: string;
+      max?: number;
+      current: number;
+      message: string;
+    }> = [];
+    
+    let hasLimits = false;
+    let withinLimits = true;
+    
+    const { canContain } = restrictions;
+    
+    // Handle structured format
+    if (!Array.isArray(canContain)) {
+      Object.entries(canContain).forEach(([resourceType, rule]) => {
+        const currentCount = this.countChildrenOfType(parentNode, resourceType, allNodes);
+        
+        if (rule.max !== undefined) {
+          hasLimits = true;
+          
+          const detail = {
+            resourceType,
+            max: rule.max,
+            current: currentCount,
+            message: this.resolveMessage(rule.validationMessage) || `${currentCount}/${rule.max} ${resourceType}`
+          };
+          limitDetails.push(detail);
+          
+          if (currentCount > rule.max) {
+            withinLimits = false;
+            violations.push({
+              isValid: false,
+              message: detail.message,
+              severity: 'error',
+              metadata: {
+                limit: rule.max,
+                current: currentCount
+              }
+            });
+          } else if (currentCount === rule.max) {
+            warnings.push({
+              isValid: true,
+              message: `At limit: ${detail.message}`,
+              severity: 'warning',
+              metadata: {
+                limit: rule.max,
+                current: currentCount
+              }
+            });
+          }
+        }
+      });
+    }
+    
+    return {
+      canContain: violations.length === 0,
+      violations,
+      warnings,
+      limits: {
+        hasLimits,
+        withinLimits,
+        details: limitDetails
+      }
+    };
+  }
+  
+  /**
+   * Count children of a specific type for a parent node
+   */
+  private countChildrenOfType(parentNode: Node, resourceType: string, allNodes: Node[]): number {
+    return allNodes.filter(node => 
+      node.parentNode === parentNode.id && 
+      node.data?.service === resourceType
+    ).length;
+  }
+  
+  /**
+   * Evaluate conditional logic for restriction rules
+   */
+  private evaluateConditions(
+    condition: RestrictionRule['condition'],
+    parentNode: Node,
+    allNodes: Node[]
+  ): boolean {
+    if (!condition) return true; // No conditions mean rule always applies
+    
+    // Check "unless" conditions - if any are true, rule doesn't apply
+    if (condition.unless) {
+      const unlessConditionsMet = condition.unless.some(cond => 
+        this.evaluateSingleCondition(cond, parentNode, allNodes)
+      );
+      if (unlessConditionsMet) return false;
+    }
+    
+    // Check "onlyIf" conditions - all must be true for rule to apply
+    if (condition.onlyIf) {
+      const onlyIfConditionsMet = condition.onlyIf.every(cond => 
+        this.evaluateSingleCondition(cond, parentNode, allNodes)
+      );
+      if (!onlyIfConditionsMet) return false;
+    }
+    
+    // Check region conditions
+    if (condition.regions) {
+      const nodeRegion = parentNode.data?.region;
+      if (nodeRegion && !condition.regions.includes(nodeRegion)) {
+        return false;
+      }
+    }
+    
+    // Check tag conditions
+    if (condition.tags) {
+      const nodeTags = parentNode.data?.tags || {};
+      const allTagsMatch = Object.entries(condition.tags).every(([key, value]) => 
+        nodeTags[key] === value
+      );
+      if (!allTagsMatch) return false;
+    }
+    
+    return true;
+  }
+  
+  /**
+   * Evaluate a single condition string
+   */
+  private evaluateSingleCondition(condition: string, parentNode: Node, allNodes: Node[]): boolean {
+    // Simple condition evaluation - can be extended
+    switch (condition) {
+      case 'has-internet-gateway':
+        return allNodes.some(node => 
+          node.parentNode === parentNode.id && 
+          node.data?.service === 'internet-gateway'
+        );
+      case 'is-public-subnet':
+        return parentNode.data?.subnetType === 'public';
+      case 'is-private-subnet':
+        return parentNode.data?.subnetType === 'private';
+      case 'multi-az-enabled':
+        return parentNode.data?.multiAZ === true;
+      default:
+        return false;
+    }
+  }
+  
+  /**
+   * Resolve validation message using localization manager
+   */
+  private resolveMessage(messageKey?: string): string | undefined {
+    if (!messageKey) return undefined;
+    
+    // Check if it's a localization key
+    if (messageKey.includes('.')) {
+      return localizationManager.getMessage(messageKey, {}, messageKey);
+    }
+    
+    return messageKey;
+  }
+  
+  /**
+   * Get summary of all restrictions for a resource type
+   */
+  getRestrictionSummary(restrictions: ResourceRestrictions): {
+    containmentRules: Array<{
+      resourceType: string;
+      canContain: boolean;
+      limits?: { max?: number; min?: number };
+      message?: string;
+    }>;
+    limits: {
+      maxChildren?: number;
+      quotas?: Record<string, number>;
+    };
+  } {
+    const containmentRules: Array<{
+      resourceType: string;
+      canContain: boolean;
+      limits?: { max?: number; min?: number };
+      message?: string;
+    }> = [];
+    
+    // Process canContain rules
+    if (!Array.isArray(restrictions.canContain)) {
+      Object.entries(restrictions.canContain).forEach(([resourceType, rule]) => {
+        containmentRules.push({
+          resourceType,
+          canContain: true,
+          limits: {
+            max: rule.max,
+            min: rule.min
+          },
+          message: this.resolveMessage(rule.validationMessage)
+        });
+      });
+    }
+    
+    // Process cannotContain rules
+    if (!Array.isArray(restrictions.cannotContain)) {
+      Object.entries(restrictions.cannotContain).forEach(([resourceType, rule]) => {
+        containmentRules.push({
+          resourceType,
+          canContain: false,
+          message: this.resolveMessage(rule.validationMessage)
+        });
+      });
+    }
+    
+    return {
+      containmentRules,
+      limits: {
+        maxChildren: restrictions.limits?.maxChildren,
+        quotas: restrictions.limits?.quotas
+      }
+    };
+  }
+}
+
+// Default instance
+export const restrictionValidator = new RestrictionValidator();
+
+// Utility functions
+export const validateNodeContainment = (
+  parentNode: Node,
+  childResourceType: string,
+  allNodes: Node[],
+  restrictions: ResourceRestrictions
+): ValidationResult => {
+  return restrictionValidator.validateContainment(parentNode, childResourceType, allNodes, restrictions);
+};
+
+export const validateNodeNonContainment = (
+  parentNode: Node,
+  childResourceType: string,
+  allNodes: Node[],
+  restrictions: ResourceRestrictions
+): ValidationResult => {
+  return restrictionValidator.validateNonContainment(parentNode, childResourceType, allNodes, restrictions);
+};
+
+export const getNodeContainmentSummary = (
+  parentNode: Node,
+  allNodes: Node[],
+  restrictions: ResourceRestrictions
+): ContainmentValidation => {
+  return restrictionValidator.validateAllContainment(parentNode, allNodes, restrictions);
 };