@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/sms/handlers/send.ts

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

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

package/src/stack-diff.ts

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

@@ -1,85 +0,0 @@
-/**
- * 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()