@stacksjs/ts-cloud-core 0.1.3 → 0.1.6

package/src/validators/quotas.test.ts

@@ -1,434 +0,0 @@
-/**
- * Service Quota Validation Tests
- */
-
-import { describe, expect, it } from 'bun:test'
-import {
-  DEFAULT_SERVICE_LIMITS,
-  checkServiceQuotas,
-  getQuotaUsageSummary,
-  suggestQuotaIncrease,
-} from './quotas'
-
-describe('DEFAULT_SERVICE_LIMITS', () => {
-  it('should have EC2 limits', () => {
-    expect(DEFAULT_SERVICE_LIMITS.ec2).toBeDefined()
-    expect(DEFAULT_SERVICE_LIMITS.ec2['Running On-Demand Instances']).toBe(20)
-    expect(DEFAULT_SERVICE_LIMITS.ec2['VPCs']).toBe(5)
-    expect(DEFAULT_SERVICE_LIMITS.ec2['Security Groups']).toBe(500)
-  })
-
-  it('should have RDS limits', () => {
-    expect(DEFAULT_SERVICE_LIMITS.rds).toBeDefined()
-    expect(DEFAULT_SERVICE_LIMITS.rds['DB Instances']).toBe(40)
-  })
-
-  it('should have S3 limits', () => {
-    expect(DEFAULT_SERVICE_LIMITS.s3).toBeDefined()
-    expect(DEFAULT_SERVICE_LIMITS.s3['Buckets']).toBe(100)
-  })
-
-  it('should have Lambda limits', () => {
-    expect(DEFAULT_SERVICE_LIMITS.lambda).toBeDefined()
-    expect(DEFAULT_SERVICE_LIMITS.lambda['Concurrent Executions']).toBe(1000)
-  })
-
-  it('should have DynamoDB limits', () => {
-    expect(DEFAULT_SERVICE_LIMITS.dynamodb).toBeDefined()
-    expect(DEFAULT_SERVICE_LIMITS.dynamodb['Tables']).toBe(256)
-  })
-})
-
-describe('checkServiceQuotas', () => {
-  it('should return empty array for minimal config', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-    })
-
-    expect(Array.isArray(quotas)).toBe(true)
-    expect(quotas.length).toBe(0)
-  })
-
-  it('should check EC2 instance quotas', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        compute: {
-          server: {
-            autoScaling: {
-              max: 10,
-            },
-          },
-        },
-      },
-    })
-
-    const ec2Quota = quotas.find(q => q.quotaName === 'Running On-Demand Instances')
-    expect(ec2Quota).toBeDefined()
-    expect(ec2Quota?.service).toBe('EC2')
-    expect(ec2Quota?.currentValue).toBe(10)
-    expect(ec2Quota?.limit).toBe(20)
-    expect(ec2Quota?.percentage).toBe(50)
-    expect(ec2Quota?.warning).toBe(false)
-  })
-
-  it('should warn when EC2 quota exceeds 80%', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        compute: {
-          server: {
-            autoScaling: {
-              max: 17,
-            },
-          },
-        },
-      },
-    })
-
-    const ec2Quota = quotas.find(q => q.quotaName === 'Running On-Demand Instances')
-    expect(ec2Quota?.warning).toBe(true)
-  })
-
-  it('should check VPC quotas', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        network: {
-          vpc: {},
-        },
-      },
-    })
-
-    const vpcQuota = quotas.find(q => q.quotaName === 'VPCs')
-    expect(vpcQuota).toBeDefined()
-    expect(vpcQuota?.service).toBe('EC2')
-    expect(vpcQuota?.currentValue).toBe(1)
-    expect(vpcQuota?.limit).toBe(5)
-  })
-
-  it('should check RDS database quotas', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        database: {
-          postgres: {},
-        },
-      },
-    })
-
-    const rdsQuota = quotas.find(q => q.quotaName === 'DB Instances')
-    expect(rdsQuota).toBeDefined()
-    expect(rdsQuota?.service).toBe('RDS')
-    expect(rdsQuota?.currentValue).toBe(1)
-    expect(rdsQuota?.limit).toBe(40)
-  })
-
-  it('should check S3 bucket quotas', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        storage: {
-          uploads: {},
-          assets: {},
-          backups: {},
-        },
-      },
-    })
-
-    const s3Quota = quotas.find(q => q.quotaName === 'Buckets')
-    expect(s3Quota).toBeDefined()
-    expect(s3Quota?.service).toBe('S3')
-    expect(s3Quota?.currentValue).toBe(3)
-    expect(s3Quota?.limit).toBe(100)
-  })
-
-  it('should warn when S3 bucket quota exceeds 80%', async () => {
-    const storage: any = {}
-    for (let i = 0; i < 85; i++) {
-      storage[`bucket${i}`] = {}
-    }
-
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        storage,
-      },
-    })
-
-    const s3Quota = quotas.find(q => q.quotaName === 'Buckets')
-    expect(s3Quota?.warning).toBe(true)
-  })
-
-  it('should check Lambda function quotas', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        functions: {
-          api: [
-            { name: 'handler1', runtime: 'nodejs20.x' },
-            { name: 'handler2', runtime: 'nodejs20.x' },
-          ],
-        },
-      },
-    })
-
-    const lambdaQuota = quotas.find(q => q.quotaName === 'Functions (estimated)')
-    expect(lambdaQuota).toBeDefined()
-    expect(lambdaQuota?.service).toBe('Lambda')
-    expect(lambdaQuota?.currentValue).toBe(2)
-    expect(lambdaQuota?.limit).toBe(1000)
-  })
-
-  it('should check DynamoDB table quotas', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        database: {
-          dynamodb: {
-            tables: [
-              { name: 'users', partitionKey: 'id' },
-              { name: 'posts', partitionKey: 'id' },
-            ],
-          },
-        },
-      },
-    })
-
-    const dynamoQuota = quotas.find(q => q.quotaName === 'Tables')
-    expect(dynamoQuota).toBeDefined()
-    expect(dynamoQuota?.service).toBe('DynamoDB')
-    expect(dynamoQuota?.currentValue).toBe(2)
-    expect(dynamoQuota?.limit).toBe(256)
-  })
-
-  it('should check multiple quotas at once', async () => {
-    const quotas = await checkServiceQuotas({
-      project: { name: 'Test', slug: 'test' },
-      infrastructure: {
-        compute: {
-          server: {
-            autoScaling: { max: 5 },
-          },
-        },
-        network: {
-          vpc: {},
-        },
-        storage: {
-          uploads: {},
-        },
-        database: {
-          postgres: {},
-        },
-      },
-    })
-
-    expect(quotas.length).toBeGreaterThan(0)
-    expect(quotas.some(q => q.service === 'EC2')).toBe(true)
-    expect(quotas.some(q => q.service === 'S3')).toBe(true)
-    expect(quotas.some(q => q.service === 'RDS')).toBe(true)
-  })
-})
-
-describe('getQuotaUsageSummary', () => {
-  it('should return message for empty quotas', () => {
-    const summary = getQuotaUsageSummary([])
-
-    expect(summary).toBe('No quotas to check')
-  })
-
-  it('should format quota usage summary', () => {
-    const summary = getQuotaUsageSummary([
-      {
-        service: 'EC2',
-        quotaName: 'Running Instances',
-        currentValue: 10,
-        limit: 20,
-        percentage: 50,
-        warning: false,
-      },
-      {
-        service: 'S3',
-        quotaName: 'Buckets',
-        currentValue: 5,
-        limit: 100,
-        percentage: 5,
-        warning: false,
-      },
-    ])
-
-    expect(summary).toContain('Service Quota Usage')
-    expect(summary).toContain('EC2')
-    expect(summary).toContain('Running Instances')
-    expect(summary).toContain('10/20')
-    expect(summary).toContain('50.0%')
-    expect(summary).toContain('S3')
-    expect(summary).toContain('Buckets')
-  })
-
-  it('should show warning indicator for quota warnings', () => {
-    const summary = getQuotaUsageSummary([
-      {
-        service: 'EC2',
-        quotaName: 'Running Instances',
-        currentValue: 18,
-        limit: 20,
-        percentage: 90,
-        warning: true,
-      },
-    ])
-
-    expect(summary).toContain('⚠')
-  })
-
-  it('should show checkmark for normal usage', () => {
-    const summary = getQuotaUsageSummary([
-      {
-        service: 'EC2',
-        quotaName: 'Running Instances',
-        currentValue: 5,
-        limit: 20,
-        percentage: 25,
-        warning: false,
-      },
-    ])
-
-    expect(summary).toContain('✓')
-  })
-
-  it('should group quotas by service', () => {
-    const summary = getQuotaUsageSummary([
-      {
-        service: 'EC2',
-        quotaName: 'Instances',
-        currentValue: 5,
-        limit: 20,
-        percentage: 25,
-        warning: false,
-      },
-      {
-        service: 'EC2',
-        quotaName: 'VPCs',
-        currentValue: 2,
-        limit: 5,
-        percentage: 40,
-        warning: false,
-      },
-      {
-        service: 'S3',
-        quotaName: 'Buckets',
-        currentValue: 3,
-        limit: 100,
-        percentage: 3,
-        warning: false,
-      },
-    ])
-
-    // Should have EC2 section with 2 items
-    const ec2Section = summary.split('S3:')[0]
-    expect(ec2Section).toContain('Instances')
-    expect(ec2Section).toContain('VPCs')
-  })
-})
-
-describe('suggestQuotaIncrease', () => {
-  it('should return empty array for no warnings', () => {
-    const suggestions = suggestQuotaIncrease([
-      {
-        service: 'EC2',
-        quotaName: 'Instances',
-        currentValue: 5,
-        limit: 20,
-        percentage: 25,
-        warning: false,
-      },
-    ])
-
-    expect(suggestions).toEqual([])
-  })
-
-  it('should suggest increase for quotas at 100%', () => {
-    const suggestions = suggestQuotaIncrease([
-      {
-        service: 'EC2',
-        quotaName: 'Instances',
-        currentValue: 20,
-        limit: 20,
-        percentage: 100,
-        warning: true,
-      },
-    ])
-
-    expect(suggestions).toHaveLength(1)
-    expect(suggestions[0]).toContain('Request quota increase')
-    expect(suggestions[0]).toContain('EC2')
-    expect(suggestions[0]).toContain('Instances')
-    expect(suggestions[0]).toContain('20')
-  })
-
-  it('should suggest consideration for quotas with warnings', () => {
-    const suggestions = suggestQuotaIncrease([
-      {
-        service: 'S3',
-        quotaName: 'Buckets',
-        currentValue: 85,
-        limit: 100,
-        percentage: 85,
-        warning: true,
-      },
-    ])
-
-    expect(suggestions).toHaveLength(1)
-    expect(suggestions[0]).toContain('Consider requesting quota increase')
-    expect(suggestions[0]).toContain('S3')
-    expect(suggestions[0]).toContain('Buckets')
-    expect(suggestions[0]).toContain('85.0%')
-  })
-
-  it('should provide multiple suggestions', () => {
-    const suggestions = suggestQuotaIncrease([
-      {
-        service: 'EC2',
-        quotaName: 'Instances',
-        currentValue: 20,
-        limit: 20,
-        percentage: 100,
-        warning: true,
-      },
-      {
-        service: 'S3',
-        quotaName: 'Buckets',
-        currentValue: 85,
-        limit: 100,
-        percentage: 85,
-        warning: true,
-      },
-    ])
-
-    expect(suggestions).toHaveLength(2)
-  })
-
-  it('should prioritize 100% quotas over warnings', () => {
-    const suggestions = suggestQuotaIncrease([
-      {
-        service: 'EC2',
-        quotaName: 'Instances',
-        currentValue: 20,
-        limit: 20,
-        percentage: 100,
-        warning: true,
-      },
-      {
-        service: 'S3',
-        quotaName: 'Buckets',
-        currentValue: 85,
-        limit: 100,
-        percentage: 85,
-        warning: true,
-      },
-    ])
-
-    expect(suggestions[0]).toContain('Request quota increase')
-    expect(suggestions[1]).toContain('Consider requesting')
-  })
-})

