@ackplus/nest-dynamic-templates 1.1.2 → 1.1.6

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

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLayoutService = 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_layout_entity_1 = require("../entities/template-layout.entity");
+const template_engine_registry_1 = require("./template-engine.registry");
+const template_errors_1 = require("../errors/template.errors");
+let TemplateLayoutService = class TemplateLayoutService {
+    constructor(layoutRepository, engineRegistry) {
+        this.layoutRepository = layoutRepository;
+        this.engineRegistry = engineRegistry;
+    }
+    async render(renderDto) {
+        const { name, scope, scopeId, locale, context } = renderDto;
+        try {
+            // Find template with fallback
+            const templateLayout = await this.findTemplateLayout(name, scope, scopeId, locale);
+            if (!templateLayout) {
+                throw new common_1.NotFoundException(`Template layout not found: ${name} in scope ${scope || 'system'}`);
+            }
+            // Validate content exists
+            if (!templateLayout.content) {
+                throw new common_1.BadRequestException(`Template layout '${name}' has no content to render`);
+            }
+            let content = templateLayout.content;
+            // Render content by template engine
+            if (templateLayout.engine) {
+                try {
+                    content = await this.renderEngine(templateLayout.engine, content, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateEngineError(templateLayout.engine, error);
+                }
+            }
+            // If template has language format, process with language engine
+            if (templateLayout.language) {
+                try {
+                    content = await this.renderLanguage(templateLayout.language, content, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateLanguageError(templateLayout.language, error);
+                }
+            }
+            return {
+                content
+            };
+        }
+        catch (error) {
+            // Re-throw known template errors
+            if (error instanceof template_errors_1.TemplateEngineError ||
+                error instanceof template_errors_1.TemplateLanguageError ||
+                error instanceof common_1.NotFoundException ||
+                error instanceof common_1.BadRequestException) {
+                throw error;
+            }
+            // Wrap unknown errors
+            throw new template_errors_1.TemplateRenderError('template layout rendering', error, name);
+        }
+    }
+    async renderContent(input) {
+        const { content, language, engine, context } = input;
+        try {
+            if (!content) {
+                throw new common_1.BadRequestException('Content is required for template layout rendering');
+            }
+            let renderContent = content;
+            // Render content by template engine
+            if (engine) {
+                try {
+                    renderContent = await this.renderEngine(engine, content, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateEngineError(engine, error);
+                }
+            }
+            // Render content by language engine
+            if (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 common_1.BadRequestException) {
+                throw error;
+            }
+            // Wrap unknown errors
+            throw new template_errors_1.TemplateRenderError('template layout 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 getTemplateLayouts(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.layoutRepository.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.layoutRepository.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 getTemplateLayoutById(id) {
+        return this.layoutRepository.findOne({
+            where: { id },
+        });
+    }
+    async findTemplateLayout(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.layoutRepository.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.layoutRepository.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 createTemplateLayout(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.layoutRepository.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.layoutRepository.create({
+            ...data,
+            scopeId: undefined, // Ensure system templates have no scopeId
+        });
+        return this.layoutRepository.save(template);
+    }
+    async overwriteSystemTemplateLayout(templateId, updates) {
+        let template = await this.layoutRepository.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.layoutRepository.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.layoutRepository.create({
+                    ...template,
+                    id: undefined,
+                    createdAt: undefined,
+                    updatedAt: undefined,
+                    scope: updates.scope,
+                    scopeId: updates.scopeId,
+                });
+                template = newTemplate;
+            }
+        }
+        template = this.layoutRepository.merge(template, updates);
+        await this.layoutRepository.save(template);
+        return template;
+    }
+    /**
+     * Update a template
+     */
+    async updateTemplateLayout(id, updates, canUpdateSystemTemplate = false) {
+        // Find the template
+        let template = await this.layoutRepository.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.overwriteSystemTemplateLayout(id, updates);
+            }
+            else {
+                throw new common_1.ForbiddenException('Cannot update system templates');
+            }
+        }
+        // For regular updates
+        template = this.layoutRepository.merge(template, updates);
+        return this.layoutRepository.save(template);
+    }
+    /**
+     * Delete a scoped template
+     */
+    async deleteTemplateLayout(id, canDeleteSystemTemplate = false) {
+        const template = await this.layoutRepository.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.layoutRepository.remove(template);
+    }
+};
+exports.TemplateLayoutService = TemplateLayoutService;
+exports.TemplateLayoutService = TemplateLayoutService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(template_layout_entity_1.NestDynamicTemplateLayout)),
+    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
+        template_engine_registry_1.TemplateEngineRegistryService])
+], TemplateLayoutService);