@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/sms/advanced/mms.d.ts

@@ -0,0 +1,35 @@
+/**
+ * MMS Support (Images, Media)
+ *
+ * Provides multimedia messaging capabilities
+ */
+export declare interface MmsMessage {
+  to: string
+  body?: string
+  mediaUrls: string[]
+  mediaType?: 'image' | 'video' | 'audio' | 'document'
+  fallbackSms?: string
+}
+export declare interface MmsMedia {
+  url: string
+  contentType: string
+  size: number
+  filename?: string
+}
+/**
+ * MMS Module
+ */
+export declare class MmsSupport {
+  static MmsSenderCode: any;
+  static createMediaBucket(config: { slug: string }): Record<string, any>;
+  static createMmsSenderLambda(config: {
+    slug: string
+    roleArn: string
+    mediaBucket: string
+    messageLogTable: string
+    originationNumber?: string
+  }): Record<string, any>;
+  static readonly SupportedMediaTypes: any;
+  static readonly MediaSizeLimits: { image: number, video: number, audio: number };
+}
+export default MmsSupport;

package/dist/sms/handlers/delivery-status.d.ts

@@ -0,0 +1,131 @@
+/**
+ * SMS Delivery Status Lambda Handler
+ *
+ * Processes delivery status updates:
+ * - Process delivery receipts
+ * - Update message status
+ * - Handle failures
+ */
+export declare const handler: `
+const { DynamoDBClient, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+
+const dynamodb = new DynamoDBClient({});
+const sns = new SNSClient({});
+
+exports.handler = async (event) => {
+  console.log('SMS delivery status event:', JSON.stringify(event, null, 2));
+
+  const messageLogTable = process.env.MESSAGE_LOG_TABLE;
+  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;
+  const webhookUrl = process.env.WEBHOOK_URL;
+
+  for (const record of event.Records) {
+    try {
+      // Parse delivery status from SNS/Pinpoint
+      const message = JSON.parse(record.Sns?.Message || record.body || '{}');
+
+      const {
+        eventType,
+        messageId,
+        destinationPhoneNumber,
+        messageStatus,
+        messageStatusDescription,
+        isoCountryCode,
+        mcc,
+        mnc,
+        priceInMillicentsUSD,
+      } = message;
+
+      if (!messageId) {
+        console.log('No messageId in delivery status');
+        continue;
+      }
+
+      const timestamp = new Date().toISOString();
+      const status = messageStatus || eventType || 'UNKNOWN';
+
+      console.log(\`Delivery status for \${messageId}: \${status}\`);
+
+      // Update message log
+      if (messageLogTable) {
+        await dynamodb.send(new UpdateItemCommand({
+          TableName: messageLogTable,
+          Key: {
+            messageId: { S: messageId },
+          },
+          UpdateExpression: 'SET deliveryStatus = :status, statusDescription = :desc, deliveredAt = :at, priceMillicents = :price, countryCode = :country',
+          ExpressionAttributeValues: {
+            ':status': { S: status },
+            ':desc': { S: messageStatusDescription || '' },
+            ':at': { S: timestamp },
+            ':price': { N: String(priceInMillicentsUSD || 0) },
+            ':country': { S: isoCountryCode || '' },
+          },
+        }));
+      }
+
+      // Handle failures - notify admin
+      const isFailure = ['FAILED', 'UNREACHABLE', 'UNKNOWN', 'CARRIER_UNREACHABLE', 'BLOCKED', 'CARRIER_BLOCKED', 'INVALID', 'INVALID_MESSAGE', 'OPTED_OUT'].includes(status);
+
+      if (isFailure) {
+        console.log(\`SMS delivery failed: \${status} - \${messageStatusDescription}\`);
+
+        // Send failure notification
+        if (notificationTopicArn) {
+          await sns.send(new PublishCommand({
+            TopicArn: notificationTopicArn,
+            Subject: \`SMS Delivery Failed: \${status}\`,
+            Message: JSON.stringify({
+              type: 'sms_delivery_failed',
+              messageId,
+              to: destinationPhoneNumber,
+              status,
+              description: messageStatusDescription,
+              countryCode: isoCountryCode,
+              timestamp,
+            }, null, 2),
+            MessageAttributes: {
+              eventType: {
+                DataType: 'String',
+                StringValue: 'sms_delivery_failed',
+              },
+            },
+          }));
+        }
+      }
+
+      // Forward to webhook for all status updates
+      if (webhookUrl) {
+        try {
+          await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              event: 'sms_delivery_status',
+              data: {
+                messageId,
+                to: destinationPhoneNumber,
+                status,
+                description: messageStatusDescription,
+                countryCode: isoCountryCode,
+                carrier: { mcc, mnc },
+                priceMillicents: priceInMillicentsUSD,
+                timestamp,
+              },
+            }),
+          });
+        } catch (err) {
+          console.error('Webhook failed:', err.message);
+        }
+      }
+
+    } catch (error) {
+      console.error('Error processing delivery status:', error);
+    }
+  }
+
+  return { statusCode: 200, body: 'OK' };
+};
+`;
+export default handler;

