@ackplus/nest-dynamic-templates 1.1.2 → 1.1.5

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestDynamicTemplate = void 0;
+const tslib_1 = require("tslib");
+const typeorm_1 = require("typeorm");
+const template_types_1 = require("../interfaces/template.types");
+const class_validator_1 = require("class-validator");
+const swagger_1 = require("@nestjs/swagger");
+let NestDynamicTemplate = class NestDynamicTemplate extends typeorm_1.BaseEntity {
+};
+exports.NestDynamicTemplate = NestDynamicTemplate;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, format: 'uuid', readOnly: true }),
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "id", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.Matches)(/^[a-z0-9\-_]+$/, { message: 'Invalid template name format' }),
+    (0, typeorm_1.Column)(),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "name", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)({ nullable: true }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "displayName", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "description", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "type", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ enum: template_types_1.TemplateEngineEnum, type: String }),
+    (0, class_validator_1.IsEnum)(template_types_1.TemplateEngineEnum),
+    (0, typeorm_1.Column)({
+        type: 'text',
+        enum: template_types_1.TemplateEngineEnum,
+        default: template_types_1.TemplateEngineEnum.NUNJUCKS
+    }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "engine", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ enum: template_types_1.TemplateLanguageEnum, type: String, nullable: true }),
+    (0, class_validator_1.IsEnum)(template_types_1.TemplateLanguageEnum),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)({ type: 'text' }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "language", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)({ nullable: true }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "subject", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)('text'),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "content", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)({ nullable: true }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "templateLayoutName", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, typeorm_1.Column)({ nullable: true, default: 'system' }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "scope", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, typeorm_1.Column)({ nullable: true }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "scopeId", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true }),
+    (0, class_validator_1.IsString)(),
+    (0, typeorm_1.Column)({ nullable: true, default: 'en' }),
+    tslib_1.__metadata("design:type", String)
+], NestDynamicTemplate.prototype, "locale", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: Object, nullable: true }),
+    (0, class_validator_1.IsOptional)(),
+    (0, typeorm_1.Column)('simple-json', { nullable: true }),
+    tslib_1.__metadata("design:type", Object)
+], NestDynamicTemplate.prototype, "previewContext", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: Boolean }),
+    (0, class_validator_1.IsBoolean)(),
+    (0, typeorm_1.Column)({ default: true }),
+    tslib_1.__metadata("design:type", Boolean)
+], NestDynamicTemplate.prototype, "isActive", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: Date, readOnly: true }),
+    (0, typeorm_1.CreateDateColumn)(),
+    tslib_1.__metadata("design:type", Date)
+], NestDynamicTemplate.prototype, "createdAt", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: Date, readOnly: true }),
+    (0, typeorm_1.UpdateDateColumn)(),
+    tslib_1.__metadata("design:type", Date)
+], NestDynamicTemplate.prototype, "updatedAt", void 0);
+exports.NestDynamicTemplate = NestDynamicTemplate = tslib_1.__decorate([
+    (0, typeorm_1.Entity)('nest_dynamic_templates'),
+    (0, typeorm_1.Index)(['name', 'scope', 'scopeId', 'locale'], { unique: true })
+], NestDynamicTemplate);

package/src/lib/errors/template.errors.js

@@ -0,0 +1,75 @@
+"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) {
+        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,
+        });
+    }
+}
+exports.TemplateRenderError = TemplateRenderError;
+class TemplateEngineError extends common_1.InternalServerErrorException {
+    constructor(engine, originalError) {
+        super({
+            message: `Template engine '${engine}' failed to render content: ${originalError.message}`,
+            error: 'TEMPLATE_ENGINE_ERROR',
+            engine,
+            originalError: originalError.message,
+        });
+    }
+}
+exports.TemplateEngineError = TemplateEngineError;
+class TemplateLanguageError extends common_1.InternalServerErrorException {
+    constructor(language, originalError) {
+        super({
+            message: `Language processor '${language}' failed to render content: ${originalError.message}`,
+            error: 'TEMPLATE_LANGUAGE_ERROR',
+            language,
+            originalError: originalError.message,
+        });
+    }
+}
+exports.TemplateLanguageError = TemplateLanguageError;
+class TemplateLayoutError extends common_1.InternalServerErrorException {
+    constructor(layoutName, originalError) {
+        super({
+            message: `Template layout '${layoutName}' failed to render: ${originalError.message}`,
+            error: 'TEMPLATE_LAYOUT_ERROR',
+            layoutName,
+            originalError: originalError.message,
+        });
+    }
+}
+exports.TemplateLayoutError = TemplateLayoutError;
+class TemplateContentError extends common_1.InternalServerErrorException {
+    constructor(contentType, originalError) {
+        super({
+            message: `Failed to process ${contentType} content: ${originalError.message}`,
+            error: 'TEMPLATE_CONTENT_ERROR',
+            contentType,
+            originalError: originalError.message,
+        });
+    }
+}
+exports.TemplateContentError = TemplateContentError;
+class TemplateValidationError extends common_1.BadRequestException {
+    constructor(field, value, reason) {
+        super({
+            message: `Template validation failed for field '${field}': ${reason}`,
+            error: 'TEMPLATE_VALIDATION_ERROR',
+            field,
+            value,
+            reason,
+        });
+    }
+}
+exports.TemplateValidationError = TemplateValidationError;

