@stacksjs/ts-cloud-core 0.1.1

package/src/phone/handlers/voicemail.ts

@@ -0,0 +1,179 @@
+/**
+ * Voicemail Lambda Handler
+ *
+ * Processes voicemail recordings:
+ * - Processes voicemail recordings from S3
+ * - Transcribes using Amazon Transcribe
+ * - Sends notification with transcription
+ */
+
+export const handler = `
+const { S3Client, GetObjectCommand, PutObjectCommand } = require('@aws-sdk/client-s3');
+const { TranscribeClient, StartTranscriptionJobCommand, GetTranscriptionJobCommand } = require('@aws-sdk/client-transcribe');
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+const { DynamoDBClient, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
+
+const s3 = new S3Client({});
+const transcribe = new TranscribeClient({});
+const sns = new SNSClient({});
+const dynamodb = new DynamoDBClient({});
+
+exports.handler = async (event) => {
+  console.log('Voicemail event:', JSON.stringify(event, null, 2));
+
+  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;
+  const voicemailBucket = process.env.VOICEMAIL_BUCKET;
+  const callLogTable = process.env.CALL_LOG_TABLE;
+  const transcriptionEnabled = process.env.TRANSCRIPTION_ENABLED === 'true';
+
+  for (const record of event.Records) {
+    try {
+      const s3Event = record.s3 || {};
+      const bucket = s3Event.bucket?.name || voicemailBucket;
+      const key = decodeURIComponent(s3Event.object?.key?.replace(/\\+/g, ' ') || '');
+
+      if (!key.includes('voicemail') || !key.endsWith('.wav')) {
+        continue;
+      }
+
+      console.log(\`Processing voicemail: \${key}\`);
+
+      // Extract metadata from key (format: voicemails/{contactId}/{timestamp}.wav)
+      const parts = key.split('/');
+      const contactId = parts[1] || 'unknown';
+      const filename = parts[parts.length - 1];
+      const timestamp = filename.replace('.wav', '');
+
+      // Get voicemail metadata if exists
+      let metadata = {};
+      try {
+        const metaResult = await s3.send(new GetObjectCommand({
+          Bucket: bucket,
+          Key: key.replace('.wav', '.json'),
+        }));
+        metadata = JSON.parse(await metaResult.Body.transformToString());
+      } catch {
+        // No metadata file
+      }
+
+      let transcription = null;
+
+      // Start transcription if enabled
+      if (transcriptionEnabled) {
+        const jobName = \`voicemail-\${contactId}-\${Date.now()}\`;
+
+        await transcribe.send(new StartTranscriptionJobCommand({
+          TranscriptionJobName: jobName,
+          LanguageCode: 'en-US',
+          MediaFormat: 'wav',
+          Media: {
+            MediaFileUri: \`s3://\${bucket}/\${key}\`,
+          },
+          OutputBucketName: bucket,
+          OutputKey: key.replace('.wav', '-transcript.json'),
+        }));
+
+        // Wait for transcription (with timeout)
+        let attempts = 0;
+        const maxAttempts = 30; // 5 minutes max
+
+        while (attempts < maxAttempts) {
+          await new Promise(resolve => setTimeout(resolve, 10000)); // 10 seconds
+
+          const jobResult = await transcribe.send(new GetTranscriptionJobCommand({
+            TranscriptionJobName: jobName,
+          }));
+
+          const status = jobResult.TranscriptionJob?.TranscriptionJobStatus;
+
+          if (status === 'COMPLETED') {
+            // Get transcription result
+            try {
+              const transcriptResult = await s3.send(new GetObjectCommand({
+                Bucket: bucket,
+                Key: key.replace('.wav', '-transcript.json'),
+              }));
+              const transcriptData = JSON.parse(await transcriptResult.Body.transformToString());
+              transcription = transcriptData.results?.transcripts?.[0]?.transcript || '';
+            } catch (err) {
+              console.error('Error getting transcription:', err.message);
+            }
+            break;
+          } else if (status === 'FAILED') {
+            console.error('Transcription failed');
+            break;
+          }
+
+          attempts++;
+        }
+      }
+
+      // Update call log
+      if (callLogTable && contactId !== 'unknown') {
+        await dynamodb.send(new UpdateItemCommand({
+          TableName: callLogTable,
+          Key: {
+            contactId: { S: contactId },
+          },
+          UpdateExpression: 'SET voicemailKey = :key, voicemailTranscript = :transcript, voicemailAt = :at',
+          ExpressionAttributeValues: {
+            ':key': { S: key },
+            ':transcript': { S: transcription || '' },
+            ':at': { S: new Date().toISOString() },
+          },
+        }));
+      }
+
+      // Save voicemail metadata
+      await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: key.replace('.wav', '-metadata.json'),
+        Body: JSON.stringify({
+          contactId,
+          callerNumber: metadata.callerNumber || 'unknown',
+          calledNumber: metadata.calledNumber || 'unknown',
+          duration: metadata.duration || 0,
+          recordedAt: timestamp,
+          processedAt: new Date().toISOString(),
+          transcription,
+          audioKey: key,
+        }, null, 2),
+        ContentType: 'application/json',
+      }));
+
+      // Send notification
+      if (notificationTopicArn) {
+        await sns.send(new PublishCommand({
+          TopicArn: notificationTopicArn,
+          Subject: 'New Voicemail',
+          Message: JSON.stringify({
+            type: 'voicemail',
+            contactId,
+            from: metadata.callerNumber || 'unknown',
+            to: metadata.calledNumber || 'unknown',
+            duration: metadata.duration || 0,
+            transcription: transcription || '(transcription not available)',
+            audioUrl: \`s3://\${bucket}/\${key}\`,
+            timestamp: new Date().toISOString(),
+          }, null, 2),
+          MessageAttributes: {
+            eventType: {
+              DataType: 'String',
+              StringValue: 'voicemail',
+            },
+          },
+        }));
+      }
+
+      console.log(\`Processed voicemail: \${contactId}\`);
+
+    } catch (error) {
+      console.error('Error processing voicemail:', error);
+    }
+  }
+
+  return { statusCode: 200, body: 'OK' };
+};
+`
+
+export default handler

