@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/src/phone/advanced/recording.ts

@@ -1,310 +0,0 @@
-/**
- * Call Recording with Transcription
- *
- * Provides call recording storage and transcription
- */
-
-export interface CallRecording {
-  recordingId: string
-  contactId: string
-  startTime: string
-  endTime: string
-  duration: number
-  participants: string[]
-  recordingUrl: string
-  transcription?: CallTranscription
-  status: 'recording' | 'processing' | 'completed' | 'failed'
-  createdAt: string
-}
-
-export interface CallTranscription {
-  transcriptId: string
-  text: string
-  segments: TranscriptionSegment[]
-  language: string
-  confidence: number
-  status: 'pending' | 'processing' | 'completed' | 'failed'
-}
-
-export interface TranscriptionSegment {
-  speaker: string
-  startTime: number
-  endTime: number
-  text: string
-  confidence: number
-  sentiment?: 'positive' | 'neutral' | 'negative'
-}
-
-/**
- * Call Recording Module
- */
-export class CallRecording {
-  /**
-   * Lambda code for processing call recordings
-   */
-  static RecordingProcessorCode = `
-const { S3Client, GetObjectCommand, PutObjectCommand, CopyObjectCommand } = require('@aws-sdk/client-s3');
-const { TranscribeClient, StartTranscriptionJobCommand, GetTranscriptionJobCommand } = require('@aws-sdk/client-transcribe');
-const { DynamoDBClient, PutItemCommand, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
-
-const s3 = new S3Client({});
-const transcribe = new TranscribeClient({});
-const dynamodb = new DynamoDBClient({});
-
-const RECORDING_BUCKET = process.env.RECORDING_BUCKET;
-const RECORDINGS_TABLE = process.env.RECORDINGS_TABLE;
-
-exports.handler = async (event) => {
-  console.log('Recording processor event:', JSON.stringify(event, null, 2));
-
-  for (const record of event.Records) {
-    try {
-      const bucket = record.s3?.bucket?.name || RECORDING_BUCKET;
-      const key = decodeURIComponent(record.s3?.object?.key?.replace(/\\+/g, ' ') || '');
-
-      // Only process audio files
-      if (!key.match(/\\.(wav|mp3|mp4|flac|ogg|webm)$/i)) continue;
-
-      const recordingId = key.split('/').pop().replace(/\\.[^.]+$/, '');
-      const now = new Date().toISOString();
-
-      // Save recording metadata
-      await dynamodb.send(new PutItemCommand({
-        TableName: RECORDINGS_TABLE,
-        Item: {
-          recordingId: { S: recordingId },
-          bucket: { S: bucket },
-          key: { S: key },
-          status: { S: 'processing' },
-          createdAt: { S: now },
-          ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) },
-        },
-      }));
-
-      // Start transcription job
-      const transcriptionJobName = \`transcribe-\${recordingId}-\${Date.now()}\`;
-      const mediaUri = \`s3://\${bucket}/\${key}\`;
-
-      await transcribe.send(new StartTranscriptionJobCommand({
-        TranscriptionJobName: transcriptionJobName,
-        LanguageCode: 'en-US',
-        MediaFormat: key.split('.').pop().toLowerCase(),
-        Media: { MediaFileUri: mediaUri },
-        OutputBucketName: bucket,
-        OutputKey: \`transcriptions/\${recordingId}.json\`,
-        Settings: {
-          ShowSpeakerLabels: true,
-          MaxSpeakerLabels: 10,
-          ChannelIdentification: false,
-        },
-      }));
-
-      // Update status
-      await dynamodb.send(new UpdateItemCommand({
-        TableName: RECORDINGS_TABLE,
-        Key: { recordingId: { S: recordingId } },
-        UpdateExpression: 'SET transcriptionJobName = :job, #status = :status',
-        ExpressionAttributeNames: { '#status': 'status' },
-        ExpressionAttributeValues: {
-          ':job': { S: transcriptionJobName },
-          ':status': { S: 'transcribing' },
-        },
-      }));
-
-      console.log(\`Started transcription for: \${recordingId}\`);
-    } catch (error) {
-      console.error('Error processing recording:', error);
-    }
-  }
-
-  return { statusCode: 200 };
-};
-`
-
-  /**
-   * Lambda code for transcription completion
-   */
-  static TranscriptionCompleteCode = `
-const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
-const { DynamoDBClient, UpdateItemCommand, QueryCommand } = require('@aws-sdk/client-dynamodb');
-
-const s3 = new S3Client({});
-const dynamodb = new DynamoDBClient({});
-
-const RECORDING_BUCKET = process.env.RECORDING_BUCKET;
-const RECORDINGS_TABLE = process.env.RECORDINGS_TABLE;
-
-exports.handler = async (event) => {
-  console.log('Transcription complete event:', JSON.stringify(event, null, 2));
-
-  const { detail } = event;
-  const jobName = detail?.TranscriptionJobName;
-  const jobStatus = detail?.TranscriptionJobStatus;
-
-  if (!jobName) return { statusCode: 400 };
-
-  // Find recording by job name
-  const queryResult = await dynamodb.send(new QueryCommand({
-    TableName: RECORDINGS_TABLE,
-    IndexName: 'job-index',
-    KeyConditionExpression: 'transcriptionJobName = :job',
-    ExpressionAttributeValues: {
-      ':job': { S: jobName },
-    },
-  }));
-
-  const recording = queryResult.Items?.[0];
-  if (!recording) {
-    console.log('Recording not found for job:', jobName);
-    return { statusCode: 404 };
-  }
-
-  const recordingId = recording.recordingId.S;
-
-  if (jobStatus === 'COMPLETED') {
-    // Get transcription result
-    const transcriptKey = \`transcriptions/\${recordingId}.json\`;
-    const result = await s3.send(new GetObjectCommand({
-      Bucket: RECORDING_BUCKET,
-      Key: transcriptKey,
-    }));
-
-    const transcriptData = JSON.parse(await result.Body.transformToString());
-
-    // Extract segments with speaker labels
-    const segments = [];
-    const items = transcriptData.results?.items || [];
-    let currentSegment = null;
-
-    for (const item of items) {
-      if (item.type === 'pronunciation') {
-        const speaker = item.speaker_label || 'spk_0';
-        const startTime = parseFloat(item.start_time || 0);
-        const endTime = parseFloat(item.end_time || 0);
-        const content = item.alternatives?.[0]?.content || '';
-        const confidence = parseFloat(item.alternatives?.[0]?.confidence || 0);
-
-        if (!currentSegment || currentSegment.speaker !== speaker) {
-          if (currentSegment) segments.push(currentSegment);
-          currentSegment = {
-            speaker,
-            startTime,
-            endTime,
-            text: content,
-            confidence,
-          };
-        } else {
-          currentSegment.endTime = endTime;
-          currentSegment.text += ' ' + content;
-          currentSegment.confidence = (currentSegment.confidence + confidence) / 2;
-        }
-      }
-    }
-    if (currentSegment) segments.push(currentSegment);
-
-    // Update recording with transcription
-    await dynamodb.send(new UpdateItemCommand({
-      TableName: RECORDINGS_TABLE,
-      Key: { recordingId: { S: recordingId } },
-      UpdateExpression: 'SET #status = :status, transcription = :transcript, completedAt = :now',
-      ExpressionAttributeNames: { '#status': 'status' },
-      ExpressionAttributeValues: {
-        ':status': { S: 'completed' },
-        ':transcript': { S: JSON.stringify({
-          text: transcriptData.results?.transcripts?.[0]?.transcript || '',
-          segments,
-          language: 'en-US',
-          confidence: segments.reduce((sum, s) => sum + s.confidence, 0) / segments.length || 0,
-        })},
-        ':now': { S: new Date().toISOString() },
-      },
-    }));
-
-    console.log(\`Transcription completed for: \${recordingId}\`);
-  } else if (jobStatus === 'FAILED') {
-    await dynamodb.send(new UpdateItemCommand({
-      TableName: RECORDINGS_TABLE,
-      Key: { recordingId: { S: recordingId } },
-      UpdateExpression: 'SET #status = :status, error = :error',
-      ExpressionAttributeNames: { '#status': 'status' },
-      ExpressionAttributeValues: {
-        ':status': { S: 'failed' },
-        ':error': { S: detail?.FailureReason || 'Unknown error' },
-      },
-    }));
-  }
-
-  return { statusCode: 200 };
-};
-`
-
-  /**
-   * Create recordings DynamoDB table
-   */
-  static createRecordingsTable(config: { slug: string }): Record<string, any> {
-    return {
-      [`${config.slug}CallRecordingsTable`]: {
-        Type: 'AWS::DynamoDB::Table',
-        Properties: {
-          TableName: `${config.slug}-call-recordings`,
-          BillingMode: 'PAY_PER_REQUEST',
-          AttributeDefinitions: [
-            { AttributeName: 'recordingId', AttributeType: 'S' },
-            { AttributeName: 'transcriptionJobName', AttributeType: 'S' },
-          ],
-          KeySchema: [
-            { AttributeName: 'recordingId', KeyType: 'HASH' },
-          ],
-          GlobalSecondaryIndexes: [
-            {
-              IndexName: 'job-index',
-              KeySchema: [
-                { AttributeName: 'transcriptionJobName', KeyType: 'HASH' },
-              ],
-              Projection: { ProjectionType: 'ALL' },
-            },
-          ],
-          TimeToLiveSpecification: {
-            AttributeName: 'ttl',
-            Enabled: true,
-          },
-        },
-      },
-    }
-  }
-
-  /**
-   * Create recording processor Lambda
-   */
-  static createRecordingProcessorLambda(config: {
-    slug: string
-    roleArn: string
-    recordingBucket: string
-    recordingsTable: string
-  }): Record<string, any> {
-    return {
-      [`${config.slug}RecordingProcessorLambda`]: {
-        Type: 'AWS::Lambda::Function',
-        Properties: {
-          FunctionName: `${config.slug}-recording-processor`,
-          Runtime: 'nodejs20.x',
-          Handler: 'index.handler',
-          Role: config.roleArn,
-          Timeout: 60,
-          MemorySize: 256,
-          Code: {
-            ZipFile: CallRecording.RecordingProcessorCode,
-          },
-          Environment: {
-            Variables: {
-              RECORDING_BUCKET: config.recordingBucket,
-              RECORDINGS_TABLE: config.recordingsTable,
-            },
-          },
-        },
-      },
-    }
-  }
-}
-
-export default CallRecording

