@flowuent-org/diagramming-core 1.0.5

package/packages/diagrams/src/lib/templates/cloud-arch/data/types.ts

@@ -0,0 +1,184 @@
+// Data types for user-created diagrams
+// Contains positions, dimensions, viewport, and UI state - NO schema rules or validation logic
+
+export interface DiagramPosition {
+  x: number;
+  y: number;
+}
+
+export interface DiagramDimensions {
+  width: number;
+  height: number;
+}
+
+export interface DiagramViewport {
+  x: number;
+  y: number;
+  zoom: number;
+}
+
+export interface DiagramNodeData {
+  id: string;
+  type: string;
+  position: DiagramPosition;
+  dimensions?: DiagramDimensions;
+  style?: {
+    [key: string]: any;
+  };
+  data: {
+    // Core node data
+    service: string;
+    label?: string;
+    sublabel?: string;
+    cloudProvider?: string;
+    
+    // UI-specific data
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    
+    // Parent-child relationships (structure only, not validation rules)
+    parentNode?: string;
+  };
+  
+  // UI state
+  selected?: boolean;
+  dragging?: boolean;
+  
+  // Custom styling
+  className?: string;
+  extent?: 'parent' | undefined;
+}
+
+export interface DiagramEdgeData {
+  id: string;
+  source: string;
+  target: string;
+  type?: string;
+  
+  // Visual styling
+  style?: {
+    [key: string]: any;
+  };
+  
+  // Connection metadata
+  label?: string;
+  animated?: boolean;
+  
+  // UI markers
+  markerStart?: {
+    type: string;
+    width: number;
+    height: number;
+    color: string;
+  };
+  markerEnd?: {
+    type: string;
+    width: number;
+    height: number;
+    color: string;
+  };
+}
+
+export interface DiagramData {
+  id: string;
+  name: string;
+  description?: string;
+  
+  // Core diagram structure
+  nodes: DiagramNodeData[];
+  edges: DiagramEdgeData[];
+  
+  // UI state
+  viewport: DiagramViewport;
+  selectedNodes: string[];
+  selectedEdges: string[];
+  
+  // Metadata
+  metadata: {
+    createdAt: string;
+    lastModified: string;
+    author: string;
+    version: string;
+    tags: string[];
+    cloudProviders: string[];
+    nodeCount: number;
+    edgeCount: number;
+  };
+  
+  // Export/import format version
+  formatVersion: string;
+}
+
+export interface DiagramCollection {
+  id: string;
+  name: string;
+  description?: string;
+  diagrams: DiagramData[];
+  metadata: {
+    createdAt: string;
+    lastModified: string;
+    author: string;
+    totalDiagrams: number;
+    tags: string[];
+  };
+}
+
+// Export/Import formats for user data
+export interface DiagramExport {
+  format: 'json' | 'yaml';
+  timestamp: string;
+  data: DiagramData;
+  includeMetadata: boolean;
+}
+
+// Search and filtering for user diagrams
+export interface DiagramFilter {
+  cloudProviders?: string[];
+  tags?: string[];
+  author?: string;
+  dateRange?: {
+    start: string;
+    end: string;
+  };
+  nodeCountRange?: {
+    min: number;
+    max: number;
+  };
+}
+
+export interface DiagramSearchResult {
+  diagrams: DiagramData[];
+  totalCount: number;
+  filteredCount: number;
+}
+
+// Diagram templates (user-shareable structures without positions)
+export interface DiagramTemplate {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  cloudProvider: string;
+  
+  // Template structure (no positions)
+  nodeTypes: Array<{
+    service: string;
+    count: number;
+    parentType?: string;
+  }>;
+  
+  connectionPatterns: Array<{
+    sourceType: string;
+    targetType: string;
+    connectionType: string;
+  }>;
+  
+  metadata: {
+    createdAt: string;
+    author: string;
+    usageCount: number;
+    rating: number;
+    tags: string[];
+    complexity: 'beginner' | 'intermediate' | 'advanced';
+  };
+} 

package/packages/diagrams/src/lib/templates/cloud-arch/integration/diagramValidator.ts

