@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/sms/advanced/chatbot.ts

@@ -1,224 +0,0 @@
-/**
- * SMS Chatbot Integration
- *
- * Provides conversational SMS with AI/rule-based responses
- */
-
-export interface ChatbotConfig {
-  enabled: boolean
-  provider: 'rules' | 'bedrock' | 'openai' | 'custom'
-  welcomeMessage?: string
-  fallbackMessage?: string
-  sessionTimeout?: number
-  maxTurns?: number
-}
-
-export interface ChatSession {
-  sessionId: string
-  phoneNumber: string
-  startedAt: string
-  lastMessageAt: string
-  turnCount: number
-  context: Record<string, any>
-  status: 'active' | 'ended' | 'timeout'
-}
-
-export interface ChatRule {
-  id: string
-  priority: number
-  patterns: string[]
-  response: string
-  action?: 'respond' | 'transfer' | 'end' | 'webhook'
-  actionParams?: Record<string, any>
-}
-
-/**
- * SMS Chatbot Module
- */
-export class SmsChatbot {
-  /**
-   * Lambda code for chatbot processing
-   */
-  static ChatbotProcessorCode: string = [
-    `const { DynamoDBClient, GetItemCommand, PutItemCommand, UpdateItemCommand, ScanCommand } = require('@aws-sdk/client-dynamodb');`,
-    "const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');",
-    "const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');",
-    "",
-    "const dynamodb = new DynamoDBClient({});",
-    "const bedrock = new BedrockRuntimeClient({});",
-    "const sns = new SNSClient({});",
-    "",
-    "const SESSIONS_TABLE = process.env.SESSIONS_TABLE;",
-    "const RULES_TABLE = process.env.RULES_TABLE;",
-    "const CHATBOT_CONFIG = JSON.parse(process.env.CHATBOT_CONFIG || '{}');",
-    "",
-    "exports.handler = async (event) => {",
-    "  console.log('Chatbot event:', JSON.stringify(event, null, 2));",
-    "  for (const record of event.Records) {",
-    "    try {",
-    "      const message = JSON.parse(record.Sns?.Message || record.body || '{}');",
-    "      const { originationNumber, messageBody } = message;",
-    "      if (!originationNumber || !messageBody) continue;",
-    "      const response = await processMessage(originationNumber, messageBody.trim());",
-    "      await sendResponse(originationNumber, response);",
-    "    } catch (error) {",
-    "      console.error('Error:', error);",
-    "    }",
-    "  }",
-    "  return { statusCode: 200 };",
-    "};",
-    "",
-    "async function processMessage(phoneNumber, message) {",
-    "  const rules = await getRules();",
-    "  const lowerMessage = message.toLowerCase();",
-    "  for (const rule of rules) {",
-    "    for (const pattern of rule.patterns) {",
-    "      if (new RegExp(pattern, 'i').test(lowerMessage)) {",
-    "        return rule.response;",
-    "      }",
-    "    }",
-    "  }",
-    "  return CHATBOT_CONFIG.fallbackMessage || 'Sorry, I did not understand. Please try again.';",
-    "}",
-    "",
-    "async function getRules() {",
-    "  const result = await dynamodb.send(new ScanCommand({ TableName: RULES_TABLE }));",
-    "  return (result.Items || []).map(item => ({",
-    "    patterns: JSON.parse(item.patterns?.S || '[]'),",
-    "    response: item.response?.S || '',",
-    "  })).sort((a, b) => (a.priority || 0) - (b.priority || 0));",
-    "}",
-    "",
-    "async function sendResponse(phoneNumber, message) {",
-    "  await sns.send(new PublishCommand({",
-    "    PhoneNumber: phoneNumber,",
-    "    Message: message.substring(0, 1600),",
-    "    MessageAttributes: {",
-    "      'AWS.SNS.SMS.SMSType': { DataType: 'String', StringValue: 'Transactional' },",
-    "    },",
-    "  }));",
-    "}",
-  ].join('\n')
-
-  /**
-   * Create sessions DynamoDB table
-   */
-  static createSessionsTable(config: { slug: string }): Record<string, any> {
-    return {
-      [`${config.slug}ChatbotSessionsTable`]: {
-        Type: 'AWS::DynamoDB::Table',
-        Properties: {
-          TableName: `${config.slug}-chatbot-sessions`,
-          BillingMode: 'PAY_PER_REQUEST',
-          AttributeDefinitions: [
-            { AttributeName: 'phoneNumber', AttributeType: 'S' },
-          ],
-          KeySchema: [
-            { AttributeName: 'phoneNumber', KeyType: 'HASH' },
-          ],
-          TimeToLiveSpecification: {
-            AttributeName: 'ttl',
-            Enabled: true,
-          },
-        },
-      },
-    }
-  }
-
-  /**
-   * Create chatbot rules table
-   */
-  static createRulesTable(config: { slug: string }): Record<string, any> {
-    return {
-      [`${config.slug}ChatbotRulesTable`]: {
-        Type: 'AWS::DynamoDB::Table',
-        Properties: {
-          TableName: `${config.slug}-chatbot-rules`,
-          BillingMode: 'PAY_PER_REQUEST',
-          AttributeDefinitions: [
-            { AttributeName: 'id', AttributeType: 'S' },
-          ],
-          KeySchema: [
-            { AttributeName: 'id', KeyType: 'HASH' },
-          ],
-        },
-      },
-    }
-  }
-
-  /**
-   * Create chatbot processor Lambda
-   */
-  static createChatbotProcessorLambda(config: {
-    slug: string
-    roleArn: string
-    sessionsTable: string
-    rulesTable: string
-    chatbotConfig: ChatbotConfig
-    originationNumber?: string
-  }): Record<string, any> {
-    return {
-      [`${config.slug}ChatbotProcessorLambda`]: {
-        Type: 'AWS::Lambda::Function',
-        Properties: {
-          FunctionName: `${config.slug}-chatbot-processor`,
-          Runtime: 'nodejs20.x',
-          Handler: 'index.handler',
-          Role: config.roleArn,
-          Timeout: 30,
-          MemorySize: 256,
-          Code: {
-            ZipFile: SmsChatbot.ChatbotProcessorCode,
-          },
-          Environment: {
-            Variables: {
-              SESSIONS_TABLE: config.sessionsTable,
-              RULES_TABLE: config.rulesTable,
-              CHATBOT_CONFIG: JSON.stringify(config.chatbotConfig),
-              ORIGINATION_NUMBER: config.originationNumber || '',
-            },
-          },
-        },
-      },
-    }
-  }
-
-  /**
-   * Built-in chatbot rules
-   */
-  static readonly DefaultRules: ChatRule[] = [
-    {
-      id: 'greeting',
-      priority: 1,
-      patterns: ['^(hi|hello|hey|howdy)$', '^good (morning|afternoon|evening)'],
-      response: 'Hello! How can I help you today?',
-    },
-    {
-      id: 'help',
-      priority: 2,
-      patterns: ['^help$', 'what can you do', 'how does this work'],
-      response: 'I can help with: 1) Account info 2) Support 3) Hours. Reply with a number.',
-    },
-    {
-      id: 'hours',
-      priority: 3,
-      patterns: ['hours', 'open', 'when are you'],
-      response: 'We are open Mon-Fri 9am-5pm EST. Closed weekends.',
-    },
-    {
-      id: 'thanks',
-      priority: 4,
-      patterns: ['^(thanks|thank you|thx)'],
-      response: "You're welcome! Is there anything else I can help with?",
-    },
-    {
-      id: 'bye',
-      priority: 5,
-      patterns: ['^(bye|goodbye|quit|exit|stop)$'],
-      response: 'Goodbye! Text us anytime if you need help.',
-      action: 'end',
-    },
-  ]
-}
-
-export default SmsChatbot

