@ackplus/nest-dynamic-templates 0.1.51 → 1.1.1

package/src/lib/dto/render-template-layout.dto.ts

@@ -0,0 +1,55 @@
+import { IsString, IsEnum, IsObject, IsOptional, IsNotEmpty } from 'class-validator';
+import { TemplateTypeEnum } from '../interfaces/template.types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+
+export class RenderTemplateLayoutDto {
+
+    @ApiPropertyOptional({
+        type: String,
+        default: 'en',
+        description: 'The locale code, i.e en, fr, es, etc.'
+    })
+    @IsString()
+    @IsOptional()
+    locale?: string = 'en';
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    name: string;
+
+    @ApiProperty({
+        type: String,
+        default: 'system',
+        description: 'The scope of the template, i.e user, organization, etc.'
+    })
+    @IsString()
+    scope: string;
+
+    @ApiPropertyOptional({
+        type: String,
+        default: null,
+        description: 'The scope id of the template, i.e user id, organization id, etc.'
+    })
+    @IsString()
+    @IsOptional()
+    scopeId?: string;
+
+    @ApiPropertyOptional({
+        type: String,
+        nullable: true,
+        description: 'The context of the template'
+    })
+    @IsObject()
+    @IsOptional()
+    context?: Record<string, any>;
+}
+
+
+export class RenderTemplateLayoutOutput {
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    content: string;
+}

package/src/lib/dto/render-template.dto.ts

@@ -0,0 +1,74 @@
+import { IsString, IsEnum, IsObject, IsOptional, IsNotEmpty, Matches, ValidateIf } from 'class-validator';
+import { TemplateLanguageEnum, TemplateTypeEnum } from '../interfaces/template.types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+
+export class RenderTemplateDto {
+
+    @ApiPropertyOptional({
+        type: String,
+        default: 'en',
+        description: 'The locale code, i.e en, fr, es, etc.'
+    })
+    @IsString()
+    @IsOptional()
+    locale?: string = 'en';
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    @ValidateIf((object, value) => !object?.content)
+    name?: string;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    @ValidateIf((object, value) => !object?.name)
+    content?: string;
+
+    @ApiProperty({ enum: TemplateLanguageEnum, type: String })
+    @IsEnum(TemplateLanguageEnum)
+    @IsNotEmpty()
+    @ValidateIf((object, value) => !object?.name)
+    language?: TemplateLanguageEnum;
+
+    @ApiPropertyOptional({
+        type: String,
+        default: 'system',
+        description: 'The scope of the template, i.e user, organization, etc.'
+    })
+    @IsString()
+    @IsOptional()
+    scope?: string = 'system';
+
+    @ApiPropertyOptional({
+        type: String,
+        default: null,
+        description: 'The scope id of the template, i.e user id, organization id, etc.'
+    })
+    @IsString()
+    @IsOptional()
+    scopeId?: string;
+
+    @ApiPropertyOptional({
+        type: String,
+        nullable: true,
+        description: 'The context of the template'
+    })
+    @IsObject()
+    @IsOptional()
+    context?: Record<string, any>;
+}
+
+
+export class RenderTemplateOutputDTO {
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    content: string;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    subject: string;
+}

package/src/lib/dto/template-filter.dto.ts

@@ -0,0 +1,52 @@
+import { IsEnum, IsOptional, IsString, IsArray } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { TemplateTypeEnum } from '../interfaces/template.types';
+
+export class TemplateFilterDto {
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by scope (e.g., system, tenant, organization)'
+    })
+    @IsString()
+    @IsOptional()
+    scope?: string;
+
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by scope ID (e.g., tenant ID, organization ID)'
+    })
+    @IsString()
+    @IsOptional()
+    scopeId?: string;
+
+    @ApiProperty({
+        enum: TemplateTypeEnum,
+        required: false,
+        description: 'Filter by template type'
+    })
+    @IsEnum(TemplateTypeEnum)
+    @IsOptional()
+    type?: TemplateTypeEnum;
+
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by locale (e.g., en, fr, es)'
+    })
+    @IsString()
+    @IsOptional()
+    locale?: string;
+
+    @ApiProperty({
+        type: [String],
+        required: false,
+        description: 'Exclude templates with these names'
+    })
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    excludeNames?: string[];
+
+}

package/src/lib/dto/template-layout-filter.dto.ts