package/dist/sms/handlers/receive.d.ts

@@ -0,0 +1,160 @@
+/**
+ * SMS Receive Lambda Handler
+ *
+ * Processes inbound SMS messages:
+ * - Process inbound SMS (two-way)
+ * - Handle opt-out keywords
+ * - Forward to webhook
+ */
+export declare const handler: `
+const { DynamoDBClient, PutItemCommand, GetItemCommand, DeleteItemCommand } = require('@aws-sdk/client-dynamodb');
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+
+const dynamodb = new DynamoDBClient({});
+const sns = new SNSClient({});
+
+const OPT_OUT_KEYWORDS = ['STOP', 'UNSUBSCRIBE', 'CANCEL', 'END', 'QUIT', 'OPTOUT', 'OPT OUT'];
+const OPT_IN_KEYWORDS = ['START', 'SUBSCRIBE', 'OPTIN', 'OPT IN', 'YES'];
+
+exports.handler = async (event) => {
+  console.log('SMS receive event:', JSON.stringify(event, null, 2));
+
+  const optOutTable = process.env.OPT_OUT_TABLE;
+  const messageLogTable = process.env.MESSAGE_LOG_TABLE;
+  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;
+  const webhookUrl = process.env.WEBHOOK_URL;
+
+  for (const record of event.Records) {
+    try {
+      // Parse SNS message from Pinpoint
+      const message = JSON.parse(record.Sns?.Message || record.body || '{}');
+
+      const {
+        originationNumber,
+        destinationNumber,
+        messageBody,
+        messageKeyword,
+        inboundMessageId,
+      } = message;
+
+      if (!originationNumber || !messageBody) {
+        console.log('Missing required fields');
+        continue;
+      }
+
+      const timestamp = new Date().toISOString();
+      const normalizedBody = messageBody.trim().toUpperCase();
+
+      // Check for opt-out keywords
+      if (OPT_OUT_KEYWORDS.some(kw => normalizedBody === kw || normalizedBody.startsWith(kw + ' '))) {
+        console.log(\`Opt-out request from \${originationNumber}\`);
+
+        if (optOutTable) {
+          await dynamodb.send(new PutItemCommand({
+            TableName: optOutTable,
+            Item: {
+              phoneNumber: { S: originationNumber },
+              optedOutAt: { S: timestamp },
+              keyword: { S: normalizedBody.split(' ')[0] },
+              originalMessage: { S: messageBody },
+            },
+          }));
+        }
+
+        // Send confirmation (optional - check carrier requirements)
+        // await sendOptOutConfirmation(originationNumber, destinationNumber);
+
+        continue;
+      }
+
+      // Check for opt-in keywords
+      if (OPT_IN_KEYWORDS.some(kw => normalizedBody === kw || normalizedBody.startsWith(kw + ' '))) {
+        console.log(\`Opt-in request from \${originationNumber}\`);
+
+        if (optOutTable) {
+          await dynamodb.send(new DeleteItemCommand({
+            TableName: optOutTable,
+            Key: {
+              phoneNumber: { S: originationNumber },
+            },
+          }));
+        }
+
+        continue;
+      }
+
+      // Log inbound message
+      if (messageLogTable) {
+        await dynamodb.send(new PutItemCommand({
+          TableName: messageLogTable,
+          Item: {
+            messageId: { S: inboundMessageId || \`inbound-\${Date.now()}\` },
+            direction: { S: 'inbound' },
+            from: { S: originationNumber },
+            to: { S: destinationNumber },
+            body: { S: messageBody },
+            keyword: { S: messageKeyword || '' },
+            receivedAt: { S: timestamp },
+            ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) },
+          },
+        }));
+      }
+
+      // Send SNS notification
+      if (notificationTopicArn) {
+        await sns.send(new PublishCommand({
+          TopicArn: notificationTopicArn,
+          Subject: 'Inbound SMS',
+          Message: JSON.stringify({
+            type: 'inbound_sms',
+            from: originationNumber,
+            to: destinationNumber,
+            body: messageBody,
+            keyword: messageKeyword,
+            timestamp,
+          }, null, 2),
+          MessageAttributes: {
+            eventType: {
+              DataType: 'String',
+              StringValue: 'inbound_sms',
+            },
+          },
+        }));
+      }
+
+      // Forward to webhook
+      if (webhookUrl) {
+        try {
+          const response = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              event: 'inbound_sms',
+              data: {
+                from: originationNumber,
+                to: destinationNumber,
+                body: messageBody,
+                keyword: messageKeyword,
+                messageId: inboundMessageId,
+                timestamp,
+              },
+            }),
+          });
+
+          console.log(\`Webhook response: \${response.status}\`);
+        } catch (err) {
+          console.error('Webhook failed:', err.message);
+        }
+      }
+
+      console.log(\`Processed inbound SMS from \${originationNumber}\`);
+
+    } catch (error) {
+      console.error('Error processing inbound SMS:', error);
+    }
+  }
+
+  return { statusCode: 200, body: 'OK' };
+};
+`;
+export default handler;

package/dist/sms/handlers/send.d.ts

