@flowuent-org/diagramming-core 1.3.10 → 1.4.0

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

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

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

@@ -1,96 +0,0 @@
-{
-  "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."
-    }
-  }
-}