@flowuent-org/diagramming-core 1.1.0 → 1.1.2

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

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

package/packages/diagrams/src/lib/templates/cloud-arch/utils/serviceIcons.tsx

@@ -0,0 +1,129 @@
+import React from 'react';
+import { getServiceInfo } from './iconMapping';
+import AccountBalanceIcon from '@mui/icons-material/AccountBalance';
+import AccountTreeIcon from '@mui/icons-material/AccountTree';
+import HubIcon from '@mui/icons-material/Hub';
+import DomainIcon from '@mui/icons-material/Domain';
+import LocationOnIcon from '@mui/icons-material/LocationOn';
+import SecurityIcon from '@mui/icons-material/Security';
+
+interface ServiceIconProps {
+  service: string;
+  width?: string | number;
+  height?: string | number;
+  cloudProvider?: 'aws' | 'azure' | 'gcp';
+}
+
+// Container service icons mapping
+const containerIcons: Record<string, React.ReactNode> = {
+  'account': <AccountBalanceIcon sx={{ color: '#FF9900', fontSize: 'inherit' }} />,
+  'aws-account': <AccountBalanceIcon sx={{ color: '#FF9900', fontSize: 'inherit' }} />,
+  'vpc': <AccountTreeIcon sx={{ color: '#61dafb', fontSize: 'inherit' }} />,
+  'subnet': <HubIcon sx={{ color: '#61dafb', fontSize: 'inherit' }} />,
+  'availability-zone': <DomainIcon sx={{ color: '#9c27b0', fontSize: 'inherit' }} />,
+  'local-zone': <LocationOnIcon sx={{ color: '#9c27b0', fontSize: 'inherit' }} />,
+  'security-group': <SecurityIcon sx={{ color: '#f44336', fontSize: 'inherit' }} />,
+  'virtual-network': <AccountTreeIcon sx={{ color: '#0078D4', fontSize: 'inherit' }} />,
+  'resource-group': <HubIcon sx={{ color: '#0078D4', fontSize: 'inherit' }} />,
+  'project': <AccountBalanceIcon sx={{ color: '#4285F4', fontSize: 'inherit' }} />,
+};
+
+export const InternetIcon: React.FC<{ width?: string | number; height?: string | number }> = ({
+  width = 48,
+  height = 48,
+}) => (
+  <svg
+    width={width}
+    height={height}
+    viewBox="0 0 48 48"
+    fill="none"
+    xmlns="http://www.w3.org/2000/svg"
+  >
+    <circle cx="24" cy="24" r="20" stroke="#61dafb" strokeWidth="2" />
+    <path
+      d="M24 4C24 4 12 14 12 24C12 34 24 44 24 44"
+      stroke="#61dafb"
+      strokeWidth="2"
+    />
+    <path
+      d="M24 4C24 4 36 14 36 24C36 34 24 44 24 44"
+      stroke="#61dafb"
+      strokeWidth="2"
+    />
+    <path
+      d="M4 24H44"
+      stroke="#61dafb"
+      strokeWidth="2"
+    />
+    <path
+      d="M7 16H41"
+      stroke="#61dafb"
+      strokeWidth="2"
+    />
+    <path
+      d="M7 32H41"
+      stroke="#61dafb"
+      strokeWidth="2"
+    />
+  </svg>
+);
+
+export const ServiceIcon: React.FC<ServiceIconProps> = ({ 
+  service, 
+  width = 48, 
+  height = 48,
+  cloudProvider = 'aws'
+}) => {
+  // Special case for internet icon
+  if (service === 'internet') {
+    return <InternetIcon width={width} height={height} />;
+  }
+
+  // Check for container service icons first
+  if (containerIcons[service]) {
+    return (
+      <div style={{ fontSize: width, width, height, display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+        {containerIcons[service]}
+      </div>
+    );
+  }
+
+  const serviceInfo = getServiceInfo(service, cloudProvider);
+  if (!serviceInfo) return null;
+
+  return (
+    <img
+      src={serviceInfo.icon}
+      alt={serviceInfo.name}
+      width={width}
+      height={height}
+      style={{ objectFit: 'contain' }}
+    />
+  );
+};
+
+// Function to return the appropriate SVG icon based on service type
+export const getServiceIcon = (service: string, cloudProvider: 'aws' | 'azure' | 'gcp' = 'aws') => {
+  // Special case for internet icon
+  if (service === 'internet') {
+    return <InternetIcon width={48} height={48} />;
+  }
+  
+  // Check for container service icons first - ensure proper rendering
+  if (containerIcons[service]) {
+    return (
+      <div style={{ 
+        width: '100%', 
+        height: '100%', 
+        display: 'flex', 
+        alignItems: 'center', 
+        justifyContent: 'center',
+        fontSize: 'inherit'
+      }}>
+        {containerIcons[service]}
+      </div>
+    );
+  }
+  
+  return <ServiceIcon service={service} cloudProvider={cloudProvider} />;
+};