package/src/sms/advanced/index.ts

@@ -1,10 +0,0 @@
-/**
- * SMS Advanced Features
- */
-
-export * from './campaigns'
-export * from './analytics'
-export * from './mms'
-export * from './chatbot'
-export * from './link-tracking'
-export * from './ab-testing'

package/src/sms/advanced/link-tracking.ts

@@ -1,248 +0,0 @@
-/**
- * Link Shortening and Tracking
- *
- * Provides URL shortening and click tracking for SMS
- */
-
-export interface ShortenedLink {
-  id: string
-  originalUrl: string
-  shortUrl: string
-  campaignId?: string
-  messageId?: string
-  clicks: number
-  uniqueClicks: number
-  createdAt: string
-  expiresAt?: string
-}
-
-export interface LinkClick {
-  linkId: string
-  clickedAt: string
-  userAgent?: string
-  ipAddress?: string
-  country?: string
-  device?: string
-}
-
-/**
- * Link Tracking Module
- */
-export class LinkTracking {
-  /**
-   * Lambda code for link shortening
-   */
-  static LinkShortenerCode = `
-const { DynamoDBClient, PutItemCommand, GetItemCommand, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
-const crypto = require('crypto');
-
-const dynamodb = new DynamoDBClient({});
-const LINKS_TABLE = process.env.LINKS_TABLE;
-const SHORT_DOMAIN = process.env.SHORT_DOMAIN;
-
-exports.handler = async (event) => {
-  console.log('Link shortener event:', JSON.stringify(event, null, 2));
-
-  const { httpMethod, body, pathParameters } = event;
-
-  try {
-    if (httpMethod === 'POST') {
-      // Create short link
-      const data = JSON.parse(body || '{}');
-      return await createShortLink(data);
-    } else if (httpMethod === 'GET' && pathParameters?.id) {
-      // Redirect to original URL
-      return await handleRedirect(pathParameters.id, event);
-    }
-
-    return { statusCode: 405, body: 'Method not allowed' };
-  } catch (error) {
-    console.error('Error:', error);
-    return { statusCode: 500, body: JSON.stringify({ error: error.message }) };
-  }
-};
-
-async function createShortLink(data) {
-  const { url, campaignId, messageId, expiresIn } = data;
-
-  if (!url) {
-    return { statusCode: 400, body: JSON.stringify({ error: 'URL is required' }) };
-  }
-
-  // Generate short ID
-  const id = generateShortId();
-  const now = new Date().toISOString();
-  const expiresAt = expiresIn
-    ? new Date(Date.now() + expiresIn * 1000).toISOString()
-    : null;
-
-  await dynamodb.send(new PutItemCommand({
-    TableName: LINKS_TABLE,
-    Item: {
-      id: { S: id },
-      originalUrl: { S: url },
-      campaignId: { S: campaignId || '' },
-      messageId: { S: messageId || '' },
-      clicks: { N: '0' },
-      uniqueClicks: { N: '0' },
-      visitors: { SS: ['_placeholder'] }, // DynamoDB requires non-empty set
-      createdAt: { S: now },
-      ...(expiresAt && { expiresAt: { S: expiresAt } }),
-      ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) },
-    },
-  }));
-
-  const shortUrl = SHORT_DOMAIN ? 'https://' + SHORT_DOMAIN + '/l/' + id : '/l/' + id;
-
-  return {
-    statusCode: 201,
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      id,
-      shortUrl,
-      originalUrl: url,
-      createdAt: now,
-    }),
-  };
-}
-
-async function handleRedirect(id, event) {
-  const result = await dynamodb.send(new GetItemCommand({
-    TableName: LINKS_TABLE,
-    Key: { id: { S: id } },
-  }));
-
-  if (!result.Item) {
-    return { statusCode: 404, body: 'Link not found' };
-  }
-
-  const link = result.Item;
-
-  // Check expiration
-  if (link.expiresAt?.S && new Date(link.expiresAt.S) < new Date()) {
-    return { statusCode: 410, body: 'Link has expired' };
-  }
-
-  const originalUrl = link.originalUrl.S;
-
-  // Track click
-  const ipAddress = event.requestContext?.identity?.sourceIp || 'unknown';
-  const userAgent = event.headers?.['user-agent'] || '';
-  const visitorId = crypto.createHash('md5').update(ipAddress + userAgent).digest('hex').substring(0, 8);
-
-  try {
-    await dynamodb.send(new UpdateItemCommand({
-      TableName: LINKS_TABLE,
-      Key: { id: { S: id } },
-      UpdateExpression: 'SET clicks = clicks + :one, visitors = list_append(if_not_exists(visitors, :empty), :visitor)',
-      ExpressionAttributeValues: {
-        ':one': { N: '1' },
-        ':empty': { L: [] },
-        ':visitor': { L: [{ S: visitorId }] },
-      },
-    }));
-  } catch (e) {
-    console.error('Error tracking click:', e);
-  }
-
-  return {
-    statusCode: 302,
-    headers: {
-      'Location': originalUrl,
-      'Cache-Control': 'no-store',
-    },
-    body: '',
-  };
-}
-
-function generateShortId() {
-  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-  let id = '';
-  for (let i = 0; i < 6; i++) {
-    id += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return id;
-}
-`
-
-  /**
-   * Create links DynamoDB table
-   */
-  static createLinksTable(config: { slug: string }): Record<string, any> {
-    return {
-      [`${config.slug}ShortLinksTable`]: {
-        Type: 'AWS::DynamoDB::Table',
-        Properties: {
-          TableName: `${config.slug}-short-links`,
-          BillingMode: 'PAY_PER_REQUEST',
-          AttributeDefinitions: [
-            { AttributeName: 'id', AttributeType: 'S' },
-          ],
-          KeySchema: [
-            { AttributeName: 'id', KeyType: 'HASH' },
-          ],
-          TimeToLiveSpecification: {
-            AttributeName: 'ttl',
-            Enabled: true,
-          },
-        },
-      },
-    }
-  }
-
-  /**
-   * Create link shortener Lambda
-   */
-  static createLinkShortenerLambda(config: {
-    slug: string
-    roleArn: string
-    linksTable: string
-    shortDomain?: string
-  }): Record<string, any> {
-    return {
-      [`${config.slug}LinkShortenerLambda`]: {
-        Type: 'AWS::Lambda::Function',
-        Properties: {
-          FunctionName: `${config.slug}-link-shortener`,
-          Runtime: 'nodejs20.x',
-          Handler: 'index.handler',
-          Role: config.roleArn,
-          Timeout: 10,
-          MemorySize: 128,
-          Code: {
-            ZipFile: LinkTracking.LinkShortenerCode,
-          },
-          Environment: {
-            Variables: {
-              LINKS_TABLE: config.linksTable,
-              SHORT_DOMAIN: config.shortDomain || '',
-            },
-          },
-        },
-      },
-    }
-  }
-
-  /**
-   * Shorten URLs in message text
-   */
-  static shortenUrlsInMessage(message: string, shortDomain: string, linkIdPrefix: string): {
-    message: string
-    links: Array<{ original: string; short: string; id: string }>
-  } {
-    const urlRegex = /(https?:\/\/[^\s]+)/g
-    const links: Array<{ original: string; short: string; id: string }> = []
-    let index = 0
-
-    const shortenedMessage = message.replace(urlRegex, (url) => {
-      const id = `${linkIdPrefix}-${index++}`
-      const shortUrl = `https://${shortDomain}/l/${id}`
-      links.push({ original: url, short: shortUrl, id })
-      return shortUrl
-    })
-
-    return { message: shortenedMessage, links }
-  }
-}
-
-export default LinkTracking