telegram-management-system/marketing-agent/shared/utils/templateClient.js

import axios from 'axios';

/**
 * Template client for rendering message templates
 * Used by other services to render templates before sending messages
 */
export class TemplateClient {
    constructor(config = {}) {
        this.baseURL = config.baseURL || process.env.TEMPLATE_SERVICE_URL || 'http://localhost:3010';
        this.timeout = config.timeout || 30000;
        this.apiVersion = config.apiVersion || 'v1';
        this.authToken = config.authToken;
        
        this.client = axios.create({
            baseURL: `${this.baseURL}/api/${this.apiVersion}`,
            timeout: this.timeout,
            headers: {
                'Content-Type': 'application/json'
            }
        });
        
        // Add auth header if token provided
        if (this.authToken) {
            this.client.defaults.headers['Authorization'] = `Bearer ${this.authToken}`;
        }
        
        // Add request interceptor for internal service header
        this.client.interceptors.request.use(config => {
            config.headers['X-Internal-Service'] = process.env.SERVICE_NAME || 'unknown';
            return config;
        });
    }
    
    /**
     * Render a template with data
     */
    async renderTemplate(templateId, data = {}, options = {}) {
        try {
            const response = await this.client.post('/templates/render', {
                templateId,
                data,
                preview: options.preview || false,
                format: options.format // Optional: override template format
            });
            
            return {
                success: true,
                content: response.data.content,
                format: response.data.format,
                metadata: response.data.metadata
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message,
                details: error.response?.data?.details
            };
        }
    }
    
    /**
     * Render a template by name and language
     */
    async renderTemplateByName(name, language, data = {}, options = {}) {
        try {
            const response = await this.client.post('/templates/render-by-name', {
                name,
                language,
                data,
                preview: options.preview || false
            });
            
            return {
                success: true,
                content: response.data.content,
                format: response.data.format,
                metadata: response.data.metadata
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message,
                details: error.response?.data?.details
            };
        }
    }
    
    /**
     * Get a template by ID (for caching or local rendering)
     */
    async getTemplate(templateId) {
        try {
            const response = await this.client.get(`/templates/${templateId}`);
            return {
                success: true,
                template: response.data.template
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message
            };
        }
    }
    
    /**
     * Get all templates for a category
     */
    async getTemplatesByCategory(categoryId) {
        try {
            const response = await this.client.get('/templates', {
                params: { category: categoryId }
            });
            return {
                success: true,
                templates: response.data.templates
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message
            };
        }
    }
    
    /**
     * Validate template data before rendering
     */
    async validateTemplateData(templateId, data) {
        try {
            const response = await this.client.post('/templates/validate-data', {
                templateId,
                data
            });
            
            return {
                success: true,
                valid: response.data.valid,
                errors: response.data.errors || []
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message
            };
        }
    }
    
    /**
     * Get available variables for a template category
     */
    async getCategoryVariables(category) {
        try {
            const response = await this.client.get('/template-variables/available', {
                params: { category }
            });
            
            return {
                success: true,
                variables: response.data.variables
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message
            };
        }
    }
    
    /**
     * Batch render multiple templates
     */
    async batchRenderTemplates(requests) {
        try {
            const response = await this.client.post('/templates/batch-render', {
                requests
            });
            
            return {
                success: true,
                results: response.data.results
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message
            };
        }
    }
    
    /**
     * Get sample data for testing templates
     */
    async getSampleData(category) {
        try {
            const response = await this.client.get('/template-variables/sample-data', {
                params: { category }
            });
            
            return {
                success: true,
                sampleData: response.data.sampleData
            };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.error || error.message
            };
        }
    }
}

// Singleton instance for easy import
let defaultClient = null;

export const getTemplateClient = (config) => {
    if (!defaultClient) {
        defaultClient = new TemplateClient(config);
    }
    return defaultClient;
};

// Direct exports for convenience
export const renderTemplate = async (templateId, data, options) => {
    const client = getTemplateClient();
    return client.renderTemplate(templateId, data, options);
};

export const renderTemplateByName = async (name, language, data, options) => {
    const client = getTemplateClient();
    return client.renderTemplateByName(name, language, data, options);
};