@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/phone/advanced/callbacks.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Callback Requests and Queue Management
+ *
+ * Provides callback scheduling and queue management
+ */
+export declare interface CallbackRequest {
+  id: string
+  phoneNumber: string
+  customerName?: string
+  reason?: string
+  preferredTime?: string
+  queueId?: string
+  priority: number
+  status: 'pending' | 'scheduled' | 'in-progress' | 'completed' | 'failed' | 'cancelled'
+  attempts: number
+  maxAttempts: number
+  createdAt: string
+  scheduledFor?: string
+  completedAt?: string
+  notes?: string
+}
+export declare interface QueuePosition {
+  position: number
+  estimatedWaitTime: number
+  callersAhead: number
+}
+/**
+ * Callback Module
+ */
+export declare class Callbacks {
+  static CallbackRequestCode: any;
+  static CallbackProcessorCode: any;
+  static createCallbacksTable(config: { slug: string }): Record<string, any>;
+  static createCallbackRequestLambda(config: {
+    slug: string
+    roleArn: string
+    callbacksTable: string
+    notificationTopicArn?: string
+  }): Record<string, any>;
+  static createCallbackProcessorLambda(config: {
+    slug: string
+    roleArn: string
+    callbacksTable: string
+    connectInstanceId: string
+    contactFlowId: string
+    sourcePhoneNumber: string
+    queueId?: string
+  }): Record<string, any>;
+}
+export default Callbacks;

package/dist/phone/advanced/index.d.ts

@@ -0,0 +1,4 @@
+export * from './recording';
+export * from './ivr-builder';
+export * from './analytics';
+export * from './callbacks';

package/dist/phone/advanced/ivr-builder.d.ts

@@ -0,0 +1,83 @@
+/**
+ * IVR Builder (Visual Contact Flow Editor)
+ *
+ * Provides a programmatic way to build Amazon Connect contact flows
+ */
+export declare interface IVRFlow {
+  id: string
+  name: string
+  description?: string
+  nodes: IVRNode[]
+  connections: IVRConnection[]
+  startNodeId: string
+  version: number
+  createdAt: string
+  updatedAt: string
+}
+export declare interface IVRNode {
+  id: string
+  type: IVRNodeType
+  position: { x: number; y: number }
+  config: Record<string, any>
+  label?: string
+}
+export declare interface IVRConnection {
+  id: string
+  sourceNodeId: string
+  targetNodeId: string
+  sourcePort: string
+  label?: string
+}
+export type IVRNodeType = | 'start'
+  | 'play-prompt'
+  | 'get-input'
+  | 'menu'
+  | 'transfer-queue'
+  | 'transfer-agent'
+  | 'transfer-phone'
+  | 'invoke-lambda'
+  | 'set-attribute'
+  | 'check-attribute'
+  | 'check-hours'
+  | 'check-queue'
+  | 'record-voicemail'
+  | 'disconnect'
+  | 'loop'
+  | 'wait'
+/**
+ * IVR Builder Module
+ */
+export declare class IVRBuilder {
+  private nodes: IVRNode[];
+  private connections: IVRConnection[];
+  private startNodeId: string;
+  static create(name: string): IVRBuilder;
+  start(): this;
+  playPrompt(text: string, options?: { ssml?: boolean; voice?: string }): this;
+  getInput(prompt: string, options?: {
+    maxDigits?: number
+    timeout?: number
+    errorPrompt?: string
+  }): this;
+  menu(prompt: string, options: Record<string, string>): this;
+  transferToQueue(queueArn: string, options?: { priority?: number }): this;
+  transferToPhone(phoneNumber: string): this;
+  invokeLambda(functionArn: string, options?: { timeout?: number }): this;
+  setAttribute(key: string, value: string): this;
+  checkHours(hoursOfOperationArn: string): this;
+  recordVoicemail(options?: {
+    maxDuration?: number
+    greeting?: string
+    beep?: boolean
+  }): this;
+  wait(seconds: number): this;
+  disconnect(): this;
+  build(): IVRFlow;
+  toContactFlow(): string;
+  private nodeToAction(node: IVRNode, nodeMap: Map<string, IVRNode>): any;
+  private connectToLast(targetId: string): void;
+  private getNextNodeId(nodeId: string): string | null;
+  private generateId(): string;
+  static readonly Templates: any;
+}
+export default IVRBuilder;

