洪都拉斯短信最佳实践、合规性和功能

import { Twilio } from 'twilio';

// Initialize the client with your credentials
const client = new Twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);

// Function to send SMS to Honduras
async function sendSMSToHonduras(
  to: string,
  message: string
): Promise<void> {
  try {
    // Ensure number is in E.164 format for Honduras (+504)
    const formattedNumber = to.startsWith('+504') ? to : `+504${to}`;
    
    const response = await client.messages.create({
      body: message,
      to: formattedNumber,
      from: process.env.TWILIO_PHONE_NUMBER,
      // Optional: statusCallback URL for delivery updates
      statusCallback: 'https://your-webhook.com/status'
    });
    
    console.log(`Message sent successfully! SID: ${response.sid}`);
  } catch (error) {
    console.error('Error sending message:', error);
  }
}

import { SinchClient } from '@sinch/sdk';

// Initialize Sinch client
const sinchClient = new SinchClient({
  apiKey: process.env.SINCH_API_KEY,
  apiSecret: process.env.SINCH_API_SECRET
});

// Send SMS function with typing
async function sendSinchSMS(
  phoneNumber: string,
  messageText: string
): Promise<void> {
  try {
    const response = await sinchClient.sms.send({
      to: phoneNumber,
      message: messageText,
      // Optional parameters
      deliveryReport: 'summary',
      expiry: '24h'
    });
    
    console.log('Message batch ID:', response.batchId);
  } catch (error) {
    console.error('Sinch SMS error:', error);
  }
}

import { MessageBird } from 'messagebird';

// Initialize MessageBird client
const messagebird = MessageBird(process.env.MESSAGEBIRD_API_KEY);

// Type definition for response handling
interface MessageResponse {
  id: string;
  status: string;
  recipient: string;
}

// Send SMS function
async function sendMessageBirdSMS(
  recipient: string,
  content: string
): Promise<MessageResponse> {
  return new Promise((resolve, reject) => {
    messagebird.messages.create({
      originator: 'YourBrand',
      recipients: [recipient],
      body: content,
      datacoding: 'auto' // Automatically handles character encoding
    }, (err, response) => {
      if (err) {
        reject(err);
        return;
      }
      resolve(response);
    });
  });
}

import { Client } from 'plivo';

// Initialize Plivo client
const plivo = new Client(
  process.env.PLIVO_AUTH_ID,
  process.env.PLIVO_AUTH_TOKEN
);

// Send SMS with error handling
async function sendPlivoSMS(
  destination: string,
  message: string
): Promise<void> {
  try {
    const response = await plivo.messages.create({
      src: process.env.PLIVO_PHONE_NUMBER, // Your Plivo number
      dst: destination,
      text: message,
      // Optional parameters
      url: 'https://your-webhook.com/delivery-status',
      method: 'POST'
    });
    
    console.log('Message sent:', response.messageUuid);
  } catch (error) {
    console.error('Plivo error:', error);
  }
}

// Common error handling implementation
interface SMSError {
  code: string;
  message: string;
  timestamp: Date;
}

class SMSLogger {
  static logError(error: SMSError): void {
    // Log to monitoring system
    console.error(`
      Error Code: ${error.code}
      Message: ${error.message}
      Time: ${error.timestamp}
    `);
  }
  
  static async retryWithBackoff(
    fn: () => Promise<any>,
    maxRetries: number = 3
  ): Promise<any> {
    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn();
      } catch (error) {
        if (i === maxRetries - 1) throw error;
        await new Promise(res => setTimeout(res, Math.pow(2, i) * 1000));
      }
    }
  }
}