@ackplus/nest-dynamic-templates 0.1.51 → 1.1.1

package/README.md

@@ -1,289 +1,11 @@
-# NestJS Dynamic Templates
+# nest-auth
 
-A powerful NestJS module for dynamic template management with support for multiple template engines and languages.
+This library was generated with [Nx](https://nx.dev).
 
-## Features
+## Building
 
-- 🚀 Multiple template engines (Nunjucks, Handlebars, EJS, Pug)
-- 🌐 Multiple language support (HTML, MJML, Markdown, Text)
-- 💾 Database storage for templates and layouts
-- 🔧 Configurable and extensible
-- 🎯 TypeScript support
-- 📦 Easy integration
+Run `nx build nest-auth` to build the library.
 
-## Installation
+## Running unit tests
 
-```bash
-npm install @ackplus/nest-dynamic-templates
-# or
-yarn add @ackplus/nest-dynamic-templates
-```
-
-## Usage
-
-### Option 1: Basic Usage (No Configuration Required)
-
-```typescript
-import { Module } from '@nestjs/common';
-import { NestDynamicTemplatesModule } from '@ackplus/nest-dynamic-templates';
-
-@Module({
-  imports: [
-    NestDynamicTemplatesModule, // Provides basic services with default configuration
-  ],
-})
-export class AppModule {}
-```
-
-### Option 2: Using forFeature() (Explicit Basic Usage)
-
-```typescript
-import { Module } from '@nestjs/common';
-import { NestDynamicTemplatesModule } from '@ackplus/nest-dynamic-templates';
-
-@Module({
-  imports: [
-    NestDynamicTemplatesModule.forFeature(), // Explicitly import basic services
-  ],
-})
-export class AppModule {}
-```
-
-### Option 3: Using forRoot() (With Configuration)
-
-```typescript
-import { Module } from '@nestjs/common';
-import { NestDynamicTemplatesModule, TemplateEngineEnum, TemplateLanguageEnum } from '@ackplus/nest-dynamic-templates';
-
-@Module({
-  imports: [
-    NestDynamicTemplatesModule.forRoot({
-      isGlobal: true,
-      engines: {
-        template: [TemplateEngineEnum.NUNJUCKS, TemplateEngineEnum.HANDLEBARS],
-        language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML],
-      },
-      enginesOptions: {
-        filters: {
-          uppercase: (str) => str.toUpperCase(),
-          reverse: (str) => str.split('').reverse().join(''),
-        },
-        template: {
-          [TemplateEngineEnum.NUNJUCKS]: {
-            autoescape: true,
-          },
-        },
-      },
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-### Option 4: Using forRootAsync() (Async Configuration)
-
-#### With useFactory
-
-```typescript
-import { Module } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { NestDynamicTemplatesModule } from '@ackplus/nest-dynamic-templates';
-
-@Module({
-  imports: [
-    ConfigModule.forRoot(),
-    NestDynamicTemplatesModule.forRootAsync({
-      imports: [ConfigModule],
-      useFactory: async (configService: ConfigService) => ({
-        isGlobal: true,
-        engines: {
-          template: configService.get('TEMPLATE_ENGINES')?.split(',') || ['nunjucks'],
-          language: configService.get('LANGUAGE_ENGINES')?.split(',') || ['html'],
-        },
-      }),
-      inject: [ConfigService],
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-#### With useClass
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import {
-  NestDynamicTemplatesModuleOptionsFactory,
-  NestDynamicTemplatesModuleConfig,
-  TemplateEngineEnum,
-  TemplateLanguageEnum
-} from '@ackplus/nest-dynamic-templates';
-
-@Injectable()
-export class TemplatesConfigService implements NestDynamicTemplatesModuleOptionsFactory {
-  createNestDynamicTemplatesModuleOptions(): NestDynamicTemplatesModuleConfig {
-    return {
-      isGlobal: true,
-      engines: {
-        template: [TemplateEngineEnum.NUNJUCKS],
-        language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML],
-      },
-    };
-  }
-}
-
-@Module({
-  imports: [
-    NestDynamicTemplatesModule.forRootAsync({
-      useClass: TemplatesConfigService,
-    }),
-  ],
-  providers: [TemplatesConfigService],
-})
-export class AppModule {}
-```
-
-## Using the Services
-
-Once imported, you can inject and use the template services:
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { TemplateService, TemplateLayoutService } from '@ackplus/nest-dynamic-templates';
-
-@Injectable()
-export class EmailService {
-  constructor(
-    private readonly templateService: TemplateService,
-    private readonly templateLayoutService: TemplateLayoutService,
-  ) {}
-
-  async sendWelcomeEmail(user: any) {
-    // Create a template
-    const template = await this.templateService.createTemplate({
-      name: 'welcome-email',
-      displayName: 'Welcome Email',
-      engine: 'nunjucks',
-      language: 'html',
-      subject: 'Welcome {{ user.name }}!',
-      content: '<h1>Hello {{ user.name }}</h1><p>Welcome to our platform!</p>',
-      scope: 'system',
-      locale: 'en',
-    });
-
-    // Render the template
-    const rendered = await this.templateService.renderTemplate('welcome-email', {
-      user: { name: user.name },
-    });
-
-    console.log('Rendered email:', rendered);
-    // Send email using your preferred email service
-  }
-
-  async createEmailLayout() {
-    // Create a layout
-    const layout = await this.templateLayoutService.createTemplateLayout({
-      name: 'email-layout',
-      displayName: 'Email Layout',
-      engine: 'nunjucks',
-      language: 'html',
-      content: `
-        <!DOCTYPE html>
-        <html>
-          <head><title>{{ subject }}</title></head>
-          <body>
-            <header>Our Company</header>
-            <main>{{ content | safe }}</main>
-            <footer>© 2024 Our Company</footer>
-          </body>
-        </html>
-      `,
-      scope: 'system',
-      locale: 'en',
-    });
-
-    return layout;
-  }
-}
-```
-
-## Configuration Options
-
-### NestDynamicTemplatesModuleConfig
-
-```typescript
-interface NestDynamicTemplatesModuleConfig {
-  isGlobal?: boolean; // Make module global
-  engines?: {
-    template?: TemplateEngineEnum[]; // Enabled template engines
-    language?: TemplateLanguageEnum[]; // Enabled language engines
-  };
-  enginesOptions?: {
-    filters?: Record<string, Function>; // Custom filters
-    template?: Partial<Record<TemplateEngineEnum, any>>; // Engine-specific options
-    language?: Partial<Record<TemplateLanguageEnum, any>>; // Language-specific options
-  };
-}
-```
-
-### Supported Engines
-
-#### Template Engines
-- `nunjucks` - Nunjucks templating
-- `handlebars` - Handlebars templating
-- `ejs` - EJS templating
-- `pug` - Pug templating
-
-#### Language Engines
-- `html` - HTML output
-- `mjml` - MJML email templates
-- `markdown` - Markdown output
-- `text` - Plain text output
-
-## Benefits of Each Approach
-
-### Basic Usage (`NestDynamicTemplatesModule`)
-- ✅ **Zero configuration** - Works out of the box
-- ✅ **Quick setup** - Just import and use
-- ✅ **Default engines** - Nunjucks + HTML/MJML/Text
-- ❌ **Limited customization** - No custom filters or options
-
-### forFeature()
-- ✅ **Explicit** - Clear intent for basic usage
-- ✅ **Same as basic** - All benefits of basic usage
-- ✅ **Consistent API** - Matches other NestJS modules
-
-### forRoot()
-- ✅ **Full configuration** - Complete control over engines and options
-- ✅ **Custom filters** - Add your own template filters
-- ✅ **Engine options** - Configure individual engines
-- ✅ **Global module** - Available throughout the app
-
-### forRootAsync()
-- ✅ **Dynamic configuration** - Load config from external sources
-- ✅ **Dependency injection** - Use other services for configuration
-- ✅ **Environment-based** - Different configs for different environments
-- ✅ **Factory pattern** - Clean separation of configuration logic
-
-## Migration Guide
-
-If you're upgrading from a previous version:
-
-### Before
-```typescript
-// Only forRoot was available
-NestDynamicTemplatesModule.forRoot(config)
-```
-
-### After
-```typescript
-// Multiple options now available
-NestDynamicTemplatesModule                    // Basic usage
-NestDynamicTemplatesModule.forFeature()       // Explicit basic usage
-NestDynamicTemplatesModule.forRoot(config)    // With configuration
-NestDynamicTemplatesModule.forRootAsync(...)  // Async configuration
-```
-
-## License
-
-MIT
+Run `nx test nest-auth` to execute the unit tests via [Jest](https://jestjs.io).

package/eslint.config.mjs

@@ -0,0 +1,22 @@
+import baseConfig from '../../eslint.base.config';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+  {
+    ignores: ['**/out-tsc'],
+  },
+];

package/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'nest-dynamic-templates',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/packages/nest-dynamic-templates',
+};

package/package.json

@@ -1,61 +1,10 @@
 {
   "name": "@ackplus/nest-dynamic-templates",
-  "version": "0.1.51",
-  "description": "Dynamic template management for NestJS applications",
-  "author": "Chetan",
-  "dependencies": {
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.0",
-    "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.1"
-  },
-  "optionalDependencies": {
-    "nunjucks": "^3.2.4",
-    "handlebars": "^4.7.8",
-    "ejs": "^3.1.9",
-    "pug": "^3.0.2",
-    "mjml": "^4.14.1",
-    "marked": "^11.1.1",
-    "htmlparser2": "^9.0.0"
-  },
-  "devDependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0",
-    "@nestjs/platform-express": "^10.0.0",
-    "@nestjs/swagger": "^7.0.0",
-    "typeorm": "^0.3.23",
-    "@nestjs/typeorm": "^11.0.0",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^20.0.0",
-    "@types/nunjucks": "^3.2.5",
-    "@types/handlebars": "^4.1.0",
-    "@types/ejs": "^3.1.5",
-    "@types/pug": "^2.0.6",
-    "@types/marked": "^5.0.2",
-    "@types/htmlparser2": "^3.10.7",
-    "eslint": "^8.0.0",
-    "jest": "^29.5.0",
-    "typescript": "^5.0.0"
-  },
-  "peerDependencies": {
-    "typeorm": "^0.3.23",
-    "@nestjs/typeorm": "^11.0.0",
-    "@nestjs/common": "^10.4.5",
-    "@nestjs/core": "^10.4.5"
-  },
-  "keywords": [
-    "nestjs",
-    "templates",
-    "dynamic",
-    "email",
-    "mjml",
-    "nunjucks",
-    "handlebars",
-    "ejs",
-    "pug"
-  ],
-  "license": "MIT",
-  "types": "./src/index.d.ts",
+  "version": "1.1.1",
+  "type": "commonjs",
   "main": "./src/index.js",
-  "type": "commonjs"
-}
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/project.json

@@ -0,0 +1,38 @@
+{
+  "name": "nest-dynamic-templates",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/nest-dynamic-templates/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": [
+        "dist/{projectRoot}"
+      ],
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk"
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": [
+        "{options.outputPath}"
+      ],
+      "options": {
+        "outputPath": "dist/packages/nest-dynamic-templates",
+        "tsConfig": "packages/nest-dynamic-templates/tsconfig.lib.json",
+        "packageJson": "packages/nest-dynamic-templates/package.json",
+        "main": "packages/nest-dynamic-templates/src/index.ts",
+        "assets": [
+          "packages/nest-dynamic-templates/*.md"
+        ]
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

package/src/{index.d.ts → index.ts}

@@ -1,14 +1,27 @@
 import { NestDynamicTemplateLayout } from './lib/entities/template-layout.entity';
+import { NestDynamicTemplate } from './lib/entities/template.entity';
+
 export * from './lib/nest-dynamic-templates.module';
+
+// Services
 export * from './lib/services/template.service';
 export * from './lib/services/template-layout.service';
 export * from './lib/services/template-config.service';
+
+// Interfaces
 export * from './lib/interfaces/module-config.interface';
 export * from './lib/interfaces/template.types';
+
+// DTOs
 export * from './lib/dto/create-template.dto';
 export * from './lib/dto/render-template.dto';
 export * from './lib/dto/template-filter.dto';
 export * from './lib/dto/create-template-layout.dto';
 export * from './lib/dto/render-template-layout.dto';
 export * from './lib/dto/template-layout-filter.dto';
-export declare const NestDynamicTemplatesEntities: (typeof NestDynamicTemplateLayout)[];
+
+
+export const NestDynamicTemplatesEntities = [
+    NestDynamicTemplate,
+    NestDynamicTemplateLayout,
+];

package/src/lib/constant.ts

@@ -0,0 +1,2 @@
+export const NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG = Symbol('NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG');
+export const NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER = 'NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER';

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

@@ -0,0 +1,65 @@
+import { IsString, IsEnum, IsOptional, IsNotEmpty, Matches } from 'class-validator';
+import { TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+
+export class CreateTemplateLayoutDto {
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    @Matches(/^[a-z0-9\-_]+$/, { message: 'Invalid template name format' })
+    name: string;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsOptional()
+    type?: string;
+
+    @ApiPropertyOptional({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    displayName: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    description?: string;
+
+    @ApiProperty({ enum: TemplateEngineEnum, type: String })
+    @IsEnum(TemplateEngineEnum)
+    @IsOptional()
+    engine: TemplateEngineEnum = TemplateEngineEnum.NUNJUCKS;
+
+    @ApiProperty({ enum: TemplateLanguageEnum, type: String })
+    @IsEnum(TemplateLanguageEnum)
+    @IsNotEmpty()
+    language: TemplateLanguageEnum;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    content: string;
+
+    @ApiPropertyOptional({ type: String, default: 'system' })
+    @IsString()
+    @IsOptional()
+    scope: string = 'system';
+
+    @ApiPropertyOptional({ type: String })
+    @IsString()
+    @IsOptional()
+    scopeId?: string;
+
+    @ApiPropertyOptional({ type: String, nullable: true, default: 'en' })
+    @IsString()
+    @IsOptional()
+    locale?: string = 'en';
+
+    @ApiPropertyOptional({ type: Object, nullable: true })
+    @IsOptional()
+    previewContext?: Record<string, any>;
+
+    @ApiPropertyOptional({ type: Boolean, nullable: true })
+    @IsOptional()
+    isActive?: boolean = true;
+}

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

@@ -0,0 +1,80 @@
+import { IsString, IsEnum, IsOptional, IsNotEmpty, Matches, IsBoolean } from 'class-validator';
+import { TemplateEngineEnum, TemplateLanguageEnum, TemplateTypeEnum } from '../interfaces/template.types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+
+export class CreateTemplateDto {
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    @Matches(/^[a-z0-9\-_]+$/, { message: 'Invalid template name format' })
+    name: string;
+
+    @ApiPropertyOptional({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    templateLayoutName?: string;
+
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsOptional()
+    type?: string;
+
+    @ApiPropertyOptional({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    displayName: string;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    description?: string;
+
+    @ApiProperty({ enum: TemplateEngineEnum, type: String })
+    @IsEnum(TemplateEngineEnum)
+    @IsOptional()
+    engine: TemplateEngineEnum = TemplateEngineEnum.NUNJUCKS;
+
+    @ApiProperty({ enum: TemplateLanguageEnum, type: String })
+    @IsEnum(TemplateLanguageEnum)
+    language: TemplateLanguageEnum;
+
+    @ApiProperty({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    content: string;
+
+    @ApiPropertyOptional({ type: String, nullable: true })
+    @IsString()
+    @IsOptional()
+    subject?: string;
+
+    @ApiPropertyOptional({ type: String, default: 'system' })
+    @IsString()
+    @IsOptional()
+    @Transform(({ value }) => value || 'system')
+    scope: string = 'system';
+
+    @ApiPropertyOptional({ type: String })
+    @IsString()
+    @IsOptional()
+    scopeId?: string;
+
+    @ApiPropertyOptional({ type: String, nullable: true, default: 'en' })
+    @IsString()
+    @IsOptional()
+    @IsNotEmpty()
+    @Transform(({ value }) => value || 'en')
+    locale?: string = 'en';
+
+    @ApiPropertyOptional({ type: Object, nullable: true })
+    @IsOptional()
+    previewContext?: Record<string, any>;
+
+    @ApiPropertyOptional({ type: Boolean, nullable: true })
+    @IsBoolean()
+    @IsOptional()
+    isActive?: boolean = true;
+
+}

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

@@ -0,0 +1,32 @@
+import { IsString, IsEnum, IsObject, IsOptional, IsNotEmpty } from 'class-validator';
+import { TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+
+
+export class RenderContentTemplateLayoutDto {
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    content?: string;
+
+    @ApiProperty({ enum: TemplateLanguageEnum, type: String })
+    @IsEnum(TemplateLanguageEnum)
+    @IsNotEmpty()
+    @Transform(({ value }) => value || TemplateLanguageEnum.HTML)
+    language?: TemplateLanguageEnum;
+
+    @ApiProperty({ enum: TemplateEngineEnum, type: String })
+    @IsEnum(TemplateEngineEnum)
+    @Transform(({ value }) => value || TemplateEngineEnum.NUNJUCKS)
+    engine?: TemplateEngineEnum;
+
+    @ApiPropertyOptional({
+        type: String,
+        nullable: true,
+        description: 'The context of the template'
+    })
+    @IsObject()
+    @IsOptional()
+    context?: Record<string, any>;
+}

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

@@ -0,0 +1,37 @@
+import { IsString, IsEnum, IsObject, IsOptional, IsNotEmpty } from 'class-validator';
+import { TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+
+
+export class RenderContentTemplateDto {
+    @ApiProperty({ type: String })
+    @IsString()
+    @IsNotEmpty()
+    content?: string;
+
+    @ApiProperty({ enum: TemplateLanguageEnum, type: String })
+    @IsEnum(TemplateLanguageEnum)
+    @IsNotEmpty()
+    @Transform(({ value }) => value || TemplateLanguageEnum.HTML)
+    language?: TemplateLanguageEnum;
+
+    @ApiProperty({ enum: TemplateEngineEnum, type: String })
+    @IsEnum(TemplateEngineEnum)
+    @Transform(({ value }) => value || TemplateEngineEnum.NUNJUCKS)
+    engine?: TemplateEngineEnum;
+
+    @ApiPropertyOptional({
+        type: String,
+        nullable: true,
+        description: 'The context of the template'
+    })
+    @IsObject()
+    @IsOptional()
+    context?: Record<string, any>;
+
+    @ApiPropertyOptional({ type: String })
+    @IsString()
+    @IsOptional()
+    templateLayoutId?: string;
+}