@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/cli/table.ts

@@ -1,332 +0,0 @@
-/**
- * Table formatting utilities for CLI output
- * Better table rendering with borders, alignment, colors
- */
-
-export interface TableColumn {
-  key: string
-  label: string
-  width?: number
-  align?: 'left' | 'right' | 'center'
-  formatter?: (value: any) => string
-}
-
-export interface TableOptions {
-  columns: TableColumn[]
-  data: Record<string, any>[]
-  border?: boolean
-  header?: boolean
-  compact?: boolean
-  maxWidth?: number
-}
-
-/**
- * Format data as a table
- */
-export function formatTable(options: TableOptions): string {
-  const { columns, data, border = true, header = true, compact = false, maxWidth } = options
-
-  if (data.length === 0) {
-    return 'No data to display'
-  }
-
-  // Calculate column widths
-  const colWidths = columns.map((col) => {
-    const labelWidth = col.label.length
-    const dataWidth = Math.max(
-      ...data.map((row) => {
-        const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || '')
-        return value.length
-      }),
-    )
-
-    let width = col.width || Math.max(labelWidth, dataWidth)
-
-    // Apply max width if specified
-    if (maxWidth && width > maxWidth) {
-      width = maxWidth
-    }
-
-    return width
-  })
-
-  const lines: string[] = []
-
-  // Top border
-  if (border) {
-    lines.push(createBorder(colWidths, 'top', compact))
-  }
-
-  // Header
-  if (header) {
-    lines.push(createRow(columns.map(col => col.label), colWidths, columns.map(col => col.align || 'left'), border))
-
-    // Header separator
-    if (border) {
-      lines.push(createBorder(colWidths, 'middle', compact))
-    }
-  }
-
-  // Data rows
-  for (const row of data) {
-    const values = columns.map((col) => {
-      const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || '')
-      return truncate(value, colWidths[columns.indexOf(col)])
-    })
-
-    lines.push(createRow(values, colWidths, columns.map(col => col.align || 'left'), border))
-  }
-
-  // Bottom border
-  if (border) {
-    lines.push(createBorder(colWidths, 'bottom', compact))
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Create a table row
- */
-function createRow(
-  values: string[],
-  widths: number[],
-  alignments: Array<'left' | 'right' | 'center'>,
-  border: boolean,
-): string {
-  const cells = values.map((value, i) => {
-    const width = widths[i]
-    const align = alignments[i]
-
-    return alignText(value, width, align)
-  })
-
-  if (border) {
-    return `│ ${cells.join(' │ ')} │`
-  }
-
-  return cells.join('  ')
-}
-
-/**
- * Create a table border
- */
-function createBorder(widths: number[], position: 'top' | 'middle' | 'bottom', compact: boolean): string {
-  const left = position === 'top' ? '┌' : position === 'middle' ? '├' : '└'
-  const right = position === 'top' ? '┐' : position === 'middle' ? '┤' : '┘'
-  const cross = position === 'top' ? '┬' : position === 'middle' ? '┼' : '┴'
-  const horizontal = '─'
-
-  if (compact) {
-    return left + widths.map(w => horizontal.repeat(w + 2)).join(cross) + right
-  }
-
-  return left + widths.map(w => horizontal.repeat(w + 2)).join(cross) + right
-}
-
-/**
- * Align text within a fixed width
- */
-function alignText(text: string, width: number, align: 'left' | 'right' | 'center'): string {
-  const textWidth = stripAnsi(text).length
-
-  if (textWidth >= width) {
-    return text
-  }
-
-  const padding = width - textWidth
-
-  switch (align) {
-    case 'right':
-      return ' '.repeat(padding) + text
-    case 'center': {
-      const leftPad = Math.floor(padding / 2)
-      const rightPad = padding - leftPad
-      return ' '.repeat(leftPad) + text + ' '.repeat(rightPad)
-    }
-    default:
-      return text + ' '.repeat(padding)
-  }
-}
-
-/**
- * Truncate text to fit width
- */
-function truncate(text: string, width: number): string {
-  const textWidth = stripAnsi(text).length
-
-  if (textWidth <= width) {
-    return text
-  }
-
-  // Truncate and add ellipsis
-  return text.substring(0, width - 1) + '…'
-}
-
-/**
- * Strip ANSI color codes from string
- */
-function stripAnsi(text: string): string {
-  // eslint-disable-next-line no-control-regex
-  return text.replace(/\x1B\[[0-9;]*m/g, '')
-}
-
-/**
- * Format data as a tree structure
- */
-export interface TreeNode {
-  label: string
-  children?: TreeNode[]
-  metadata?: Record<string, any>
-}
-
-export interface TreeOptions {
-  indent?: string
-  showMetadata?: boolean
-}
-
-/**
- * Format data as a tree
- */
-export function formatTree(nodes: TreeNode[], options: TreeOptions = {}): string {
-  const { indent = '  ', showMetadata = false } = options
-
-  const lines: string[] = []
-
-  function renderNode(node: TreeNode, prefix: string, isLast: boolean): void {
-    const connector = isLast ? '└─ ' : '├─ '
-    const line = prefix + connector + node.label
-
-    lines.push(line)
-
-    // Render metadata if enabled
-    if (showMetadata && node.metadata) {
-      const metadataPrefix = prefix + (isLast ? '   ' : '│  ')
-      for (const [key, value] of Object.entries(node.metadata)) {
-        lines.push(`${metadataPrefix}${key}: ${value}`)
-      }
-    }
-
-    // Render children
-    if (node.children && node.children.length > 0) {
-      const childPrefix = prefix + (isLast ? '   ' : '│  ')
-      node.children.forEach((child, index) => {
-        renderNode(child, childPrefix, index === node.children!.length - 1)
-      })
-    }
-  }
-
-  nodes.forEach((node, index) => {
-    renderNode(node, '', index === nodes.length - 1)
-  })
-
-  return lines.join('\n')
-}
-
-/**
- * Create a simple progress bar
- */
-export interface ProgressBarOptions {
-  total: number
-  current: number
-  width?: number
-  format?: string
-  complete?: string
-  incomplete?: string
-}
-
-/**
- * Format a progress bar
- */
-export function formatProgressBar(options: ProgressBarOptions): string {
-  const {
-    total,
-    current,
-    width = 40,
-    format = ':bar :percent :current/:total',
-    complete = '█',
-    incomplete = '░',
-  } = options
-
-  const percentage = Math.min(100, Math.max(0, (current / total) * 100))
-  const completed = Math.floor((width * current) / total)
-  const remaining = width - completed
-
-  const bar = complete.repeat(completed) + incomplete.repeat(remaining)
-
-  return format
-    .replace(':bar', bar)
-    .replace(':percent', `${percentage.toFixed(0)}%`)
-    .replace(':current', String(current))
-    .replace(':total', String(total))
-}
-
-/**
- * Format bytes as human-readable size
- */
-export function formatBytes(bytes: number, decimals = 2): string {
-  if (bytes === 0) return '0 Bytes'
-
-  const k = 1024
-  const dm = decimals < 0 ? 0 : decimals
-  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-
-  return `${Number.parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`
-}
-
-/**
- * Format duration as human-readable time
- */
-export function formatDuration(ms: number): string {
-  if (ms < 1000) return `${ms}ms`
-
-  const seconds = Math.floor(ms / 1000)
-  if (seconds < 60) return `${seconds}s`
-
-  const minutes = Math.floor(seconds / 60)
-  const remainingSeconds = seconds % 60
-
-  if (minutes < 60) {
-    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`
-  }
-
-  const hours = Math.floor(minutes / 60)
-  const remainingMinutes = minutes % 60
-
-  if (hours < 24) {
-    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`
-  }
-
-  const days = Math.floor(hours / 24)
-  const remainingHours = hours % 24
-
-  return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`
-}
-
-/**
- * Format list with bullets
- */
-export function formatList(items: string[], bullet = '•'): string {
-  return items.map(item => `${bullet} ${item}`).join('\n')
-}
-
-/**
- * Format key-value pairs
- */
-export function formatKeyValue(
-  data: Record<string, any>,
-  options: { indent?: string; separator?: string } = {},
-): string {
-  const { indent = '', separator = ': ' } = options
-
-  const maxKeyLength = Math.max(...Object.keys(data).map(k => k.length))
-
-  return Object.entries(data)
-    .map(([key, value]) => {
-      const paddedKey = key.padEnd(maxKeyLength)
-      return `${indent}${paddedKey}${separator}${value}`
-    })
-    .join('\n')
-}

package/src/cloudformation/builder.test.ts

@@ -1,327 +0,0 @@
-/**
- * CloudFormation Builder Tests
- */
-
-import { describe, expect, it } from 'bun:test'
-import { CloudFormationBuilder } from './builder'
-import { Fn } from './types'
-
-describe('CloudFormationBuilder', () => {
-  it('should initialize with empty template', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    const template = builder.build()
-
-    expect(template.AWSTemplateFormatVersion).toBe('2010-09-09')
-    expect(template.Description).toContain('Test')
-    expect(template.Resources).toEqual({})
-  })
-
-  it('should add resources to template', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('MyBucket', 'AWS::S3::Bucket', {
-      BucketName: 'my-test-bucket',
-    })
-
-    const template = builder.build()
-
-    expect(template.Resources.MyBucket).toBeDefined()
-    expect(template.Resources.MyBucket.Type).toBe('AWS::S3::Bucket')
-    expect(template.Resources.MyBucket.Properties!.BucketName).toBe('my-test-bucket')
-  })
-
-  it('should add multiple resources', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('Bucket1', 'AWS::S3::Bucket', { BucketName: 'bucket1' })
-    builder.addResource('Bucket2', 'AWS::S3::Bucket', { BucketName: 'bucket2' })
-
-    const template = builder.build()
-
-    expect(template.Resources.Bucket1).toBeDefined()
-    expect(template.Resources.Bucket2).toBeDefined()
-  })
-
-  it('should handle resource with DependsOn', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('Bucket', 'AWS::S3::Bucket', { BucketName: 'bucket' })
-    builder.addResource('BucketPolicy', 'AWS::S3::BucketPolicy', {
-      Bucket: Fn.ref('Bucket'),
-    }, {
-      dependsOn: 'Bucket',
-    })
-
-    const template = builder.build()
-
-    expect(template.Resources.BucketPolicy.DependsOn).toBe('Bucket')
-  })
-
-  it('should handle resource with multiple DependsOn', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('Resource1', 'AWS::S3::Bucket', {})
-    builder.addResource('Resource2', 'AWS::S3::Bucket', {})
-    builder.addResource('Resource3', 'AWS::S3::Bucket', {}, {
-      dependsOn: ['Resource1', 'Resource2'],
-    })
-
-    const template = builder.build()
-
-    expect(template.Resources.Resource3.DependsOn).toEqual(['Resource1', 'Resource2'])
-  })
-
-  it('should handle deletion policy', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('Database', 'AWS::RDS::DBInstance', {
-      DBInstanceIdentifier: 'mydb',
-    }, {
-      deletionPolicy: 'Snapshot',
-    })
-
-    const template = builder.build()
-
-    expect(template.Resources.Database.DeletionPolicy).toBe('Snapshot')
-  })
-
-  it('should include parameters in built template', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    const template = builder.build()
-
-    expect(template.Parameters).toBeDefined()
-    expect(template.Parameters?.Environment).toBeDefined()
-  })
-
-  it('should include conditions in built template', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    const template = builder.build()
-
-    expect(template.Conditions).toBeDefined()
-  })
-
-  it('should throw error for circular dependencies', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('Resource1', 'AWS::S3::Bucket', {}, { dependsOn: 'Resource2' })
-    builder.addResource('Resource2', 'AWS::S3::Bucket', {}, { dependsOn: 'Resource1' })
-
-    expect(() => builder.build()).toThrow('Circular dependency detected')
-  })
-
-  it('should detect complex circular dependencies', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('A', 'AWS::S3::Bucket', {}, { dependsOn: 'B' })
-    builder.addResource('B', 'AWS::S3::Bucket', {}, { dependsOn: 'C' })
-    builder.addResource('C', 'AWS::S3::Bucket', {}, { dependsOn: 'A' })
-
-    expect(() => builder.build()).toThrow('Circular dependency detected')
-  })
-
-  it('should handle valid dependency chains', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('A', 'AWS::S3::Bucket', {})
-    builder.addResource('B', 'AWS::S3::Bucket', {}, { dependsOn: 'A' })
-    builder.addResource('C', 'AWS::S3::Bucket', {}, { dependsOn: 'B' })
-
-    expect(() => builder.build()).not.toThrow()
-  })
-
-  it('should handle tags', () => {
-    const builder = new CloudFormationBuilder({
-      project: { name: 'Test', slug: 'test', region: 'us-east-1' },
-      environments: { production: { type: 'production' } },
-    })
-
-    builder.addResource('Bucket', 'AWS::S3::Bucket', {
-      BucketName: 'bucket',
-      Tags: [
-        { Key: 'Environment', Value: 'production' },
-        { Key: 'Project', Value: 'test' },
-      ],
-    })
-
-    const template = builder.build()
-
-    expect(template.Resources.Bucket.Properties!.Tags).toHaveLength(2)
-    expect(template.Resources.Bucket.Properties!.Tags![0]).toEqual({
-      Key: 'Environment',
-      Value: 'production',
-    })
-  })
-})
-
-describe('CloudFormation Intrinsic Functions', () => {
-  it('should create Ref function', () => {
-    const ref = Fn.ref('MyBucket')
-
-    expect(ref).toEqual({ Ref: 'MyBucket' })
-  })
-
-  it('should create GetAtt function', () => {
-    const getAtt = Fn.getAtt('MyBucket', 'Arn')
-
-    expect(getAtt).toEqual({ 'Fn::GetAtt': ['MyBucket', 'Arn'] })
-  })
-
-  it('should create Join function', () => {
-    const join = Fn.join('-', ['prefix', 'middle', 'suffix'])
-
-    expect(join).toEqual({ 'Fn::Join': ['-', ['prefix', 'middle', 'suffix']] })
-  })
-
-  it('should create Sub function with template only', () => {
-    const sub = Fn.sub('arn:aws:s3:::${BucketName}')
-
-    expect(sub).toEqual({ 'Fn::Sub': 'arn:aws:s3:::${BucketName}' })
-  })
-
-  it('should create Sub function with variables', () => {
-    const sub = Fn.sub('arn:aws:s3:::${Bucket}', {
-      Bucket: Fn.ref('MyBucket'),
-    })
-
-    expect(sub).toEqual({
-      'Fn::Sub': ['arn:aws:s3:::${Bucket}', { Bucket: { Ref: 'MyBucket' } }],
-    })
-  })
-
-  it('should create Select function', () => {
-    const select = Fn.select(0, ['a', 'b', 'c'])
-
-    expect(select).toEqual({ 'Fn::Select': [0, ['a', 'b', 'c']] })
-  })
-
-  it('should create Split function', () => {
-    const split = Fn.split(',', 'a,b,c')
-
-    expect(split).toEqual({ 'Fn::Split': [',', 'a,b,c'] })
-  })
-
-  it('should create If function', () => {
-    const ifFunc = Fn.if('IsProduction', 'prod-value', 'dev-value')
-
-    expect(ifFunc).toEqual({ 'Fn::If': ['IsProduction', 'prod-value', 'dev-value'] })
-  })
-
-  it('should create Equals function', () => {
-    const equals = Fn.equals('value1', 'value2')
-
-    expect(equals).toEqual({ 'Fn::Equals': ['value1', 'value2'] })
-  })
-
-  it('should create Not function', () => {
-    const not = Fn.not(Fn.equals('a', 'b'))
-
-    expect(not).toEqual({ 'Fn::Not': [{ 'Fn::Equals': ['a', 'b'] }] })
-  })
-
-  it('should create And function', () => {
-    const and = Fn.and(
-      Fn.equals('a', 'a'),
-      Fn.equals('b', 'b'),
-    )
-
-    expect(and).toEqual({
-      'Fn::And': [{ 'Fn::Equals': ['a', 'a'] }, { 'Fn::Equals': ['b', 'b'] }],
-    })
-  })
-
-  it('should create Or function', () => {
-    const or = Fn.or(
-      Fn.equals('a', 'b'),
-      Fn.equals('c', 'c'),
-    )
-
-    expect(or).toEqual({
-      'Fn::Or': [{ 'Fn::Equals': ['a', 'b'] }, { 'Fn::Equals': ['c', 'c'] }],
-    })
-  })
-
-  it('should create Base64 function', () => {
-    const base64 = Fn.base64('user data script')
-
-    expect(base64).toEqual({ 'Fn::Base64': 'user data script' })
-  })
-
-  it('should create Cidr function', () => {
-    const cidr = Fn.cidr('10.0.0.0/16', 6, 8)
-
-    expect(cidr).toEqual({ 'Fn::Cidr': ['10.0.0.0/16', 6, 8] })
-  })
-
-  it('should create GetAZs function', () => {
-    const getAZs = Fn.getAZs('us-east-1')
-
-    expect(getAZs).toEqual({ 'Fn::GetAZs': 'us-east-1' })
-  })
-
-  it('should create GetAZs for current region', () => {
-    const getAZs = Fn.getAZs()
-
-    expect(getAZs).toEqual({ 'Fn::GetAZs': '' })
-  })
-
-  it('should create ImportValue function', () => {
-    const importValue = Fn.importValue('NetworkStackVpcId')
-
-    expect(importValue).toEqual({ 'Fn::ImportValue': 'NetworkStackVpcId' })
-  })
-
-  it('should nest intrinsic functions', () => {
-    const nested = Fn.join('-', [
-      Fn.ref('AWS::StackName'),
-      'bucket',
-      Fn.select(0, Fn.getAZs()),
-    ])
-
-    expect(nested).toEqual({
-      'Fn::Join': [
-        '-',
-        [
-          { Ref: 'AWS::StackName' },
-          'bucket',
-          { 'Fn::Select': [0, { 'Fn::GetAZs': '' }] },
-        ],
-      ],
-    })
-  })
-})