Sankofa/api/src/services/network-products.ts

/**
 * Network Products Service
 * Manages VPC, Load Balancer, DNS, and API Gateway products
 */

import { logger } from '../lib/logger.js'
import { Context } from '../types/context.js'
import { deploymentService } from './deployment.js'
import { catalogService } from './catalog.js'

export interface VPCConfig {
  name: string
  cidr: string
  subnets: Array<{
    name: string
    cidr: string
    availabilityZone?: string
  }>
  enableNatGateway?: boolean
  enableInternetGateway?: boolean
  tags?: Record<string, string>
}

export interface LoadBalancerConfig {
  name: string
  type: 'application' | 'network' | 'classic'
  listeners: Array<{
    protocol: string
    port: number
    targetPort?: number
  }>
  healthCheck?: {
    path: string
    interval: number
    timeout: number
    healthyThreshold: number
    unhealthyThreshold: number
  }
  targets: string[]
}

export interface DNSConfig {
  domain: string
  zoneId?: string
  records: Array<{
    name: string
    type: string
    value: string
    ttl?: number
  }>
}

export interface APIGatewayConfig {
  name: string
  protocol: 'http' | 'https' | 'websocket'
  routes: Array<{
    path: string
    method?: string
    target: string
    middleware?: string[]
  }>
  cors?: {
    allowedOrigins: string[]
    allowedMethods: string[]
    allowedHeaders: string[]
  }
}

class NetworkProductsService {
  /**
   * Create VPC
   */
  async createVPC(
    context: Context,
    config: VPCConfig,
    region?: string
  ): Promise<string> {
    logger.info('Creating VPC', { name: config.name, region })

    // Create deployment for VPC
    const deployment = await deploymentService.createDeployment(context, {
      name: config.name,
      templateId: await this.getVPCTemplateId(),
      region,
      deploymentType: 'TERRAFORM',
      parameters: {
        vpcName: config.name,
        cidr: config.cidr,
        subnets: config.subnets,
        enableNatGateway: config.enableNatGateway || false,
        enableInternetGateway: config.enableInternetGateway || true,
        tags: config.tags || {},
      },
    })

    return deployment.id
  }

  /**
   * Create Load Balancer
   */
  async createLoadBalancer(
    context: Context,
    config: LoadBalancerConfig,
    region?: string
  ): Promise<string> {
    logger.info('Creating Load Balancer', { name: config.name, region })

    const deployment = await deploymentService.createDeployment(context, {
      name: config.name,
      templateId: await this.getLoadBalancerTemplateId(),
      region,
      deploymentType: 'TERRAFORM',
      parameters: {
        lbName: config.name,
        lbType: config.type,
        listeners: config.listeners,
        healthCheck: config.healthCheck,
        targets: config.targets,
      },
    })

    return deployment.id
  }

  /**
   * Create DNS Zone
   */
  async createDNSZone(
    context: Context,
    config: DNSConfig,
    region?: string
  ): Promise<string> {
    logger.info('Creating DNS Zone', { domain: config.domain, region })

    // Use Cloudflare for DNS if available
    const deployment = await deploymentService.createDeployment(context, {
      name: `dns-${config.domain}`,
      templateId: await this.getDNSTemplateId(),
      region,
      deploymentType: 'TERRAFORM',
      parameters: {
        domain: config.domain,
        zoneId: config.zoneId,
        records: config.records,
      },
    })

    return deployment.id
  }

  /**
   * Create API Gateway
   */
  async createAPIGateway(
    context: Context,
    config: APIGatewayConfig,
    region?: string
  ): Promise<string> {
    logger.info('Creating API Gateway', { name: config.name, region })

    const deployment = await deploymentService.createDeployment(context, {
      name: config.name,
      templateId: await this.getAPIGatewayTemplateId(),
      region,
      deploymentType: 'TERRAFORM',
      parameters: {
        gatewayName: config.name,
        protocol: config.protocol,
        routes: config.routes,
        cors: config.cors,
      },
    })

    return deployment.id
  }

  // Helper methods to get template IDs
  private async getVPCTemplateId(): Promise<string> {
    // In production, this would look up the VPC template from catalog
    // For now, return a placeholder
    return 'vpc-template-id'
  }

  private async getLoadBalancerTemplateId(): Promise<string> {
    return 'lb-template-id'
  }

  private async getDNSTemplateId(): Promise<string> {
    return 'dns-template-id'
  }

  private async getAPIGatewayTemplateId(): Promise<string> {
    return 'api-gateway-template-id'
  }
}

export const networkProductsService = new NetworkProductsService()