@ackplus/nest-dynamic-templates 1.1.1 → 1.1.5

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

@@ -1,258 +1,212 @@
-import { BadRequestException, ConflictException, ForbiddenException, Injectable, NotFoundException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Equal, In, IsNull, Not, Repository } from 'typeorm';
-import { NestDynamicTemplateLayout } from '../entities/template-layout.entity';
-import { TemplateEngineEnum, TemplateLanguageEnum, TemplateTypeEnum } from '../interfaces/template.types';
-import { TemplateLayoutFilterDto } from '../dto/template-layout-filter.dto';
-import { TemplateEngineRegistryService } from './template-engine.registry';
-import { RenderTemplateLayoutDto, RenderTemplateLayoutOutput } from '../dto/render-template-layout.dto';
-import { CreateTemplateLayoutDto } from '../dto/create-template-layout.dto';
-import { RenderContentTemplateLayoutDto } from '../dto/render-content-template-layout.dto';
-import {
-    TemplateRenderError,
-    TemplateEngineError,
-    TemplateLanguageError,
-} from '../errors/template.errors';
-
-@Injectable()
-export class TemplateLayoutService {
-    constructor(
-        @InjectRepository(NestDynamicTemplateLayout)
-        private readonly layoutRepository: Repository<NestDynamicTemplateLayout>,
-        private readonly engineRegistry: TemplateEngineRegistryService
-    ) { }
-
-
-    async render(renderDto: RenderTemplateLayoutDto): Promise<RenderTemplateLayoutOutput> {
+"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 NotFoundException(`Template layout not found: ${name} in scope ${scope || 'system'}`);
+                throw new common_1.NotFoundException(`Template layout not found: ${name} in scope ${scope || 'system'}`);
             }
-
             // Validate content exists
             if (!templateLayout.content) {
-                throw new BadRequestException(`Template layout '${name}' has no content to render`);
+                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 TemplateEngineError(templateLayout.engine, error as Error);
+                }
+                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 TemplateLanguageError(templateLayout.language, error as Error);
+                }
+                catch (error) {
+                    throw new template_errors_1.TemplateLanguageError(templateLayout.language, error);
                 }
             }
-
             return {
                 content
             };
-        } catch (error) {
+        }
+        catch (error) {
             // Re-throw known template errors
-            if (error instanceof TemplateEngineError ||
-                error instanceof TemplateLanguageError ||
-                error instanceof NotFoundException ||
-                error instanceof BadRequestException) {
+            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 TemplateRenderError('template layout rendering', error as Error, name);
+            throw new template_errors_1.TemplateRenderError('template layout rendering', error, name);
         }
     }
