加拿大短信最佳实践、合规性和功能

import { Twilio } from 'twilio';

// Initialize client with environment variables
const client = new Twilio(
  process.env.TWILIO_ACCOUNT_SID,
  process.env.TWILIO_AUTH_TOKEN
);

async function sendSMS(to: string, message: string) {
  try {
    // Send message with proper Canadian formatting
    const response = await client.messages.create({
      from: process.env.TWILIO_PHONE_NUMBER, // Must be in +1XXXXXXXXXX format
      to: `+1${to.replace(/\D/g, '')}`, // Sanitize and format number
      body: message,
      // Optional parameters for Canadian requirements
      statusCallback: 'https://your-callback-url.com/status',
    });
    
    console.log(`Message sent successfully: ${response.sid}`);
    return response;
  } catch (error) {
    console.error('Error sending message:', error);
    throw error;
  }
}

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

class SinchSMSService {
  private client: SinchClient;

  constructor() {
    this.client = new SinchClient({
      servicePlanId: process.env.SINCH_SERVICE_PLAN_ID,
      apiToken: process.env.SINCH_API_TOKEN,
      region: 'ca-central-1'
    });
  }

  async sendBatchSMS(recipients: string[], message: string) {
    try {
      const response = await this.client.sms.batches.send({
        from: process.env.SINCH_NUMBER,
        to: recipients.map(num => `+1${num.replace(/\D/g, '')}`),
        body: message,
        // Canadian compliance parameters
        deliveryReport: 'summary',
        parameters: {
          campaign_id: 'CANADA_CAMPAIGN'
        }
      });

      return response;
    } catch (error) {
      console.error('Sinch SMS Error:', error);
      throw error;
    }
  }
}

import { MessageBirdClient } from 'messagebird';

class MessageBirdService {
  private client: MessageBirdClient;

  constructor() {
    this.client = new MessageBirdClient(
      process.env.MESSAGEBIRD_API_KEY
    );
  }

  async sendMessage(to: string, message: string) {
    const params = {
      originator: process.env.MESSAGEBIRD_NUMBER,
      recipients: [`+1${to.replace(/\D/g, '')}`],
      body: message,
      // Canadian market specifics
      datacoding: 'auto',
      reportUrl: 'https://your-domain.com/delivery-reports'
    };

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

import { Client } from 'plivo';

class PlivoSMSService {
  private client: Client;

  constructor() {
    this.client = new Client(
      process.env.PLIVO_AUTH_ID,
      process.env.PLIVO_AUTH_TOKEN
    );
  }

  async sendSMS(to: string, message: string) {
    try {
      const response = await this.client.messages.create({
        src: process.env.PLIVO_NUMBER, // Your Plivo number
        dst: `+1${to.replace(/\D/g, '')}`,
        text: message,
        // Canadian specific parameters
        powerpack_uuid: process.env.PLIVO_POWERPACK_ID,
        log: true
      });

      return response;
    } catch (error) {
      console.error('Plivo Error:', error);
      throw error;
    }
  }
}

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

class SMSErrorHandler {
  async logError(error: SMSError): Promise<void> {
    // Log to monitoring system
    await logger.error('SMS_DELIVERY_ERROR', {
      ...error,
      market: 'CANADA'
    });

    // Alert if error threshold exceeded
    if (await this.errorThresholdExceeded()) {
      await this.triggerAlert();
    }
  }
}