package/src/validators/quotas.ts

@@ -1,217 +0,0 @@
-/**
- * AWS Service Quota Checking
- * Check if deployment will exceed service limits
- */
-
-import { DebugLogger } from '../errors'
-
-export interface ServiceQuota {
-  service: string
-  quotaName: string
-  currentValue: number
-  limit: number
-  percentage: number
-  warning: boolean
-}
-
-/**
- * Common AWS service limits by region
- */
-export const DEFAULT_SERVICE_LIMITS = {
-  ec2: {
-    'Running On-Demand Instances': 20,
-    'Elastic IPs': 5,
-    'VPCs': 5,
-    'Internet Gateways': 5,
-    'NAT Gateways': 5,
-    'Security Groups': 500,
-  },
-  rds: {
-    'DB Instances': 40,
-    'DB Snapshots': 100,
-    'DB Parameter Groups': 50,
-  },
-  lambda: {
-    'Concurrent Executions': 1000,
-    'Function Storage': 75 * 1024 * 1024 * 1024 as number, // 75 GB
-  },
-  s3: {
-    'Buckets': 100,
-  },
-  cloudformation: {
-    'Stacks': 200,
-    'StackSets': 100,
-  },
-  elasticache: {
-    'Nodes': 100,
-    'Clusters': 100,
-  },
-  dynamodb: {
-    'Tables': 256,
-  },
-  ecs: {
-    'Clusters': 10000,
-    'Services per Cluster': 2000,
-  },
-}
-
-/**
- * Check service quotas for deployment
- */
-export async function checkServiceQuotas(config: any): Promise<ServiceQuota[]> {
-  const quotas: ServiceQuota[] = []
-
-  DebugLogger.verbose('Checking AWS service quotas...')
-
-  // Check EC2 quotas
-  if (config.infrastructure?.compute?.server) {
-    const instanceCount = config.infrastructure.compute.server.autoScaling?.max || 1
-
-    quotas.push({
-      service: 'EC2',
-      quotaName: 'Running On-Demand Instances',
-      currentValue: instanceCount,
-      limit: DEFAULT_SERVICE_LIMITS.ec2['Running On-Demand Instances'],
-      percentage: (instanceCount / DEFAULT_SERVICE_LIMITS.ec2['Running On-Demand Instances']) * 100,
-      warning: instanceCount > DEFAULT_SERVICE_LIMITS.ec2['Running On-Demand Instances'] * 0.8,
-    })
-  }
-
-  // Check VPC quotas
-  if (config.infrastructure?.network?.vpc) {
-    quotas.push({
-      service: 'EC2',
-      quotaName: 'VPCs',
-      currentValue: 1,
-      limit: DEFAULT_SERVICE_LIMITS.ec2.VPCs,
-      percentage: (1 / DEFAULT_SERVICE_LIMITS.ec2.VPCs) * 100,
-      warning: false,
-    })
-  }
-
-  // Check RDS quotas
-  if (config.infrastructure?.database?.postgres || config.infrastructure?.database?.mysql) {
-    quotas.push({
-      service: 'RDS',
-      quotaName: 'DB Instances',
-      currentValue: 1,
-      limit: DEFAULT_SERVICE_LIMITS.rds['DB Instances'],
-      percentage: (1 / DEFAULT_SERVICE_LIMITS.rds['DB Instances']) * 100,
-      warning: false,
-    })
-  }
-
-  // Check S3 quotas
-  if (config.infrastructure?.storage) {
-    const bucketCount = Object.keys(config.infrastructure.storage).length
-
-    quotas.push({
-      service: 'S3',
-      quotaName: 'Buckets',
-      currentValue: bucketCount,
-      limit: DEFAULT_SERVICE_LIMITS.s3.Buckets,
-      percentage: (bucketCount / DEFAULT_SERVICE_LIMITS.s3.Buckets) * 100,
-      warning: bucketCount > DEFAULT_SERVICE_LIMITS.s3.Buckets * 0.8,
-    })
-  }
-
-  // Check Lambda quotas
-  if (config.infrastructure?.functions) {
-    let functionCount = 0
-    for (const category of Object.values(config.infrastructure.functions)) {
-      if (Array.isArray(category)) {
-        functionCount += category.length
-      }
-    }
-
-    // Lambda doesn't have a function count limit, but we can check storage
-    quotas.push({
-      service: 'Lambda',
-      quotaName: 'Functions (estimated)',
-      currentValue: functionCount,
-      limit: 1000, // Soft limit
-      percentage: (functionCount / 1000) * 100,
-      warning: functionCount > 800,
-    })
-  }
-
-  // Check DynamoDB quotas
-  if (config.infrastructure?.database?.dynamodb) {
-    const tableCount = config.infrastructure.database.dynamodb.tables?.length || 0
-
-    quotas.push({
-      service: 'DynamoDB',
-      quotaName: 'Tables',
-      currentValue: tableCount,
-      limit: DEFAULT_SERVICE_LIMITS.dynamodb.Tables,
-      percentage: (tableCount / DEFAULT_SERVICE_LIMITS.dynamodb.Tables) * 100,
-      warning: tableCount > DEFAULT_SERVICE_LIMITS.dynamodb.Tables * 0.8,
-    })
-  }
-
-  // Log warnings
-  const warnings = quotas.filter(q => q.warning)
-  if (warnings.length > 0) {
-    DebugLogger.warn('Service quota warnings detected:')
-    for (const warning of warnings) {
-      DebugLogger.warn(`  ${warning.service} - ${warning.quotaName}: ${warning.currentValue}/${warning.limit} (${warning.percentage.toFixed(1)}%)`)
-    }
-  }
-  else {
-    DebugLogger.verbose('All service quotas are within limits')
-  }
-
-  return quotas
-}
-
-/**
- * Get quota usage summary
- */
-export function getQuotaUsageSummary(quotas: ServiceQuota[]): string {
-  if (quotas.length === 0) {
-    return 'No quotas to check'
-  }
-
-  let summary = 'Service Quota Usage:\n\n'
-
-  const byService = quotas.reduce((acc, quota) => {
-    if (!acc[quota.service]) {
-      acc[quota.service] = []
-    }
-    acc[quota.service].push(quota)
-    return acc
-  }, {} as Record<string, ServiceQuota[]>)
-
-  for (const [service, serviceQuotas] of Object.entries(byService)) {
-    summary += `${service}:\n`
-    for (const quota of serviceQuotas) {
-      const indicator = quota.warning ? '⚠' : '✓'
-      summary += `  ${indicator} ${quota.quotaName}: ${quota.currentValue}/${quota.limit} (${quota.percentage.toFixed(1)}%)\n`
-    }
-    summary += '\n'
-  }
-
-  return summary
-}
-
-/**
- * Suggest quota increase if needed
- */
-export function suggestQuotaIncrease(quotas: ServiceQuota[]): string[] {
-  const suggestions: string[] = []
-
-  for (const quota of quotas) {
-    if (quota.percentage >= 100) {
-      suggestions.push(
-        `Request quota increase for ${quota.service} - ${quota.quotaName} (currently ${quota.limit})`,
-      )
-    }
-    else if (quota.warning) {
-      suggestions.push(
-        `Consider requesting quota increase for ${quota.service} - ${quota.quotaName} (${quota.percentage.toFixed(1)}% used)`,
-      )
-    }
-  }
-
-  return suggestions
-}