@mirad-work/sms-core/dist/drivers/kavenegar-driver.js

A framework-agnostic TypeScript SMS service core with provider abstraction for Iranian SMS providers

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.KavenegarDriver = void 0;
const base_driver_1 = require("./base-driver");
const url_utils_1 = require("../utils/url-utils");
/**
 * Kavenegar SMS driver implementation
 * Implements the Iranian Kavenegar SMS API
 */
class KavenegarDriver extends base_driver_1.BaseSmsDriver {
    constructor(config, httpClient) {
        super(config, httpClient);
        this.kavenegarConfig = config;
    }
    /**
     * Send a template-based SMS message (OTP/verification)
     */
    async verify(message) {
        this.validateMessage(message);
        if (!message.template) {
            return this.createErrorResponse("Template is required for verify operation", "MISSING_TEMPLATE");
        }
        if (!message.tokens) {
            return this.createErrorResponse("Tokens are required for verify operation", "MISSING_TOKENS");
        }
        try {
            const baseUrl = this.buildUrl(`${this.kavenegarConfig.apiKey}/verify/lookup.json`);
            const payload = this.buildVerifyPayload(message);
            const url = (0, url_utils_1.buildUrlWithParams)(baseUrl, payload);
            this.log("info", "Sending verification SMS via Kavenegar", {
                to: message.to,
                template: message.template,
            });
            const response = await this.handleHttpRequest(() => this.httpClient.get(url, {
                headers: this.buildHeaders(),
            }));
            return this.processKavenegarResponse(response.data);
        }
        catch (error) {
            const err = error;
            this.log("error", "SMS verify failed", { error: err.message });
            return this.createErrorResponse(err.message, "VERIFY_FAILED");
        }
    }
    /**
     * Build payload for verify/OTP requests
     */
    buildVerifyPayload(message) {
        const payload = {
            receptor: message.to,
            template: message.template,
        };
        // Handle different token formats
        if (Array.isArray(message.tokens)) {
            // Positional tokens
            const tokens = message.tokens;
            if (tokens[0] !== undefined)
                payload.token = String(tokens[0]);
            if (tokens[1] !== undefined)
                payload.token2 = String(tokens[1]);
            if (tokens[2] !== undefined)
                payload.token3 = String(tokens[2]);
            if (tokens[3] !== undefined)
                payload.token10 = String(tokens[3]);
            if (tokens[4] !== undefined)
                payload.token20 = String(tokens[4]);
        }
        else {
            // Named tokens (convert to Kavenegar format)
            const tokens = message.tokens;
            if (tokens.token || tokens.code) {
                payload.token = String(tokens.token || tokens.code);
            }
            if (tokens.token2)
                payload.token2 = String(tokens.token2);
            if (tokens.token3)
                payload.token3 = String(tokens.token3);
            if (tokens.token10)
                payload.token10 = String(tokens.token10);
            if (tokens.token20)
                payload.token20 = String(tokens.token20);
        }
        return payload;
    }
    /**
     * Process Kavenegar API response and convert to standard format
     */
    processKavenegarResponse(response) {
        if (response.return.status === 200) {
            const messageId = response.entries?.[0]?.messageid?.toString();
            return this.createSuccessResponse(response, messageId);
        }
        else {
            const errorMessage = response.return.message || "Unknown error";
            return this.createErrorResponse(errorMessage, `KAVENEGAR_${response.return.status}`, response);
        }
    }
}
exports.KavenegarDriver = KavenegarDriver;
//# sourceMappingURL=kavenegar-driver.js.map