@mirad-work/sms-core/dist/drivers/ippanel-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.IppanelDriver = void 0;
const base_driver_1 = require("./base-driver");
const sms_exceptions_1 = require("../exceptions/sms-exceptions");
/**
 * IPPanel SMS driver implementation
 * Implements the Iranian IPPanel SMS API
 */
class IppanelDriver extends base_driver_1.BaseSmsDriver {
    constructor(config, httpClient) {
        super(config, httpClient);
        this.ippanelConfig = config;
    }
    /**
     * Build headers with API key for IPPanel requests
     */
    buildHeaders(additionalHeaders = {}) {
        return {
            ...super.buildHeaders(),
            apikey: this.ippanelConfig.apiKey,
            ...additionalHeaders,
        };
    }
    /**
     * 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 url = this.buildUrl("api/v1/sms/pattern/normal/send");
            const payload = this.buildVerifyPayload(message);
            this.log("info", "Sending verification SMS via IPPanel", {
                to: message.to,
                template: message.template,
            });
            const response = await this.handleHttpRequest(() => this.httpClient.post(url, payload, {
                headers: this.buildHeaders(),
            }));
            return this.processIppanelResponse(response.data);
        }
        catch (error) {
            // Check if it's an HttpException with response data that might be IPPanel response
            if (error instanceof sms_exceptions_1.HttpException && error._originalError) {
                // Try to parse the original error as IPPanel response
                const responseData = error._originalError;
                if (responseData &&
                    typeof responseData === "object" &&
                    "code" in responseData) {
                    return this.processIppanelResponse(responseData);
                }
            }
            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 variable = {};
        // Handle different token formats
        if (Array.isArray(message.tokens)) {
            // Positional tokens - convert to named variables
            const tokens = message.tokens;
            tokens.forEach((token, index) => {
                if (token !== undefined) {
                    // Use common variable names based on position
                    const varName = index === 0 ? "name" : `var${index + 1}`;
                    variable[varName] = String(token);
                }
            });
        }
        else {
            // Named tokens - use as is
            const tokens = message.tokens;
            Object.entries(tokens).forEach(([name, value]) => {
                if (value !== undefined) {
                    variable[name] = String(value);
                }
            });
        }
        // Use sender from message or fallback to config lineNumber
        const sender = message.from || this.ippanelConfig.lineNumber;
        return {
            code: message.template,
            sender,
            recipient: message.to,
            variable,
        };
    }
    /**
     * Process IPPanel API response and convert to standard format
     */
    processIppanelResponse(response) {
        // IPPanel returns 200 status code for successful requests
        // Check the response status field for business logic status
        if (response.code === 200) {
            const messageId = response.data?.messageId;
            return this.createSuccessResponse(response, messageId);
        }
        else {
            // Handle different error formats
            let errorMessage = "Unknown error";
            if (typeof response.errorMessage === "string") {
                errorMessage = response.errorMessage;
            }
            else if (response.errorMessage &&
                typeof response.errorMessage === "object") {
                // Handle validation errors (422) where errorMessage is an object
                const errorObj = response.errorMessage;
                const errorMessages = [];
                Object.entries(errorObj).forEach(([key, value]) => {
                    if (Array.isArray(value)) {
                        errorMessages.push(`${key}: ${value.join(", ")}`);
                    }
                    else {
                        errorMessages.push(`${key}: ${String(value)}`);
                    }
                });
                errorMessage = errorMessages.join("; ") || "Unknown error";
            }
            else if (response.status) {
                errorMessage = response.status;
            }
            return this.createErrorResponse(errorMessage, `IPPANEL_${response.code}`, response);
        }
    }
}
exports.IppanelDriver = IppanelDriver;
//# sourceMappingURL=ippanel-driver.js.map