package/src/lib/interfaces/module-config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLanguageEnum = exports.TemplateEngineEnum = exports.TemplateTypeEnum = void 0;
+var TemplateTypeEnum;
+(function (TemplateTypeEnum) {
+    TemplateTypeEnum["EMAIL"] = "email";
+    TemplateTypeEnum["SMS"] = "sms";
+    TemplateTypeEnum["PUSH"] = "push";
+    TemplateTypeEnum["PDF"] = "pdf";
+})(TemplateTypeEnum || (exports.TemplateTypeEnum = TemplateTypeEnum = {}));
+var TemplateEngineEnum;
+(function (TemplateEngineEnum) {
+    TemplateEngineEnum["NUNJUCKS"] = "njk";
+    TemplateEngineEnum["HANDLEBARS"] = "hbs";
+    TemplateEngineEnum["EJS"] = "ejs";
+    TemplateEngineEnum["PUG"] = "pug";
+})(TemplateEngineEnum || (exports.TemplateEngineEnum = TemplateEngineEnum = {}));
+var TemplateLanguageEnum;
+(function (TemplateLanguageEnum) {
+    TemplateLanguageEnum["MJML"] = "mjml";
+    TemplateLanguageEnum["HTML"] = "html";
+    TemplateLanguageEnum["MARKDOWN"] = "md";
+    TemplateLanguageEnum["TEXT"] = "txt";
+})(TemplateLanguageEnum || (exports.TemplateLanguageEnum = TemplateLanguageEnum = {}));

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

