@ackplus/nest-dynamic-templates 1.1.1 → 1.1.5

package/src/lib/services/{template.service.ts → template.service.js}

@@ -1,70 +1,56 @@
-import { Injectable, ForbiddenException, ConflictException, NotFoundException, BadRequestException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { IsNull, Repository, Not, In, Equal } from 'typeorm';
-import { NestDynamicTemplate } from '../entities/template.entity';
-import { TemplateEngineEnum, TemplateLanguageEnum, TemplateTypeEnum } from '../interfaces/template.types';
-import { RenderTemplateDto, RenderTemplateOutputDTO } from '../dto/render-template.dto';
-import { CreateTemplateDto } from '../dto/create-template.dto';
-import { TemplateFilterDto } from '../dto/template-filter.dto';
-import { TemplateLayoutService } from './template-layout.service';
-import { TemplateEngineRegistryService } from './template-engine.registry';
-import { omit } from 'lodash';
-import { RenderContentTemplateDto } from '../dto/render-content-template.dto';
-import { NestDynamicTemplateLayout } from '../entities/template-layout.entity';
-import {
-    TemplateRenderError,
-    TemplateEngineError,
-    TemplateLanguageError,
-    TemplateLayoutError,
-    TemplateContentError
-} from '../errors/template.errors';
-
-@Injectable()
-export class TemplateService {
-    constructor(
-        @InjectRepository(NestDynamicTemplate)
-        private readonly templateRepository: Repository<NestDynamicTemplate>,
-        private readonly engineRegistry: TemplateEngineRegistryService,
-        private readonly templateLayoutService: TemplateLayoutService,
-    ) { }
-
-    async render(renderDto: RenderTemplateDto): Promise<RenderTemplateOutputDTO> {
+"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 BadRequestException('Template name is required');
+                throw new common_1.BadRequestException('Template name is required');
             }
             const template = await this.findTemplate(name, scope || 'system', scopeId, locale);
             if (!template) {
-                throw new NotFoundException(`Template not found: ${name} in scope ${scope || 'system'}`);
+                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 TemplateEngineError(template.engine, error as Error);
+                    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 TemplateEngineError(template.engine, error as Error);
+                    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: any;
+            let layout;
             if (template.templateLayoutName) {
                 try {
                     layout = await this.templateLayoutService.render({
@@ -78,70 +64,66 @@ export class TemplateService {
                         }
                     });
                     content = layout.content;
-                } catch (error) {
-                    throw new TemplateLayoutError(template.templateLayoutName, error as Error);
+                }
+                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 TemplateLanguageError(template.language, error as Error);
+                    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) {
+        }
+        catch (error) {
             // Re-throw known template errors
-            if (error instanceof TemplateEngineError ||
-                error instanceof TemplateLanguageError ||
-                error instanceof TemplateLayoutError ||
-                error instanceof NotFoundException) {
+            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 TemplateRenderError('template rendering', error as Error, name);
+            throw new template_errors_1.TemplateRenderError('template rendering', error, name);
         }
     }
-
-    async renderContent(input: RenderContentTemplateDto): Promise<string> {
+    async renderContent(input) {
         const { content, language, engine, context, templateLayoutId } = input;
-
         try {
             if (!content) {
-                throw new BadRequestException('Content is required for rendering');
+                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 || TemplateEngineEnum.NUNJUCKS, renderContent,  context || {});
-            } catch (error) {
-                throw new TemplateEngineError(engine || TemplateEngineEnum.NUNJUCKS, error as Error);
+                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: NestDynamicTemplateLayout | null = null;
+            let templateLayout = null;
             if (templateLayoutId) {
                 try {
                     templateLayout = await this.templateLayoutService.getTemplateLayoutById(templateLayoutId);
                     if (!templateLayout) {
-                        throw new NotFoundException(`Template layout not found with ID: ${templateLayoutId}`);
+                        throw new common_1.NotFoundException(`Template layout not found with ID: ${templateLayoutId}`);
                     }
-                } catch (error) {
-                    if (error instanceof NotFoundException) {
+                }
+                catch (error) {
+                    if (error instanceof common_1.NotFoundException) {
                         throw error;
                     }
-                    throw new TemplateContentError('template layout retrieval', error as Error);
+                    throw new template_errors_1.TemplateContentError('template layout retrieval', error);
                 }
-
                 if (templateLayout) {
                     try {
                         // Step 3: Render the layout content
@@ -149,179 +131,151 @@ export class TemplateService {
                             content: templateLayout.content,
                             language: language,
                             engine: engine,
-                        context: {
-                            ...(context || {}),
-                            content: renderContent
-                        }
+                            context: {
+                                ...(context || {}),
+                                content: renderContent
+                            }
                         });
-                    } catch (error) {
-                        throw new TemplateLayoutError(templateLayout.name, error as Error);
+                    }
+                    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 TemplateLanguageError(language, error as Error);
+                    renderContent = await this.renderLanguage(language, renderContent, context || {});
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateLanguageError(language, error);
                 }
             }
-
             return renderContent;
-        } catch (error) {
+        }
+        catch (error) {
             // Re-throw known template errors
-            if (error instanceof TemplateEngineError ||
-                error instanceof TemplateLanguageError ||
-                error instanceof TemplateLayoutError ||
-                error instanceof TemplateContentError ||
-                error instanceof NotFoundException ||
-                error instanceof BadRequestException) {
+            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 TemplateRenderError('content rendering', error as Error);
+            throw new template_errors_1.TemplateRenderError('content rendering', error);
         }
     }
-
-    async renderLanguage(language: TemplateLanguageEnum, content: string, context: Record<string, any>): Promise<string> {
+    async renderLanguage(language, content, context) {
         try {
             if (!content) {
-                throw new BadRequestException('Content is required for language rendering');
+                throw new common_1.BadRequestException('Content is required for language rendering');
             }
-
             const languageEngine = this.engineRegistry.getLanguageEngine(language);
             if (!languageEngine) {
-                throw new BadRequestException(`Language engine not found for: ${language}`);
+                throw new common_1.BadRequestException(`Language engine not found for: ${language}`);
             }
-
-            return await languageEngine.render(content,  context || {});
-        } catch (error) {
-            if (error instanceof BadRequestException) {
+            return await languageEngine.render(content, context || {});
+        }
+        catch (error) {
+            if (error instanceof common_1.BadRequestException) {
                 throw error;
             }
-            throw new TemplateLanguageError(language, error as Error);
+            throw new template_errors_1.TemplateLanguageError(language, error);
         }
     }
-
-    async renderEngine(engine: TemplateEngineEnum, content: string, context: Record<string, any>): Promise<string> {
+    async renderEngine(engine, content, context) {
         try {
             if (!content) {
-                throw new BadRequestException('Content is required for engine rendering');
+                throw new common_1.BadRequestException('Content is required for engine rendering');
             }
-
             const templateEngine = this.engineRegistry.getTemplateEngine(engine);
             if (!templateEngine) {
-                throw new BadRequestException(`Template engine not found for: ${engine}`);
+                throw new common_1.BadRequestException(`Template engine not found for: ${engine}`);
             }
-
-            return await templateEngine.render(content,  context || {});
-        } catch (error) {
-            if (error instanceof BadRequestException) {
+            return await templateEngine.render(content, context || {});
+        }
+        catch (error) {
+            if (error instanceof common_1.BadRequestException) {
                 throw error;
             }
-            throw new TemplateEngineError(engine, error as Error);
+            throw new template_errors_1.TemplateEngineError(engine, error);
         }
     }
-
     /**
      * Get all templates, with scoped templates taking precedence over system templates
      */
-    async getTemplates(filter: TemplateFilterDto = {}): Promise<NestDynamicTemplate[]> {
-        const {
-            scope,
-            scopeId,
-            type,
-            locale,
-            excludeNames = [],
-        } = filter;
-
-
+    async getTemplates(filter = {}) {
+        const { scope, scopeId, type, locale, excludeNames = [], } = filter;
         // Build the where clause
-        const where: any = {};
-        if (type) where.type = type;
-        if (locale) where.locale = locale;
-        if (excludeNames.length > 0) where.name = Not(In(excludeNames));
-
+        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: IsNull(),
+                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: Equal(scope),
-                scopeId: scopeId as any,
+                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<string, NestDynamicTemplate>();
-
+        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: string): Promise<NestDynamicTemplate | null> {
+    async getTemplateById(id) {
         return this.templateRepository.findOne({
             where: { id },
         });
     }
-
-    async findTemplate(
-        name: string,
-        scope?: string,
-        scopeId?: string,
-        locale?: string
-    ): Promise<NestDynamicTemplate | null> {
+    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' ? IsNull() : Equal(scopeId),
+                    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) {
@@ -329,79 +283,68 @@ export class TemplateService {
                     where: {
                         name,
                         scope: 'system',
-                        scopeId: IsNull(),
+                        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: CreateTemplateDto): Promise<NestDynamicTemplate> {
+    async createTemplate(data) {
         // Ensure this is a system template
         if (data.scope !== 'system') {
-            throw new ForbiddenException('Only system templates can be created directly');
+            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: IsNull(),
+                scopeId: (0, typeorm_2.IsNull)(),
                 locale: data.locale,
             },
         });
-
         if (existingTemplate) {
-            throw new ConflictException(`System template already exists`);
+            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: string, updates: Partial<CreateTemplateDto>): Promise<NestDynamicTemplate> {
+    async overwriteSystemTemplate(templateId, updates) {
         let template = await this.templateRepository.findOne({
             where: { id: templateId },
         });
-
         if (!template) {
-            throw new NotFoundException(`Template not found: ${templateId}`);
+            throw new common_1.NotFoundException(`Template not found: ${templateId}`);
         }
-
         if (template.scope === 'system') {
             if (!updates.scope) {
-                throw new BadRequestException('Scope is required when overwriting system template');
+                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 as any,
+                    scopeId: updates.scopeId,
                 },
             });
-
             if (existingTemplate) {
                 // Update existing template in target scope
                 template = existingTemplate;
-            } else {
+            }
+            else {
                 // Create new template in target scope
                 const newTemplate = this.templateRepository.create({
                     ...template,
@@ -414,63 +357,58 @@ export class TemplateService {
                 template = newTemplate;
             }
         }
-        updates = omit(updates, ['name', 'id', 'createdAt', 'updatedAt']);
-
+        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: string,
-        updates: Partial<CreateTemplateDto>,
-        canUpdateSystemTemplate: boolean = false,
-    ): Promise<NestDynamicTemplate> {
+    async updateTemplate(id, updates, canUpdateSystemTemplate = false) {
         // Find the template
         let template = await this.templateRepository.findOne({
             where: { id },
         });
-
         if (!template) {
-            throw new NotFoundException(`Template not found: ${id}`);
+            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 ForbiddenException('Cannot update system templates');
+            }
+            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: string, canDeleteSystemTemplate: boolean = false): Promise<void> {
+    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 ForbiddenException('Cannot delete system templates');
+            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.d.ts

@@ -0,0 +1,5 @@
+export declare const engineFilters: {
+    formatDate: (date: Date, format: string) => string;
+    formatCurrency: (amount: number, currency: string) => string;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/src/test/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../packages/nest-dynamic-templates/src/test/helpers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;uBACH,IAAI,UAAU,MAAM;6BAoBd,MAAM,YAAY,MAAM;CASpD,CAAA"}

package/src/test/{helpers.ts → helpers.js}

@@ -1,9 +1,11 @@
-export const engineFilters = {
-    formatDate: (date: Date, format: string) => {
+"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}`;
@@ -19,7 +21,7 @@ export const engineFilters = {
                 return `${year}-${month}-${day}`;
         }
     },
-    formatCurrency: (amount: number, currency: string) => {
+    formatCurrency: (amount, currency) => {
         const formatter = new Intl.NumberFormat('en-US', {
             style: 'currency',
             currency: currency,
@@ -28,4 +30,4 @@ export const engineFilters = {
         });
         return formatter.format(amount);
     }
-}
+};

package/src/test/test-database.config.d.ts

@@ -0,0 +1,5 @@
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import { RedisModuleOptions } from '@nestjs-modules/ioredis';
+export declare const testDatabaseConfig: TypeOrmModuleOptions;
+export declare const testRedisConfig: RedisModuleOptions;
+//# sourceMappingURL=test-database.config.d.ts.map

package/src/test/test-database.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-database.config.d.ts","sourceRoot":"","sources":["../../../../../packages/nest-dynamic-templates/src/test/test-database.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAI7D,eAAO,MAAM,kBAAkB,EAAE,oBAOhC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,kBAS7B,CAAC"}