package/src/phone/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Phone/Voice Advanced Features
+ */
+
+// Advanced features
+export * as PhoneAdvanced from './advanced'
+
+// Handlers (namespaced)
+export * as PhoneHandlers from './handlers/incoming-call'

package/src/presets/api-backend.ts

@@ -0,0 +1,134 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+
+/**
+ * API-Only Backend Preset
+ * Perfect for: REST APIs, GraphQL APIs, mobile backends
+ * Includes: API Gateway + Lambda functions + DynamoDB
+ */
+export function createApiBackendPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+}): Partial<CloudConfig> {
+  const { name, slug, domain } = options
+
+  return {
+    project: {
+      name,
+      slug,
+      region: 'us-east-1',
+    },
+    mode: 'serverless',
+    environments: {
+      production: {
+        type: 'production',
+        domain,
+      },
+    },
+    infrastructure: {
+      apiGateway: {
+        type: 'HTTP', // HTTP API is cheaper and simpler
+        cors: {
+          allowOrigins: ['*'],
+          allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
+          allowHeaders: ['Content-Type', 'Authorization'],
+          maxAge: 3600,
+        },
+        customDomain: domain ? {
+          domain,
+          certificateArn: 'TO_BE_GENERATED',
+        } : undefined,
+        throttling: {
+          rateLimit: 10000,
+          burstLimit: 5000,
+        },
+        authorizer: {
+          type: 'JWT',
+          identitySource: '$request.header.Authorization',
+        },
+      },
+      functions: {
+        users: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/api/users.handler',
+          memory: 512,
+          timeout: 30,
+          events: [{
+            type: 'http',
+            path: '/users',
+            method: 'GET',
+          }, {
+            type: 'http',
+            path: '/users',
+            method: 'POST',
+          }],
+        },
+        products: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/api/products.handler',
+          memory: 512,
+          timeout: 30,
+          events: [{
+            type: 'http',
+            path: '/products',
+            method: 'GET',
+          }],
+        },
+      },
+      databases: {
+        dynamodb: {
+          tables: {
+            [`${slug}-users`]: {
+              partitionKey: { name: 'userId', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+              streamEnabled: true,
+              pointInTimeRecovery: true,
+              globalSecondaryIndexes: [{
+                name: 'EmailIndex',
+                partitionKey: { name: 'email', type: 'S' },
+                projection: 'ALL',
+              }],
+            },
+            [`${slug}-products`]: {
+              partitionKey: { name: 'productId', type: 'S' },
+              sortKey: { name: 'category', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+              streamEnabled: false,
+            },
+          },
+        },
+      },
+      cache: {
+        elasticache: {
+          nodeType: 'cache.t3.micro',
+          numCacheNodes: 1,
+          engine: 'redis',
+          engineVersion: '7.0',
+        },
+      },
+      security: {
+        certificate: domain ? {
+          domain,
+          validationMethod: 'DNS',
+        } : undefined,
+        waf: {
+          enabled: true,
+          rules: ['rateLimit', 'sqlInjection'],
+        },
+      },
+      monitoring: {
+        alarms: [{
+          metric: 'Errors',
+          threshold: 10,
+          period: 300,
+          evaluationPeriods: 1,
+        }, {
+          metric: 'Duration',
+          threshold: 3000, // 3 seconds
+          period: 300,
+          evaluationPeriods: 2,
+        }],
+      },
+    },
+  }
+}

package/src/presets/data-pipeline.ts

