@skoolite/notify-hub 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1646 @@
+import { isValidPhoneNumber, parsePhoneNumber } from 'libphonenumber-js';
+import * as crypto from 'crypto';
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  backoffMs: 1e3,
+  backoffMultiplier: 2,
+  maxBackoffMs: 3e4,
+  jitter: true
+};
+var RETRIABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EPIPE",
+  "RATE_LIMIT",
+  "SERVICE_UNAVAILABLE",
+  "GATEWAY_TIMEOUT",
+  "429",
+  // Too Many Requests
+  "500",
+  // Internal Server Error
+  "502",
+  // Bad Gateway
+  "503",
+  // Service Unavailable
+  "504"
+  // Gateway Timeout
+]);
+function isRetriableError(error) {
+  if (!error) return false;
+  if (typeof error === "object" && "retriable" in error) {
+    return error.retriable;
+  }
+  const errorCode = getErrorCode(error);
+  if (errorCode && RETRIABLE_ERROR_CODES.has(errorCode)) {
+    return true;
+  }
+  const statusCode = getStatusCode(error);
+  if (statusCode && RETRIABLE_ERROR_CODES.has(String(statusCode))) {
+    return true;
+  }
+  return false;
+}
+function getErrorCode(error) {
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    if (typeof err["code"] === "string") {
+      return err["code"];
+    }
+    if (typeof err["errorCode"] === "string") {
+      return err["errorCode"];
+    }
+  }
+  return void 0;
+}
+function getStatusCode(error) {
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    if (typeof err["status"] === "number") {
+      return err["status"];
+    }
+    if (typeof err["statusCode"] === "number") {
+      return err["statusCode"];
+    }
+    if (typeof err["response"] === "object" && err["response"] !== null && typeof err["response"]["status"] === "number") {
+      return err["response"]["status"];
+    }
+  }
+  return void 0;
+}
+function calculateBackoff(attempt, config) {
+  const exponentialDelay = config.backoffMs * Math.pow(config.backoffMultiplier, attempt - 1);
+  const maxDelay = config.maxBackoffMs ?? 3e4;
+  const baseDelay = Math.min(exponentialDelay, maxDelay);
+  if (config.jitter) {
+    const jitter = Math.random() * baseDelay * 0.5;
+    return Math.floor(baseDelay + jitter);
+  }
+  return Math.floor(baseDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, config = DEFAULT_RETRY_CONFIG, shouldRetry = isRetriableError) {
+  const startTime = Date.now();
+  let lastError;
+  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+    try {
+      const value = await fn();
+      return {
+        success: true,
+        value,
+        attempts: attempt,
+        totalDurationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt >= config.maxAttempts;
+      const canRetry = !isLastAttempt && shouldRetry(error);
+      if (!canRetry) {
+        return {
+          success: false,
+          error: lastError,
+          attempts: attempt,
+          totalDurationMs: Date.now() - startTime
+        };
+      }
+      const backoffMs = calculateBackoff(attempt, config);
+      await sleep(backoffMs);
+    }
+  }
+  return {
+    success: false,
+    error: lastError,
+    attempts: config.maxAttempts,
+    totalDurationMs: Date.now() - startTime
+  };
+}
+function createNotifyError(error, defaultCode = "UNKNOWN_ERROR") {
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    return {
+      code: typeof err["code"] === "string" ? err["code"] : defaultCode,
+      message: err["message"] ?? String(error),
+      retriable: isRetriableError(error),
+      originalError: error
+    };
+  }
+  return {
+    code: defaultCode,
+    message: String(error),
+    retriable: false,
+    originalError: error
+  };
+}
+function validatePhoneNumber(phone, defaultCountry = "PK") {
+  try {
+    const cleaned = cleanPhoneNumber(phone);
+    if (!isValidPhoneNumber(cleaned, defaultCountry)) {
+      return {
+        isValid: false,
+        error: "Invalid phone number format"
+      };
+    }
+    const parsed = parsePhoneNumber(cleaned, defaultCountry);
+    return {
+      isValid: true,
+      e164: parsed.format("E.164"),
+      countryCode: parsed.country,
+      nationalNumber: parsed.nationalNumber
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      error: error instanceof Error ? error.message : "Failed to parse phone number"
+    };
+  }
+}
+function cleanPhoneNumber(phone) {
+  let cleaned = phone.trim();
+  const hasPlus = cleaned.startsWith("+");
+  cleaned = cleaned.replace(/[\s\-().]/g, "");
+  if (hasPlus && !cleaned.startsWith("+")) {
+    cleaned = "+" + cleaned;
+  }
+  return cleaned;
+}
+function toE164(phone, defaultCountry = "PK") {
+  const result = validatePhoneNumber(phone, defaultCountry);
+  return result.e164 ?? null;
+}
+function isCountry(phone, countryCode) {
+  try {
+    const parsed = parsePhoneNumber(phone);
+    return parsed.country === countryCode;
+  } catch {
+    return false;
+  }
+}
+function getCountryCode(phone) {
+  try {
+    const parsed = parsePhoneNumber(phone);
+    return parsed.country ?? null;
+  } catch {
+    return null;
+  }
+}
+function getCallingCode(phone) {
+  try {
+    const parsed = parsePhoneNumber(phone);
+    return parsed.countryCallingCode ? `+${parsed.countryCallingCode}` : null;
+  } catch {
+    return null;
+  }
+}
+function isPakistanMobile(phone) {
+  try {
+    const parsed = parsePhoneNumber(phone, "PK");
+    if (parsed.country !== "PK") return false;
+    const national = parsed.nationalNumber;
+    return national.startsWith("3");
+  } catch {
+    return false;
+  }
+}
+function getPakistanNetwork(phone) {
+  try {
+    const parsed = parsePhoneNumber(phone, "PK");
+    if (parsed.country !== "PK") return null;
+    const national = parsed.nationalNumber;
+    if (!national.startsWith("3")) return null;
+    const prefix = national.substring(0, 3);
+    if (["300", "301", "302", "303", "304", "305", "306", "307", "308", "309"].includes(prefix) || ["310", "311", "312", "313", "314", "315", "316", "317", "318", "319"].includes(prefix) || ["320", "321", "322", "323", "324", "325", "326", "327", "328", "329"].includes(prefix) || ["330", "331", "332", "333", "334", "335", "336", "337", "338", "339"].includes(prefix)) {
+      return "jazz";
+    }
+    if (["340", "341", "342", "343", "344", "345", "346", "347", "348", "349"].includes(prefix) || ["350", "351", "352", "353", "354", "355", "356", "357", "358", "359"].includes(prefix)) {
+      return "telenor";
+    }
+    if (["310", "311", "312", "313", "314", "315", "316", "317", "318", "319"].includes(prefix)) {
+      return "zong";
+    }
+    if (["330", "331", "332", "333"].includes(prefix)) {
+      return "ufone";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function routeByPrefix(phone, routing) {
+  const prefixes = Object.keys(routing).filter((k) => k !== "*").sort((a, b) => b.length - a.length);
+  for (const prefix of prefixes) {
+    if (phone.startsWith(prefix)) {
+      return routing[prefix];
+    }
+  }
+  return routing["*"] ?? "primary";
+}
+
+// src/providers/sms/twilio.provider.ts
+function mapTwilioStatus(twilioStatus) {
+  const statusMap = {
+    queued: "queued",
+    sending: "queued",
+    sent: "sent",
+    delivered: "delivered",
+    undelivered: "undelivered",
+    failed: "failed",
+    read: "read",
+    accepted: "queued"
+  };
+  return statusMap[twilioStatus] ?? "unknown";
+}
+var TwilioSmsProvider = class {
+  name = "twilio";
+  client = null;
+  config;
+  logger;
+  retryConfig;
+  constructor(config, options) {
+    this.config = config;
+    this.logger = options?.logger;
+    this.retryConfig = options?.retryConfig ?? DEFAULT_RETRY_CONFIG;
+  }
+  /**
+   * Initialize the Twilio client
+   */
+  async initialize() {
+    if (this.client) return;
+    const twilio = await import('twilio');
+    this.client = twilio.default(this.config.accountSid, this.config.authToken);
+    this.logger?.debug("TwilioSmsProvider initialized");
+  }
+  /**
+   * Ensure client is initialized
+   */
+  async ensureClient() {
+    if (!this.client) {
+      await this.initialize();
+    }
+    if (!this.client) {
+      throw new Error("Twilio client not initialized");
+    }
+    return this.client;
+  }
+  /**
+   * Send an SMS message
+   */
+  async send(to, message, options) {
+    const timestamp = /* @__PURE__ */ new Date();
+    const from = options?.from ?? this.config.fromNumber;
+    const e164To = toE164(to);
+    if (!e164To) {
+      return {
+        success: false,
+        channel: "sms",
+        status: "failed",
+        provider: this.name,
+        error: {
+          code: "INVALID_PHONE_NUMBER",
+          message: `Invalid phone number: ${to}`,
+          retriable: false
+        },
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    this.logger?.debug(`Sending SMS to ${e164To}`);
+    const result = await withRetry(
+      async () => {
+        const client = await this.ensureClient();
+        const messageParams = {
+          to: e164To,
+          body: message
+        };
+        if (this.config.messagingServiceSid) {
+          messageParams.messagingServiceSid = this.config.messagingServiceSid;
+        } else {
+          messageParams.from = from;
+        }
+        return client.messages.create(messageParams);
+      },
+      this.retryConfig
+    );
+    if (result.success && result.value) {
+      const twilioMessage = result.value;
+      this.logger?.info(`SMS sent successfully: ${twilioMessage.sid}`);
+      return {
+        success: true,
+        messageId: twilioMessage.sid,
+        channel: "sms",
+        status: mapTwilioStatus(twilioMessage.status),
+        provider: this.name,
+        cost: twilioMessage.price ? {
+          amount: Math.abs(parseFloat(twilioMessage.price)),
+          currency: twilioMessage.priceUnit ?? "USD"
+        } : void 0,
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    this.logger?.error(`SMS send failed: ${result.error?.message}`);
+    return {
+      success: false,
+      channel: "sms",
+      status: "failed",
+      provider: this.name,
+      error: createNotifyError(result.error, "TWILIO_ERROR"),
+      timestamp,
+      metadata: options?.metadata
+    };
+  }
+  /**
+   * Get delivery status of a message
+   */
+  async getStatus(messageId) {
+    try {
+      const client = await this.ensureClient();
+      const message = await client.messages(messageId).fetch();
+      return mapTwilioStatus(message.status);
+    } catch (error) {
+      this.logger?.error(`Failed to get status for ${messageId}: ${error}`);
+      return "unknown";
+    }
+  }
+  /**
+   * Send bulk SMS messages
+   */
+  async sendBulk(messages, options) {
+    const startTime = Date.now();
+    const results = [];
+    let sent = 0;
+    let failed = 0;
+    let totalCost = 0;
+    const concurrency = options?.concurrency ?? 10;
+    const messagesPerSecond = options?.rateLimit?.messagesPerSecond ?? 10;
+    const delayBetweenBatches = Math.ceil(1e3 / messagesPerSecond) * concurrency;
+    for (let i = 0; i < messages.length; i += concurrency) {
+      const batch = messages.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(
+          (msg) => this.send(msg.to, msg.message, { metadata: msg.metadata })
+        )
+      );
+      for (const result of batchResults) {
+        results.push(result);
+        if (result.success) {
+          sent++;
+          if (result.cost) {
+            totalCost += result.cost.amount;
+          }
+        } else {
+          failed++;
+          if (options?.stopOnError) {
+            return {
+              results,
+              summary: {
+                total: messages.length,
+                sent,
+                failed,
+                cost: { amount: totalCost, currency: "USD" },
+                durationMs: Date.now() - startTime
+              }
+            };
+          }
+        }
+      }
+      options?.onProgress?.(sent + failed, messages.length);
+      if (i + concurrency < messages.length) {
+        await new Promise((resolve) => setTimeout(resolve, delayBetweenBatches));
+      }
+    }
+    return {
+      results,
+      summary: {
+        total: messages.length,
+        sent,
+        failed,
+        cost: { amount: totalCost, currency: "USD" },
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  async destroy() {
+    this.client = null;
+    this.logger?.debug("TwilioSmsProvider destroyed");
+  }
+};
+
+// src/providers/sms/local/base.provider.ts
+var BaseLocalSmsProvider = class {
+  config;
+  logger;
+  retryConfig;
+  constructor(config, options) {
+    this.config = config;
+    this.logger = options?.logger;
+    this.retryConfig = options?.retryConfig ?? DEFAULT_RETRY_CONFIG;
+  }
+  /**
+   * Initialize the provider
+   */
+  async initialize() {
+    if (!this.config.apiKey) {
+      throw new Error(`${this.name}: apiKey is required`);
+    }
+    if (!this.config.senderId) {
+      throw new Error(`${this.name}: senderId is required`);
+    }
+    this.logger?.debug(`${this.name} provider initialized`);
+  }
+  /**
+   * Format phone number for local provider
+   * Pakistan providers typically want: 923001234567 (no + prefix)
+   */
+  formatPhoneNumber(phone) {
+    const e164 = toE164(phone, "PK");
+    if (!e164) return null;
+    return e164.replace("+", "");
+  }
+  /**
+   * Send an SMS message
+   */
+  async send(to, message, options) {
+    const timestamp = /* @__PURE__ */ new Date();
+    const formattedTo = this.formatPhoneNumber(to);
+    if (!formattedTo) {
+      return {
+        success: false,
+        channel: "sms",
+        status: "failed",
+        provider: this.name,
+        error: {
+          code: "INVALID_PHONE_NUMBER",
+          message: `Invalid phone number: ${to}`,
+          retriable: false
+        },
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    if (!formattedTo.startsWith("92")) {
+      return {
+        success: false,
+        channel: "sms",
+        status: "failed",
+        provider: this.name,
+        error: {
+          code: "UNSUPPORTED_DESTINATION",
+          message: "Local SMS providers only support Pakistan numbers",
+          retriable: false
+        },
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    this.logger?.debug(`Sending SMS via ${this.name} to ${formattedTo}`);
+    const result = await withRetry(
+      async () => this.makeRequest(formattedTo, message),
+      this.retryConfig
+    );
+    if (result.success && result.value?.success) {
+      this.logger?.info(`SMS sent via ${this.name}: ${result.value.messageId}`);
+      return {
+        success: true,
+        messageId: result.value.messageId,
+        channel: "sms",
+        status: "sent",
+        provider: this.name,
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    this.logger?.error(`SMS send via ${this.name} failed: ${result.error?.message ?? result.value?.error}`);
+    return {
+      success: false,
+      channel: "sms",
+      status: "failed",
+      provider: this.name,
+      error: createNotifyError(result.error ?? new Error(result.value?.error ?? "Unknown error"), `${this.name.toUpperCase()}_ERROR`),
+      timestamp,
+      metadata: options?.metadata
+    };
+  }
+  /**
+   * Get delivery status (most local providers don't support this)
+   */
+  async getStatus(_messageId) {
+    this.logger?.warn(`${this.name} does not support status queries`);
+    return "unknown";
+  }
+  /**
+   * Send bulk SMS messages
+   */
+  async sendBulk(messages, options) {
+    const startTime = Date.now();
+    const results = [];
+    let sent = 0;
+    let failed = 0;
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      const result = await this.send(msg.to, msg.message, { metadata: msg.metadata });
+      results.push(result);
+      if (result.success) {
+        sent++;
+      } else {
+        failed++;
+        if (options?.stopOnError) {
+          break;
+        }
+      }
+      options?.onProgress?.(i + 1, messages.length);
+      if (options?.rateLimit?.messagesPerSecond && i < messages.length - 1) {
+        const delay = 1e3 / options.rateLimit.messagesPerSecond;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    return {
+      results,
+      summary: {
+        total: messages.length,
+        sent,
+        failed,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  async destroy() {
+    this.logger?.debug(`${this.name} provider destroyed`);
+  }
+};
+
+// src/providers/sms/local/telenor.provider.ts
+var TelenorSmsProvider = class extends BaseLocalSmsProvider {
+  name = "telenor";
+  baseUrl;
+  constructor(config, options) {
+    super(config, options);
+    this.baseUrl = config.baseUrl ?? "https://api.telenor.com.pk/sms/v2/send";
+  }
+  /**
+   * Make API request to Telenor
+   */
+  async makeRequest(to, message) {
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          to,
+          message,
+          sender_id: this.config.senderId,
+          ...this.config.apiSecret && { api_secret: this.config.apiSecret }
+        })
+      });
+      const data = await response.json();
+      if (!response.ok || data.error) {
+        return {
+          success: false,
+          error: data.error ?? data.response?.error ?? `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: true,
+        messageId: data.response?.message_id ?? `tel-${Date.now()}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+// src/providers/sms/local/jazz.provider.ts
+var JazzSmsProvider = class extends BaseLocalSmsProvider {
+  name = "jazz";
+  baseUrl;
+  constructor(config, options) {
+    super(config, options);
+    this.baseUrl = config.baseUrl ?? "https://api.jazz.com.pk/sms/v1/send";
+  }
+  /**
+   * Make API request to Jazz
+   */
+  async makeRequest(to, message) {
+    try {
+      const params = new URLSearchParams({
+        username: this.config.apiKey,
+        ...this.config.apiSecret && { password: this.config.apiSecret },
+        to,
+        text: message,
+        from: this.config.senderId
+      });
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params.toString()
+      });
+      const data = await response.json();
+      if (!response.ok || data.errorCode) {
+        return {
+          success: false,
+          error: data.errorMessage ?? data.errorCode ?? `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: true,
+        messageId: data.messageId ?? `jazz-${Date.now()}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+// src/providers/sms/local/zong.provider.ts
+var ZongSmsProvider = class extends BaseLocalSmsProvider {
+  name = "zong";
+  baseUrl;
+  constructor(config, options) {
+    super(config, options);
+    this.baseUrl = config.baseUrl ?? "https://api.zong.com.pk/sms/send";
+  }
+  /**
+   * Make API request to Zong
+   */
+  async makeRequest(to, message) {
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({
+          recipient: to,
+          message,
+          senderId: this.config.senderId,
+          ...this.config.apiSecret && { apiSecret: this.config.apiSecret }
+        })
+      });
+      const data = await response.json();
+      if (!response.ok || data.responseCode && data.responseCode !== "00" && data.responseCode !== "0") {
+        return {
+          success: false,
+          error: data.responseMessage ?? `Error code: ${data.responseCode}`
+        };
+      }
+      return {
+        success: true,
+        messageId: data.messageId ?? `zong-${Date.now()}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+// src/providers/whatsapp/meta.provider.ts
+var MetaWhatsAppProvider = class {
+  name = "meta";
+  config;
+  logger;
+  retryConfig;
+  apiVersion;
+  baseUrl;
+  constructor(config, options) {
+    this.config = config;
+    this.logger = options?.logger;
+    this.retryConfig = options?.retryConfig ?? DEFAULT_RETRY_CONFIG;
+    this.apiVersion = config.apiVersion ?? "v18.0";
+    this.baseUrl = `https://graph.facebook.com/${this.apiVersion}/${config.phoneNumberId}/messages`;
+  }
+  /**
+   * Initialize the provider (no-op for Meta, just validates config)
+   */
+  async initialize() {
+    if (!this.config.accessToken) {
+      throw new Error("Meta WhatsApp: accessToken is required");
+    }
+    if (!this.config.phoneNumberId) {
+      throw new Error("Meta WhatsApp: phoneNumberId is required");
+    }
+    this.logger?.debug("MetaWhatsAppProvider initialized");
+  }
+  /**
+   * Make an API request to Meta WhatsApp Cloud API
+   */
+  async makeRequest(body) {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.config.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    if (!response.ok || "error" in data) {
+      const error = data.error;
+      const err = new Error(error?.message ?? "Unknown Meta API error");
+      err.code = String(error?.code ?? "UNKNOWN");
+      err.statusCode = response.status;
+      throw err;
+    }
+    return data;
+  }
+  /**
+   * Send a text message (within 24hr conversation window)
+   */
+  async sendText(to, message, options) {
+    const timestamp = /* @__PURE__ */ new Date();
+    const e164 = toE164(to);
+    if (!e164) {
+      return {
+        success: false,
+        channel: "whatsapp",
+        status: "failed",
+        provider: this.name,
+        error: {
+          code: "INVALID_PHONE_NUMBER",
+          message: `Invalid phone number: ${to}`,
+          retriable: false
+        },
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    const whatsappNumber = e164.replace("+", "");
+    this.logger?.debug(`Sending WhatsApp text to ${whatsappNumber}`);
+    const result = await withRetry(
+      async () => {
+        return this.makeRequest({
+          messaging_product: "whatsapp",
+          recipient_type: "individual",
+          to: whatsappNumber,
+          type: "text",
+          text: {
+            preview_url: false,
+            body: message
+          }
+        });
+      },
+      this.retryConfig
+    );
+    if (result.success && result.value) {
+      const messageId = result.value.messages[0]?.id;
+      this.logger?.info(`WhatsApp text sent successfully: ${messageId}`);
+      return {
+        success: true,
+        messageId,
+        channel: "whatsapp",
+        status: "sent",
+        provider: this.name,
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    this.logger?.error(`WhatsApp text send failed: ${result.error?.message}`);
+    return {
+      success: false,
+      channel: "whatsapp",
+      status: "failed",
+      provider: this.name,
+      error: createNotifyError(result.error, "META_API_ERROR"),
+      timestamp,
+      metadata: options?.metadata
+    };
+  }
+  /**
+   * Send a template message (works outside 24hr window)
+   */
+  async sendTemplate(to, template, options) {
+    const timestamp = /* @__PURE__ */ new Date();
+    const e164 = toE164(to);
+    if (!e164) {
+      return {
+        success: false,
+        channel: "whatsapp",
+        status: "failed",
+        provider: this.name,
+        error: {
+          code: "INVALID_PHONE_NUMBER",
+          message: `Invalid phone number: ${to}`,
+          retriable: false
+        },
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    const whatsappNumber = e164.replace("+", "");
+    this.logger?.debug(`Sending WhatsApp template "${template.name}" to ${whatsappNumber}`);
+    const components = [];
+    if (template.header) {
+      const headerComponent = {
+        type: "header",
+        parameters: []
+      };
+      if (template.header.type === "text" && template.header.text) {
+        headerComponent.parameters = [{ type: "text", text: template.header.text }];
+      } else if (template.header.type === "image" && template.header.url) {
+        headerComponent.parameters = [{ type: "image", image: { link: template.header.url } }];
+      } else if (template.header.type === "document" && template.header.url) {
+        headerComponent.parameters = [{ type: "document", document: { link: template.header.url } }];
+      } else if (template.header.type === "video" && template.header.url) {
+        headerComponent.parameters = [{ type: "video", video: { link: template.header.url } }];
+      }
+      if (headerComponent.parameters && headerComponent.parameters.length > 0) {
+        components.push(headerComponent);
+      }
+    }
+    if (template.variables) {
+      const variables = Array.isArray(template.variables) ? template.variables : Object.values(template.variables);
+      if (variables.length > 0) {
+        components.push({
+          type: "body",
+          parameters: variables.map((text) => ({
+            type: "text",
+            text: String(text)
+          }))
+        });
+      }
+    }
+    if (template.buttons && template.buttons.length > 0) {
+      for (const button of template.buttons) {
+        if (button.payload) {
+          components.push({
+            type: "button",
+            sub_type: button.type === "url" ? "url" : "quick_reply",
+            index: button.index,
+            parameters: [{ type: "text", text: button.payload }]
+          });
+        }
+      }
+    }
+    const result = await withRetry(
+      async () => {
+        return this.makeRequest({
+          messaging_product: "whatsapp",
+          recipient_type: "individual",
+          to: whatsappNumber,
+          type: "template",
+          template: {
+            name: template.name,
+            language: {
+              code: template.language
+            },
+            components: components.length > 0 ? components : void 0
+          }
+        });
+      },
+      this.retryConfig
+    );
+    if (result.success && result.value) {
+      const messageId = result.value.messages[0]?.id;
+      this.logger?.info(`WhatsApp template sent successfully: ${messageId}`);
+      return {
+        success: true,
+        messageId,
+        channel: "whatsapp",
+        status: "sent",
+        provider: this.name,
+        timestamp,
+        metadata: options?.metadata
+      };
+    }
+    this.logger?.error(`WhatsApp template send failed: ${result.error?.message}`);
+    return {
+      success: false,
+      channel: "whatsapp",
+      status: "failed",
+      provider: this.name,
+      error: createNotifyError(result.error, "META_API_ERROR"),
+      timestamp,
+      metadata: options?.metadata
+    };
+  }
+  /**
+   * Get delivery status of a message
+   * Note: Meta doesn't have a direct status lookup API - statuses come via webhooks
+   */
+  async getStatus(_messageId) {
+    this.logger?.warn("Meta WhatsApp does not support direct status queries. Use webhooks instead.");
+    return "unknown";
+  }
+  /**
+   * Cleanup resources (no-op for Meta)
+   */
+  async destroy() {
+    this.logger?.debug("MetaWhatsAppProvider destroyed");
+  }
+};
+
+// src/notify-hub.ts
+var noopLogger = {
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+var NotifyHub = class {
+  config;
+  logger;
+  retryConfig;
+  // Providers
+  primarySmsProvider;
+  fallbackSmsProvider;
+  whatsappProvider;
+  emailProvider;
+  // Initialization state
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? noopLogger;
+    this.retryConfig = config.retry ?? DEFAULT_RETRY_CONFIG;
+  }
+  /**
+   * Initialize all configured providers
+   */
+  async initialize() {
+    if (this.initialized) return;
+    this.logger.debug("Initializing NotifyHub");
+    if (this.config.sms) {
+      this.primarySmsProvider = await this.createSmsProvider(
+        this.config.sms.primary
+      );
+      if (this.config.sms.fallback) {
+        this.fallbackSmsProvider = await this.createSmsProvider(
+          this.config.sms.fallback
+        );
+      }
+    }
+    if (this.config.whatsapp) {
+      this.whatsappProvider = await this.createWhatsAppProvider(
+        this.config.whatsapp
+      );
+    }
+    if (this.config.email) {
+      this.emailProvider = await this.createEmailProvider(this.config.email);
+    }
+    this.initialized = true;
+    this.logger.info("NotifyHub initialized");
+  }
+  /**
+   * Create an SMS provider from configuration
+   */
+  async createSmsProvider(config) {
+    if (config.provider === "custom" && config.instance) {
+      return config.instance;
+    }
+    if (config.provider === "twilio") {
+      const twilioConfig = config.config;
+      const provider = new TwilioSmsProvider(twilioConfig, {
+        logger: this.logger,
+        retryConfig: this.retryConfig
+      });
+      await provider.initialize();
+      return provider;
+    }
+    if (config.provider === "local") {
+      const localConfig = config.config;
+      let provider;
+      switch (localConfig.provider) {
+        case "telenor":
+          provider = new TelenorSmsProvider(localConfig, {
+            logger: this.logger,
+            retryConfig: this.retryConfig
+          });
+          break;
+        case "jazz":
+          provider = new JazzSmsProvider(localConfig, {
+            logger: this.logger,
+            retryConfig: this.retryConfig
+          });
+          break;
+        case "zong":
+          provider = new ZongSmsProvider(localConfig, {
+            logger: this.logger,
+            retryConfig: this.retryConfig
+          });
+          break;
+        default:
+          throw new Error(`Unknown local SMS provider: ${localConfig.provider}`);
+      }
+      await provider.initialize();
+      return provider;
+    }
+    throw new Error(`Unknown SMS provider: ${config.provider}`);
+  }
+  /**
+   * Create a WhatsApp provider from configuration
+   */
+  async createWhatsAppProvider(config) {
+    if (config.provider === "custom" && config.instance) {
+      return config.instance;
+    }
+    if (config.provider === "meta") {
+      const metaConfig = config.config;
+      const provider = new MetaWhatsAppProvider(metaConfig, {
+        logger: this.logger,
+        retryConfig: this.retryConfig
+      });
+      await provider.initialize();
+      return provider;
+    }
+    throw new Error(`Unknown WhatsApp provider: ${config.provider}`);
+  }
+  /**
+   * Create an Email provider from configuration
+   */
+  async createEmailProvider(config) {
+    if (config.provider === "custom" && config.instance) {
+      return config.instance;
+    }
+    if (config.provider === "ses") {
+      throw new Error("SES email provider not yet implemented");
+    }
+    throw new Error(`Unknown email provider: ${config.provider}`);
+  }
+  /**
+   * Ensure NotifyHub is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Get the appropriate SMS provider based on phone number
+   */
+  getSmsProvider(to) {
+    if (!this.primarySmsProvider) {
+      throw new Error("SMS provider not configured");
+    }
+    if (!this.config.sms?.routing || !this.fallbackSmsProvider) {
+      return this.primarySmsProvider;
+    }
+    const e164 = toE164(to);
+    if (!e164) {
+      return this.primarySmsProvider;
+    }
+    const route = routeByPrefix(e164, this.config.sms.routing);
+    return route === "fallback" && this.fallbackSmsProvider ? this.fallbackSmsProvider : this.primarySmsProvider;
+  }
+  // ==================== SMS METHODS ====================
+  /**
+   * Send an SMS message
+   * @param to Phone number in any format (will be converted to E.164)
+   * @param message Message content
+   * @param options Additional options
+   */
+  async sms(to, message, options) {
+    await this.ensureInitialized();
+    const provider = this.getSmsProvider(to);
+    this.logger.debug(`Sending SMS via ${provider.name} to ${to}`);
+    try {
+      const result = await provider.send(to, message, options);
+      if (!result.success && result.error?.retriable && this.fallbackSmsProvider && provider !== this.fallbackSmsProvider) {
+        this.logger.warn(
+          `Primary SMS provider failed, trying fallback: ${result.error.message}`
+        );
+        return this.fallbackSmsProvider.send(to, message, options);
+      }
+      return result;
+    } catch (error) {
+      this.logger.error(`SMS send error: ${error}`);
+      if (this.fallbackSmsProvider && provider !== this.fallbackSmsProvider) {
+        this.logger.warn("Primary SMS provider threw, trying fallback");
+        return this.fallbackSmsProvider.send(to, message, options);
+      }
+      return {
+        success: false,
+        channel: "sms",
+        status: "failed",
+        provider: provider.name,
+        error: {
+          code: "SEND_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          retriable: false
+        },
+        timestamp: /* @__PURE__ */ new Date(),
+        metadata: options?.metadata
+      };
+    }
+  }
+  /**
+   * Send bulk SMS messages
+   */
+  async bulkSms(messages, options) {
+    await this.ensureInitialized();
+    if (!this.primarySmsProvider) {
+      throw new Error("SMS provider not configured");
+    }
+    if (this.primarySmsProvider.sendBulk) {
+      return this.primarySmsProvider.sendBulk(messages, options);
+    }
+    const startTime = Date.now();
+    const results = [];
+    let sent = 0;
+    let failed = 0;
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      const result = await this.sms(msg.to, msg.message, { metadata: msg.metadata });
+      results.push(result);
+      if (result.success) {
+        sent++;
+      } else {
+        failed++;
+        if (options?.stopOnError) {
+          break;
+        }
+      }
+      options?.onProgress?.(i + 1, messages.length);
+      if (options?.rateLimit?.messagesPerSecond && i < messages.length - 1) {
+        const delay = 1e3 / options.rateLimit.messagesPerSecond;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    return {
+      results,
+      summary: {
+        total: messages.length,
+        sent,
+        failed,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Get SMS delivery status
+   */
+  async getSmsStatus(messageId) {
+    await this.ensureInitialized();
+    if (!this.primarySmsProvider?.getStatus) {
+      throw new Error("SMS provider does not support status checks");
+    }
+    return this.primarySmsProvider.getStatus(messageId);
+  }
+  // ==================== WHATSAPP METHODS ====================
+  /**
+   * Send a WhatsApp text message (within 24hr window)
+   */
+  async whatsapp(to, message, options) {
+    await this.ensureInitialized();
+    if (!this.whatsappProvider) {
+      throw new Error("WhatsApp provider not configured");
+    }
+    return this.whatsappProvider.sendText(to, message, options);
+  }
+  /**
+   * Send a WhatsApp template message
+   */
+  async whatsappTemplate(to, template, options) {
+    await this.ensureInitialized();
+    if (!this.whatsappProvider) {
+      throw new Error("WhatsApp provider not configured");
+    }
+    return this.whatsappProvider.sendTemplate(to, template, options);
+  }
+  /**
+   * Send bulk WhatsApp messages
+   */
+  async bulkWhatsApp(messages, options) {
+    await this.ensureInitialized();
+    if (!this.whatsappProvider) {
+      throw new Error("WhatsApp provider not configured");
+    }
+    const startTime = Date.now();
+    const results = [];
+    let sent = 0;
+    let failed = 0;
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      let result;
+      if (msg.template) {
+        result = await this.whatsappTemplate(msg.to, msg.template, {
+          metadata: msg.metadata
+        });
+      } else if (msg.message) {
+        result = await this.whatsapp(msg.to, msg.message, { metadata: msg.metadata });
+      } else {
+        result = {
+          success: false,
+          channel: "whatsapp",
+          status: "failed",
+          provider: this.whatsappProvider.name,
+          error: {
+            code: "INVALID_MESSAGE",
+            message: "Message must have either message or template",
+            retriable: false
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+      results.push(result);
+      if (result.success) {
+        sent++;
+      } else {
+        failed++;
+        if (options?.stopOnError) {
+          break;
+        }
+      }
+      options?.onProgress?.(i + 1, messages.length);
+      if (options?.rateLimit?.messagesPerSecond && i < messages.length - 1) {
+        const delay = 1e3 / options.rateLimit.messagesPerSecond;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    return {
+      results,
+      summary: {
+        total: messages.length,
+        sent,
+        failed,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  // ==================== EMAIL METHODS ====================
+  /**
+   * Send an email
+   */
+  async email(to, email, options) {
+    await this.ensureInitialized();
+    if (!this.emailProvider) {
+      throw new Error("Email provider not configured");
+    }
+    return this.emailProvider.send(to, email, options);
+  }
+  /**
+   * Send bulk emails
+   */
+  async bulkEmail(messages, options) {
+    await this.ensureInitialized();
+    if (!this.emailProvider) {
+      throw new Error("Email provider not configured");
+    }
+    if (this.emailProvider.sendBulk) {
+      return this.emailProvider.sendBulk(messages, options);
+    }
+    const startTime = Date.now();
+    const results = [];
+    let sent = 0;
+    let failed = 0;
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      const result = await this.email(msg.to, msg, { metadata: msg.metadata });
+      results.push(result);
+      if (result.success) {
+        sent++;
+      } else {
+        failed++;
+        if (options?.stopOnError) {
+          break;
+        }
+      }
+      options?.onProgress?.(i + 1, messages.length);
+    }
+    return {
+      results,
+      summary: {
+        total: messages.length,
+        sent,
+        failed,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  // ==================== GENERIC SEND ====================
+  /**
+   * Send a notification using the specified channel
+   */
+  async send(notification) {
+    switch (notification.channel) {
+      case "sms":
+        if (!notification.message) {
+          return {
+            success: false,
+            channel: "sms",
+            status: "failed",
+            provider: "unknown",
+            error: {
+              code: "INVALID_NOTIFICATION",
+              message: "SMS notification requires message",
+              retriable: false
+            },
+            timestamp: /* @__PURE__ */ new Date()
+          };
+        }
+        return this.sms(notification.to, notification.message, {
+          metadata: notification.metadata
+        });
+      case "whatsapp":
+        if (notification.template) {
+          return this.whatsappTemplate(notification.to, notification.template, {
+            metadata: notification.metadata
+          });
+        }
+        if (notification.message) {
+          return this.whatsapp(notification.to, notification.message, {
+            metadata: notification.metadata
+          });
+        }
+        return {
+          success: false,
+          channel: "whatsapp",
+          status: "failed",
+          provider: "unknown",
+          error: {
+            code: "INVALID_NOTIFICATION",
+            message: "WhatsApp notification requires message or template",
+            retriable: false
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      case "email":
+        if (!notification.email) {
+          return {
+            success: false,
+            channel: "email",
+            status: "failed",
+            provider: "unknown",
+            error: {
+              code: "INVALID_NOTIFICATION",
+              message: "Email notification requires email object",
+              retriable: false
+            },
+            timestamp: /* @__PURE__ */ new Date()
+          };
+        }
+        return this.email(notification.to, notification.email, {
+          metadata: notification.metadata
+        });
+      default:
+        return {
+          success: false,
+          channel: notification.channel,
+          status: "failed",
+          provider: "unknown",
+          error: {
+            code: "INVALID_CHANNEL",
+            message: `Unknown channel: ${notification.channel}`,
+            retriable: false
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+    }
+  }
+  // ==================== LIFECYCLE ====================
+  /**
+   * Cleanup and destroy all providers
+   */
+  async destroy() {
+    this.logger.debug("Destroying NotifyHub");
+    await Promise.all([
+      this.primarySmsProvider?.destroy?.(),
+      this.fallbackSmsProvider?.destroy?.(),
+      this.whatsappProvider?.destroy?.(),
+      this.emailProvider?.destroy?.()
+    ]);
+    this.primarySmsProvider = void 0;
+    this.fallbackSmsProvider = void 0;
+    this.whatsappProvider = void 0;
+    this.emailProvider = void 0;
+    this.initialized = false;
+    this.logger.info("NotifyHub destroyed");
+  }
+};
+function mapTwilioStatus2(status) {
+  const statusMap = {
+    queued: "queued",
+    sending: "queued",
+    sent: "sent",
+    delivered: "delivered",
+    undelivered: "undelivered",
+    failed: "failed",
+    read: "read",
+    accepted: "queued"
+  };
+  return statusMap[status.toLowerCase()] ?? "unknown";
+}
+var TwilioWebhookHandler = class {
+  authToken;
+  constructor(authToken) {
+    this.authToken = authToken;
+  }
+  /**
+   * Verify Twilio webhook signature
+   * @see https://www.twilio.com/docs/usage/webhooks/webhooks-security
+   */
+  verify(body, headers) {
+    const signature = headers["x-twilio-signature"] ?? headers["X-Twilio-Signature"];
+    const url = headers["x-original-url"] ?? headers["X-Original-Url"] ?? "";
+    if (!signature || !url) {
+      return false;
+    }
+    const params = body;
+    let validationString = url;
+    if (params && typeof params === "object") {
+      const sortedKeys = Object.keys(params).sort();
+      for (const key of sortedKeys) {
+        validationString += key + params[key];
+      }
+    }
+    const expectedSignature = crypto.createHmac("sha1", this.authToken).update(validationString, "utf-8").digest("base64");
+    try {
+      return crypto.timingSafeEqual(
+        Buffer.from(signature),
+        Buffer.from(expectedSignature)
+      );
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Parse Twilio webhook payload
+   */
+  parse(body) {
+    const events = [];
+    if ("MessageStatus" in body) {
+      const statusEvent = {
+        type: "status",
+        messageId: body.MessageSid,
+        channel: "sms",
+        timestamp: /* @__PURE__ */ new Date(),
+        provider: "twilio",
+        status: mapTwilioStatus2(body.MessageStatus),
+        to: body.To,
+        error: body.ErrorCode ? {
+          code: body.ErrorCode,
+          message: body.ErrorMessage ?? "Unknown error",
+          retriable: false
+        } : void 0
+      };
+      events.push(statusEvent);
+    } else if ("Body" in body) {
+      const messageEvent = {
+        type: "message",
+        messageId: body.MessageSid,
+        channel: "sms",
+        timestamp: /* @__PURE__ */ new Date(),
+        provider: "twilio",
+        from: body.From,
+        message: body.Body,
+        mediaUrl: body.MediaUrl0,
+        mediaType: body.MediaContentType0
+      };
+      events.push(messageEvent);
+    }
+    return events;
+  }
+};
+function createTwilioWebhookHandler(authToken) {
+  return new TwilioWebhookHandler(authToken);
+}
+function mapMetaStatus(status) {
+  const statusMap = {
+    sent: "sent",
+    delivered: "delivered",
+    read: "read",
+    failed: "failed"
+  };
+  return statusMap[status.toLowerCase()] ?? "unknown";
+}
+var WhatsAppWebhookHandler = class {
+  appSecret;
+  verifyToken;
+  constructor(appSecret, verifyToken) {
+    this.appSecret = appSecret;
+    this.verifyToken = verifyToken;
+  }
+  /**
+   * Verify WhatsApp webhook challenge (for initial setup)
+   */
+  verifyChallenge(verifyToken, challenge) {
+    if (verifyToken === this.verifyToken) {
+      return challenge;
+    }
+    return null;
+  }
+  /**
+   * Verify Meta webhook signature
+   * @see https://developers.facebook.com/docs/graph-api/webhooks/getting-started#verification-requests
+   */
+  verify(body, headers) {
+    const signature = headers["x-hub-signature-256"] ?? headers["X-Hub-Signature-256"];
+    if (!signature || !this.appSecret) {
+      return false;
+    }
+    const rawBody = typeof body === "string" ? body : JSON.stringify(body);
+    const expectedSignature = "sha256=" + crypto.createHmac("sha256", this.appSecret).update(rawBody, "utf-8").digest("hex");
+    try {
+      return crypto.timingSafeEqual(
+        Buffer.from(signature),
+        Buffer.from(expectedSignature)
+      );
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Parse Meta WhatsApp webhook payload
+   */
+  parse(body) {
+    const events = [];
+    if (body.object !== "whatsapp_business_account") {
+      return events;
+    }
+    for (const entry of body.entry) {
+      for (const change of entry.changes) {
+        if (change.field !== "messages") continue;
+        const value = change.value;
+        if (value.statuses) {
+          for (const status of value.statuses) {
+            const statusEvent = {
+              type: "status",
+              messageId: status.id,
+              channel: "whatsapp",
+              timestamp: new Date(parseInt(status.timestamp) * 1e3),
+              provider: "meta",
+              status: mapMetaStatus(status.status),
+              to: status.recipient_id,
+              error: status.errors && status.errors.length > 0 ? {
+                code: String(status.errors[0].code),
+                message: status.errors[0].message ?? status.errors[0].title,
+                retriable: false
+              } : void 0
+            };
+            events.push(statusEvent);
+          }
+        }
+        if (value.messages) {
+          for (const message of value.messages) {
+            let messageText;
+            let mediaType;
+            switch (message.type) {
+              case "text":
+                messageText = message.text?.body;
+                break;
+              case "button":
+                messageText = message.button?.text;
+                break;
+              case "interactive":
+                messageText = message.interactive?.button_reply?.title ?? message.interactive?.list_reply?.title;
+                break;
+              case "image":
+                mediaType = message.image?.mime_type;
+                break;
+              case "document":
+                mediaType = message.document?.mime_type;
+                break;
+              case "audio":
+                mediaType = message.audio?.mime_type;
+                break;
+              case "video":
+                mediaType = message.video?.mime_type;
+                break;
+            }
+            const messageEvent = {
+              type: "message",
+              messageId: message.id,
+              channel: "whatsapp",
+              timestamp: new Date(parseInt(message.timestamp) * 1e3),
+              provider: "meta",
+              from: message.from,
+              message: messageText,
+              mediaType
+            };
+            events.push(messageEvent);
+          }
+        }
+      }
+    }
+    return events;
+  }
+};
+function createWhatsAppWebhookHandler(appSecret, verifyToken) {
+  return new WhatsAppWebhookHandler(appSecret, verifyToken);
+}
+
+export { BaseLocalSmsProvider, DEFAULT_RETRY_CONFIG, JazzSmsProvider, MetaWhatsAppProvider, NotifyHub, TelenorSmsProvider, TwilioSmsProvider, TwilioWebhookHandler, WhatsAppWebhookHandler, ZongSmsProvider, calculateBackoff, cleanPhoneNumber, createNotifyError, createTwilioWebhookHandler, createWhatsAppWebhookHandler, getCallingCode, getCountryCode, getPakistanNetwork, isCountry, isPakistanMobile, isRetriableError, routeByPrefix, toE164, validatePhoneNumber, withRetry };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map