@stacksjs/ts-cloud-core 0.1.1

package/src/validators/quotas.test.ts

@@ -0,0 +1,434 @@
+/**
+ * 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

@@ -0,0 +1,217 @@
+/**
+ * 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
+}