@ackplus/nest-dynamic-templates 0.1.50 → 1.1.0

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

@@ -0,0 +1,105 @@
+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/errors/{template.errors.js → template.errors.ts}

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateValidationError = exports.TemplateContentError = exports.TemplateLayoutError = exports.TemplateLanguageError = exports.TemplateEngineError = exports.TemplateRenderError = void 0;
-const common_1 = require("@nestjs/common");
-class TemplateRenderError extends common_1.InternalServerErrorException {
-    constructor(operation, originalError, templateName) {
+import { BadRequestException, InternalServerErrorException } from '@nestjs/common';
+
+export class TemplateRenderError extends InternalServerErrorException {
+    constructor(operation: string, originalError: Error, templateName?: string) {
         const message = templateName
             ? `Failed to render template '${templateName}' during ${operation}: ${originalError.message}`
             : `Failed to render content during ${operation}: ${originalError.message}`;
+
         super({
             message,
             error: 'TEMPLATE_RENDER_ERROR',
@@ -16,9 +15,9 @@ class TemplateRenderError extends common_1.InternalServerErrorException {
         });
     }
 }
-exports.TemplateRenderError = TemplateRenderError;
-class TemplateEngineError extends common_1.InternalServerErrorException {
-    constructor(engine, originalError) {
+
+export class TemplateEngineError extends InternalServerErrorException {
+    constructor(engine: string, originalError: Error) {
         super({
             message: `Template engine '${engine}' failed to render content: ${originalError.message}`,
             error: 'TEMPLATE_ENGINE_ERROR',
@@ -27,9 +26,9 @@ class TemplateEngineError extends common_1.InternalServerErrorException {
         });
     }
 }
-exports.TemplateEngineError = TemplateEngineError;
-class TemplateLanguageError extends common_1.InternalServerErrorException {
-    constructor(language, originalError) {
+
+export class TemplateLanguageError extends InternalServerErrorException {
+    constructor(language: string, originalError: Error) {
         super({
             message: `Language processor '${language}' failed to render content: ${originalError.message}`,
             error: 'TEMPLATE_LANGUAGE_ERROR',
@@ -38,9 +37,9 @@ class TemplateLanguageError extends common_1.InternalServerErrorException {
         });
     }
 }
-exports.TemplateLanguageError = TemplateLanguageError;
-class TemplateLayoutError extends common_1.InternalServerErrorException {
-    constructor(layoutName, originalError) {
+
+export class TemplateLayoutError extends InternalServerErrorException {
+    constructor(layoutName: string, originalError: Error) {
         super({
             message: `Template layout '${layoutName}' failed to render: ${originalError.message}`,
             error: 'TEMPLATE_LAYOUT_ERROR',
@@ -49,9 +48,9 @@ class TemplateLayoutError extends common_1.InternalServerErrorException {
         });
     }
 }
-exports.TemplateLayoutError = TemplateLayoutError;
-class TemplateContentError extends common_1.InternalServerErrorException {
-    constructor(contentType, originalError) {
+
+export class TemplateContentError extends InternalServerErrorException {
+    constructor(contentType: string, originalError: Error) {
         super({
             message: `Failed to process ${contentType} content: ${originalError.message}`,
             error: 'TEMPLATE_CONTENT_ERROR',
@@ -60,9 +59,9 @@ class TemplateContentError extends common_1.InternalServerErrorException {
         });
     }
 }
-exports.TemplateContentError = TemplateContentError;
-class TemplateValidationError extends common_1.BadRequestException {
-    constructor(field, value, reason) {
+
+export class TemplateValidationError extends BadRequestException {
+    constructor(field: string, value: any, reason: string) {
         super({
             message: `Template validation failed for field '${field}': ${reason}`,
             error: 'TEMPLATE_VALIDATION_ERROR',
@@ -72,5 +71,3 @@ class TemplateValidationError extends common_1.BadRequestException {
         });
     }
 }
-exports.TemplateValidationError = TemplateValidationError;
-//# sourceMappingURL=template.errors.js.map

package/src/lib/interfaces/{module-config.interface.d.ts → module-config.interface.ts}

@@ -1,18 +1,25 @@
 import { TemplateEngineEnum, TemplateLanguageEnum } from './template.types';
 import { ModuleMetadata, Type } from '@nestjs/common';
+
 export interface EngineConfig {
     enabled: boolean;
     options?: Record<string, any>;
 }
+
 export interface FilterOptions {
     name: string;
     filter: (...args: any[]) => any;
 }
-export type EngineOptions<T> = T & {};
+
+export type EngineOptions<T> = T & {
+
+};
+
 export type CustomEngineOptions = {
     filters?: Record<string, FilterOptions['filter']>;
-    globalValues?: Record<string, (...args: any[]) => any>;
+    globalValues?: Record<string, (...args: any) => any>;
 };
+
 export interface NestDynamicTemplatesModuleConfig {
     isGlobal?: boolean;
     enginesOptions?: {
@@ -26,9 +33,17 @@ export interface NestDynamicTemplatesModuleConfig {
         language?: TemplateLanguageEnum[];
     };
 }
+
+/**
+ * Interface for async module configuration factory
+ */
 export interface NestDynamicTemplatesModuleOptionsFactory {
     createNestDynamicTemplatesModuleOptions(): Promise<NestDynamicTemplatesModuleConfig> | NestDynamicTemplatesModuleConfig;
 }
+
+/**
+ * Interface for async module configuration
+ */
 export interface NestDynamicTemplatesModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
     isGlobal?: boolean;
     useExisting?: Type<NestDynamicTemplatesModuleOptionsFactory>;

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

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

@@ -0,0 +1,143 @@
+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-config.service.ts

@@ -0,0 +1,112 @@
+import { Injectable } from '@nestjs/common';
+import { NestDynamicTemplatesModuleConfig } from '../interfaces/module-config.interface';
+import { TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
+
+@Injectable()
+export class TemplateConfigService {
+    private static config: NestDynamicTemplatesModuleConfig;
+
+    private static readonly defaultConfig: NestDynamicTemplatesModuleConfig = {
+        engines: {
+            template: [TemplateEngineEnum.NUNJUCKS],
+            language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML, TemplateLanguageEnum.TEXT]
+        }
+    };
+
+    /**
+     * Set the configuration options
+     */
+    static setOptions(config: NestDynamicTemplatesModuleConfig): void {
+        this.config = { ...this.defaultConfig, ...config };
+    }
+
+    /**
+     * Get the current configuration options
+     */
+    static getOptions(): NestDynamicTemplatesModuleConfig {
+        if (!this.config) {
+            return this.defaultConfig;
+        }
+        return this.config;
+    }
+
+    /**
+     * Check if configuration has been set
+     */
+    static hasConfig(): boolean {
+        return !!this.config;
+    }
+
+    /**
+     * Reset configuration to default
+     */
+    static reset(): void {
+        this.config = { ...this.defaultConfig };
+    }
+
+    /**
+     * Get a specific configuration value
+     */
+    static get<K extends keyof NestDynamicTemplatesModuleConfig>(
+        key: K
+    ): NestDynamicTemplatesModuleConfig[K] {
+        const config = this.getOptions();
+        return config[key];
+    }
+
+    /**
+     * Check if a template engine is enabled
+     */
+    static isTemplateEngineEnabled(engine: TemplateEngineEnum): boolean {
+        const config = this.getOptions();
+        return config.engines?.template?.includes(engine) ?? false;
+    }
+
+    /**
+     * Check if a language engine is enabled
+     */
+    static isLanguageEngineEnabled(language: TemplateLanguageEnum): boolean {
+        const config = this.getOptions();
+        return config.engines?.language?.includes(language) ?? false;
+    }
+
+    /**
+     * Get enabled template engines
+     */
+    static getEnabledTemplateEngines(): TemplateEngineEnum[] {
+        const config = this.getOptions();
+        return config.engines?.template ?? this.defaultConfig.engines!.template!;
+    }
+
+    /**
+     * Get enabled language engines
+     */
+    static getEnabledLanguageEngines(): TemplateLanguageEnum[] {
+        const config = this.getOptions();
+        return config.engines?.language ?? this.defaultConfig.engines!.language!;
+    }
+
+    /**
+     * Get engine options for a specific template engine
+     */
+    static getTemplateEngineOptions(engine: TemplateEngineEnum): any {
+        const config = this.getOptions();
+        return config.enginesOptions?.template?.[engine];
+    }
+
+    /**
+     * Get engine options for a specific language engine
+     */
+    static getLanguageEngineOptions(language: TemplateLanguageEnum): any {
+        const config = this.getOptions();
+        return config.enginesOptions?.language?.[language];
+    }
+
+    /**
+     * Get custom filters
+     */
+    static getCustomFilters(): Record<string, Function> {
+        const config = this.getOptions();
+        return config.enginesOptions?.filters ?? {};
+    }
+}

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

@@ -0,0 +1,109 @@
+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());
+    }
+}