@flowuent-org/diagramming-core 1.0.5

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

@@ -0,0 +1,384 @@
+import { NodeLabel } from '../components/CloudArchitectureDiagram';
+import {
+  AWS_CATEGORIES,
+  AWS_COMPUTE_ICONS,
+  AWS_CONTAINER_ICONS,
+  AWS_DATABASE_ICONS,
+  AWS_NETWORKING_ICONS,
+  AWS_SECURITY_ICONS,
+  AWS_STORAGE_ICONS,
+} from './aws-icons';
+import {
+  AZURE_CATEGORIES,
+  AZURE_COMPUTE_ICONS,
+  AZURE_CONTAINER_ICONS,
+  AZURE_DATABASE_ICONS,
+  AZURE_NETWORKING_ICONS,
+  AZURE_SECURITY_ICONS,
+  AZURE_STORAGE_ICONS,
+} from './azure-icons';
+import {
+  GCP_CATEGORIES,
+  GCP_COMPUTE_ICONS,
+  GCP_DATA_STORAGE_ICONS,
+  GCP_NETWORKING_ICONS,
+  GCP_SECURITY_ICONS,
+  GCP_SERVERLESS_ICONS,
+} from './gcp-icons';
+
+// GCP Service Categories
+
+// Combine all GCP icons
+export const GCP_SERVICE_ICONS = {
+  ...GCP_COMPUTE_ICONS,
+  ...GCP_DATA_STORAGE_ICONS,
+  ...GCP_NETWORKING_ICONS,
+  ...GCP_SECURITY_ICONS,
+  ...GCP_SERVERLESS_ICONS,
+} as const;
+
+// Combine all AWS icons
+export const AWS_SERVICE_ICONS = {
+  ...AWS_COMPUTE_ICONS,
+  ...AWS_STORAGE_ICONS,
+  ...AWS_DATABASE_ICONS,
+  ...AWS_NETWORKING_ICONS,
+  ...AWS_SECURITY_ICONS,
+  ...AWS_CONTAINER_ICONS,
+} as const;
+
+export interface ServiceInfo {
+  name: string;
+  category: string;
+  icon: string;
+}
+
+export const AZURE_SERVICE_ICONS = {
+  ...AZURE_COMPUTE_ICONS,
+  ...AZURE_STORAGE_ICONS,
+  ...AZURE_NETWORKING_ICONS,
+  ...AZURE_DATABASE_ICONS,
+  ...AZURE_SECURITY_ICONS,
+  ...AZURE_CONTAINER_ICONS,
+  // ... other Azure service categories
+} as const;
+
+// Combined cloud service icons
+export const CLOUD_SERVICE_ICONS = {
+  aws: AWS_SERVICE_ICONS,
+  azure: AZURE_SERVICE_ICONS,
+  gcp: GCP_SERVICE_ICONS,
+} as const;
+
+export interface ServiceIconInfo {
+  name: string;
+  icon: string;
+  category: string;
+}
+
+type CloudServiceIcon = {
+  name: string;
+  icon: string;
+  category: string;
+};
+
+type CloudServiceIcons = {
+  [key: string]: CloudServiceIcon;
+};
+
+// Helper function to get icons by category and cloud provider
+export const getIconsByCategory = (
+  category: string,
+  cloudProvider: 'aws' | 'azure' | 'gcp' = 'aws',
+) => {
+  const icons =
+    cloudProvider === 'aws'
+      ? AWS_SERVICE_ICONS
+      : cloudProvider === 'azure'
+        ? AZURE_SERVICE_ICONS
+        : GCP_SERVICE_ICONS;
+  return Object.entries(icons).filter(
+    ([_, service]) => service.category === category,
+  );
+};
+
+// Helper function to get all categories with their services by cloud provider
+export const getCategorizedServices = (
+  cloudProvider: 'aws' | 'azure' | 'gcp' = 'aws',
+) => {
+  const icons =
+    cloudProvider === 'aws'
+      ? AWS_SERVICE_ICONS
+      : cloudProvider === 'azure'
+        ? AZURE_SERVICE_ICONS
+        : GCP_SERVICE_ICONS;
+  const categories =
+    cloudProvider === 'aws'
+      ? AWS_CATEGORIES
+      : cloudProvider === 'azure'
+        ? AZURE_CATEGORIES
+        : GCP_CATEGORIES;
+
+  const categorized: Record<string, CloudServiceIcon[]> = {};
+
+  Object.values(categories).forEach((category) => {
+    categorized[category] = Object.values(icons).filter(
+      (service) => service.category === category,
+    ) as CloudServiceIcon[];
+  });
+
+  return categorized;
+};
+
+// Helper function to get service info
+export const getServiceInfo = (
+  serviceKey: string,
+  cloudProvider: 'aws' | 'azure' | 'gcp' = 'aws',
+): ServiceIconInfo | undefined => {
+  const icons =
+    cloudProvider === 'aws'
+      ? AWS_SERVICE_ICONS
+      : cloudProvider === 'azure'
+        ? AZURE_SERVICE_ICONS
+        : GCP_SERVICE_ICONS;
+  const service = icons[serviceKey as keyof typeof icons] as
+    | CloudServiceIcon
+    | undefined;
+  return service
+    ? {
+        name: service.name,
+        icon: service.icon,
+        category: service.category,
+      }
+    : undefined;
+};
+
+export const labelMap: Record<string, NodeLabel> = {
+  // Internet Node
+  internet: { label: 'Internet', sublabel: 'Gateway' },
+  
+  // ========== AWS SERVICES ==========
+  // AWS Compute Services
+  ec2: { label: 'EC2', sublabel: 'Instance' },
+  lambda: { label: 'AWS Lambda', sublabel: 'Function' },
+  autoscaling: { label: 'Auto Scaling', sublabel: 'Group' },
+  
+  // Storage Services
+  'backup': { label: 'AWS Backup', sublabel: 'Service' },
+  'efs': { label: 'Amazon EFS', sublabel: 'Storage' },
+  'ebs': { label: 'Amazon EBS', sublabel: 'Storage' },
+  'elastic-disaster-recovery': { label: 'Elastic', sublabel: 'Disaster Recovery' },
+  'file-cache': { label: 'File Cache', sublabel: 'Service' },
+  'fsx-lustre': { label: 'FSx', sublabel: 'for Lustre' },
+  'fsx-ontap': { label: 'FSx', sublabel: 'for NetApp ONTAP' },
+  'fsx-openzfs': { label: 'FSx', sublabel: 'for OpenZFS' },
+  'fsx-wfs': { label: 'FSx', sublabel: 'for WFS' },
+  'fsx': { label: 'Amazon FSx', sublabel: 'Service' },
+  's3-outposts': { label: 'S3', sublabel: 'on Outposts' },
+  'snowball-edge': { label: 'Snowball', sublabel: 'Edge' },
+  'snowball': { label: 'AWS', sublabel: 'Snowball' },
+  'snowcone': { label: 'AWS', sublabel: 'Snowcone' },
+  'snowmobile': { label: 'AWS', sublabel: 'Snowmobile' },
+  'storage-gateway': { label: 'Storage', sublabel: 'Gateway' },
+
+  // Database Services
+  'aurora': { label: 'Amazon', sublabel: 'Aurora' },
+  'database-migration-service': { label: 'Database', sublabel: 'Migration Service' },
+  'documentdb': { label: 'Amazon', sublabel: 'DocumentDB' },
+  'elasticache': { label: 'Amazon', sublabel: 'ElastiCache' },
+  'keyspaces': { label: 'Amazon', sublabel: 'Keyspaces' },
+  'memorydb-redis': { label: 'MemoryDB', sublabel: 'for Redis' },
+  'neptune': { label: 'Amazon', sublabel: 'Neptune' },
+  'rds-vmware': { label: 'RDS', sublabel: 'on VMware' },
+  'rds': { label: 'Amazon', sublabel: 'RDS' },
+  'timestream': { label: 'Amazon', sublabel: 'Timestream' },
+
+  // Networking Services
+  'app-mesh': { label: 'AWS', sublabel: 'App Mesh' },
+  'client-vpn': { label: 'Client', sublabel: 'VPN' },
+  'cloud-directory': { label: 'Cloud', sublabel: 'Directory' },
+  'cloud-map': { label: 'Cloud', sublabel: 'Map' },
+  'cloud-wan': { label: 'Cloud', sublabel: 'WAN' },
+  'cloudfront': { label: 'Amazon', sublabel: 'CloudFront' },
+  'direct-connect': { label: 'AWS', sublabel: 'Direct Connect' },
+  'elastic-load-balancing': { label: 'Elastic', sublabel: 'Load Balancing' },
+  'global-accelerator': { label: 'Global', sublabel: 'Accelerator' },
+  'private-5g': { label: 'AWS', sublabel: 'Private 5G' },
+  'privatelink': { label: 'AWS', sublabel: 'PrivateLink' },
+  'route-53': { label: 'Amazon', sublabel: 'Route 53' },
+  'site-to-site-vpn': { label: 'Site-to-Site', sublabel: 'VPN' },
+  'transit-gateway': { label: 'Transit', sublabel: 'Gateway' },
+  'verified-access': { label: 'Verified', sublabel: 'Access' },
+  'vpc-lattice': { label: 'VPC', sublabel: 'Lattice' },
+
+  // Security Services
+  'artifact': { label: 'AWS', sublabel: 'Artifact' },
+  'audit-manager': { label: 'Audit', sublabel: 'Manager' },
+  'certificate-manager': { label: 'Certificate', sublabel: 'Manager' },
+  'cloudhsm': { label: 'AWS', sublabel: 'CloudHSM' },
+  'cognito': { label: 'Amazon', sublabel: 'Cognito' },
+  'detective': { label: 'Amazon', sublabel: 'Detective' },
+  'directory-service': { label: 'Directory', sublabel: 'Service' },
+  'firewall-manager': { label: 'Firewall', sublabel: 'Manager' },
+  'guardduty': { label: 'Amazon', sublabel: 'GuardDuty' },
+  'iam-identity-center': { label: 'IAM', sublabel: 'Identity Center' },
+  'iam': { label: 'Identity and', sublabel: 'Access Management' },
+  'inspector': { label: 'Amazon', sublabel: 'Inspector' },
+  'kms': { label: 'Key Management', sublabel: 'Service' },
+  'macie': { label: 'Amazon', sublabel: 'Macie' },
+  'network-firewall': { label: 'Network', sublabel: 'Firewall' },
+  'private-certificate-authority': { label: 'Private Certificate', sublabel: 'Authority' },
+  'resource-access-manager': { label: 'Resource Access', sublabel: 'Manager' },
+  'secrets-manager': { label: 'Secrets', sublabel: 'Manager' },
+  'security-hub': { label: 'Security', sublabel: 'Hub' },
+  'security-lake': { label: 'Security', sublabel: 'Lake' },
+  'shield': { label: 'AWS', sublabel: 'Shield' },
+  'signer': { label: 'AWS', sublabel: 'Signer' },
+  'verified-permissions': { label: 'Verified', sublabel: 'Permissions' },
+  'waf': { label: 'AWS', sublabel: 'WAF' },
+
+  // Container Services
+  'ecs-anywhere': { label: 'ECS', sublabel: 'Anywhere' },
+  'eks-anywhere': { label: 'EKS', sublabel: 'Anywhere' },
+  'eks-cloud': { label: 'EKS', sublabel: 'Cloud' },
+  'eks-distro': { label: 'EKS', sublabel: 'Distro' },
+  'elastic-container-registry': { label: 'Elastic Container', sublabel: 'Registry' },
+  'elastic-container-service': { label: 'Elastic Container', sublabel: 'Service' },
+  'elastic-kubernetes-service': { label: 'Elastic Kubernetes', sublabel: 'Service' },
+  'fargate': { label: 'AWS', sublabel: 'Fargate' },
+  'openshift': { label: 'Red Hat', sublabel: 'OpenShift' },
+
+  // ========== AZURE SERVICES ==========
+  // Azure Container Services
+  'subscription': { label: 'Azure', sublabel: 'Subscription' },
+  'resource-group': { label: 'Resource', sublabel: 'Group' },
+  'virtual-network': { label: 'Virtual', sublabel: 'Network' },
+  'network-security-group': { label: 'Network Security', sublabel: 'Group' },
+
+  // Azure Compute Services
+  'virtual-machines': { label: 'Virtual', sublabel: 'Machine' },
+  'virtual-machine': { label: 'Virtual', sublabel: 'Machine' },
+  'vm': { label: 'Virtual', sublabel: 'Machine' },
+  'vm-scale-sets': { label: 'VM Scale', sublabel: 'Sets' },
+  'virtual-machine-scale-sets': { label: 'VM Scale', sublabel: 'Sets' },
+  'app-services': { label: 'App', sublabel: 'Service' },
+  'app-service': { label: 'App', sublabel: 'Service' },
+  'function-apps': { label: 'Function', sublabel: 'App' },
+  'batch-accounts': { label: 'Azure', sublabel: 'Batch' },
+  'kubernetes-services': { label: 'Azure Kubernetes', sublabel: 'Service' },
+  'container-instances': { label: 'Container', sublabel: 'Instances' },
+  'container-registries': { label: 'Container', sublabel: 'Registry' },
+  'service-fabric-clusters': { label: 'Service Fabric', sublabel: 'Cluster' },
+
+  // Azure Storage Services
+  'storage-accounts': { label: 'Storage', sublabel: 'Account' },
+  'storage-account': { label: 'Storage', sublabel: 'Account' },
+  'blob-storage': { label: 'Blob', sublabel: 'Storage' },
+  'file-storage': { label: 'File', sublabel: 'Storage' },
+  'managed-disks': { label: 'Managed', sublabel: 'Disks' },
+  'azure-netapp-files': { label: 'NetApp', sublabel: 'Files' },
+  'data-shares': { label: 'Data', sublabel: 'Share' },
+  'import-export-jobs': { label: 'Import/Export', sublabel: 'Jobs' },
+  'recovery-services-vaults': { label: 'Recovery Services', sublabel: 'Vault' },
+
+  // Azure Database Services
+  'sql-database': { label: 'SQL', sublabel: 'Database' },
+  'azure-sql': { label: 'Azure', sublabel: 'SQL' },
+  'cosmos-db': { label: 'Cosmos', sublabel: 'DB' },
+  'mysql-server': { label: 'MySQL', sublabel: 'Server' },
+  'postgresql-server': { label: 'PostgreSQL', sublabel: 'Server' },
+  'mariadb-server': { label: 'MariaDB', sublabel: 'Server' },
+  'redis-cache': { label: 'Redis', sublabel: 'Cache' },
+  'synapse-analytics': { label: 'Synapse', sublabel: 'Analytics' },
+  'purview-accounts': { label: 'Purview', sublabel: 'Account' },
+
+  // Azure Networking Services
+  'load-balancer': { label: 'Load', sublabel: 'Balancer' },
+  'load-balancers': { label: 'Load', sublabel: 'Balancer' },
+  'application-gateway': { label: 'Application', sublabel: 'Gateway' },
+  'azure-firewall': { label: 'Azure', sublabel: 'Firewall' },
+  'vpn-gateway': { label: 'VPN', sublabel: 'Gateway' },
+  'express-route': { label: 'Express', sublabel: 'Route' },
+  'network-interface': { label: 'Network', sublabel: 'Interface' },
+  'network-interfaces': { label: 'Network', sublabel: 'Interface' },
+  'private-endpoint': { label: 'Private', sublabel: 'Endpoint' },
+  'cdn-profiles': { label: 'CDN', sublabel: 'Profile' },
+  'azure-firewall-manager': { label: 'Firewall', sublabel: 'Manager' },
+  'azure-firewall-policy': { label: 'Firewall', sublabel: 'Policy' },
+
+  // Azure Security Services
+  'key-vaults': { label: 'Key', sublabel: 'Vault' },
+  'security-center': { label: 'Security', sublabel: 'Center' },
+  'azure-active-directory': { label: 'Active', sublabel: 'Directory' },
+  'microsoft-defender-for-iot': { label: 'Defender', sublabel: 'for IoT' },
+  'microsoft-defender-easm': { label: 'Defender', sublabel: 'EASM' },
+  'detonation': { label: 'Detonation', sublabel: 'Chamber' },
+
+  // Azure Integration Services
+  'service-bus': { label: 'Service', sublabel: 'Bus' },
+  'event-hubs': { label: 'Event', sublabel: 'Hubs' },
+  'logic-apps': { label: 'Logic', sublabel: 'Apps' },
+  'api-management': { label: 'API', sublabel: 'Management' },
+
+  // Azure AI & Analytics Services
+  'cognitive-services': { label: 'Cognitive', sublabel: 'Services' },
+  'machine-learning': { label: 'Machine', sublabel: 'Learning' },
+  'stream-analytics': { label: 'Stream', sublabel: 'Analytics' },
+  'data-factory': { label: 'Data', sublabel: 'Factory' },
+
+  // Azure DevOps & Management Services
+  'devops': { label: 'Azure', sublabel: 'DevOps' },
+  'monitor': { label: 'Azure', sublabel: 'Monitor' },
+  'automation': { label: 'Azure', sublabel: 'Automation' },
+  'azure-backup': { label: 'Azure', sublabel: 'Backup' },
+  'site-recovery': { label: 'Site', sublabel: 'Recovery' },
+
+  // ========== GCP SERVICES ==========
+  // GCP Container Services
+  'project': { label: 'GCP', sublabel: 'Project' },
+  'folder': { label: 'GCP', sublabel: 'Folder' },
+
+  // GCP Compute Services
+  'compute-engine': { label: 'Compute', sublabel: 'Engine' },
+  'app-engine': { label: 'App', sublabel: 'Engine' },
+  'cloud-functions': { label: 'Cloud', sublabel: 'Functions' },
+  'cloud-run': { label: 'Cloud', sublabel: 'Run' },
+  'kubernetes-engine': { label: 'Google Kubernetes', sublabel: 'Engine' },
+
+  // GCP Storage Services
+  'cloud-storage': { label: 'Cloud', sublabel: 'Storage' },
+  'persistent-disk': { label: 'Persistent', sublabel: 'Disk' },
+  'filestore': { label: 'Cloud', sublabel: 'Filestore' },
+
+  // GCP Database Services
+  'cloud-sql': { label: 'Cloud', sublabel: 'SQL' },
+  'cloud-spanner': { label: 'Cloud', sublabel: 'Spanner' },
+  'cloud-bigtable': { label: 'Cloud', sublabel: 'Bigtable' },
+  'cloud-firestore': { label: 'Cloud', sublabel: 'Firestore' },
+
+  // GCP Networking Services
+  'cloud-load-balancing': { label: 'Cloud Load', sublabel: 'Balancing' },
+  'cloud-cdn': { label: 'Cloud', sublabel: 'CDN' },
+  'cloud-dns': { label: 'Cloud', sublabel: 'DNS' },
+  'cloud-vpn': { label: 'Cloud', sublabel: 'VPN' },
+  'cloud-interconnect': { label: 'Cloud', sublabel: 'Interconnect' },
+  'cloud-nat': { label: 'Cloud', sublabel: 'NAT' },
+  'cloud-armor': { label: 'Cloud', sublabel: 'Armor' },
+  'cloud-firewall-rules': { label: 'Firewall', sublabel: 'Rules' },
+
+  // GCP Security Services
+  'cloud-iam': { label: 'Cloud', sublabel: 'IAM' },
+  'gcp-iam': { label: 'GCP Identity and Access', sublabel: 'Management' },
+  'cloud-kms': { label: 'Cloud Key', sublabel: 'Management' },
+  'cloud-security-command-center': { label: 'Security Command', sublabel: 'Center' },
+  'binary-authorization': { label: 'Binary', sublabel: 'Authorization' },
+  'cloud-asset-inventory': { label: 'Cloud Asset', sublabel: 'Inventory' },
+  'data-loss-prevention-api': { label: 'Data Loss', sublabel: 'Prevention' },
+  'beyondcorp': { label: 'BeyondCorp', sublabel: 'Enterprise' },
+
+  // GCP AI & Analytics Services
+  'bigquery': { label: 'BigQuery', sublabel: 'Analytics' },
+  'dataflow': { label: 'Cloud', sublabel: 'Dataflow' },
+  'dataproc': { label: 'Cloud', sublabel: 'Dataproc' },
+  'pub-sub': { label: 'Cloud', sublabel: 'Pub/Sub' },
+};

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