@@ -0,0 +1,204 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+
+/**
+ * Data Pipeline Preset
+ * Perfect for: ETL pipelines, data processing, analytics workflows
+ * Includes: Kinesis + Lambda + S3 + Athena + Glue
+ */
+export function createDataPipelinePreset(options: {
+  name: string
+  slug: string
+  retentionDays?: number
+}): Partial<CloudConfig> {
+  const {
+    name,
+    slug,
+    retentionDays = 7,
+  } = options
+
+  return {
+    project: {
+      name,
+      slug,
+      region: 'us-east-1',
+    },
+    mode: 'serverless',
+    infrastructure: {
+      streaming: {
+        dataStream: {
+          name: `${slug}-stream`,
+          shardCount: 2,
+          retentionPeriod: retentionDays * 24, // Convert to hours
+          encryption: true,
+        },
+      },
+      storage: {
+        raw: {
+          public: false,
+          versioning: true,
+          encryption: true,
+          intelligentTiering: true,
+          lifecycleRules: [{
+            id: 'ArchiveOldData',
+            enabled: true,
+            transitions: [{
+              days: 30,
+              storageClass: 'GLACIER',
+            }, {
+              days: 90,
+              storageClass: 'DEEP_ARCHIVE',
+            }],
+          }],
+        },
+        processed: {
+          public: false,
+          versioning: true,
+          encryption: true,
+          intelligentTiering: true,
+        },
+      },
+      functions: {
+        'stream-processor': {
+          runtime: 'nodejs20.x',
+          handler: 'dist/processors/stream.handler',
+          memory: 2048,
+          timeout: 300, // 5 minutes for batch processing
+          events: [{
+            type: 'kinesis',
+            streamName: `${slug}-stream`,
+            batchSize: 1000,
+            startingPosition: 'LATEST',
+            parallelizationFactor: 10,
+          }],
+        },
+        transformer: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/processors/transform.handler',
+          memory: 3008,
+          timeout: 900, // 15 minutes
+          events: [{
+            type: 's3',
+            bucket: `${slug}-raw`,
+            prefix: 'incoming/',
+          }],
+        },
+        aggregator: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/processors/aggregate.handler',
+          memory: 2048,
+          timeout: 600, // 10 minutes
+          events: [{
+            type: 'schedule',
+            expression: 'cron(0 * * * ? *)', // Every hour
+          }],
+        },
+      },
+      analytics: {
+        athena: {
+          database: `${slug}_analytics`,
+          workgroup: `${slug}-workgroup`,
+          outputBucket: `${slug}-query-results`,
+          tables: [{
+            name: 'raw_events',
+            location: `s3://${slug}-raw/events/`,
+            format: 'parquet',
+            partitionKeys: ['year', 'month', 'day'],
+          }, {
+            name: 'processed_events',
+            location: `s3://${slug}-processed/events/`,
+            format: 'parquet',
+            partitionKeys: ['year', 'month', 'day'],
+          }],
+        },
+        glue: {
+          crawlers: [{
+            name: `${slug}-crawler`,
+            databaseName: `${slug}_analytics`,
+            s3Targets: [
+              `s3://${slug}-raw/`,
+              `s3://${slug}-processed/`,
+            ],
+            schedule: 'cron(0 2 * * ? *)', // Daily at 2 AM
+          }],
+          jobs: [{
+            name: `${slug}-etl-job`,
+            scriptLocation: `s3://${slug}-scripts/etl.py`,
+            role: `${slug}-glue-role`,
+            maxCapacity: 10,
+            timeout: 120, // 2 hours
+          }],
+        },
+      },
+      databases: {
+        dynamodb: {
+          tables: {
+            [`${slug}-metadata`]: {
+              partitionKey: { name: 'pipelineId', type: 'S' },
+              sortKey: { name: 'timestamp', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+            },
+          },
+        },
+      },
+      queues: {
+        failedJobs: {
+          fifo: false,
+          visibilityTimeout: 900, // 15 minutes
+          messageRetentionPeriod: 1209600, // 14 days
+          deadLetterQueue: true,
+          maxReceiveCount: 3,
+        },
+      },
+      workflow: {
+        pipelines: [{
+          name: `${slug}-daily-pipeline`,
+          type: 'stepFunctions',
+          definition: {
+            StartAt: 'ExtractData',
+            States: {
+              ExtractData: {
+                Type: 'Task',
+                Resource: 'arn:aws:states:::lambda:invoke',
+                Next: 'TransformData',
+              },
+              TransformData: {
+                Type: 'Task',
+                Resource: 'arn:aws:states:::lambda:invoke',
+                Next: 'LoadData',
+              },
+              LoadData: {
+                Type: 'Task',
+                Resource: 'arn:aws:states:::lambda:invoke',
+                End: true,
+              },
+            },
+          },
+          schedule: 'cron(0 0 * * ? *)', // Daily at midnight
+        }],
+      },
+      monitoring: {
+        dashboard: {
+          name: `${slug}-pipeline`,
+          widgets: [{
+            type: 'metric',
+            metrics: [
+              'KinesisIncomingRecords',
+              'LambdaInvocations',
+              'S3ObjectsCreated',
+              'GlueJobsSucceeded',
+            ],
+          }],
+        },
+        alarms: [{
+          metric: 'LambdaErrors',
+          threshold: 10,
+          evaluationPeriods: 1,
+        }, {
+          metric: 'KinesisIteratorAge',
+          threshold: 60000, // 1 minute
+          evaluationPeriods: 2,
+        }],
+      },
+    },
+  }
+}