科威特短信最佳实践、合规性和功能

import { Twilio } from 'twilio';

// Initialize Twilio client with credentials
const client = new Twilio(
  process.env.TWILIO_ACCOUNT_SID,    // Your Account SID
  process.env.TWILIO_AUTH_TOKEN      // Your Auth Token
);

// Function to send SMS to Kuwait
async function sendSMSToKuwait(
  to: string,
  message: string,
  senderId: string
): Promise<void> {
  try {
    // Ensure Kuwait number format: +965XXXXXXXX
    const formattedNumber = to.startsWith('+965') ? to : `+965${to}`;
    
    const response = await client.messages.create({
      body: message,
      from: senderId,        // Pre-registered Sender ID
      to: formattedNumber,
      // Optional parameters for Kuwait
      statusCallback: 'https://your-callback-url.com/status',
      provideFeedback: true
    });
    
    console.log(`Message sent successfully! SID: ${response.sid}`);
  } catch (error) {
    console.error('Error sending message:', error);
    throw error;
  }
}

import axios from 'axios';

interface SinchSMSConfig {
  apiToken: string;
  servicePlanId: string;
  senderId: string;
}

class SinchSMSService {
  private readonly baseUrl: string;
  private readonly config: SinchSMSConfig;

  constructor(config: SinchSMSConfig) {
    this.config = config;
    this.baseUrl = 'https://sms.api.sinch.com/xms/v1';
  }

  async sendSMS(to: string, message: string): Promise<void> {
    try {
      const response = await axios.post(
        `${this.baseUrl}/${this.config.servicePlanId}/batches`,
        {
          from: this.config.senderId,
          to: [to],
          body: message,
          encoding: 'AUTO'  // Handles Arabic text automatically
        },
        {
          headers: {
            'Authorization': `Bearer ${this.config.apiToken}`,
            'Content-Type': 'application/json'
          }
        }
      );
      
      console.log('Message sent:', response.data.id);
    } catch (error) {
      console.error('Sinch SMS error:', error);
      throw error;
    }
  }
}

import messagebird from 'messagebird';

class MessageBirdService {
  private client: any;
  
  constructor(apiKey: string) {
    this.client = messagebird(apiKey);
  }

  sendSMS(
    to: string,
    message: string,
    senderId: string
  ): Promise<any> {
    return new Promise((resolve, reject) => {
      // Configure message parameters
      const params = {
        originator: senderId,
        recipients: [to],
        body: message,
        type: 'unicode',  // Required for Arabic text
        datacoding: 'unicode'
      };

      this.client.messages.create(params, (err: any, response: any) => {
        if (err) {
          reject(err);
          return;
        }
        resolve(response);
      });
    });
  }
}

import plivo from 'plivo';

class PlivoSMSService {
  private client: any;

  constructor(authId: string, authToken: string) {
    this.client = new plivo.Client(authId, authToken);
  }

  async sendSMS(
    to: string,
    message: string,
    senderId: string
  ): Promise<void> {
    try {
      const response = await this.client.messages.create({
        src: senderId,
        dst: to,
        text: message,
        // Kuwait-specific parameters
        url_strip_query_params: false,
        method: 'POST',
        log: true
      });
      
      console.log('Message sent:', response.messageUuid);
    } catch (error) {
      console.error('Plivo error:', error);
      throw error;
    }
  }
}

// Example rate limiting implementation
import { RateLimiter } from 'limiter';

const limiter = new RateLimiter({
  tokensPerInterval: 30,
  interval: 'second'
});

async function sendBulkSMS(messages: Message[]): Promise<void> {
  for (const message of messages) {
    await limiter.removeTokens(1);
    await sendSMS(message);
  }
}

interface SMSError {
  code: string;
  message: string;
  timestamp: Date;
  recipient: string;
}

class SMSErrorHandler {
  static handleError(error: any): SMSError {
    // Common Kuwait-specific error codes
    const errorMap: Record<string, string> = {
      '21614': 'Invalid number format for Kuwait',
      '30007': 'Blocked by carrier',
      '30008': 'Message content restricted'
    };

    return {
      code: error.code,
      message: errorMap[error.code] || error.message,
      timestamp: new Date(),
      recipient: error.recipient
    };
  }
}