@stacksjs/ts-cloud-core 0.1.1

package/src/sms/handlers/send.ts

@@ -0,0 +1,174 @@
+/**
+ * SMS Send Lambda Handler
+ *
+ * Sends SMS messages:
+ * - Send SMS via Pinpoint/SNS
+ * - Handle templated messages
+ * - Track delivery status
+ */
+
+export const handler = `
+const { PinpointClient, SendMessagesCommand } = require('@aws-sdk/client-pinpoint');
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+const { DynamoDBClient, PutItemCommand } = require('@aws-sdk/client-dynamodb');
+
+const pinpoint = new PinpointClient({});
+const sns = new SNSClient({});
+const dynamodb = new DynamoDBClient({});
+
+exports.handler = async (event) => {
+  console.log('SMS send event:', JSON.stringify(event, null, 2));
+
+  const applicationId = process.env.PINPOINT_APP_ID;
+  const messageLogTable = process.env.MESSAGE_LOG_TABLE;
+  const senderId = process.env.SMS_SENDER_ID;
+  const originationNumber = process.env.SMS_ORIGINATION_NUMBER;
+
+  // Handle both direct invocation and SQS/SNS events
+  const messages = event.Records
+    ? event.Records.map(r => JSON.parse(r.body || r.Sns?.Message || '{}'))
+    : [event];
+
+  const results = [];
+
+  for (const message of messages) {
+    try {
+      const {
+        to,
+        body,
+        template,
+        templateData,
+        messageType = 'TRANSACTIONAL',
+      } = message;
+
+      if (!to || (!body && !template)) {
+        console.log('Missing required fields (to, body/template)');
+        continue;
+      }
+
+      // Resolve template if provided
+      let messageBody = body;
+      if (template && templateData) {
+        messageBody = resolveTemplate(template, templateData);
+      }
+
+      const messageId = \`sms-\${Date.now()}-\${Math.random().toString(36).substr(2)}\`;
+
+      // Send via Pinpoint if app ID is configured
+      if (applicationId) {
+        const sendResult = await pinpoint.send(new SendMessagesCommand({
+          ApplicationId: applicationId,
+          MessageRequest: {
+            Addresses: {
+              [to]: {
+                ChannelType: 'SMS',
+              },
+            },
+            MessageConfiguration: {
+              SMSMessage: {
+                Body: messageBody,
+                MessageType: messageType,
+                SenderId: senderId,
+                OriginationNumber: originationNumber,
+              },
+            },
+          },
+        }));
+
+        const result = sendResult.MessageResponse?.Result?.[to] || {};
+
+        // Log message
+        if (messageLogTable) {
+          await dynamodb.send(new PutItemCommand({
+            TableName: messageLogTable,
+            Item: {
+              messageId: { S: result.MessageId || messageId },
+              to: { S: to },
+              body: { S: messageBody },
+              messageType: { S: messageType },
+              deliveryStatus: { S: result.DeliveryStatus || 'UNKNOWN' },
+              statusCode: { N: String(result.StatusCode || 0) },
+              statusMessage: { S: result.StatusMessage || '' },
+              sentAt: { S: new Date().toISOString() },
+              ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) },
+            },
+          }));
+        }
+
+        results.push({
+          to,
+          messageId: result.MessageId || messageId,
+          status: result.DeliveryStatus,
+          statusCode: result.StatusCode,
+        });
+
+      } else {
+        // Fallback to SNS
+        const snsResult = await sns.send(new PublishCommand({
+          PhoneNumber: to,
+          Message: messageBody,
+          MessageAttributes: {
+            'AWS.SNS.SMS.SMSType': {
+              DataType: 'String',
+              StringValue: messageType === 'PROMOTIONAL' ? 'Promotional' : 'Transactional',
+            },
+            ...(senderId && {
+              'AWS.SNS.SMS.SenderID': {
+                DataType: 'String',
+                StringValue: senderId,
+              },
+            }),
+          },
+        }));
+
+        // Log message
+        if (messageLogTable) {
+          await dynamodb.send(new PutItemCommand({
+            TableName: messageLogTable,
+            Item: {
+              messageId: { S: snsResult.MessageId || messageId },
+              to: { S: to },
+              body: { S: messageBody },
+              messageType: { S: messageType },
+              deliveryStatus: { S: 'SENT' },
+              sentAt: { S: new Date().toISOString() },
+              ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) },
+            },
+          }));
+        }
+
+        results.push({
+          to,
+          messageId: snsResult.MessageId || messageId,
+          status: 'SENT',
+        });
+      }
+
+      console.log(\`SMS sent to \${to}: \${results[results.length - 1].status}\`);
+
+    } catch (error) {
+      console.error('Error sending SMS:', error);
+      results.push({
+        to: message.to,
+        error: error.message,
+        status: 'FAILED',
+      });
+    }
+  }
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ results }),
+  };
+};
+
+function resolveTemplate(template, data) {
+  let result = template;
+  for (const [key, value] of Object.entries(data)) {
+    result = result.replace(new RegExp(\`{{\\\\s*\${key}\\\\s*}}\`, 'g'), value);
+  }
+  return result;
+}
+`
+
+export default handler