package/src/phone/handlers/__tests__/incoming-call.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { handler } from '../incoming-call'
-
-describe('Incoming Call Handler', () => {
-  it('should export handler code as string', () => {
-    expect(typeof handler).toBe('string')
-    expect(handler).toContain('exports.handler')
-  })
-
-  it('should contain SNS client import', () => {
-    expect(handler).toContain('SNSClient')
-    expect(handler).toContain('PublishCommand')
-  })
-
-  it('should contain DynamoDB client import', () => {
-    expect(handler).toContain('DynamoDBClient')
-    expect(handler).toContain('PutItemCommand')
-  })
-
-  it('should extract contact data', () => {
-    expect(handler).toContain('ContactData')
-    expect(handler).toContain('CustomerEndpoint')
-    expect(handler).toContain('SystemEndpoint')
-  })
-
-  it('should log calls to DynamoDB', () => {
-    expect(handler).toContain('CALL_LOG_TABLE')
-    expect(handler).toContain('contactId')
-  })
-
-  it('should send notifications', () => {
-    expect(handler).toContain('NOTIFICATION_TOPIC_ARN')
-    expect(handler).toContain('incoming_call')
-  })
-
-  it('should support webhook notifications', () => {
-    expect(handler).toContain('WEBHOOK_URL')
-    expect(handler).toContain('fetch')
-  })
-})

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,
-        }],
-      },
-    },
-  }
-}