-
-    async renderContent(input: RenderContentTemplateLayoutDto): Promise<string> {
+    async renderContent(input) {
         const { content, language, engine, context } = input;
-
         try {
             if (!content) {
-                throw new BadRequestException('Content is required for template layout rendering');
+                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 TemplateEngineError(engine, error as Error);
+                }
+                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 TemplateLanguageError(language, error as Error);
+                }
+                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 BadRequestException) {
+            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 TemplateRenderError('template layout content rendering', error as Error);
+            throw new template_errors_1.TemplateRenderError('template layout 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) {
+        }
+        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) {
+        }
+        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 getTemplateLayouts(filter: TemplateLayoutFilterDto = {}): Promise<NestDynamicTemplateLayout[]> {
-        const {
-            scope,
-            scopeId,
-            type,
-            locale,
-            excludeNames = [],
-        } = filter;
-
-
+    async getTemplateLayouts(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.layoutRepository.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.layoutRepository.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, NestDynamicTemplateLayout>();
-
+        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: string): Promise<NestDynamicTemplateLayout | null> {
+    async getTemplateLayoutById(id) {
         return this.layoutRepository.findOne({
             where: { id },
         });
     }
-
-    async findTemplateLayout(
-        name: string,
-        scope?: string,
-        scopeId?: string,
-        locale?: string
-    ): Promise<NestDynamicTemplateLayout | null> {
+    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' ? 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) {
@@ -260,79 +214,68 @@ export class TemplateLayoutService {
                     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 createTemplateLayout(data: CreateTemplateLayoutDto): Promise<NestDynamicTemplateLayout> {
+    async createTemplateLayout(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.layoutRepository.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.layoutRepository.create({
             ...data,
             scopeId: undefined, // Ensure system templates have no scopeId
         });
-
         return this.layoutRepository.save(template);
     }
-
-    async overwriteSystemTemplateLayout(templateId: string, updates: Partial<CreateTemplateLayoutDto>): Promise<NestDynamicTemplateLayout> {
+    async overwriteSystemTemplateLayout(templateId, updates) {
         let template = await this.layoutRepository.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.layoutRepository.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.layoutRepository.create({
                     ...template,
@@ -345,63 +288,56 @@ export class TemplateLayoutService {
                 template = newTemplate;
             }
         }
-
         template = this.layoutRepository.merge(template, updates);
         await this.layoutRepository.save(template);
         return template;
     }
-
-
     /**
      * Update a template
      */
-    async updateTemplateLayout(
-        id: string,
-        updates: Partial<CreateTemplateLayoutDto>,
-        canUpdateSystemTemplate: boolean = false,
-    ): Promise<NestDynamicTemplateLayout> {
+    async updateTemplateLayout(id, updates, canUpdateSystemTemplate = false) {
         // Find the template
         let template = await this.layoutRepository.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.overwriteSystemTemplateLayout(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.layoutRepository.merge(template, updates);
         return this.layoutRepository.save(template);
     }
-
     /**
      * Delete a scoped template
      */
-    async deleteTemplateLayout(id: string, canDeleteSystemTemplate: boolean = false): Promise<void> {
+    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 ForbiddenException('Cannot delete system templates');
+            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);

package/src/lib/services/template.service.d.ts

@@ -0,0 +1,39 @@
+import { Repository } from 'typeorm';
+import { NestDynamicTemplate } from '../entities/template.entity';
+import { TemplateEngineEnum, TemplateLanguageEnum } 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 { RenderContentTemplateDto } from '../dto/render-content-template.dto';
+export declare class TemplateService {
+    private readonly templateRepository;
+    private readonly engineRegistry;
+    private readonly templateLayoutService;
+    constructor(templateRepository: Repository<NestDynamicTemplate>, engineRegistry: TemplateEngineRegistryService, templateLayoutService: TemplateLayoutService);
+    render(renderDto: RenderTemplateDto): Promise<RenderTemplateOutputDTO>;
+    renderContent(input: RenderContentTemplateDto): Promise<string>;
+    renderLanguage(language: TemplateLanguageEnum, content: string, context: Record<string, any>): Promise<string>;
+    renderEngine(engine: TemplateEngineEnum, content: string, context: Record<string, any>): Promise<string>;
+    /**
+     * Get all templates, with scoped templates taking precedence over system templates
+     */
+    getTemplates(filter?: TemplateFilterDto): Promise<NestDynamicTemplate[]>;
+    getTemplateById(id: string): Promise<NestDynamicTemplate | null>;
+    findTemplate(name: string, scope?: string, scopeId?: string, locale?: string): Promise<NestDynamicTemplate | null>;
+    /**
+     * Create a system template. Only system templates can be created directly.
+     */
+    createTemplate(data: CreateTemplateDto): Promise<NestDynamicTemplate>;
+    overwriteSystemTemplate(templateId: string, updates: Partial<CreateTemplateDto>): Promise<NestDynamicTemplate>;
+    /**
+     * Update a template
+     */
+    updateTemplate(id: string, updates: Partial<CreateTemplateDto>, canUpdateSystemTemplate?: boolean): Promise<NestDynamicTemplate>;
+    /**
+     * Delete a scoped template
+     */
+    deleteTemplate(id: string, canDeleteSystemTemplate?: boolean): Promise<void>;
+}
+//# sourceMappingURL=template.service.d.ts.map

package/src/lib/services/template.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.service.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-dynamic-templates/src/lib/services/template.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,UAAU,EAAkB,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAoB,MAAM,8BAA8B,CAAC;AAC1G,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAE3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AAU9E,qBACa,eAAe;IAGpB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAFrB,kBAAkB,EAAE,UAAU,CAAC,mBAAmB,CAAC,EACnD,cAAc,EAAE,6BAA6B,EAC7C,qBAAqB,EAAE,qBAAqB;IAG3D,MAAM,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkFtE,aAAa,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC;IA4E/D,cAAc,CAAC,QAAQ,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAoB9G,YAAY,CAAC,MAAM,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAoB9G;;OAEG;IACG,YAAY,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAyD5E,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAMhE,YAAY,CACd,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IA8CtC;;OAEG;IACG,cAAc,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA4BrE,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAgDpH;;OAEG;IACG,cAAc,CAChB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC,EACnC,uBAAuB,GAAE,OAAe,GACzC,OAAO,CAAC,mBAAmB,CAAC;IAyB/B;;OAEG;IACG,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,uBAAuB,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CAgB5F"}