package/src/sms/index.ts

@@ -0,0 +1,9 @@
+/**
+ * SMS Advanced Features
+ */
+
+// Advanced features
+export * as SmsAdvanced from './advanced'
+
+// Handlers (namespaced)
+export * as SmsHandlers from './handlers/send'

package/src/stack-diff.ts

@@ -0,0 +1,389 @@
+/**
+ * Stack Diff Analyzer
+ * Analyzes differences between CloudFormation templates for stack updates
+ */
+
+import type { CloudFormationResource, CloudFormationTemplate } from '@stacksjs/ts-cloud-aws-types'
+
+export interface ResourceDiff {
+  logicalId: string
+  action: 'add' | 'remove' | 'update' | 'replace'
+  resourceType: string
+  changes?: PropertyChange[]
+  reason?: string
+}
+
+export interface PropertyChange {
+  path: string
+  oldValue: any
+  newValue: any
+  requiresReplacement?: boolean
+}
+
+export interface StackDiff {
+  added: ResourceDiff[]
+  removed: ResourceDiff[]
+  updated: ResourceDiff[]
+  replaced: ResourceDiff[]
+  unchanged: string[]
+  summary: {
+    totalChanges: number
+    requiresReplacement: boolean
+    dangerousChanges: string[]
+  }
+}
+
+/**
+ * Analyze differences between two CloudFormation templates
+ */
+export function analyzeStackDiff(
+  oldTemplate: CloudFormationTemplate,
+  newTemplate: CloudFormationTemplate,
+): StackDiff {
+  const added: ResourceDiff[] = []
+  const removed: ResourceDiff[] = []
+  const updated: ResourceDiff[] = []
+  const replaced: ResourceDiff[] = []
+  const unchanged: string[] = []
+
+  const oldResources = oldTemplate.Resources || {}
+  const newResources = newTemplate.Resources || {}
+
+  const allLogicalIds = new Set([
+    ...Object.keys(oldResources),
+    ...Object.keys(newResources),
+  ])
+
+  for (const logicalId of allLogicalIds) {
+    const oldResource = oldResources[logicalId]
+    const newResource = newResources[logicalId]
+
+    if (!oldResource && newResource) {
+      // Resource added
+      added.push({
+        logicalId,
+        action: 'add',
+        resourceType: newResource.Type,
+      })
+    }
+    else if (oldResource && !newResource) {
+      // Resource removed
+      removed.push({
+        logicalId,
+        action: 'remove',
+        resourceType: oldResource.Type,
+      })
+    }
+    else if (oldResource && newResource) {
+      // Resource exists in both - check for changes
+      if (oldResource.Type !== newResource.Type) {
+        // Type changed - this is a replacement
+        replaced.push({
+          logicalId,
+          action: 'replace',
+          resourceType: newResource.Type,
+          reason: `Type changed from ${oldResource.Type} to ${newResource.Type}`,
+        })
+      }
+      else {
+        const changes = compareProperties(
+          oldResource.Properties || {},
+          newResource.Properties || {},
+        )
+
+        if (changes.length > 0) {
+          const requiresReplacement = checkIfReplacementRequired(
+            oldResource.Type,
+            changes,
+          )
+
+          if (requiresReplacement) {
+            replaced.push({
+              logicalId,
+              action: 'replace',
+              resourceType: newResource.Type,
+              changes,
+              reason: 'Property changes require replacement',
+            })
+          }
+          else {
+            updated.push({
+              logicalId,
+              action: 'update',
+              resourceType: newResource.Type,
+              changes,
+            })
+          }
+        }
+        else {
+          unchanged.push(logicalId)
+        }
+      }
+    }
+  }
+
+  const dangerousChanges = identifyDangerousChanges([
+    ...removed,
+    ...replaced,
+    ...updated,
+  ])
+
+  return {
+    added,
+    removed,
+    updated,
+    replaced,
+    unchanged,
+    summary: {
+      totalChanges: added.length + removed.length + updated.length + replaced.length,
+      requiresReplacement: replaced.length > 0,
+      dangerousChanges,
+    },
+  }
+}
+
+/**
+ * Compare properties of two resources
+ */
+function compareProperties(
+  oldProps: Record<string, any>,
+  newProps: Record<string, any>,
+  path = '',
+): PropertyChange[] {
+  const changes: PropertyChange[] = []
+  const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)])
+
+  for (const key of allKeys) {
+    const currentPath = path ? `${path}.${key}` : key
+    const oldValue = oldProps[key]
+    const newValue = newProps[key]
+
+    if (oldValue === undefined && newValue !== undefined) {
+      changes.push({
+        path: currentPath,
+        oldValue: undefined,
+        newValue,
+      })
+    }
+    else if (oldValue !== undefined && newValue === undefined) {
+      changes.push({
+        path: currentPath,
+        oldValue,
+        newValue: undefined,
+      })
+    }
+    else if (typeof oldValue !== typeof newValue) {
+      changes.push({
+        path: currentPath,
+        oldValue,
+        newValue,
+      })
+    }
+    else if (typeof oldValue === 'object' && oldValue !== null) {
+      if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+        if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+          changes.push({
+            path: currentPath,
+            oldValue,
+            newValue,
+          })
+        }
+      }
+      else if (!Array.isArray(oldValue) && !Array.isArray(newValue)) {
+        const nestedChanges = compareProperties(oldValue, newValue, currentPath)
+        changes.push(...nestedChanges)
+      }
+      else {
+        changes.push({
+          path: currentPath,
+          oldValue,
+          newValue,
+        })
+      }
+    }
+    else if (oldValue !== newValue) {
+      changes.push({
+        path: currentPath,
+        oldValue,
+        newValue,
+      })
+    }
+  }
+
+  return changes
+}
+
+/**
+ * Check if property changes require resource replacement
+ * Based on CloudFormation resource specifications
+ */
+function checkIfReplacementRequired(
+  resourceType: string,
+  changes: PropertyChange[],
+): boolean {
+  // Map of resource types to properties that require replacement
+  const replacementProperties: Record<string, Set<string>> = {
+    'AWS::S3::Bucket': new Set(['BucketName']),
+    'AWS::DynamoDB::Table': new Set(['TableName', 'KeySchema']),
+    'AWS::RDS::DBInstance': new Set(['DBInstanceIdentifier', 'DBName', 'Engine']),
+    'AWS::Lambda::Function': new Set(['FunctionName']), // Changed in some cases
+    'AWS::EC2::Instance': new Set(['ImageId', 'InstanceType', 'KeyName']),
+    'AWS::ECS::TaskDefinition': new Set(['Family', 'ContainerDefinitions']),
+    'AWS::ElastiCache::CacheCluster': new Set(['CacheNodeType', 'Engine']),
+    'AWS::CloudFront::Distribution': new Set([]), // Most properties can be updated
+    'AWS::Route53::HostedZone': new Set(['Name']),
+    'AWS::IAM::Role': new Set(['RoleName', 'Path']),
+    'AWS::KMS::Key': new Set(['KeyPolicy']), // Some properties require replacement
+    'AWS::Cognito::UserPool': new Set(['UserPoolName']),
+    'AWS::OpenSearchService::Domain': new Set(['DomainName']),
+  }
+
+  const replaceProps = replacementProperties[resourceType]
+  if (!replaceProps) {
+    // Unknown resource type - assume updates might require replacement
+    return false
+  }
+
+  for (const change of changes) {
+    const topLevelProp = change.path.split('.')[0]
+    if (replaceProps.has(topLevelProp)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Identify potentially dangerous changes
+ */
+function identifyDangerousChanges(diffs: ResourceDiff[]): string[] {
+  const dangerous: string[] = []
+
+  for (const diff of diffs) {
+    // Removing databases is dangerous
+    if (diff.action === 'remove' && (
+      diff.resourceType === 'AWS::RDS::DBInstance'
+      || diff.resourceType === 'AWS::DynamoDB::Table'
+      || diff.resourceType === 'AWS::ElastiCache::CacheCluster'
+    )) {
+      dangerous.push(`Removing ${diff.resourceType} ${diff.logicalId} - data loss risk!`)
+    }
+
+    // Replacing databases is dangerous
+    if (diff.action === 'replace' && (
+      diff.resourceType === 'AWS::RDS::DBInstance'
+      || diff.resourceType === 'AWS::DynamoDB::Table'
+    )) {
+      dangerous.push(`Replacing ${diff.resourceType} ${diff.logicalId} - data loss risk!`)
+    }
+
+    // Removing/replacing S3 buckets
+    if ((diff.action === 'remove' || diff.action === 'replace')
+      && diff.resourceType === 'AWS::S3::Bucket') {
+      dangerous.push(`${diff.action === 'remove' ? 'Removing' : 'Replacing'} S3 bucket ${diff.logicalId} - data loss risk!`)
+    }
+
+    // Replacing EC2 instances
+    if (diff.action === 'replace' && diff.resourceType === 'AWS::EC2::Instance') {
+      dangerous.push(`Replacing EC2 instance ${diff.logicalId} - downtime expected`)
+    }
+
+    // Security group changes
+    if (diff.action === 'update' && diff.resourceType === 'AWS::EC2::SecurityGroup') {
+      dangerous.push(`Updating security group ${diff.logicalId} - may affect connectivity`)
+    }
+
+    // IAM role/policy changes
+    if ((diff.action === 'update' || diff.action === 'replace') && (
+      diff.resourceType === 'AWS::IAM::Role'
+      || diff.resourceType === 'AWS::IAM::Policy'
+    )) {
+      dangerous.push(`Modifying IAM ${diff.resourceType.split('::')[2]} ${diff.logicalId} - may affect permissions`)
+    }
+  }
+
+  return dangerous
+}
+
+/**
+ * Format diff for display
+ */
+export function formatDiff(diff: StackDiff): string {
+  const lines: string[] = []
+
+  lines.push('=== Stack Update Analysis ===\n')
+
+  if (diff.summary.totalChanges === 0) {
+    lines.push('No changes detected.\n')
+    return lines.join('\n')
+  }
+
+  lines.push(`Total changes: ${diff.summary.totalChanges}`)
+  lines.push(`Requires replacement: ${diff.summary.requiresReplacement ? 'Yes' : 'No'}\n`)
+
+  if (diff.summary.dangerousChanges.length > 0) {
+    lines.push('⚠️  DANGEROUS CHANGES DETECTED:')
+    for (const warning of diff.summary.dangerousChanges) {
+      lines.push(`  • ${warning}`)
+    }
+    lines.push('')
+  }
+
+  if (diff.added.length > 0) {
+    lines.push(`✅ Resources to Add (${diff.added.length}):`)
+    for (const resource of diff.added) {
+      lines.push(`  + ${resource.logicalId} (${resource.resourceType})`)
+    }
+    lines.push('')
+  }
+
+  if (diff.removed.length > 0) {
+    lines.push(`❌ Resources to Remove (${diff.removed.length}):`)
+    for (const resource of diff.removed) {
+      lines.push(`  - ${resource.logicalId} (${resource.resourceType})`)
+    }
+    lines.push('')
+  }
+
+  if (diff.replaced.length > 0) {
+    lines.push(`🔄 Resources to Replace (${diff.replaced.length}):`)
+    for (const resource of diff.replaced) {
+      lines.push(`  ~ ${resource.logicalId} (${resource.resourceType})`)
+      if (resource.reason) {
+        lines.push(`    Reason: ${resource.reason}`)
+      }
+      if (resource.changes) {
+        for (const change of resource.changes.slice(0, 3)) {
+          lines.push(`    • ${change.path}: ${JSON.stringify(change.oldValue)} → ${JSON.stringify(change.newValue)}`)
+        }
+        if (resource.changes.length > 3) {
+          lines.push(`    ... and ${resource.changes.length - 3} more changes`)
+        }
+      }
+    }
+    lines.push('')
+  }
+
+  if (diff.updated.length > 0) {
+    lines.push(`📝 Resources to Update (${diff.updated.length}):`)
+    for (const resource of diff.updated) {
+      lines.push(`  ~ ${resource.logicalId} (${resource.resourceType})`)
+      if (resource.changes) {
+        for (const change of resource.changes.slice(0, 3)) {
+          lines.push(`    • ${change.path}: ${JSON.stringify(change.oldValue)} → ${JSON.stringify(change.newValue)}`)
+        }
+        if (resource.changes.length > 3) {
+          lines.push(`    ... and ${resource.changes.length - 3} more changes`)
+        }
+      }
+    }
+    lines.push('')
+  }
+
+  if (diff.unchanged.length > 0) {
+    lines.push(`⚪ Unchanged Resources (${diff.unchanged.length})`)
+  }
+
+  return lines.join('\n')
+}

package/src/static-site/index.ts

@@ -0,0 +1,85 @@
+/**
+ * Static Site Advanced Features
+ * Asset optimization, image optimization, SSG support, and prerendering
+ */
+
+export interface AssetOptimization {
+  id: string
+  name: string
+  minify: boolean
+  compress: boolean
+  compressionType: 'gzip' | 'brotli' | 'both'
+  sourceMaps: boolean
+  cacheControl: string
+}
+
+export interface ImageOptimization {
+  id: string
+  formats: Array<'webp' | 'avif' | 'jpeg' | 'png'>
+  quality: number
+  responsive: boolean
+  lazy: boolean
+  sizes: number[]
+}
+
+export interface SSGConfig {
+  id: string
+  framework: 'next' | 'gatsby' | 'astro' | 'hugo' | 'eleventy'
+  outputDir: string
+  buildCommand: string
+  routes: string[]
+}
+
+export interface PrerenderConfig {
+  id: string
+  routes: string[]
+  fallback: 'blocking' | 'static' | false
+  revalidate?: number
+}
+
+export class StaticSiteManager {
+  private optimizations: Map<string, AssetOptimization> = new Map()
+  private imageConfigs: Map<string, ImageOptimization> = new Map()
+  private ssgConfigs: Map<string, SSGConfig> = new Map()
+  private prerenderConfigs: Map<string, PrerenderConfig> = new Map()
+  private counter = 0
+
+  createAssetOptimization(config: Omit<AssetOptimization, 'id'>): AssetOptimization {
+    const id = `asset-opt-${Date.now()}-${this.counter++}`
+    const optimization = { id, ...config }
+    this.optimizations.set(id, optimization)
+    return optimization
+  }
+
+  createImageOptimization(config: Omit<ImageOptimization, 'id'>): ImageOptimization {
+    const id = `image-opt-${Date.now()}-${this.counter++}`
+    const optimization = { id, ...config }
+    this.imageConfigs.set(id, optimization)
+    return optimization
+  }
+
+  createSSGConfig(config: Omit<SSGConfig, 'id'>): SSGConfig {
+    const id = `ssg-${Date.now()}-${this.counter++}`
+    const ssgConfig = { id, ...config }
+    this.ssgConfigs.set(id, ssgConfig)
+    return ssgConfig
+  }
+
+  createPrerenderConfig(config: Omit<PrerenderConfig, 'id'>): PrerenderConfig {
+    const id = `prerender-${Date.now()}-${this.counter++}`
+    const prerenderConfig = { id, ...config }
+    this.prerenderConfigs.set(id, prerenderConfig)
+    return prerenderConfig
+  }
+
+  listOptimizations(): AssetOptimization[] { return Array.from(this.optimizations.values()) }
+  listImageConfigs(): ImageOptimization[] { return Array.from(this.imageConfigs.values()) }
+  clear(): void {
+    this.optimizations.clear()
+    this.imageConfigs.clear()
+    this.ssgConfigs.clear()
+    this.prerenderConfigs.clear()
+  }
+}
+
+export const staticSiteManager: StaticSiteManager = new StaticSiteManager()