@@ -0,0 +1,131 @@
+"use strict";
+var NestDynamicTemplatesModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestDynamicTemplatesModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const template_entity_1 = require("./entities/template.entity");
+const template_layout_entity_1 = require("./entities/template-layout.entity");
+const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
+const template_engine_registry_1 = require("./services/template-engine.registry");
+const template_layout_service_1 = require("./services/template-layout.service");
+const template_service_1 = require("./services/template.service");
+const template_config_service_1 = require("./services/template-config.service");
+const constant_1 = require("./constant");
+const template_types_1 = require("./interfaces/template.types");
+const template_types_2 = require("./interfaces/template.types");
+const defaultConfig = {
+    engines: {
+        template: [template_types_1.TemplateEngineEnum.NUNJUCKS],
+        language: [template_types_2.TemplateLanguageEnum.HTML, template_types_2.TemplateLanguageEnum.MJML, template_types_2.TemplateLanguageEnum.TEXT]
+    }
+};
+let NestDynamicTemplatesModule = NestDynamicTemplatesModule_1 = class NestDynamicTemplatesModule {
+    static forRoot(config = {}) {
+        const mergedConfig = this.getOptions(config);
+        // Set options in static service
+        template_config_service_1.TemplateConfigService.setOptions(mergedConfig);
+        return {
+            module: NestDynamicTemplatesModule_1,
+            global: mergedConfig.isGlobal,
+            imports: [
+                typeorm_1.TypeOrmModule.forFeature([template_entity_1.NestDynamicTemplate, template_layout_entity_1.NestDynamicTemplateLayout]),
+            ],
+            providers: [
+                template_config_service_1.TemplateConfigService,
+                template_engine_registry_1.TemplateEngineRegistryService,
+                template_layout_service_1.TemplateLayoutService,
+                template_service_1.TemplateService,
+            ],
+            exports: [
+                template_config_service_1.TemplateConfigService,
+                template_service_1.TemplateService,
+                template_layout_service_1.TemplateLayoutService,
+            ],
+        };
+    }
+    static forRootAsync(options) {
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: NestDynamicTemplatesModule_1,
+            global: options.isGlobal,
+            imports: [
+                typeorm_1.TypeOrmModule.forFeature([template_entity_1.NestDynamicTemplate, template_layout_entity_1.NestDynamicTemplateLayout]),
+                ...(options.imports || []),
+            ],
+            providers: [
+                ...asyncProviders,
+                template_config_service_1.TemplateConfigService,
+                template_engine_registry_1.TemplateEngineRegistryService,
+                template_layout_service_1.TemplateLayoutService,
+                template_service_1.TemplateService,
+            ],
+            exports: [
+                template_config_service_1.TemplateConfigService,
+                template_service_1.TemplateService,
+                template_layout_service_1.TemplateLayoutService,
+            ],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        if (options.useClass) {
+            return [
+                this.createAsyncOptionsProvider(options),
+                {
+                    provide: options.useClass,
+                    useClass: options.useClass,
+                },
+            ];
+        }
+        return [];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: constant_1.NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER,
+                useFactory: async (...args) => {
+                    const userOptions = options.useFactory ? await options.useFactory(...args) : {};
+                    const mergedOptions = this.getOptions(userOptions);
+                    template_config_service_1.TemplateConfigService.setOptions(mergedOptions);
+                    return mergedOptions;
+                },
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: constant_1.NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER,
+            useFactory: async (optionsFactory) => {
+                const userOptions = await optionsFactory.createNestDynamicTemplatesModuleOptions();
+                const mergedOptions = this.getOptions(userOptions);
+                template_config_service_1.TemplateConfigService.setOptions(mergedOptions);
+                return mergedOptions;
+            },
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+    static getOptions(options) {
+        return (0, deepmerge_1.default)(this.moduleDefaultOptions, options);
+    }
+};
+exports.NestDynamicTemplatesModule = NestDynamicTemplatesModule;
+NestDynamicTemplatesModule.moduleDefaultOptions = defaultConfig;
+exports.NestDynamicTemplatesModule = NestDynamicTemplatesModule = NestDynamicTemplatesModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({
+        imports: [typeorm_1.TypeOrmModule.forFeature([template_entity_1.NestDynamicTemplate, template_layout_entity_1.NestDynamicTemplateLayout])],
+        providers: [
+            template_config_service_1.TemplateConfigService,
+            template_engine_registry_1.TemplateEngineRegistryService,
+            template_layout_service_1.TemplateLayoutService,
+            template_service_1.TemplateService,
+        ],
+        exports: [
+            template_config_service_1.TemplateConfigService,
+            template_service_1.TemplateService,
+            template_layout_service_1.TemplateLayoutService,
+        ],
+    })
+], NestDynamicTemplatesModule);