@@ -0,0 +1,221 @@
+// Meaningful ID generation for cloud architecture nodes
+// Follows pattern: cloud-provider + resource (e.g., aws-vpc, azure-subnet)
+
+export type CloudProvider = 'aws' | 'azure' | 'gcp';
+
+interface IdCounters {
+  [key: string]: number;
+}
+
+// Global counters for each service type per cloud provider
+const serviceCounters: IdCounters = {};
+
+/**
+ * Generates a meaningful, unique ID for cloud architecture nodes
+ * @param cloudProvider - The cloud provider (aws, azure, gcp)
+ * @param service - The service/resource type (vpc, subnet, ec2, etc.)
+ * @param suffix - Optional suffix for special cases
+ * @returns Meaningful ID string like "aws-vpc-1", "azure-subnet-2", etc.
+ */
+export const generateMeaningfulId = (
+  cloudProvider: CloudProvider,
+  service: string,
+  suffix?: string
+): string => {
+  // Create the base ID pattern: cloud-provider-service
+  const baseKey = `${cloudProvider}-${service}`;
+  
+  // Get or initialize counter for this service type
+  if (!serviceCounters[baseKey]) {
+    serviceCounters[baseKey] = 0;
+  }
+  
+  // Increment counter
+  serviceCounters[baseKey]++;
+  
+  // Generate the ID
+  let id = `${baseKey}-${serviceCounters[baseKey]}`;
+  
+  // Add suffix if provided
+  if (suffix) {
+    id += `-${suffix}`;
+  }
+  
+  return id;
+};
+
+/**
+ * Generates a meaningful ID for users (external actors)
+ * @param suffix - Optional suffix for multiple user groups
+ * @returns ID like "users-1", "users-admin", etc.
+ */
+export const generateUsersId = (suffix?: string): string => {
+  const baseKey = 'users';
+  
+  if (!serviceCounters[baseKey]) {
+    serviceCounters[baseKey] = 0;
+  }
+  
+  serviceCounters[baseKey]++;
+  
+  let id = `${baseKey}-${serviceCounters[baseKey]}`;
+  
+  if (suffix) {
+    id = `${baseKey}-${suffix}`;
+  }
+  
+  return id;
+};
+
+/**
+ * Generates a meaningful ID for edges/connections
+ * @param sourceId - Source node ID
+ * @param targetId - Target node ID
+ * @param connectionType - Optional connection type (e.g., 'https', 'tcp')
+ * @returns ID like "aws-ec2-1--aws-rds-1" or "aws-ec2-1--aws-rds-1-https"
+ */
+export const generateConnectionId = (
+  sourceId: string,
+  targetId: string,
+  connectionType?: string
+): string => {
+  let id = `${sourceId}--${targetId}`;
+  
+  if (connectionType) {
+    id += `-${connectionType}`;
+  }
+  
+  return id;
+};
+
+/**
+ * Reset counters for a specific service or all services
+ * Useful for testing or when starting a new diagram
+ * @param serviceKey - Optional specific service to reset (e.g., "aws-vpc")
+ */
+export const resetCounters = (serviceKey?: string): void => {
+  if (serviceKey) {
+    delete serviceCounters[serviceKey];
+  } else {
+    Object.keys(serviceCounters).forEach(key => {
+      delete serviceCounters[key];
+    });
+  }
+};
+
+/**
+ * Get current counter value for a service
+ * @param cloudProvider - The cloud provider
+ * @param service - The service type
+ * @returns Current counter value
+ */
+export const getServiceCounter = (
+  cloudProvider: CloudProvider,
+  service: string
+): number => {
+  const baseKey = `${cloudProvider}-${service}`;
+  return serviceCounters[baseKey] || 0;
+};
+
+/**
+ * Check if an ID already exists and suggest alternatives
+ * @param proposedId - The ID to check
+ * @param existingIds - Array of existing IDs to check against
+ * @returns Object with conflict status and suggested alternative
+ */
+export const checkIdConflict = (
+  proposedId: string,
+  existingIds: string[]
+): { hasConflict: boolean; suggestedId?: string } => {
+  const hasConflict = existingIds.includes(proposedId);
+  
+  if (!hasConflict) {
+    return { hasConflict: false };
+  }
+  
+  // Generate alternative by finding the next available number
+  const basePattern = proposedId.replace(/-\d+$/, '');
+  let counter = 1;
+  let suggestedId = `${basePattern}-${counter}`;
+  
+  while (existingIds.includes(suggestedId)) {
+    counter++;
+    suggestedId = `${basePattern}-${counter}`;
+  }
+  
+  return { hasConflict: true, suggestedId };
+};
+
+/**
+ * Extract components from a meaningful ID
+ * @param id - The ID to parse (e.g., "aws-vpc-1")
+ * @returns Object with parsed components
+ */
+export const parseIdComponents = (id: string): {
+  cloudProvider?: CloudProvider;
+  service?: string;
+  number?: number;
+  isValid: boolean;
+} => {
+  // Handle special cases
+  if (id.startsWith('users-')) {
+    const parts = id.split('-');
+    return {
+      service: 'users',
+      number: parts.length > 1 ? parseInt(parts[1], 10) : undefined,
+      isValid: true,
+    };
+  }
+  
+  // Standard cloud provider pattern: provider-service-number
+  const cloudProviders: CloudProvider[] = ['aws', 'azure', 'gcp'];
+  const parts = id.split('-');
+  
+  if (parts.length < 3) {
+    return { isValid: false };
+  }
+  
+  const provider = parts[0] as CloudProvider;
+  const service = parts[1];
+  const number = parseInt(parts[2], 10);
+  
+  if (!cloudProviders.includes(provider) || isNaN(number)) {
+    return { isValid: false };
+  }
+  
+  return {
+    cloudProvider: provider,
+    service,
+    number,
+    isValid: true,
+  };
+};
+
+/**
+ * Generate a batch of meaningful IDs for multiple nodes
+ * @param requests - Array of ID generation requests
+ * @returns Array of generated IDs
+ */
+export const generateBatchIds = (
+  requests: Array<{
+    cloudProvider: CloudProvider;
+    service: string;
+    suffix?: string;
+  }>
+): string[] => {
+  return requests.map(request => 
+    generateMeaningfulId(request.cloudProvider, request.service, request.suffix)
+  );
+};
+
+// Export default instance with commonly used functions
+export const IdGenerator = {
+  generate: generateMeaningfulId,
+  generateUsers: generateUsersId,
+  generateConnection: generateConnectionId,
+  reset: resetCounters,
+  getCounter: getServiceCounter,
+  checkConflict: checkIdConflict,
+  parse: parseIdComponents,
+  batch: generateBatchIds,
+};