@flowuent-org/diagramming-core 1.3.9 → 1.4.0

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

@@ -1,312 +0,0 @@
-import { Node } from 'reactflow';
-import {
-  getTranslatedMessage,
-  getCloudProviderMessageId,
-  formatPlacementRules,
-} from './translations';
-
-// Define types for validation results
-interface ValidationResult {
-  isValid: boolean;
-  message?: string;
-  suggestions?: string[];
-}
-
-// Define GCP resource types
-type GCPResourceType =
-  | 'project'
-  | 'vpc'
-  | 'subnet'
-  | 'compute'
-  | 'storage'
-  | 'cloudFunction'
-  | 'cloudSQL'
-  | 'loadBalancer'
-  | 'firewall'
-  | 'routeTable'
-  | 'cloudNAT'
-  | 'cloudRouter'
-  | 'networkInterface'
-  | 'privateServiceConnect'
-  | 'folder';
-
-// Define container rules with detailed descriptions
-const containerRules: Record<
-  string,
-  {
-    canContain: string[];
-    cannotContain: string[];
-    description: string;
-    placementRules: string[];
-  }
-> = {
-  project: {
-    canContain: ['folder', 'vpc', 'storage', 'cloudFunction', 'cloudSQL', 'loadBalancer', 'compute', 'networkInterface', 'privateServiceConnect', 'cloudNAT'],
-    cannotContain: ['project'],
-    description: 'GCP Project is the root container for all resources',
-    placementRules: [
-      'Must be at the root level',
-      'Can contain Folders, VPCs, and other GCP resources',
-      'Cannot contain other Projects',
-      'Resources should be organized by region',
-    ],
-  },
-  folder: {
-    canContain: ['folder', 'vpc', 'storage', 'cloudFunction', 'cloudSQL', 'loadBalancer', 'compute'],
-    cannotContain: ['project'],
-    description: 'GCP Folder is an organizational unit for resources',
-    placementRules: [
-      'Must be placed within a Project or another Folder',
-      'Can contain other Folders and GCP resources',
-      'Cannot contain Projects',
-    ],
-  },
-  vpc: {
-    canContain: ['subnet', 'firewall', 'routeTable', 'cloudNAT', 'cloudRouter'],
-    cannotContain: ['compute', 'vpc', 'project', 'folder'],
-    description: 'VPC is an isolated network in GCP',
-    placementRules: [
-      'Must be placed within a Project or Folder',
-      'Cannot contain Compute instances directly (use Subnets)',
-      'Cannot contain other VPCs (use VPC peering)',
-      'Can contain multiple Subnets',
-    ],
-  },
-  subnet: {
-    canContain: [
-      'compute',
-      'networkInterface',
-      'privateServiceConnect',
-      'cloudNAT',
-    ],
-    cannotContain: ['subnet', 'vpc', 'project', 'folder'],
-    description: 'Subnet is a range of IP addresses in a VPC',
-    placementRules: [
-      'Must be placed within a VPC',
-      'Cannot contain other Subnets',
-      'Cannot contain VPC-level resources',
-      'Should have non-overlapping IP ranges',
-    ],
-  },
-};
-
-// Helper function to get resource type from node
-function getGCPResourceType(node: Node): GCPResourceType | null {
-  if (!node.data?.service) return null;
-
-  // Map node service to GCP resource type
-  const serviceToType: Record<string, GCPResourceType> = {
-    // Containers
-    project: 'project',
-    folder: 'folder',
-    vpc: 'vpc',
-    subnet: 'subnet',
-
-    // Networking
-    firewall: 'firewall',
-    'route-table': 'routeTable',
-    'cloud-nat': 'cloudNAT',
-    'cloud-router': 'cloudRouter',
-    'network-interface': 'networkInterface',
-    'private-service-connect': 'privateServiceConnect',
-
-    // Compute
-    compute: 'compute',
-    'compute-instance': 'compute',
-    'cloud-function': 'cloudFunction',
-    'cloud-functions': 'cloudFunction',
-
-    // Storage
-    storage: 'storage',
-    'cloud-storage': 'storage',
-    'storage-bucket': 'storage',
-
-    // Database
-    'cloud-sql': 'cloudSQL',
-    'cloud-sql-instance': 'cloudSQL',
-
-    // Load Balancing
-    'load-balancer': 'loadBalancer',
-    'cloud-load-balancer': 'loadBalancer',
-    'network-load-balancer': 'loadBalancer',
-    'http-load-balancer': 'loadBalancer',
-  };
-
-  return serviceToType[node.data.service] || null;
-}
-
-// Validate placement of a GCP resource
-export const validateGCPPlacement = (
-  node: Node,
-  parentNode: Node | null,
-  allNodes: Node[],
-): ValidationResult => {
-  // Only validate GCP resources
-  if (node.data?.cloudProvider !== 'gcp') {
-    return { isValid: true };
-  }
-
-  const resourceType = getGCPResourceType(node);
-  const parentType = parentNode ? getGCPResourceType(parentNode) : null;
-
-  if (!resourceType) {
-    return {
-      isValid: false,
-      message: getTranslatedMessage(
-        getCloudProviderMessageId('gcp', 'invalid_resource_type'),
-        { service: node.data?.service },
-      ),
-    };
-  }
-
-  // Project must always be at root level
-  if (resourceType === 'project' && parentNode !== null) {
-    return {
-      isValid: false,
-      message: getTranslatedMessage(
-        getCloudProviderMessageId('gcp', 'project_must_be_root'),
-        { resourceType },
-      ),
-      suggestions: [
-        'GCP Projects must be at the root level',
-        'Remove the Project from its parent container',
-        'Projects are the highest level container in GCP'
-      ]
-    };
-  }
-
-  // If no parent, only project is allowed at root
-  if (!parentNode && resourceType !== 'project') {
-    return {
-      isValid: false,
-      message: getTranslatedMessage(
-        getCloudProviderMessageId('gcp', 'must_be_in_project'),
-        { resourceType },
-      ),
-    };
-  }
-
-  // Check if the resource can be placed in the parent container
-  if (parentNode && parentType) {
-    const rules = containerRules[parentType];
-    if (!rules) {
-      return {
-        isValid: false,
-        message: getTranslatedMessage(
-          getCloudProviderMessageId('gcp', 'invalid_parent_container'),
-          { parentType },
-        ),
-      };
-    }
-
-    if (!rules.canContain.includes(resourceType)) {
-      const suggestedContainer = getSuggestedContainer(resourceType);
-      return {
-        isValid: false,
-        message: getTranslatedMessage(
-          getCloudProviderMessageId('gcp', 'container_validation'),
-          {
-            parentType,
-            resourceType,
-            description: rules.description,
-            rules: formatPlacementRules(rules.placementRules),
-            suggestion: suggestedContainer,
-          },
-        ),
-      };
-    }
-
-    // Check for specific placement rules
-    if (resourceType === 'compute' && parentType !== 'subnet') {
-      return {
-        isValid: false,
-        message: getTranslatedMessage(
-          getCloudProviderMessageId('gcp', 'compute_must_be_in_subnet'),
-        ),
-      };
-    }
-  }
-
-  return { isValid: true };
-};
-
-// Helper function to suggest the correct container
-const getSuggestedContainer = (resourceType: GCPResourceType): string => {
-  const suggestions: Record<GCPResourceType, string> = {
-    compute: 'Compute instances must be placed in a Subnet',
-    subnet: 'Subnets must be placed in a VPC',
-    vpc: 'VPCs must be placed in a Project',
-    storage: 'Cloud Storage buckets must be placed in a Project',
-    cloudFunction: 'Cloud Functions must be placed in a Project',
-    cloudSQL: 'Cloud SQL instances must be placed in a Project',
-    loadBalancer: 'Load Balancers must be placed in a Project',
-    firewall: 'Firewall rules must be placed in a VPC',
-    routeTable: 'Route Tables must be placed in a VPC',
-    cloudNAT: 'Cloud NAT can be placed in a VPC or Subnet',
-    cloudRouter: 'Cloud Routers must be placed in a VPC',
-    networkInterface: 'Network Interfaces must be placed in a Subnet',
-    privateServiceConnect: 'Private Service Connect must be placed in a Subnet',
-    project: 'Projects must be placed at the root level',
-    folder: 'Folders must be placed in a Project or another Folder',
-  };
-
-  return `Suggestion: ${suggestions[resourceType]}`;
-};
-
-// Validate the entire GCP diagram
-export const validateGCPDiagram = (
-  nodes: Node[],
-): ValidationResult & { messages?: string[] } => {
-  const messages: string[] = [];
-
-  // Get all GCP nodes
-  const gcpNodes = nodes.filter((node) => node.data?.cloudProvider === 'gcp');
-
-  // Validate each node
-  for (const node of gcpNodes) {
-    const foundParentNode = node.parentNode
-      ? nodes.find((n) => n.id === node.parentNode)
-      : null;
-    const parentNode = foundParentNode || null;
-
-    const validation = validateGCPPlacement(node, parentNode, nodes);
-    if (!validation.isValid && validation.message) {
-      messages.push(validation.message);
-    }
-  }
-
-  // Additional diagram-wide validations
-  const projects = gcpNodes.filter(
-    (node) => getGCPResourceType(node) === 'project',
-  );
-
-  // Check if there are multiple projects
-  if (projects.length > 1) {
-    messages.push(
-      getTranslatedMessage(
-        getCloudProviderMessageId('gcp', 'multiple_projects'),
-      ),
-    );
-  }
-
-  // Check for cross-region dependencies in VPCs
-  const vpcs = gcpNodes.filter((node) => getGCPResourceType(node) === 'vpc');
-
-  for (const vpc of vpcs) {
-    const vpcResources = gcpNodes.filter((node) => node.parentNode === vpc.id);
-    const regions = new Set(vpcResources.map((r) => r.data?.region));
-    if (regions.size > 1) {
-      messages.push(
-        getTranslatedMessage(
-          getCloudProviderMessageId('gcp', 'cross_region_resources'),
-          { vpcName: vpc.data?.label },
-        ),
-      );
-    }
-  }
-
-  return {
-    isValid: messages.length === 0,
-    messages,
-  };
-};