@@ -0,0 +1,379 @@
+import { Node, Edge } from 'reactflow';
+import { diagramDataManager } from '../data/diagramManager';
+import { CloudProvider } from '../types/validation';
+import { validateCloudProviderPlacement } from '../utils/cloudValidation';
+import { ALL_RESTRICTIONS } from '../utils/genericValidation';
+
+export interface ValidationResult {
+  isValid: boolean;
+  message?: string;
+  suggestions?: string[];
+  violations?: ValidationViolation[];
+}
+
+export interface ValidationViolation {
+  nodeId: string;
+  ruleId: string;
+  message: string;
+  severity: 'error' | 'warning' | 'info';
+  category: 'placement' | 'security' | 'networking' | 'cost' | 'compliance';
+}
+
+export interface DiagramValidationReport {
+  overallValid: boolean;
+  nodeValidations: Array<{
+    nodeId: string;
+    nodeName: string;
+    isValid: boolean;
+    violations: ValidationViolation[];
+  }>;
+  edgeValidations: Array<{
+    edgeId: string;
+    isValid: boolean;
+    violations: ValidationViolation[];
+  }>;
+  summary: {
+    totalNodes: number;
+    validNodes: number;
+    totalErrors: number;
+    totalWarnings: number;
+    cloudProviders: string[];
+  };
+}
+
+export class DiagramValidator {
+  // Validate a single node placement using cloud validation
+  validateNodePlacement(
+    node: Node,
+    parentNode: Node | null,
+    allNodes: Node[],
+  ): ValidationResult {
+    const cloudProvider = node.data?.cloudProvider as CloudProvider;
+    const service = node.data?.service;
+
+    if (!cloudProvider || !service) {
+      return {
+        isValid: false,
+        message: 'Node missing cloud provider or service type',
+        suggestions: ['Specify cloud provider and service type'],
+      };
+    }
+
+    // Use direct validation without schema manager
+    const validation = validateCloudProviderPlacement(
+      node,
+      parentNode,
+      allNodes,
+      cloudProvider
+    );
+
+    return {
+      isValid: validation.isValid,
+      message: validation.message,
+      suggestions: validation.suggestions,
+    };
+  }
+
+  // Validate entire diagram (combines schema and structural validation)
+  validateDiagram(nodes: Node[], edges: Edge[]): DiagramValidationReport {
+    const nodeValidations: DiagramValidationReport['nodeValidations'] = [];
+    const edgeValidations: DiagramValidationReport['edgeValidations'] = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+
+    // Validate each node
+    for (const node of nodes) {
+      const parentNode = node.parentNode
+        ? nodes.find((n) => n.id === node.parentNode) || null
+        : null;
+
+      const validation = this.validateNodePlacement(node, parentNode, nodes);
+      const violations: ValidationViolation[] = [];
+
+      if (!validation.isValid) {
+        const violation: ValidationViolation = {
+          nodeId: node.id,
+          ruleId: 'placement-validation',
+          message: validation.message || 'Placement validation failed',
+          severity: 'error',
+          category: 'placement',
+        };
+        violations.push(violation);
+        totalErrors++;
+      }
+
+      nodeValidations.push({
+        nodeId: node.id,
+        nodeName: node.data?.label || node.data?.service || node.id,
+        isValid: validation.isValid,
+        violations,
+      });
+    }
+
+    // Validate edges (basic validation for now)
+    for (const edge of edges) {
+      const sourceNode = nodes.find((n) => n.id === edge.source);
+      const targetNode = nodes.find((n) => n.id === edge.target);
+
+      const violations: ValidationViolation[] = [];
+      let isValid = true;
+
+      if (!sourceNode || !targetNode) {
+        violations.push({
+          nodeId: edge.id,
+          ruleId: 'edge-endpoints',
+          message: 'Edge has invalid source or target',
+          severity: 'error',
+          category: 'networking',
+        });
+        isValid = false;
+        totalErrors++;
+      }
+
+      edgeValidations.push({
+        edgeId: edge.id,
+        isValid,
+        violations,
+      });
+    }
+
+    const cloudProviders = [
+      ...new Set(
+        nodes
+          .map((node) => node.data?.cloudProvider)
+          .filter((provider) => provider),
+      ),
+    ] as string[];
+
+    return {
+      overallValid: totalErrors === 0,
+      nodeValidations,
+      edgeValidations,
+      summary: {
+        totalNodes: nodes.length,
+        validNodes: nodeValidations.filter((v) => v.isValid).length,
+        totalErrors,
+        totalWarnings,
+        cloudProviders,
+      },
+    };
+  }
+
+  // Enhanced node creation with validation
+  createValidatedNode(
+    service: string,
+    cloudProvider: CloudProvider,
+    position: { x: number; y: number },
+    parentNode?: Node,
+  ): { node: Node | null; validation: ValidationResult } {
+    // Create temporary node for validation
+    const tempNode: Node = {
+      id: `temp-${cloudProvider}-${service}`,
+      type: 'serviceNode',
+      position,
+      data: {
+        service,
+        cloudProvider,
+        label: service,
+      },
+    };
+
+    // Validate using cloud validation
+    const validation = this.validateNodePlacement(tempNode, parentNode || null, []);
+
+    if (!validation.isValid) {
+      return {
+        node: null,
+        validation,
+      };
+    }
+
+    // Create node with basic data
+    const isContainer = ['vpc', 'account', 'availability-zone', 'local-zone', 'subnet', 'security-group'].includes(service);
+    const node: Node = {
+      id: `${cloudProvider}-${service}-${Date.now()}`,
+      type: isContainer ? 'subnetNode' : 'serviceNode',
+      position,
+      data: {
+        service,
+        cloudProvider,
+        label: service,
+        description: `${cloudProvider} ${service}`,
+      },
+      parentNode: parentNode?.id,
+      extent: parentNode ? 'parent' : undefined,
+    };
+
+    return {
+      node,
+      validation: { isValid: true },
+    };
+  }
+
+  // Save diagram with validation
+  saveValidatedDiagram(
+    nodes: Node[],
+    edges: Edge[],
+    metadata: {
+      name: string;
+      description?: string;
+      author: string;
+      tags?: string[];
+    },
+    viewport: { x: number; y: number; zoom: number },
+  ): { diagramId: string | null; validationReport: DiagramValidationReport } {
+    const validationReport = this.validateDiagram(nodes, edges);
+
+    // Only save if validation passes or user explicitly allows
+    if (validationReport.overallValid) {
+      const diagramData = diagramDataManager.toDiagramData(
+        nodes,
+        edges,
+        metadata,
+        viewport,
+      );
+      diagramDataManager.saveDiagram(diagramData);
+
+      return {
+        diagramId: diagramData.id,
+        validationReport,
+      };
+    }
+
+    return {
+      diagramId: null,
+      validationReport,
+    };
+  }
+
+  // Load diagram and apply current schema validation
+  loadAndValidateDiagram(diagramId: string): {
+    nodes: Node[];
+    edges: Edge[];
+    viewport: { x: number; y: number; zoom: number };
+    validationReport: DiagramValidationReport;
+  } | null {
+    const diagramData = diagramDataManager.loadDiagram(diagramId);
+    if (!diagramData) return null;
+
+    const { nodes, edges, viewport } =
+      diagramDataManager.fromDiagramData(diagramData);
+
+    // Apply current schema validation (schema may have been updated since save)
+    const validationReport = this.validateDiagram(nodes, edges);
+
+    return {
+      nodes,
+      edges,
+      viewport,
+      validationReport,
+    };
+  }
+
+  // Get basic service information for UI
+  getServiceInfo(cloudProvider: CloudProvider): {
+    containerTypes: string[];
+    serviceTypes: string[];
+  } {
+    // Simplified service types without schema dependencies
+    const commonContainers = ['account', 'vpc', 'availability-zone', 'local-zone', 'subnet', 'security-group'];
+    
+    let serviceTypes: string[] = [];
+    switch (cloudProvider) {
+      case 'aws':
+        serviceTypes = ['account', 'vpc', 'availability-zone', 'subnet', 'ec2', 's3', 'rds', 'lambda', 'api-gateway'];
+        break;
+      case 'azure':
+        serviceTypes = ['subscription', 'resource-group', 'virtual-network', 'subnet', 'virtual-machine', 'storage-account'];
+        break;
+      case 'gcp':
+        serviceTypes = ['project', 'vpc', 'subnet', 'compute-engine', 'cloud-storage', 'cloud-function'];
+        break;
+    }
+
+    return {
+      containerTypes: commonContainers.filter(c => serviceTypes.includes(c)),
+      serviceTypes,
+    };
+  }
+
+  // Auto-suggest parent for a service (simplified, position-aware)
+  suggestParent(
+    service: string,
+    cloudProvider: CloudProvider,
+    position: { x: number; y: number },
+    allNodes: Node[],
+  ): Node | null {
+    // Simplified parent relationships without schema dependencies
+    const getValidParents = (serviceType: string, provider: CloudProvider): string[] => {
+      switch (provider) {
+        case 'aws':
+          switch (serviceType) {
+            case 'vpc': return ['account'];
+            case 'availability-zone': return ['vpc'];
+            case 'subnet': return ['availability-zone', 'vpc'];
+            case 'ec2': case 's3': case 'rds': case 'lambda': return ['subnet', 'vpc'];
+            default: return ['vpc', 'subnet'];
+          }
+        case 'azure':
+          switch (serviceType) {
+            case 'resource-group': return ['subscription'];
+            case 'virtual-network': return ['resource-group'];
+            case 'subnet': return ['virtual-network'];
+            case 'virtual-machine': return ['subnet', 'resource-group'];
+            default: return ['resource-group'];
+          }
+        case 'gcp':
+          switch (serviceType) {
+            case 'vpc': return ['project'];
+            case 'subnet': return ['vpc'];
+            case 'compute-engine': case 'cloud-storage': return ['subnet', 'vpc'];
+            default: return ['project'];
+          }
+        default: return [];
+      }
+    };
+
+    const validParentTypes = getValidParents(service, cloudProvider);
+    
+    // Filter nodes to valid parents
+    const validParentNodes = allNodes.filter((node) => {
+      const nodeService = node.data?.service;
+      const nodeProvider = node.data?.cloudProvider;
+      return nodeProvider === cloudProvider && validParentTypes.includes(nodeService);
+    });
+
+    if (validParentNodes.length === 0) return null;
+
+    // Find the closest valid parent by position
+    let closestParent = validParentNodes[0];
+    let minDistance = this.calculateDistance(position, closestParent.position);
+
+    for (const parentNode of validParentNodes) {
+      const distance = this.calculateDistance(position, parentNode.position);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestParent = parentNode;
+      }
+    }
+
+    return closestParent;
+  }
+
+  private calculateDistance(
+    pos1: { x: number; y: number },
+    pos2: { x: number; y: number },
+  ): number {
+    const dx = pos1.x - pos2.x;
+    const dy = pos1.y - pos2.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+
+  // Export only diagram data (what user drew)
+  exportDiagramData(diagramId: string): any | null {
+    return diagramDataManager.loadDiagram(diagramId);
+  }
+}
+
+// Default instance
+export const diagramValidator = new DiagramValidator();