package/src/lib/services/template-config.service.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateConfigService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const template_types_1 = require("../interfaces/template.types");
+let TemplateConfigService = class TemplateConfigService {
+    /**
+     * Set the configuration options
+     */
+    static setOptions(config) {
+        this.config = { ...this.defaultConfig, ...config };
+    }
+    /**
+     * Get the current configuration options
+     */
+    static getOptions() {
+        if (!this.config) {
+            return this.defaultConfig;
+        }
+        return this.config;
+    }
+    /**
+     * Check if configuration has been set
+     */
+    static hasConfig() {
+        return !!this.config;
+    }
+    /**
+     * Reset configuration to default
+     */
+    static reset() {
+        this.config = { ...this.defaultConfig };
+    }
+    /**
+     * Get a specific configuration value
+     */
+    static get(key) {
+        const config = this.getOptions();
+        return config[key];
+    }
+    /**
+     * Check if a template engine is enabled
+     */
+    static isTemplateEngineEnabled(engine) {
+        const config = this.getOptions();
+        return config.engines?.template?.includes(engine) ?? false;
+    }
+    /**
+     * Check if a language engine is enabled
+     */
+    static isLanguageEngineEnabled(language) {
+        const config = this.getOptions();
+        return config.engines?.language?.includes(language) ?? false;
+    }
+    /**
+     * Get enabled template engines
+     */
+    static getEnabledTemplateEngines() {
+        const config = this.getOptions();
+        return config.engines?.template ?? this.defaultConfig.engines.template;
+    }
+    /**
+     * Get enabled language engines
+     */
+    static getEnabledLanguageEngines() {
+        const config = this.getOptions();
+        return config.engines?.language ?? this.defaultConfig.engines.language;
+    }
+    /**
+     * Get engine options for a specific template engine
+     */
+    static getTemplateEngineOptions(engine) {
+        const config = this.getOptions();
+        return config.enginesOptions?.template?.[engine];
+    }
+    /**
+     * Get engine options for a specific language engine
+     */
+    static getLanguageEngineOptions(language) {
+        const config = this.getOptions();
+        return config.enginesOptions?.language?.[language];
+    }
+    /**
+     * Get custom filters
+     */
+    static getCustomFilters() {
+        const config = this.getOptions();
+        return config.enginesOptions?.filters ?? {};
+    }
+};
+exports.TemplateConfigService = TemplateConfigService;
+TemplateConfigService.defaultConfig = {
+    engines: {
+        template: [template_types_1.TemplateEngineEnum.NUNJUCKS],
+        language: [template_types_1.TemplateLanguageEnum.HTML, template_types_1.TemplateLanguageEnum.MJML, template_types_1.TemplateLanguageEnum.TEXT]
+    }
+};
+exports.TemplateConfigService = TemplateConfigService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], TemplateConfigService);

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateEngineRegistryService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const nunjucks_engine_1 = require("../engines/template/nunjucks.engine");
+const mjml_engine_1 = require("../engines/language/mjml.engine");
+const html_engine_1 = require("../engines/language/html.engine");
+const language_1 = require("../engines/language");
+const ejs_engine_1 = require("../engines/template/ejs.engine");
+const handlebars_engine_1 = require("../engines/template/handlebars.engine");
+const pug_engine_1 = require("../engines/template/pug.engine");
+const template_config_service_1 = require("./template-config.service");
+let TemplateEngineRegistryService = class TemplateEngineRegistryService {
+    constructor() {
+        this.templateEngines = new Map();
+        this.languageEngines = new Map();
+        this.config = template_config_service_1.TemplateConfigService.getOptions();
+        this.registerTemplateEngines([
+            nunjucks_engine_1.NunjucksEngine,
+            handlebars_engine_1.HandlebarsEngine,
+            ejs_engine_1.EjsEngine,
+            pug_engine_1.PugEngine
+        ]);
+        this.registerLanguageEngines([
+            mjml_engine_1.MjmlEngine,
+            html_engine_1.HtmlEngine,
+            language_1.TextEngine,
+            language_1.MarkdownEngine
+        ]);
+    }
+    registerTemplateEngines(engineClasses) {
+        engineClasses.forEach(EngineClass => {
+            const engineName = EngineClass.engineName;
+            if (!engineName) {
+                throw new Error(`Engine class ${EngineClass.name} must define static engineName property`);
+            }
+            const options = this.config.enginesOptions?.template?.[engineName];
+            const customOptions = {
+                filters: this.config.enginesOptions?.filters,
+                globalValues: this.config.enginesOptions?.globalValues
+            };
+            this.registerTemplateEngine(engineName, new EngineClass(options, customOptions));
+        });
+    }
+    registerTemplateEngine(format, engine) {
+        this.templateEngines.set(format, engine);
+    }
+    registerLanguageEngine(format, engine) {
+        this.languageEngines.set(format, engine);
+    }
+    getTemplateEngine(format) {
+        const engine = this.templateEngines.get(format);
+        if (!engine) {
+            throw new Error(`Template engine not found for format: ${format}`);
+        }
+        return engine;
+    }
+    getLanguageEngine(format) {
+        const engine = this.languageEngines.get(format);
+        if (!engine) {
+            throw new Error(`Language engine not found for format: ${format}`);
+        }
+        return engine;
+    }
+    registerLanguageEngines(engineClasses) {
+        engineClasses.forEach(EngineClass => {
+            const engineName = EngineClass.engineName;
+            if (!engineName) {
+                throw new Error(`Engine class ${EngineClass.name} must define static engineName property`);
+            }
+            const options = this.config.enginesOptions?.language?.[engineName];
+            this.registerLanguageEngine(engineName, new EngineClass(options));
+        });
+    }
+    hasTemplateEngine(format) {
+        return this.templateEngines.has(format);
+    }
+    hasLanguageEngine(format) {
+        return this.languageEngines.has(format);
+    }
+    getSupportedTemplateFormats() {
+        return Array.from(this.templateEngines.keys());
+    }
+    getSupportedLanguageFormats() {
+        return Array.from(this.languageEngines.keys());
+    }
+};
+exports.TemplateEngineRegistryService = TemplateEngineRegistryService;
+exports.TemplateEngineRegistryService = TemplateEngineRegistryService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], TemplateEngineRegistryService);