@ackplus/nest-dynamic-templates 1.1.1 → 1.1.5

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

@@ -1,44 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/template/ejs.engine.ts

@@ -1,33 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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/pug.engine.ts

@@ -1,43 +0,0 @@
-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/entities/template-layout.entity.ts

@@ -1,99 +0,0 @@
-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;
-}

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

@@ -1,105 +0,0 @@
-import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, Index, JoinColumn, ManyToOne, RelationId, BaseEntity } from 'typeorm';
-import { TemplateTypeEnum, TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
-import { IsBoolean, IsEnum, IsNotEmpty, IsOptional, IsString, Matches } from 'class-validator';
-import { ApiProperty } from '@nestjs/swagger';
-
-
-@Entity('nest_dynamic_templates')
-@Index(['name', 'scope', 'scopeId', 'locale'], { unique: true })
-export class NestDynamicTemplate 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, nullable: true })
-    @IsString()
-    @IsOptional()
-    @Column({ type: 'text', nullable: true })
-    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, nullable: true })
-    @IsString()
-    @IsOptional()
-    @Column({ nullable: true })
-    subject?: string;
-
-    @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;
-}

package/src/lib/interfaces/template.types.ts

@@ -1,25 +0,0 @@
-export enum TemplateTypeEnum {
-    EMAIL = 'email',
-    SMS = 'sms',
-    PUSH = 'push',
-    PDF = 'pdf',
-}
-
-export enum TemplateEngineEnum {
-    NUNJUCKS = 'njk',
-    HANDLEBARS = 'hbs',
-    EJS = 'ejs',
-    PUG = 'pug',
-}
-
-export enum TemplateLanguageEnum {
-    MJML = 'mjml',
-    HTML = 'html',
-    MARKDOWN = 'md',
-    TEXT = 'txt',
-}
-
-export interface Scope {
-    scope: string;
-    id: string;
-}

package/src/lib/nest-dynamic-templates.module.ts

@@ -1,143 +0,0 @@
-import { Module, DynamicModule, Provider } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { NestDynamicTemplate } from './entities/template.entity';
-import { NestDynamicTemplateLayout } from './entities/template-layout.entity';
-import {
-  NestDynamicTemplatesModuleConfig,
-  NestDynamicTemplatesModuleAsyncOptions,
-  NestDynamicTemplatesModuleOptionsFactory
-} from './interfaces/module-config.interface';
-import deepmerge from 'deepmerge';
-import { TemplateEngineRegistryService } from './services/template-engine.registry';
-import { TemplateLayoutService } from './services/template-layout.service';
-import { TemplateService } from './services/template.service';
-import { TemplateConfigService } from './services/template-config.service';
-import { NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER } from './constant';
-import { TemplateEngineEnum } from './interfaces/template.types';
-import { TemplateLanguageEnum } from './interfaces/template.types';
-
-
-const defaultConfig: NestDynamicTemplatesModuleConfig = {
-  engines: {
-    template: [TemplateEngineEnum.NUNJUCKS],
-    language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML, TemplateLanguageEnum.TEXT]
-  }
-}
-
-@Module({
-  imports: [TypeOrmModule.forFeature([NestDynamicTemplate, NestDynamicTemplateLayout])],
-  providers: [
-    TemplateConfigService,
-    TemplateEngineRegistryService,
-    TemplateLayoutService,
-    TemplateService,
-  ],
-  exports: [
-    TemplateConfigService,
-    TemplateService,
-    TemplateLayoutService,
-  ],
-})
-export class NestDynamicTemplatesModule {
-  static moduleDefaultOptions: Partial<NestDynamicTemplatesModuleConfig> = defaultConfig;
-
-  static forRoot(config: NestDynamicTemplatesModuleConfig = {}): DynamicModule {
-    const mergedConfig = this.getOptions(config);
-
-    // Set options in static service
-    TemplateConfigService.setOptions(mergedConfig);
-
-    return {
-      module: NestDynamicTemplatesModule,
-      global: mergedConfig.isGlobal,
-      imports: [
-        TypeOrmModule.forFeature([NestDynamicTemplate, NestDynamicTemplateLayout]),
-      ],
-      providers: [
-        TemplateConfigService,
-        TemplateEngineRegistryService,
-        TemplateLayoutService,
-        TemplateService,
-      ],
-      exports: [
-        TemplateConfigService,
-        TemplateService,
-        TemplateLayoutService,
-      ],
-    };
-  }
-
-  static forRootAsync(options: NestDynamicTemplatesModuleAsyncOptions): DynamicModule {
-    const asyncProviders = this.createAsyncProviders(options);
-
-    return {
-      module: NestDynamicTemplatesModule,
-      global: options.isGlobal,
-      imports: [
-        TypeOrmModule.forFeature([NestDynamicTemplate, NestDynamicTemplateLayout]),
-        ...(options.imports || []),
-      ],
-      providers: [
-        ...asyncProviders,
-        TemplateConfigService,
-        TemplateEngineRegistryService,
-        TemplateLayoutService,
-        TemplateService,
-      ],
-      exports: [
-        TemplateConfigService,
-        TemplateService,
-        TemplateLayoutService,
-      ],
-    };
-  }
-
-  private static createAsyncProviders(options: NestDynamicTemplatesModuleAsyncOptions): Provider[] {
-    if (options.useExisting || options.useFactory) {
-      return [this.createAsyncOptionsProvider(options)];
-    }
-
-    if (options.useClass) {
-      return [
-        this.createAsyncOptionsProvider(options),
-        {
-          provide: options.useClass,
-          useClass: options.useClass,
-        },
-      ];
-    }
-
-    return [];
-  }
-
-  private static createAsyncOptionsProvider(options: NestDynamicTemplatesModuleAsyncOptions): Provider {
-    if (options.useFactory) {
-      return {
-        provide: NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER,
-        useFactory: async (...args: any[]) => {
-          const userOptions = options.useFactory ? await options.useFactory(...args) : {};
-          const mergedOptions = this.getOptions(userOptions);
-          TemplateConfigService.setOptions(mergedOptions);
-          return mergedOptions;
-        },
-        inject: options.inject || [],
-      };
-    }
-
-    return {
-      provide: NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER,
-      useFactory: async (optionsFactory: NestDynamicTemplatesModuleOptionsFactory) => {
-        const userOptions = await optionsFactory.createNestDynamicTemplatesModuleOptions();
-        const mergedOptions = this.getOptions(userOptions);
-        TemplateConfigService.setOptions(mergedOptions);
-        return mergedOptions;
-      },
-      inject: [options.useExisting || options.useClass!],
-    };
-  }
-
-  private static getOptions(options: NestDynamicTemplatesModuleConfig): NestDynamicTemplatesModuleConfig {
-    return deepmerge(this.moduleDefaultOptions, options);
-  }
-
-}