package/dist/phone/advanced/recording.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Call Recording with Transcription
+ *
+ * Provides call recording storage and transcription
+ */
+export declare 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 declare interface CallTranscription {
+  transcriptId: string
+  text: string
+  segments: TranscriptionSegment[]
+  language: string
+  confidence: number
+  status: 'pending' | 'processing' | 'completed' | 'failed'
+}
+export declare interface TranscriptionSegment {
+  speaker: string
+  startTime: number
+  endTime: number
+  text: string
+  confidence: number
+  sentiment?: 'positive' | 'neutral' | 'negative'
+}
+/**
+ * Call Recording Module
+ */
+export declare class CallRecording {
+  static RecordingProcessorCode: any;
+  static TranscriptionCompleteCode: any;
+  static createRecordingsTable(config: { slug: string }): Record<string, any>;
+  static createRecordingProcessorLambda(config: {
+    slug: string
+    roleArn: string
+    recordingBucket: string
+    recordingsTable: string
+  }): Record<string, any>;
+}
+export default CallRecording;

package/dist/phone/handlers/incoming-call.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Incoming Call Lambda Handler
+ *
+ * Processes incoming calls from Amazon Connect:
+ * - Logs call details
+ * - Sends notifications (SNS, webhook)
+ * - Routes based on caller ID
+ */
+export declare const handler: `
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+const { DynamoDBClient, PutItemCommand } = require('@aws-sdk/client-dynamodb');
+
+const sns = new SNSClient({});
+const dynamodb = new DynamoDBClient({});
+
+exports.handler = async (event) => {
+  console.log('Incoming call event:', JSON.stringify(event, null, 2));
+
+  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;
+  const callLogTable = process.env.CALL_LOG_TABLE;
+  const webhookUrl = process.env.WEBHOOK_URL;
+
+  try {
+    // Extract call details from Connect event
+    const contactData = event.Details?.ContactData || {};
+    const parameters = event.Details?.Parameters || {};
+
+    const callDetails = {
+      contactId: contactData.ContactId,
+      channel: contactData.Channel || 'VOICE',
+      initiationMethod: contactData.InitiationMethod,
+      customerEndpoint: contactData.CustomerEndpoint?.Address,
+      systemEndpoint: contactData.SystemEndpoint?.Address,
+      queue: contactData.Queue?.Name,
+      attributes: contactData.Attributes || {},
+      timestamp: new Date().toISOString(),
+    };
+
+    console.log('Call details:', callDetails);
+
+    // Log call to DynamoDB
+    if (callLogTable) {
+      await dynamodb.send(new PutItemCommand({
+        TableName: callLogTable,
+        Item: {
+          contactId: { S: callDetails.contactId },
+          timestamp: { S: callDetails.timestamp },
+          callerNumber: { S: callDetails.customerEndpoint || 'unknown' },
+          calledNumber: { S: callDetails.systemEndpoint || 'unknown' },
+          channel: { S: callDetails.channel },
+          initiationMethod: { S: callDetails.initiationMethod || 'unknown' },
+          status: { S: 'incoming' },
+          ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) }, // 90 days
+        },
+      }));
+    }
+
+    // Send SNS notification
+    if (notificationTopicArn) {
+      await sns.send(new PublishCommand({
+        TopicArn: notificationTopicArn,
+        Subject: 'Incoming Call',
+        Message: JSON.stringify({
+          type: 'incoming_call',
+          from: callDetails.customerEndpoint,
+          to: callDetails.systemEndpoint,
+          contactId: callDetails.contactId,
+          timestamp: callDetails.timestamp,
+        }, null, 2),
+        MessageAttributes: {
+          eventType: {
+            DataType: 'String',
+            StringValue: 'incoming_call',
+          },
+        },
+      }));
+    }
+
+    // Send webhook notification
+    if (webhookUrl) {
+      try {
+        await fetch(webhookUrl, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'incoming_call',
+            data: callDetails,
+          }),
+        });
+      } catch (err) {
+        console.error('Webhook notification failed:', err.message);
+      }
+    }
+
+    // Return routing decision
+    // Can be customized based on caller ID, time of day, etc.
+    return {
+      statusCode: 200,
+      route: parameters.defaultRoute || 'main_queue',
+      callerInfo: {
+        number: callDetails.customerEndpoint,
+        isKnown: false, // Could lookup in CRM
+      },
+    };
+
+  } catch (error) {
+    console.error('Error processing incoming call:', error);
+    return {
+      statusCode: 500,
+      error: error.message,
+    };
+  }
+};
+`;
+export default handler;