@@ -0,0 +1,51 @@
+import { IsOptional, IsString, IsArray } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class TemplateLayoutFilterDto {
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by scope (e.g., system, tenant, organization)'
+    })
+    @IsString()
+    @IsOptional()
+    scope?: string;
+
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by scope ID (e.g., tenant ID, organization ID)'
+    })
+    @IsString()
+    @IsOptional()
+    scopeId?: string;
+
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by template type'
+    })
+    @IsString()
+    @IsOptional()
+    type?: string;
+
+    @ApiProperty({
+        type: String,
+        required: false,
+        description: 'Filter by locale (e.g., en, fr, es)'
+    })
+    @IsString()
+    @IsOptional()
+    locale?: string;
+
+    @ApiProperty({
+        type: [String],
+        required: false,
+        description: 'Exclude templates with these names'
+    })
+    @IsArray()
+    @IsString({ each: true })
+    @IsOptional()
+    excludeNames?: string[];
+
+}

package/src/lib/engines/language/html.engine.ts

@@ -0,0 +1,49 @@
+import { TemplateLanguageEnum } from '../../interfaces/template.types';
+import { LanguageEngine } from '../language-engine';
+
+export class HtmlEngine extends LanguageEngine {
+    static override engineName = TemplateLanguageEnum.HTML;
+
+    private options: any; // Using any for now since htmlparser2 types are causing issues
+
+    constructor(options?: any) {
+        super();
+        this.options = options;
+    }
+
+    async render(content: string): Promise<string> {
+        try {
+            // For HTML, we just return the content as is
+            // But we validate it first to ensure it's valid HTML
+            const isValid = await this.validate(content);
+            if (!isValid) {
+                throw new Error('Invalid HTML content');
+            }
+            return content;
+        } catch (error: any) {
+            throw new Error(`Failed to render HTML: ${error?.message || 'Unknown error'}`);
+        }
+    }
+
+    async validate(content: string): Promise<boolean> {
+        try {
+            const { Parser } = await import('htmlparser2');
+
+            return new Promise((resolve) => {
+                const parser = new Parser({
+                    onerror: () => {
+                        resolve(false);
+                    },
+                    onend: () => {
+                        resolve(true);
+                    }
+                }, this.options);
+
+                parser.write(content);
+                parser.end();
+            });
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/lib/engines/language/markdown.engine.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { TemplateLanguageEnum } from '../../interfaces/template.types';
+import { LanguageEngine } from '../language-engine';
+
+@Injectable()
+export class MarkdownEngine extends LanguageEngine {
+    static override engineName = TemplateLanguageEnum.MARKDOWN;
+
+    private options: any; // Using any for now since marked types are causing issues
+
+    constructor(options?: any) {
+        super();
+        this.options = options;
+    }
+
+    async render(content: string): Promise<string> {
+        // try {
+        //     const { marked } = await import('marked');
+        //     return marked(content, this.options);
+        // } catch (error: any) {
+        //     throw new Error(`Failed to render Markdown: ${error?.message || 'Unknown error'}`);
+        // }
+        return content;
+    }
+
+    async validate(content: string): Promise<boolean> {
+        // try {
+        //     const { marked } = await import('marked');
+        //     // Basic Markdown validation - check for common syntax errors
+        //     marked(content, this.options);
+        //     return true;
+        // } catch (error) {
+        //     return false;
+        // }
+        return true;
+    }
+}

package/src/lib/engines/language/mjml.engine.ts

@@ -0,0 +1,44 @@
+import { TemplateLanguageEnum } from '../../interfaces/template.types';
+import { LanguageEngine } from '../language-engine';
+
+export class MjmlEngine extends LanguageEngine {
+
+    static override engineName = TemplateLanguageEnum.MJML;
+
+    private readonly options: any = {};
+
+    constructor(options: any = {}) {
+        super();
+        this.options = options;
+    }
+
+    async render(content: string): Promise<string> {
+        try {
+            const mjml2html = (await import('mjml')).default;
+            const result = mjml2html(content, {
+                ...this.options,
+                validationLevel: 'strict',
+            });
+
+            if (result.errors && result.errors.length > 0) {
+                throw new Error(`MJML validation errors: ${result.errors.join(', ')}`);
+            }
+
+            return result.html;
+        } catch (error: any) {
+            throw new Error(`MJML rendering error: ${error?.message || 'Unknown error'}`);
+        }
+    }
+
+    async validate(content: string): Promise<boolean> {
+        try {
+            const mjml2html = (await import('mjml')).default;
+            const result = mjml2html(content, {
+                validationLevel: 'strict',
+            });
+            return result.errors.length === 0;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/lib/engines/language/text.engine.ts

@@ -0,0 +1,15 @@
+import { TemplateLanguageEnum } from '../../interfaces/template.types';
+import { LanguageEngine } from '../language-engine';
+
+export class TextEngine extends LanguageEngine {
+
+    static override engineName = TemplateLanguageEnum.TEXT;
+
+    async render(content: string): Promise<string> {
+        return content;
+    }
+
+    async validate(content: string): Promise<boolean> {
+        return true;
+    }
+}

package/src/lib/engines/{language-engine.d.ts → language-engine.ts}

@@ -1,5 +1,11 @@
-export declare abstract class LanguageEngine {
+
+export abstract class LanguageEngine {
+
     static engineName: string;
+
     abstract render(content: string, data?: Record<string, any>): Promise<string>;
+
     abstract validate(content: string): Promise<boolean>;
+
+
 }

package/src/lib/engines/template/ejs.engine.ts

@@ -0,0 +1,33 @@
+import { TemplateEngine } from '../template-engine';
+import { TemplateEngineEnum } from '../../interfaces/template.types';
+import { EngineOptions } from '../../interfaces/module-config.interface';
+export class EjsEngine extends TemplateEngine {
+
+    static override engineName = TemplateEngineEnum.EJS;
+
+    private options: ejs.Options;
+
+    constructor(options?: EngineOptions<ejs.Options>) {
+        super();
+        this.options = options || {};
+    }
+
+    async render(content: string, data?: Record<string, any>): Promise<string> {
+        try {
+            const ejs = await import('ejs');
+            return ejs.render(content, data, this.options);
+        } catch (error: any) {
+            throw new Error(`Failed to render EJS template: ${error?.message || 'Unknown error'}`);
+        }
+    }
+
+    async validate(content: string): Promise<boolean> {
+        try {
+            const ejs = await import('ejs');
+            ejs.compile(content, this.options);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/lib/engines/template/handlebars.engine.ts

@@ -0,0 +1,35 @@
+import { TemplateEngineEnum } from '../../interfaces/template.types';
+import { TemplateEngine } from '../template-engine';
+import { EngineOptions } from '../../interfaces/module-config.interface';
+
+export class HandlebarsEngine extends TemplateEngine {
+
+    static override engineName = TemplateEngineEnum.HANDLEBARS;
+
+    private options: Handlebars.ParseOptions;
+
+    constructor(options?: EngineOptions<Handlebars.ParseOptions>) {
+        super();
+        this.options = options || {};
+    }
+
+    async render(content: string, data?: Record<string, any>): Promise<string> {
+        try {
+            const Handlebars = await import('handlebars');
+            const template = Handlebars.compile(content, this.options);
+            return template(data);
+        } catch (error: any) {
+            throw new Error(`Failed to render Handlebars template: ${error?.message || 'Unknown error'}`);
+        }
+    }
+
+    async validate(content: string): Promise<boolean> {
+        try {
+            const Handlebars = await import('handlebars');
+            Handlebars.precompile(content, this.options);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/lib/engines/template/nunjucks.engine.ts

@@ -0,0 +1,70 @@
+import { omit } from 'lodash';
+import { TemplateEngineEnum } from '../../interfaces/template.types';
+import { TemplateEngine } from '../template-engine';
+import type { Environment, ConfigureOptions } from 'nunjucks';
+import { CustomEngineOptions, EngineOptions } from '../../interfaces/module-config.interface';
+
+export class NunjucksEngine extends TemplateEngine {
+
+    static override engineName = TemplateEngineEnum.NUNJUCKS;
+
+    private env: Environment;
+
+    constructor(private options?: EngineOptions<ConfigureOptions>, private customOptions?: CustomEngineOptions) {
+        super();
+        this.initNunjucks();
+    }
+
+    initNunjucks() {
+        const nunjucks = require('nunjucks');
+
+        const nunjucksOptions = omit(this.options, 'filters');
+
+        this.env = nunjucks.configure({
+            autoescape: true,
+            throwOnUndefined: true,
+            ...nunjucksOptions,
+        });
+
+        // Register filters immediately
+        if (this.customOptions?.filters) {
+            Object.entries(this.customOptions.filters).forEach(([name, filter]) => {
+                this.registerFilter(name, filter);
+            });
+        }
+    }
+
+    async render(content: string, data?: Record<string, any>): Promise<string> {
+        try {
+            return new Promise((resolve, reject) => {
+                this.env.renderString(content, data || {}, (err: any, result: any) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(result);
+                    }
+                });
+            });
+        } catch (error: any) {
+            throw new Error(`Failed to render Nunjucks template: ${error?.message || 'Unknown error'}`);
+        }
+    }
+
+    async validate(content: string): Promise<boolean> {
+        try {
+            // Use renderString with empty data to validate the template
+            await this.render(content, {});
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    registerFilter(name: string, filter: (...args: any[]) => any) {
+        this.env.addFilter(name, filter);
+    }
+
+    registerGlobal(name: string, global: (...args: any[]) => any) {
+        this.env.addGlobal(name, global);
+    }
+}

package/src/lib/engines/template/pug.engine.ts

@@ -0,0 +1,43 @@
+import type { Options } from 'pug';
+import { TemplateEngineEnum } from '../../interfaces/template.types';
+import { TemplateEngine } from '../template-engine';
+import { CustomEngineOptions, EngineOptions } from '../../interfaces/module-config.interface';
+
+export class PugEngine extends TemplateEngine {
+
+    static override engineName = TemplateEngineEnum.PUG;
+
+    private options: Options;
+
+    constructor(options?: EngineOptions<Options>, private customOptions?: CustomEngineOptions) {
+        super();
+        this.options = options || {};
+    }
+
+    async render(content: string, data: any): Promise<string> {
+        try {
+            const pug = await import('pug');
+            const template = pug.compile(content, {
+                ...this.options,
+                filters: this.customOptions?.filters
+            });
+            return template({
+                ...this.options.filters,
+                ...data,
+                ...this.customOptions?.filters
+            });
+        } catch (error: any) {
+            throw new Error(`Failed to render Pug template: ${error?.message || 'Unknown error'}`);
+        }
+    }
+
+    async validate(content: string): Promise<boolean> {
+        try {
+            const pug = await import('pug');
+            pug.compile(content, this.options);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/lib/engines/{template-engine.d.ts → template-engine.ts}

@@ -1,5 +1,10 @@
-export declare abstract class TemplateEngine {
+
+export abstract class TemplateEngine {
+
     static engineName: string;
+
     abstract render(content: string, data?: Record<string, any>): Promise<string>;
+
     abstract validate(content: string): Promise<boolean>;
+
 }

package/src/lib/entities/template-layout.entity.ts

@@ -0,0 +1,99 @@
+import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, Index, BaseEntity } from 'typeorm';
+import { IsBoolean, IsEnum, IsNotEmpty, IsOptional, IsString, Matches } from 'class-validator';
+import { TemplateEngineEnum, TemplateTypeEnum, TemplateLanguageEnum } from '../interfaces/template.types';
+import { ApiProperty } from '@nestjs/swagger';
+
+
+@Entity('nest_dynamic_template_layouts')
+@Index(['name', 'scope', 'scopeId', 'locale'], { unique: true })
+export class NestDynamicTemplateLayout extends BaseEntity {
+
+    @ApiProperty({ type: String, format: 'uuid', readOnly: true })
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    @Matches(/^[a-z0-9\-_]+$/, { message: 'Invalid template name format' })
+    @Column()
+    name: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    @Column({ nullable: true })
+    displayName?: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    @Column({ type: 'text', nullable: true })
+    description?: string;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsOptional()
+    @Column({ type: 'text' })
+    type?: string;
+
+    @ApiProperty({ enum: TemplateEngineEnum, type: String })
+    @IsEnum(TemplateEngineEnum)
+    @Column({
+        type: 'text',
+        enum: TemplateEngineEnum,
+        default: TemplateEngineEnum.NUNJUCKS
+    })
+    engine: TemplateEngineEnum;
+
+    @ApiProperty({ enum: TemplateLanguageEnum, type: String, nullable: true })
+    @IsEnum(TemplateLanguageEnum)
+    @IsOptional()
+    @Column({ type: 'text' })
+    language?: TemplateLanguageEnum;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsOptional()
+    @Column('text')
+    content: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    @Column({ nullable: true })
+    templateLayoutName?: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @Column({ nullable: true, default: 'system' })
+    scope?: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @Column({ nullable: true })
+    scopeId?: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @Column({ nullable: true, default: 'en' })
+    locale?: string;
+
+    @ApiProperty({ type: Object, nullable: true })
+    @IsOptional()
+    @Column('simple-json', { nullable: true })
+    previewContext?: Record<string, any>;
+
+    @ApiProperty({ type: Boolean })
+    @IsBoolean()
+    @Column({ default: true })
+    isActive: boolean;
+
+    @ApiProperty({ type: Date, readOnly: true })
+    @CreateDateColumn()
+    createdAt: Date;
+
+    @ApiProperty({ type: Date, readOnly: true })
+    @UpdateDateColumn()
+    updatedAt: Date;
+}