@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/phone/handlers/voicemail.ts

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

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

@@ -1,134 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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,
-        }],
-      },
-    },
-  }
-}