package/dist/phone/handlers/missed-call.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Missed Call Lambda Handler
+ *
+ * Processes missed call events:
+ * - Logs missed call
+ * - Sends notification
+ */
+export declare const handler: `
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+const { DynamoDBClient, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
+
+const sns = new SNSClient({});
+const dynamodb = new DynamoDBClient({});
+
+exports.handler = async (event) => {
+  console.log('Missed call event:', JSON.stringify(event, null, 2));
+
+  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;
+  const callLogTable = process.env.CALL_LOG_TABLE;
+  const webhookUrl = process.env.WEBHOOK_URL;
+
+  try {
+    // Extract call details from Connect event
+    const contactData = event.Details?.ContactData || {};
+
+    const callDetails = {
+      contactId: contactData.ContactId,
+      customerEndpoint: contactData.CustomerEndpoint?.Address,
+      systemEndpoint: contactData.SystemEndpoint?.Address,
+      queue: contactData.Queue?.Name,
+      waitTime: contactData.Queue?.EnqueueTimestamp
+        ? Math.floor((Date.now() - new Date(contactData.Queue.EnqueueTimestamp).getTime()) / 1000)
+        : 0,
+      disconnectReason: event.Details?.Parameters?.disconnectReason || 'customer_abandoned',
+      timestamp: new Date().toISOString(),
+    };
+
+    console.log('Missed call details:', callDetails);
+
+    // Update call log
+    if (callLogTable && callDetails.contactId) {
+      await dynamodb.send(new UpdateItemCommand({
+        TableName: callLogTable,
+        Key: {
+          contactId: { S: callDetails.contactId },
+        },
+        UpdateExpression: 'SET #status = :status, disconnectReason = :reason, waitTime = :wait, missedAt = :at',
+        ExpressionAttributeNames: {
+          '#status': 'status',
+        },
+        ExpressionAttributeValues: {
+          ':status': { S: 'missed' },
+          ':reason': { S: callDetails.disconnectReason },
+          ':wait': { N: String(callDetails.waitTime) },
+          ':at': { S: callDetails.timestamp },
+        },
+      }));
+    }
+
+    // Send SNS notification
+    if (notificationTopicArn) {
+      await sns.send(new PublishCommand({
+        TopicArn: notificationTopicArn,
+        Subject: 'Missed Call Alert',
+        Message: JSON.stringify({
+          type: 'missed_call',
+          from: callDetails.customerEndpoint,
+          to: callDetails.systemEndpoint,
+          queue: callDetails.queue,
+          waitTime: callDetails.waitTime,
+          reason: callDetails.disconnectReason,
+          contactId: callDetails.contactId,
+          timestamp: callDetails.timestamp,
+        }, null, 2),
+        MessageAttributes: {
+          eventType: {
+            DataType: 'String',
+            StringValue: 'missed_call',
+          },
+        },
+      }));
+    }
+
+    // Send webhook notification
+    if (webhookUrl) {
+      try {
+        await fetch(webhookUrl, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'missed_call',
+            data: callDetails,
+          }),
+        });
+      } catch (err) {
+        console.error('Webhook notification failed:', err.message);
+      }
+    }
+
+    return {
+      statusCode: 200,
+      message: 'Missed call logged',
+    };
+
+  } catch (error) {
+    console.error('Error processing missed call:', error);
+    return {
+      statusCode: 500,
+      error: error.message,
+    };
+  }
+};
+`;
+export default handler;

package/dist/phone/handlers/voicemail.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Voicemail Lambda Handler
+ *
+ * Processes voicemail recordings:
+ * - Processes voicemail recordings from S3
+ * - Transcribes using Amazon Transcribe
+ * - Sends notification with transcription
+ */
+export declare 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/dist/phone/index.d.ts

@@ -0,0 +1,2 @@
+export * as PhoneAdvanced from './advanced';
+export * as PhoneHandlers from './handlers/incoming-call';

package/dist/presets/api-backend.d.ts

@@ -0,0 +1,11 @@
+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 declare function createApiBackendPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+}): Partial<CloudConfig>;

package/dist/presets/data-pipeline.d.ts

@@ -0,0 +1,11 @@
+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 declare function createDataPipelinePreset(options: {
+  name: string
+  slug: string
+  retentionDays?: number
+}): Partial<CloudConfig>;