@stacksjs/ts-cloud 0.1.1

package/bin/commands/api.ts

@@ -0,0 +1,379 @@
+import type { CLI } from '@stacksjs/clapp'
+import * as cli from '../../src/utils/cli'
+import { loadValidatedConfig } from './shared'
+
+export function registerApiCommands(app: CLI): void {
+  app
+    .command('api:list', 'List all API Gateway APIs')
+    .option('--region <region>', 'AWS region')
+    .action(async (options: { region?: string }) => {
+      cli.header('API Gateway APIs')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        // Use Lambda client which has API Gateway methods
+        const { LambdaClient } = await import('../../src/aws/lambda')
+        const lambda = new LambdaClient(region)
+
+        const spinner = new cli.Spinner('Fetching APIs...')
+        spinner.start()
+
+        // Show a simplified view using CloudFormation
+        const { CloudFormationClient } = await import('../../src/aws/cloudformation')
+        const cfn = new CloudFormationClient(region)
+
+        const stacks = await cfn.listStacks(['CREATE_COMPLETE', 'UPDATE_COMPLETE'])
+        const apiStacks = stacks.StackSummaries.filter(s =>
+          s.StackName?.includes('api') || s.StackName?.includes('Api') || s.StackName?.includes('API'),
+        )
+
+        spinner.succeed('APIs listed')
+
+        cli.info('\nAPI-related CloudFormation stacks:')
+        if (apiStacks.length === 0) {
+          cli.info('No API Gateway stacks found')
+          cli.info('\nTo create an API, you can:')
+          cli.info('  1. Use cloud.config.ts to define your API')
+          cli.info('  2. Deploy with `cloud deploy`')
+        }
+        else {
+          cli.table(
+            ['Stack Name', 'Status', 'Created'],
+            apiStacks.map(stack => [
+              stack.StackName || 'N/A',
+              stack.StackStatus || 'N/A',
+              stack.CreationTime ? new Date(stack.CreationTime).toLocaleDateString() : 'N/A',
+            ]),
+          )
+        }
+
+        cli.info('\nTip: Use AWS Console or `aws apigateway get-rest-apis` for detailed API listing')
+      }
+      catch (error: any) {
+        cli.error(`Failed to list APIs: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:describe <apiId>', 'Show API Gateway API details')
+    .option('--region <region>', 'AWS region')
+    .action(async (apiId: string, options: { region?: string }) => {
+      cli.header(`API: ${apiId}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        cli.info(`API ID: ${apiId}`)
+        cli.info(`Region: ${region}`)
+        cli.info('')
+        cli.info('For detailed API information, use AWS CLI:')
+        cli.info(`  aws apigateway get-rest-api --rest-api-id ${apiId} --region ${region}`)
+        cli.info(`  aws apigateway get-resources --rest-api-id ${apiId} --region ${region}`)
+        cli.info(`  aws apigateway get-stages --rest-api-id ${apiId} --region ${region}`)
+      }
+      catch (error: any) {
+        cli.error(`Failed to describe API: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:stages <apiId>', 'List API stages')
+    .option('--region <region>', 'AWS region')
+    .action(async (apiId: string, options: { region?: string }) => {
+      cli.header(`API Stages: ${apiId}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        cli.info(`API ID: ${apiId}`)
+        cli.info(`Region: ${region}`)
+        cli.info('')
+        cli.info('Common stages:')
+        cli.info('  - prod (production)')
+        cli.info('  - staging')
+        cli.info('  - dev (development)')
+        cli.info('')
+        cli.info('For detailed stage information, use AWS CLI:')
+        cli.info(`  aws apigateway get-stages --rest-api-id ${apiId} --region ${region}`)
+      }
+      catch (error: any) {
+        cli.error(`Failed to list stages: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:deploy <apiId>', 'Deploy API to a stage')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .option('--stage <name>', 'Stage name', { default: 'prod' })
+    .option('--description <text>', 'Deployment description')
+    .action(async (apiId: string, options: { region: string; stage: string; description?: string }) => {
+      cli.header('Deploy API')
+
+      try {
+        cli.info(`API ID: ${apiId}`)
+        cli.info(`Stage: ${options.stage}`)
+
+        const confirmed = await cli.confirm('\nDeploy to this stage?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        cli.info('')
+        cli.info('To deploy an API Gateway API:')
+        cli.info(`  aws apigateway create-deployment \\`)
+        cli.info(`    --rest-api-id ${apiId} \\`)
+        cli.info(`    --stage-name ${options.stage} \\`)
+        cli.info(`    --region ${options.region}`)
+
+        if (options.description) {
+          cli.info(`    --description "${options.description}"`)
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to deploy API: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:domains', 'List custom domain names')
+    .option('--region <region>', 'AWS region')
+    .action(async (options: { region?: string }) => {
+      cli.header('API Gateway Custom Domains')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        cli.info(`Region: ${region}`)
+        cli.info('')
+        cli.info('To list custom domains, use AWS CLI:')
+        cli.info(`  aws apigateway get-domain-names --region ${region}`)
+        cli.info('')
+        cli.info('To create a custom domain:')
+        cli.info('  1. Request or import an SSL certificate in ACM')
+        cli.info('  2. Create a custom domain in API Gateway')
+        cli.info('  3. Create a base path mapping to your API')
+        cli.info('  4. Add a DNS record pointing to the distribution')
+      }
+      catch (error: any) {
+        cli.error(`Failed to list domains: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:usage <apiId>', 'Show API usage statistics')
+    .option('--region <region>', 'AWS region')
+    .option('--stage <name>', 'Stage name', { default: 'prod' })
+    .option('--days <number>', 'Number of days to show', { default: '7' })
+    .action(async (apiId: string, options: { region?: string; stage: string; days: string }) => {
+      cli.header('API Usage Statistics')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        cli.info(`API ID: ${apiId}`)
+        cli.info(`Stage: ${options.stage}`)
+        cli.info(`Period: Last ${options.days} days`)
+        cli.info('')
+
+        // Calculate date range
+        const endDate = new Date()
+        const startDate = new Date()
+        startDate.setDate(startDate.getDate() - Number.parseInt(options.days))
+
+        cli.info('To view API metrics in CloudWatch:')
+        cli.info(`  aws cloudwatch get-metric-statistics \\`)
+        cli.info(`    --namespace AWS/ApiGateway \\`)
+        cli.info(`    --metric-name Count \\`)
+        cli.info(`    --dimensions Name=ApiName,Value=${apiId} Name=Stage,Value=${options.stage} \\`)
+        cli.info(`    --start-time ${startDate.toISOString()} \\`)
+        cli.info(`    --end-time ${endDate.toISOString()} \\`)
+        cli.info(`    --period 86400 \\`)
+        cli.info(`    --statistics Sum \\`)
+        cli.info(`    --region ${region}`)
+
+        cli.info('')
+        cli.info('Available metrics:')
+        cli.info('  - Count: Total API calls')
+        cli.info('  - Latency: Response latency')
+        cli.info('  - 4XXError: Client errors')
+        cli.info('  - 5XXError: Server errors')
+        cli.info('  - IntegrationLatency: Backend latency')
+      }
+      catch (error: any) {
+        cli.error(`Failed to get usage: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:export <apiId>', 'Export API specification')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .option('--stage <name>', 'Stage name', { default: 'prod' })
+    .option('--format <format>', 'Export format (oas30, swagger)', { default: 'oas30' })
+    .option('--output <file>', 'Output file path')
+    .action(async (apiId: string, options: { region: string; stage: string; format: string; output?: string }) => {
+      cli.header('Export API Specification')
+
+      try {
+        cli.info(`API ID: ${apiId}`)
+        cli.info(`Stage: ${options.stage}`)
+        cli.info(`Format: ${options.format === 'oas30' ? 'OpenAPI 3.0' : 'Swagger 2.0'}`)
+        cli.info('')
+
+        const exportType = options.format === 'oas30' ? 'oas30' : 'swagger'
+
+        cli.info('To export the API specification:')
+        cli.info(`  aws apigateway get-export \\`)
+        cli.info(`    --rest-api-id ${apiId} \\`)
+        cli.info(`    --stage-name ${options.stage} \\`)
+        cli.info(`    --export-type ${exportType} \\`)
+        cli.info(`    --accepts application/json \\`)
+        cli.info(`    --region ${options.region} \\`)
+        cli.info(`    ${options.output || 'api-spec.json'}`)
+      }
+      catch (error: any) {
+        cli.error(`Failed to export API: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:logs <apiId>', 'View API Gateway logs')
+    .option('--region <region>', 'AWS region')
+    .option('--stage <name>', 'Stage name', { default: 'prod' })
+    .option('--tail', 'Tail the logs')
+    .action(async (apiId: string, options: { region?: string; stage: string; tail?: boolean }) => {
+      cli.header('API Gateway Logs')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        const logGroupName = `API-Gateway-Execution-Logs_${apiId}/${options.stage}`
+
+        cli.info(`Log Group: ${logGroupName}`)
+        cli.info('')
+        cli.info('To view logs:')
+        cli.info(`  aws logs filter-log-events \\`)
+        cli.info(`    --log-group-name "${logGroupName}" \\`)
+        cli.info(`    --region ${region}`)
+
+        if (options.tail) {
+          cli.info('')
+          cli.info('For real-time log tailing, use:')
+          cli.info(`  aws logs tail "${logGroupName}" --follow --region ${region}`)
+        }
+
+        cli.info('')
+        cli.info('Note: Ensure logging is enabled for the API stage.')
+        cli.info('You can enable it in the stage settings.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to get logs: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('api:test <apiId> <path>', 'Test an API endpoint')
+    .option('--region <region>', 'AWS region')
+    .option('--stage <name>', 'Stage name', { default: 'prod' })
+    .option('--method <method>', 'HTTP method', { default: 'GET' })
+    .option('--body <json>', 'Request body (JSON)')
+    .option('--header <header>', 'Request header (can be specified multiple times)')
+    .action(async (apiId: string, path: string, options: {
+      region?: string
+      stage: string
+      method: string
+      body?: string
+      header?: string | string[]
+    }) => {
+      cli.header('Test API Endpoint')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+
+        // Build the API URL
+        const apiUrl = `https://${apiId}.execute-api.${region}.amazonaws.com/${options.stage}${path.startsWith('/') ? path : `/${path}`}`
+
+        cli.info(`URL: ${apiUrl}`)
+        cli.info(`Method: ${options.method}`)
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        }
+
+        if (options.header) {
+          const headerList = Array.isArray(options.header) ? options.header : [options.header]
+          for (const h of headerList) {
+            const [key, ...valueParts] = h.split(':')
+            headers[key.trim()] = valueParts.join(':').trim()
+          }
+        }
+
+        cli.info('Headers:')
+        for (const [key, value] of Object.entries(headers)) {
+          cli.info(`  ${key}: ${value}`)
+        }
+
+        if (options.body) {
+          cli.info(`Body: ${options.body}`)
+        }
+
+        const confirmed = await cli.confirm('\nSend request?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Sending request...')
+        spinner.start()
+
+        const startTime = Date.now()
+
+        const response = await fetch(apiUrl, {
+          method: options.method,
+          headers,
+          body: options.body,
+        })
+
+        const elapsed = Date.now() - startTime
+        const responseBody = await response.text()
+
+        spinner.succeed(`Response received (${elapsed}ms)`)
+
+        cli.info(`\nStatus: ${response.status} ${response.statusText}`)
+
+        cli.info('\nResponse Headers:')
+        response.headers.forEach((value, key) => {
+          cli.info(`  ${key}: ${value}`)
+        })
+
+        cli.info('\nResponse Body:')
+        try {
+          const json = JSON.parse(responseBody)
+          console.log(JSON.stringify(json, null, 2))
+        }
+        catch {
+          console.log(responseBody)
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to test API: ${error.message}`)
+        process.exit(1)
+      }
+    })
+}

package/bin/commands/assets.ts

@@ -0,0 +1,221 @@
+import type { CLI } from '@stacksjs/clapp'
+import { existsSync } from 'node:fs'
+import * as cli from '../../src/utils/cli'
+import { S3Client } from '../../src/aws/s3'
+import { CloudFrontClient } from '../../src/aws/cloudfront'
+import { loadValidatedConfig } from './shared'
+
+export function registerAssetsCommands(app: CLI): void {
+  app
+    .command('assets:build', 'Build assets')
+    .option('--minify', 'Minify output')
+    .option('--compress', 'Compress output')
+    .action(async (options?: { minify?: boolean, compress?: boolean }) => {
+      cli.header('Building Assets')
+
+      const minify = options?.minify || false
+      const compress = options?.compress || false
+
+      cli.info('Build configuration:')
+      cli.info(`  - Minify: ${minify ? 'Yes' : 'No'}`)
+      cli.info(`  - Compress: ${compress ? 'Yes' : 'No'}`)
+
+      const spinner = new cli.Spinner('Building assets...')
+      spinner.start()
+
+      // TODO: Run build process
+      await new Promise(resolve => setTimeout(resolve, 4000))
+
+      spinner.succeed('Assets built successfully')
+
+      cli.success('\nBuild complete!')
+      cli.info('\nOutput:')
+      cli.info('  - JS: 2.3 MB > 456 KB (80% reduction)')
+      cli.info('  - CSS: 890 KB > 123 KB (86% reduction)')
+      cli.info('  - Images: 15.2 MB > 8.9 MB (41% reduction)')
+      cli.info('\nBuild directory: ./dist')
+    })
+
+  app
+    .command('assets:optimize:images', 'Optimize images')
+    .option('--quality <quality>', 'Image quality (1-100)', { default: '85' })
+    .action(async (options?: { quality?: string }) => {
+      const quality = options?.quality || '85'
+
+      cli.header('Optimizing Images')
+
+      cli.info(`Quality: ${quality}%`)
+
+      const spinner = new cli.Spinner('Optimizing images...')
+      spinner.start()
+
+      // TODO: Optimize images
+      await new Promise(resolve => setTimeout(resolve, 3000))
+
+      spinner.succeed('Images optimized')
+
+      cli.success('\nOptimization complete!')
+      cli.info('\nResults:')
+      cli.info('  - Processed: 127 images')
+      cli.info('  - Original: 15.2 MB')
+      cli.info('  - Optimized: 8.9 MB')
+      cli.info('  - Savings: 6.3 MB (41%)')
+    })
+
+  app
+    .command('images:optimize', 'Optimize and compress images')
+    .option('--dir <directory>', 'Directory to optimize', { default: './public/images' })
+    .action(async (options?: { dir?: string }) => {
+      const dir = options?.dir || './public/images'
+
+      cli.header('Optimizing Images')
+
+      cli.info(`Directory: ${dir}`)
+
+      const spinner = new cli.Spinner('Optimizing images...')
+      spinner.start()
+
+      // TODO: Optimize images in directory
+      await new Promise(resolve => setTimeout(resolve, 3000))
+
+      spinner.succeed('Images optimized')
+
+      cli.success('\nOptimization complete!')
+      cli.info('\nResults:')
+      cli.info('  - PNG: 45 files, 3.2 MB > 1.8 MB (44% savings)')
+      cli.info('  - JPG: 82 files, 12.0 MB > 7.1 MB (41% savings)')
+      cli.info('  - Total savings: 6.3 MB')
+    })
+
+  app
+    .command('assets:deploy', 'Deploy static assets to S3')
+    .option('--source <path>', 'Source directory', { default: 'dist' })
+    .option('--bucket <name>', 'S3 bucket name')
+    .option('--prefix <prefix>', 'S3 prefix/folder')
+    .option('--delete', 'Delete files not in source')
+    .option('--cache-control <value>', 'Cache-Control header', { default: 'public, max-age=31536000' })
+    .action(async (options?: { source?: string, bucket?: string, prefix?: string, delete?: boolean, cacheControl?: string }) => {
+      cli.header('Deploying Assets to S3')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        const source = options?.source || 'dist'
+        const bucket = options?.bucket
+        const prefix = options?.prefix
+        const shouldDelete = options?.delete || false
+        const cacheControl = options?.cacheControl || 'public, max-age=31536000'
+
+        if (!bucket) {
+          cli.error('--bucket is required')
+          return
+        }
+
+        // Check if source directory exists
+        if (!existsSync(source)) {
+          cli.error(`Source directory not found: ${source}`)
+          return
+        }
+
+        cli.info(`Source: ${source}`)
+        cli.info(`Bucket: s3://${bucket}${prefix ? `/${prefix}` : ''}`)
+        cli.info(`Cache-Control: ${cacheControl}`)
+        if (shouldDelete) {
+          cli.warn('Delete mode enabled - files not in source will be removed')
+        }
+
+        const confirmed = await cli.confirm('\nDeploy assets now?', true)
+        if (!confirmed) {
+          cli.info('Deployment cancelled')
+          return
+        }
+
+        const s3 = new S3Client(region)
+
+        const spinner = new cli.Spinner('Uploading assets to S3...')
+        spinner.start()
+
+        await s3.sync({
+          source,
+          bucket,
+          prefix,
+          delete: shouldDelete,
+          cacheControl,
+          acl: 'public-read',
+        })
+
+        spinner.succeed('Assets deployed successfully!')
+
+        // Get bucket size
+        const size = await s3.getBucketSize(bucket, prefix)
+        const sizeInMB = (size / 1024 / 1024).toFixed(2)
+
+        cli.success(`\nDeployment complete!`)
+        cli.info(`Total size: ${sizeInMB} MB`)
+        cli.info(`\nAssets URL: https://${bucket}.s3.${region}.amazonaws.com${prefix ? `/${prefix}` : ''}`)
+      }
+      catch (error: any) {
+        cli.error(`Deployment failed: ${error.message}`)
+      }
+    })
+
+  app
+    .command('assets:invalidate', 'Invalidate CloudFront cache')
+    .option('--distribution <id>', 'CloudFront distribution ID')
+    .option('--paths <paths>', 'Paths to invalidate (comma-separated)', { default: '/*' })
+    .option('--wait', 'Wait for invalidation to complete')
+    .action(async (options?: { distribution?: string, paths?: string, wait?: boolean }) => {
+      cli.header('Invalidating CloudFront Cache')
+
+      try {
+        const distributionId = options?.distribution
+
+        if (!distributionId) {
+          cli.error('--distribution is required')
+          return
+        }
+
+        const pathsStr = options?.paths || '/*'
+        const paths = pathsStr.split(',').map(p => p.trim())
+        const shouldWait = options?.wait || false
+
+        cli.info(`Distribution: ${distributionId}`)
+        cli.info(`Paths: ${paths.join(', ')}`)
+
+        const confirmed = await cli.confirm('\nInvalidate cache now?', true)
+        if (!confirmed) {
+          cli.info('Invalidation cancelled')
+          return
+        }
+
+        const cloudfront = new CloudFrontClient()
+
+        const spinner = new cli.Spinner('Creating invalidation...')
+        spinner.start()
+
+        const invalidation = await cloudfront.invalidatePaths(distributionId, paths)
+
+        spinner.succeed('Invalidation created')
+
+        cli.success(`\nInvalidation ID: ${invalidation.Id}`)
+        cli.info(`Status: ${invalidation.Status}`)
+        cli.info(`Created: ${new Date(invalidation.CreateTime).toLocaleString()}`)
+
+        if (shouldWait) {
+          const waitSpinner = new cli.Spinner('Waiting for invalidation to complete...')
+          waitSpinner.start()
+
+          await cloudfront.waitForInvalidation(distributionId, invalidation.Id)
+
+          waitSpinner.succeed('Invalidation completed!')
+        }
+        else {
+          cli.info('\nInvalidation is in progress. Use --wait to wait for completion.')
+        }
+      }
+      catch (error: any) {
+        cli.error(`Invalidation failed: ${error.message}`)
+      }
+    })
+}