@flowuent-org/diagramming-core 1.3.10 → 1.4.1

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

@@ -1,312 +1,312 @@
-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,
-  };
-};
+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,
+  };
+};