@mirad-work/sms-core/dist/drivers/mock-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.MockDriver = void 0;
const base_driver_1 = require("./base-driver");
/**
 * Mock SMS driver for testing purposes
 * Simulates SMS operations without making actual API calls
 */
class MockDriver extends base_driver_1.BaseSmsDriver {
    constructor(config, httpClient) {
        // Mock driver doesn't need a real URL, so we provide a dummy one
        const mockBaseConfig = {
            url: "https://mock-sms-provider.com",
        };
        super(mockBaseConfig, httpClient);
        this.sentMessages = new Map();
        this.messageIdCounter = 1;
        this.mockConfig = config;
    }
    /**
     * Mock verify SMS implementation
     */
    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");
        }
        // Simulate network delay
        if (this.mockConfig.delay) {
            await this.delay(this.mockConfig.delay);
        }
        // Simulate failure if configured
        if (this.mockConfig.shouldFail) {
            return this.createErrorResponse("Mock driver configured to fail", "MOCK_FAILURE");
        }
        const messageId = this.generateMessageId();
        const status = "sent";
        // Generate mock content based on template and tokens
        const mockContent = this.processTemplate(message);
        // Store message for later retrieval
        this.sentMessages.set(messageId, {
            message: {
                ...message,
                content: mockContent,
            },
            messageId,
            status,
            sentAt: new Date(),
        });
        this.log("info", "Mock verification SMS sent successfully", {
            messageId,
            to: message.to,
            template: message.template,
        });
        return this.createSuccessResponse({
            provider: "mock",
            timestamp: new Date().toISOString(),
            recipient: message.to,
            template: message.template,
            processedContent: mockContent,
        }, messageId);
    }
    /**
     * Generate a mock message ID
     */
    generateMessageId() {
        return `mock-${Date.now()}-${this.messageIdCounter++}`;
    }
    /**
     * Process template with tokens to create mock content
     */
    processTemplate(message) {
        let content = `[Template: ${message.template}]`;
        if (message.tokens) {
            if (Array.isArray(message.tokens)) {
                content += ` Tokens: [${message.tokens.join(", ")}]`;
            }
            else {
                content += ` Tokens: ${JSON.stringify(message.tokens)}`;
            }
        }
        return content;
    }
    /**
     * Simple delay utility for simulating network latency
     */
    delay(ms) {
        return new Promise((resolve) => setTimeout(resolve, ms));
    }
}
exports.MockDriver = MockDriver;
//# sourceMappingURL=mock-driver.js.map