package/packages/diagrams/src/lib/templates/cloud-arch/messages/errorMessages.json

@@ -0,0 +1,96 @@
+{
+  "azure": {
+    "invalid_resource_type": {
+      "id": "azure.invalid_resource_type",
+      "defaultMessage": "Invalid Azure resource type: \"{service}\". This service might not be supported or might have a different name."
+    },
+    "must_be_in_subscription": {
+      "id": "azure.must_be_in_subscription",
+      "defaultMessage": "Azure {resourceType} must be placed within a Subscription. All Azure resources must be organized within a Subscription hierarchy."
+    },
+    "invalid_parent_container": {
+      "id": "azure.invalid_parent_container",
+      "defaultMessage": "Invalid parent container type: {parentType}. This might be a configuration issue."
+    },
+    "container_validation": {
+      "id": "azure.container_validation",
+      "defaultMessage": "{parentType} cannot contain {resourceType}.\n\nReason: {description}\n\nPlacement Rules:\n{rules}\n\n{suggestion}"
+    },
+    "vm_must_be_in_subnet": {
+      "id": "azure.vm_must_be_in_subnet",
+      "defaultMessage": "Virtual Machines must be placed within a Subnet. This is required for proper network isolation and IP address assignment."
+    },
+    "multiple_subscriptions": {
+      "id": "azure.multiple_subscriptions",
+      "defaultMessage": "Multiple Subscriptions are not allowed in the same diagram. Azure resources should be organized within a single Subscription."
+    },
+    "cross_region_resources": {
+      "id": "azure.cross_region_resources",
+      "defaultMessage": "Resource Group \"{resourceGroupName}\" contains resources from multiple regions. It's recommended to group resources from the same region together."
+    }
+  },
+  "aws": {
+    "invalid_resource_type": {
+      "id": "aws.invalid_resource_type",
+      "defaultMessage": "Invalid AWS resource type: \"{service}\". This service might not be supported or might have a different name."
+    },
+    "must_be_in_account": {
+      "id": "aws.must_be_in_account",
+      "defaultMessage": "AWS {resourceType} must be placed within an AWS Account. All AWS resources must be organized within an Account hierarchy."
+    },
+    "invalid_parent_container": {
+      "id": "aws.invalid_parent_container",
+      "defaultMessage": "Invalid parent container type: {parentType}. This might be a configuration issue."
+    },
+    "container_validation": {
+      "id": "aws.container_validation",
+      "defaultMessage": "{parentType} cannot contain {resourceType}.\n\nReason: {description}\n\nPlacement Rules:\n{rules}\n\n{suggestion}"
+    },
+    "ec2_must_be_in_subnet": {
+      "id": "aws.ec2_must_be_in_subnet",
+      "defaultMessage": "EC2 instances must be placed within a Subnet. This is required for proper network isolation and IP address assignment."
+    },
+    "vpc_must_be_in_account": {
+      "id": "aws.vpc_must_be_in_account",
+      "defaultMessage": "VPC must be placed within an AWS Account. All VPCs must be organized within an Account hierarchy."
+    },
+    "multiple_accounts": {
+      "id": "aws.multiple_accounts",
+      "defaultMessage": "Multiple AWS Accounts are not allowed in the same diagram. AWS resources should be organized within a single Account."
+    },
+    "cross_region_resources": {
+      "id": "aws.cross_region_resources",
+      "defaultMessage": "VPC \"{vpcName}\" contains resources from multiple regions. It's recommended to group resources from the same region together."
+    }
+  },
+  "gcp": {
+    "invalid_resource_type": {
+      "id": "gcp.invalid_resource_type",
+      "defaultMessage": "Invalid GCP resource type: \"{service}\". This service might not be supported or might have a different name."
+    },
+    "must_be_in_project": {
+      "id": "gcp.must_be_in_project",
+      "defaultMessage": "GCP {resourceType} must be placed within a Project. All GCP resources must be organized within a Project hierarchy."
+    },
+    "invalid_parent_container": {
+      "id": "gcp.invalid_parent_container",
+      "defaultMessage": "Invalid parent container type: {parentType}. This might be a configuration issue."
+    },
+    "container_validation": {
+      "id": "gcp.container_validation",
+      "defaultMessage": "{parentType} cannot contain {resourceType}.\n\nReason: {description}\n\nPlacement Rules:\n{rules}\n\n{suggestion}"
+    },
+    "compute_must_be_in_subnet": {
+      "id": "gcp.compute_must_be_in_subnet",
+      "defaultMessage": "Compute instances must be placed within a Subnet. This is required for proper network isolation and IP address assignment."
+    },
+    "multiple_projects": {
+      "id": "gcp.multiple_projects",
+      "defaultMessage": "Multiple GCP Projects are not allowed in the same diagram. GCP resources should be organized within a single Project."
+    },
+    "cross_region_resources": {
+      "id": "gcp.cross_region_resources",
+      "defaultMessage": "VPC Network \"{vpcName}\" contains resources from multiple regions. It's recommended to group resources from the same region together."
+    }
+  }
+}