@ackplus/nest-dynamic-templates 1.1.2 → 1.1.6

package/src/lib/services/template.service.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const template_entity_1 = require("../entities/template.entity");
+const template_types_1 = require("../interfaces/template.types");
+const template_layout_service_1 = require("./template-layout.service");
+const template_engine_registry_1 = require("./template-engine.registry");
+const lodash_1 = require("lodash");
+const template_errors_1 = require("../errors/template.errors");
+let TemplateService = class TemplateService {
+    constructor(templateRepository, engineRegistry, templateLayoutService) {
+        this.templateRepository = templateRepository;
+        this.engineRegistry = engineRegistry;
+        this.templateLayoutService = templateLayoutService;
+    }
+    async render(renderDto) {
+        const { name, scope, scopeId, locale, context } = renderDto;
+        try {
+            // Find template with fallback
+            if (!name) {
+                throw new common_1.BadRequestException('Template name is required');
+            }
+            const template = await this.findTemplate(name, scope || 'system', scopeId, locale);
+            if (!template) {
+                throw new common_1.NotFoundException(`Template not found: ${name} in scope ${scope || 'system'}`);
+            }
+            let content = template.content;
+            let subject = template.subject;
+            // Render subject by template engine
+            if (template.subject && template.engine) {
+                try {
+                    const subjectEngine = this.engineRegistry.getTemplateEngine(template.engine);
+                    subject = await subjectEngine.render(template.subject, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateEngineError(template.engine, error);
+                }
+            }
+            // Render content by template engine
+            if (template.engine) {
+                try {
+                    content = await this.renderEngine(template.engine, content, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateEngineError(template.engine, error);
+                }
+            }
+            // If template has layout, apply it
+            let layout;
+            if (template.templateLayoutName) {
+                try {
+                    layout = await this.templateLayoutService.render({
+                        name: template.templateLayoutName,
+                        scope: scope || 'system',
+                        scopeId,
+                        locale,
+                        context: {
+                            ...(context || {}),
+                            content
+                        }
+                    });
+                    content = layout.content;
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateLayoutError(template.templateLayoutName, error);
+                }
+            }
+            // If template has language format, process with language engine
+            if (!layout && template.language) {
+                try {
+                    content = await this.renderLanguage(template.language, content, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateLanguageError(template.language, error);
+                }
+            }
+            return {
+                subject: subject || '',
+                content
+            };
+        }
+        catch (error) {
+            // Re-throw known template errors
+            if (error instanceof template_errors_1.TemplateEngineError ||
+                error instanceof template_errors_1.TemplateLanguageError ||
+                error instanceof template_errors_1.TemplateLayoutError ||
+                error instanceof common_1.NotFoundException) {
+                throw error;
+            }
+            // Wrap unknown errors
+            throw new template_errors_1.TemplateRenderError('template rendering', error, name);
+        }
+    }
+    async renderContent(input) {
+        const { content, language, engine, context, templateLayoutId } = input;
+        try {
+            if (!content) {
+                throw new common_1.BadRequestException('Content is required for rendering');
+            }
+            let renderContent = content;
+            // Step 1: Render template variables first
+            try {
+                renderContent = await this.renderEngine(engine || template_types_1.TemplateEngineEnum.NUNJUCKS, renderContent, context || {});
+            }
+            catch (error) {
+                throw new template_errors_1.TemplateEngineError(engine || template_types_1.TemplateEngineEnum.NUNJUCKS, error);
+            }
+            // Step 2: Handle MJML with layouts intelligently
+            let templateLayout = null;
+            if (templateLayoutId) {
+                try {
+                    templateLayout = await this.templateLayoutService.getTemplateLayoutById(templateLayoutId);
+                    if (!templateLayout) {
+                        throw new common_1.NotFoundException(`Template layout not found with ID: ${templateLayoutId}`);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof common_1.NotFoundException) {
+                        throw error;
+                    }
+                    throw new template_errors_1.TemplateContentError('template layout retrieval', error);
+                }
+                if (templateLayout) {
+                    try {
+                        // Step 3: Render the layout content
+                        renderContent = await this.templateLayoutService.renderContent({
+                            content: templateLayout.content,
+                            language: language,
+                            engine: engine,
+                            context: {
+                                ...(context || {}),
+                                content: renderContent
+                            }
+                        });
+                    }
+                    catch (error) {
+                        throw new template_errors_1.TemplateLayoutError(templateLayout.name, error);
+                    }
+                }
+            }
+            // Step 4: Render the content with the language engine
+            if ((!templateLayoutId || !templateLayout) && language) {
+                try {
+                    renderContent = await this.renderLanguage(language, renderContent, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateLanguageError(language, error);
+                }
+            }
+            return renderContent;
+        }
+        catch (error) {
+            // Re-throw known template errors
+            if (error instanceof template_errors_1.TemplateEngineError ||
+                error instanceof template_errors_1.TemplateLanguageError ||
+                error instanceof template_errors_1.TemplateLayoutError ||
+                error instanceof template_errors_1.TemplateContentError ||
+                error instanceof common_1.NotFoundException ||
+                error instanceof common_1.BadRequestException) {
+                throw error;
+            }
+            // Wrap unknown errors
+            throw new template_errors_1.TemplateRenderError('content rendering', error);
+        }
+    }
+    async renderLanguage(language, content, context) {
+        try {
+            if (!content) {
+                throw new common_1.BadRequestException('Content is required for language rendering');
+            }
+            const languageEngine = this.engineRegistry.getLanguageEngine(language);
+            if (!languageEngine) {
+                throw new common_1.BadRequestException(`Language engine not found for: ${language}`);
+            }
+            return await languageEngine.render(content, context || {});
+        }
+        catch (error) {
+            if (error instanceof common_1.BadRequestException) {
+                throw error;
+            }
+            throw new template_errors_1.TemplateLanguageError(language, error);
+        }
+    }
+    async renderEngine(engine, content, context) {
+        try {
+            if (!content) {
+                throw new common_1.BadRequestException('Content is required for engine rendering');
+            }
+            const templateEngine = this.engineRegistry.getTemplateEngine(engine);
+            if (!templateEngine) {
+                throw new common_1.BadRequestException(`Template engine not found for: ${engine}`);
+            }
+            return await templateEngine.render(content, context || {});
+        }
+        catch (error) {
+            if (error instanceof common_1.BadRequestException) {
+                throw error;
+            }
+            throw new template_errors_1.TemplateEngineError(engine, error);
+        }
+    }
+    /**
+     * Get all templates, with scoped templates taking precedence over system templates
+     */
+    async getTemplates(filter = {}) {
+        const { scope, scopeId, type, locale, excludeNames = [], } = filter;
+        // Build the where clause
+        const where = {};
+        if (type)
+            where.type = type;
+        if (locale)
+            where.locale = locale;
+        if (excludeNames.length > 0)
+            where.name = (0, typeorm_2.Not)((0, typeorm_2.In)(excludeNames));
+        const systemTemplates = await this.templateRepository.find({
+            where: {
+                ...where,
+                scope: 'system',
+                scopeId: (0, typeorm_2.IsNull)(),
+            },
+        });
+        if (scope === 'system') {
+            return systemTemplates;
+        }
+        // First get all templates matching the filters
+        const templates = await this.templateRepository.find({
+            where: {
+                ...where,
+                scope: (0, typeorm_2.Equal)(scope),
+                scopeId: scopeId,
+            },
+            order: {
+                createdAt: 'DESC',
+            },
+        });
+        // Create a map to store unique templates by name+type
+        const templateMap = new Map();
+        for (const template of systemTemplates) {
+            const key = `${template.type}/${template.name}/${template.locale}`;
+            templateMap.set(key, template);
+        }
+        for (const template of templates) {
+            const key = `${template.type}/${template.name}/${template.locale}`;
+            templateMap.set(key, template);
+        }
+        // Convert map values back to array
+        return Array.from(templateMap.values());
+    }
+    async getTemplateById(id) {
+        return this.templateRepository.findOne({
+            where: { id },
+        });
+    }
+    async findTemplate(name, scope, scopeId, locale) {
+        // Try to find template in the following order:
+        // 1. Scoped template with locale
+        // 2. Scoped template without locale
+        // 3. System template with locale
+        // 4. System template without locale
+        const locales = (locale ? [locale, 'en'] : ['en']).filter(Boolean);
+        // First try to find in the specified scope
+        for (const currentLocale of locales) {
+            const template = await this.templateRepository.findOne({
+                where: {
+                    name,
+                    scope,
+                    scopeId: scope === 'system' ? (0, typeorm_2.IsNull)() : (0, typeorm_2.Equal)(scopeId),
+                    locale: currentLocale,
+                }
+            });
+            if (template) {
+                return template;
+            }
+        }
+        // If not found and not already in system scope, try system scope
+        if (scope !== 'system') {
+            for (const currentLocale of locales) {
+                const template = await this.templateRepository.findOne({
+                    where: {
+                        name,
+                        scope: 'system',
+                        scopeId: (0, typeorm_2.IsNull)(),
+                        locale: currentLocale,
+                    }
+                });
+                if (template) {
+                    return template;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Create a system template. Only system templates can be created directly.
+     */
+    async createTemplate(data) {
+        // Ensure this is a system template
+        if (data.scope !== 'system') {
+            throw new common_1.ForbiddenException('Only system templates can be created directly');
+        }
+        // Check if template already exists
+        const existingTemplate = await this.templateRepository.findOne({
+            where: {
+                name: data.name,
+                scope: 'system',
+                scopeId: (0, typeorm_2.IsNull)(),
+                locale: data.locale,
+            },
+        });
+        if (existingTemplate) {
+            throw new common_1.ConflictException(`System template already exists`);
+        }
+        const template = this.templateRepository.create({
+            ...data,
+            scopeId: undefined, // Ensure system templates have no scopeId
+        });
+        return this.templateRepository.save(template);
+    }
+    async overwriteSystemTemplate(templateId, updates) {
+        let template = await this.templateRepository.findOne({
+            where: { id: templateId },
+        });
+        if (!template) {
+            throw new common_1.NotFoundException(`Template not found: ${templateId}`);
+        }
+        if (template.scope === 'system') {
+            if (!updates.scope) {
+                throw new common_1.BadRequestException('Scope is required when overwriting system template');
+            }
+            // Check if template already exists in target scope
+            const existingTemplate = await this.templateRepository.findOne({
+                where: {
+                    name: template.name,
+                    locale: template.locale,
+                    scope: updates.scope,
+                    scopeId: updates.scopeId,
+                },
+            });
+            if (existingTemplate) {
+                // Update existing template in target scope
+                template = existingTemplate;
+            }
+            else {
+                // Create new template in target scope
+                const newTemplate = this.templateRepository.create({
+                    ...template,
+                    id: undefined,
+                    createdAt: undefined,
+                    updatedAt: undefined,
+                    scope: updates.scope,
+                    scopeId: updates.scopeId,
+                });
+                template = newTemplate;
+            }
+        }
+        updates = (0, lodash_1.omit)(updates, ['name', 'id', 'createdAt', 'updatedAt']);
+        template = this.templateRepository.merge(template, updates);
+        await this.templateRepository.save(template);
+        return template;
+    }
+    /**
+     * Update a template
+     */
+    async updateTemplate(id, updates, canUpdateSystemTemplate = false) {
+        // Find the template
+        let template = await this.templateRepository.findOne({
+            where: { id },
+        });
+        if (!template) {
+            throw new common_1.NotFoundException(`Template not found: ${id}`);
+        }
+        // If it's a system template and we can't update it, try to overwrite it
+        if (template.scope === 'system' && !canUpdateSystemTemplate) {
+            if (updates.scope) {
+                // Otherwise, allow overwriting to custom scope
+                return this.overwriteSystemTemplate(id, updates);
+            }
+            else {
+                throw new common_1.ForbiddenException('Cannot update system templates');
+            }
+        }
+        // For regular updates
+        template = this.templateRepository.merge(template, updates);
+        return this.templateRepository.save(template);
+    }
+    /**
+     * Delete a scoped template
+     */
+    async deleteTemplate(id, canDeleteSystemTemplate = false) {
+        const template = await this.templateRepository.findOne({
+            where: { id },
+        });
+        if (!template) {
+            throw new Error(`Template not found: ${id}`);
+        }
+        // Prevent deleting system templates
+        if (template.scope === 'system' && !canDeleteSystemTemplate) {
+            throw new common_1.ForbiddenException('Cannot delete system templates');
+        }
+        await this.templateRepository.remove(template);
+    }
+};
+exports.TemplateService = TemplateService;
+exports.TemplateService = TemplateService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(template_entity_1.NestDynamicTemplate)),
+    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
+        template_engine_registry_1.TemplateEngineRegistryService,
+        template_layout_service_1.TemplateLayoutService])
+], TemplateService);

package/src/test/helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engineFilters = void 0;
+exports.engineFilters = {
+    formatDate: (date, format) => {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        switch (format) {
+            case 'YYYY-MM-DD':
+                return `${year}-${month}-${day}`;
+            case 'MM/DD/YY':
+                return `${month}/${day}/${String(year).slice(-2)}`;
+            case 'MMMM D, YYYY':
+                return date.toLocaleDateString('en-US', {
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric'
+                });
+            default:
+                return `${year}-${month}-${day}`;
+        }
+    },
+    formatCurrency: (amount, currency) => {
+        const formatter = new Intl.NumberFormat('en-US', {
+            style: 'currency',
+            currency: currency,
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+        });
+        return formatter.format(amount);
+    }
+};

package/src/test/test-database.config.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testRedisConfig = exports.testDatabaseConfig = void 0;
+const template_entity_1 = require("../lib/entities/template.entity");
+const template_layout_entity_1 = require("../lib/entities/template-layout.entity");
+exports.testDatabaseConfig = {
+    type: 'sqlite',
+    database: ':memory:',
+    entities: [template_entity_1.NestDynamicTemplate, template_layout_entity_1.NestDynamicTemplateLayout],
+    logging: ['error', 'warn'],
+    synchronize: true, // Disable auto-synchronization
+    dropSchema: true, // Drop schema before tests
+};
+exports.testRedisConfig = {
+    type: 'single',
+    options: {
+        host: 'localhost',
+        port: 6379,
+        retryStrategy: (times) => {
+            return Math.min(times * 50, 2000);
+        },
+    },
+};

package/src/test/test.setup.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestModule = createTestModule;
+exports.createTestApp = createTestApp;
+const testing_1 = require("@nestjs/testing");
+const typeorm_1 = require("@nestjs/typeorm");
+const test_database_config_1 = require("./test-database.config");
+const template_layout_entity_1 = require("../lib/entities/template-layout.entity");
+const template_entity_1 = require("../lib/entities/template.entity");
+const common_1 = require("@nestjs/common");
+const nest_dynamic_templates_module_1 = require("../lib/nest-dynamic-templates.module");
+async function createTestModule(options = {}) {
+    const moduleRef = await testing_1.Test.createTestingModule({
+        imports: [
+            typeorm_1.TypeOrmModule.forRoot(test_database_config_1.testDatabaseConfig),
+            typeorm_1.TypeOrmModule.forFeature([template_entity_1.NestDynamicTemplate, template_layout_entity_1.NestDynamicTemplateLayout]),
+            // RedisModule.forRoot(testRedisConfig),
+            nest_dynamic_templates_module_1.NestDynamicTemplatesModule.forRoot(options),
+        ],
+    }).compile();
+    return moduleRef;
+}
+async function createTestApp(options = {}) {
+    const moduleRef = await createTestModule(options);
+    const app = moduleRef.createNestApplication();
+    // Enable validation
+    app.useGlobalPipes(new common_1.ValidationPipe());
+    await app.init();
+    return app;
+}