package/src/lib/services/template-engine.registry.ts

@@ -1,109 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
-import { NunjucksEngine } from '../engines/template/nunjucks.engine';
-import { MjmlEngine } from '../engines/language/mjml.engine';
-import { HtmlEngine } from '../engines/language/html.engine';
-import { MarkdownEngine, TextEngine } from '../engines/language';
-import { EjsEngine } from '../engines/template/ejs.engine';
-import { HandlebarsEngine } from '../engines/template/handlebars.engine';
-import { PugEngine } from '../engines/template/pug.engine';
-import { TemplateConfigService } from './template-config.service';
-import { TemplateEngine } from '../engines/template-engine';
-import { LanguageEngine } from '../engines/language-engine';
-import { NestDynamicTemplatesModuleConfig } from '../interfaces/module-config.interface';
-
-type ClassType<T> = new (...args: any[]) => T;
-
-@Injectable()
-export class TemplateEngineRegistryService {
-    private templateEngines: Map<TemplateEngineEnum, TemplateEngine> = new Map();
-    private languageEngines: Map<TemplateLanguageEnum, LanguageEngine> = new Map();
-    private config: NestDynamicTemplatesModuleConfig;
-
-    constructor() {
-        this.config = TemplateConfigService.getOptions();
-
-        this.registerTemplateEngines([
-            NunjucksEngine,
-            HandlebarsEngine,
-            EjsEngine,
-            PugEngine
-        ]);
-
-
-        this.registerLanguageEngines([
-            MjmlEngine,
-            HtmlEngine,
-            TextEngine,
-            MarkdownEngine
-        ]);
-    }
-
-    registerTemplateEngines(engineClasses: ClassType<TemplateEngine>[]): void {
-        engineClasses.forEach(EngineClass => {
-            const engineName = (EngineClass as any).engineName;
-            if (!engineName) {
-                throw new Error(`Engine class ${EngineClass.name} must define static engineName property`);
-            }
-            const options = (this.config.enginesOptions?.template as any)?.[engineName];
-
-            const customOptions = {
-                filters: this.config.enginesOptions?.filters,
-                globalValues: this.config.enginesOptions?.globalValues
-            }
-
-            this.registerTemplateEngine(engineName, new EngineClass(options, customOptions));
-        });
-    }
-
-    registerTemplateEngine(format: TemplateEngineEnum, engine: TemplateEngine): void {
-        this.templateEngines.set(format, engine);
-    }
-
-    registerLanguageEngine(format: TemplateLanguageEnum, engine: LanguageEngine): void {
-        this.languageEngines.set(format, engine);
-    }
-
-    getTemplateEngine(format: TemplateEngineEnum): TemplateEngine {
-        const engine = this.templateEngines.get(format);
-        if (!engine) {
-            throw new Error(`Template engine not found for format: ${format}`);
-        }
-        return engine;
-    }
-
-    getLanguageEngine(format: TemplateLanguageEnum): LanguageEngine {
-        const engine = this.languageEngines.get(format);
-        if (!engine) {
-            throw new Error(`Language engine not found for format: ${format}`);
-        }
-        return engine;
-    }
-
-    registerLanguageEngines(engineClasses: ClassType<LanguageEngine>[]): void {
-        engineClasses.forEach(EngineClass => {
-            const engineName = (EngineClass as any).engineName;
-            if (!engineName) {
-                throw new Error(`Engine class ${EngineClass.name} must define static engineName property`);
-            }
-            const options = (this.config.enginesOptions?.language as any)?.[engineName];
-            this.registerLanguageEngine(engineName, new EngineClass(options));
-        });
-    }
-
-    hasTemplateEngine(format: TemplateEngineEnum): boolean {
-        return this.templateEngines.has(format);
-    }
-
-    hasLanguageEngine(format: TemplateLanguageEnum): boolean {
-        return this.languageEngines.has(format);
-    }
-
-    getSupportedTemplateFormats(): TemplateEngineEnum[] {
-        return Array.from(this.templateEngines.keys());
-    }
-
-    getSupportedLanguageFormats(): TemplateLanguageEnum[] {
-        return Array.from(this.languageEngines.keys());
-    }
-}