@@ -0,0 +1,172 @@
+/**
+ * SMS Send Lambda Handler
+ *
+ * Sends SMS messages:
+ * - Send SMS via Pinpoint/SNS
+ * - Handle templated messages
+ * - Track delivery status
+ */
+export declare 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/dist/sms/index.d.ts

@@ -0,0 +1,2 @@
+export * as SmsAdvanced from './advanced';
+export * as SmsHandlers from './handlers/send';

package/dist/stack-diff.d.ts

@@ -0,0 +1,34 @@
+import type { CloudFormationTemplate } from '@stacksjs/ts-cloud-aws-types';
+/**
+ * Analyze differences between two CloudFormation templates
+ */
+export declare function analyzeStackDiff(oldTemplate: CloudFormationTemplate, newTemplate: CloudFormationTemplate): StackDiff;
+/**
+ * Format diff for display
+ */
+export declare function formatDiff(diff: StackDiff): string;
+export declare interface ResourceDiff {
+  logicalId: string
+  action: 'add' | 'remove' | 'update' | 'replace'
+  resourceType: string
+  changes?: PropertyChange[]
+  reason?: string
+}
+export declare interface PropertyChange {
+  path: string
+  oldValue: any
+  newValue: any
+  requiresReplacement?: boolean
+}
+export declare interface StackDiff {
+  added: ResourceDiff[]
+  removed: ResourceDiff[]
+  updated: ResourceDiff[]
+  replaced: ResourceDiff[]
+  unchanged: string[]
+  summary: {
+    totalChanges: number
+    requiresReplacement: boolean
+    dangerousChanges: string[]
+  }
+}

package/dist/static-site/index.d.ts

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

package/dist/template-builder.d.ts

@@ -0,0 +1,14 @@
+import type { CloudFormationResource, CloudFormationTemplate } from '@stacksjs/ts-cloud-aws-types';
+export declare class TemplateBuilder {
+  private template: CloudFormationTemplate;
+  constructor(description?: string);
+  addResource(logicalId: string, resource: CloudFormationResource): this;
+  addResources(resources: Record<string, CloudFormationResource>): this;
+  addParameter(name: string, parameter: NonNullable<CloudFormationTemplate['Parameters']>[string]): this;
+  addOutput(name: string, output: NonNullable<CloudFormationTemplate['Outputs']>[string]): this;
+  getResources(): Record<string, CloudFormationResource>;
+  build(): CloudFormationTemplate;
+  toJSON(pretty?: any): string;
+  toYAML(): string;
+  private convertToYAML(obj: any, indent?: any): string;
+}

package/dist/template-validator.d.ts

@@ -0,0 +1,24 @@
+import type { CloudFormationTemplate } from '@stacksjs/ts-cloud-aws-types';
+/**
+ * Validate a CloudFormation template
+ */
+export declare function validateTemplate(template: CloudFormationTemplate): ValidationResult;
+/**
+ * Validate template size
+ */
+export declare function validateTemplateSize(templateJson: string): ValidationResult;
+/**
+ * Validate resource limits
+ */
+export declare function validateResourceLimits(template: CloudFormationTemplate): ValidationResult;
+export declare interface ValidationError {
+  path: string
+  message: string
+  severity: 'error' | 'warning' | 'info'
+}
+export declare interface ValidationResult {
+  valid: boolean
+  errors: ValidationError[]
+  warnings: ValidationError[]
+  info: ValidationError[]
+}

package/dist/utils/cache.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Global template cache instance
+ */
+export declare const templateCache: TemplateCache;
+export declare interface CacheOptions {
+  ttl?: number
+  maxSize?: number
+}
+export declare interface CacheEntry<T> {
+  value: T
+  timestamp: number
+  hash?: string
+}
+/**
+ * Simple in-memory cache with TTL support
+ */
+export declare class Cache<T = any> {
+  private cache: Map<string, CacheEntry<T>>;
+  private ttl: number;
+  private maxSize: number;
+  constructor(options?: CacheOptions);
+  get(key: string): T | undefined;
+  set(key: string, value: T, hash?: string): void;
+  has(key: string): boolean;
+  clear(): void;
+  prune(): void;
+  stats(): { size: number, ttl: number, maxSize: number };
+}
+/**
+ * File-based cache for persistent caching
+ */
+export declare class FileCache<T = any> {
+  private cacheDir: string;
+  private ttl: number;
+  constructor(cacheDir: string, options?: CacheOptions);
+  private getCachePath(key: string): string;
+  get(key: string): T | undefined;
+  set(key: string, value: T, hash?: string): void;
+  has(key: string): boolean;
+  clear(): void;
+  prune(): void;
+}
+/**
+ * Template cache for CloudFormation templates
+ */
+export declare class TemplateCache {
+  private cache: FileCache<string>;
+  constructor(cacheDir?: string);
+  getTemplate(stackName: string): string | undefined;
+  setTemplate(stackName: string, template: string): void;
+  hasChanged(stackName: string, newTemplate: string): boolean;
+  private hashTemplate(template: string): string;
+  clear(): void;
+  prune(): void;
+}