@ackplus/nest-dynamic-templates 1.1.1 → 1.1.2

package/src/lib/errors/template.errors.ts

@@ -1,73 +0,0 @@
-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',
-            operation,
-            templateName,
-            originalError: originalError.message,
-        });
-    }
-}
-
-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',
-            engine,
-            originalError: originalError.message,
-        });
-    }
-}
-
-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',
-            language,
-            originalError: originalError.message,
-        });
-    }
-}
-
-export class TemplateLayoutError extends InternalServerErrorException {
-    constructor(layoutName: string, originalError: Error) {
-        super({
-            message: `Template layout '${layoutName}' failed to render: ${originalError.message}`,
-            error: 'TEMPLATE_LAYOUT_ERROR',
-            layoutName,
-            originalError: originalError.message,
-        });
-    }
-}
-
-export class TemplateContentError extends InternalServerErrorException {
-    constructor(contentType: string, originalError: Error) {
-        super({
-            message: `Failed to process ${contentType} content: ${originalError.message}`,
-            error: 'TEMPLATE_CONTENT_ERROR',
-            contentType,
-            originalError: originalError.message,
-        });
-    }
-}
-
-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',
-            field,
-            value,
-            reason,
-        });
-    }
-}

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-config.service.ts

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

@@ -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());
-    }
-}