@ackplus/nest-dynamic-templates 1.1.16 → 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## 2.0.0
+
+A focused redesign around clearer configuration, diagnostic errors and a lighter install. See [MIGRATION.md](./MIGRATION.md) for upgrade steps.
+
+### Added
+- **Diagnostic render errors.** Failures now throw `TemplateRenderError` carrying a structured `details` payload: the missing variable, the source `location` (line/column), a `snippet` of the offending line, the `contextKeys` you actually passed, and an actionable `hint`. The original error is preserved on `cause`.
+- **Stable error codes** via `TemplateErrorCode` and an `isTemplateError()` guard. Every error extends its matching NestJS HTTP exception (404/422/400/403/409/500).
+- **Flat configuration**: top-level `filters`, `globals` and `engineOptions`.
+- **Custom filters/globals now work across all engines** (Nunjucks, Handlebars, EJS, Pug), not just Nunjucks.
+- **Real Markdown rendering** via the optional `marked` peer.
+- VitePress documentation site (GitHub Pages).
+
+### Changed
+- The `engines` list now **gates which engines are loaded** — only enabled engines are instantiated, making peer dependencies genuinely optional. The list is replaced, not merged with defaults.
+- `TemplateConfigService` is now an injectable instance service (was a global static); this fixes `forRootAsync` timing.
+- Render failures are **HTTP 422** (were 500).
+- `render()` returns `subject: string | null` when there is no subject (was `''`).
+- The HTML processor is a pass-through (the old strict validation that rejected valid output is removed).
+- Engines load lazily; nothing is required until first use.
+
+### Fixed
+- MJML validation errors are now readable (were serialized as `[object Object]`).
+- A missing layout now throws `TemplateNotFoundError` (404) instead of being miscategorized as a generic layout error.
+- Removed double-wrapped error messages.
+- The default HTML render path no longer fails with `"Invalid HTML content"`.
+
+### Removed
+- Required peer dependencies `@faker-js/faker` and `htmlparser2`; internal `yargs` and `deepmerge`.
+- Error classes `TemplateEngineError`, `TemplateLanguageError`, `TemplateLayoutError`, `TemplateContentError`, `TemplateValidationError` (superseded by `TemplateRenderError` + `TemplateInputError`).
+- Inline `content`/`language` fields on `RenderTemplateDto` (use `renderContent()`), and the `renderEngine()`/`renderLanguage()` service helpers.

package/MIGRATION.md

@@ -0,0 +1,97 @@
+# Migrating to v2
+
+v2 is a focused redesign around three goals: **clearer configuration**, **diagnostic errors**, and a **lighter install**. Most apps only need the config rename in step 1.
+
+## 1. Configuration: flatten `enginesOptions`
+
+The nested `enginesOptions` block is replaced by top-level fields. The old shape still works (with a one-time deprecation warning), but you should migrate:
+
+```diff
+ NestDynamicTemplatesModule.forRoot({
+   engines: { template: ['njk'], language: ['html', 'mjml'] },
+-  enginesOptions: {
+-    filters: { formatDate },
+-    globalValues: { brandName: 'Acme' },
+-    template: { njk: { autoescape: true } },
+-    language: { mjml: { validationLevel: 'soft' } },
+-  },
++  filters: { formatDate },
++  globals: { brandName: 'Acme' },          // renamed from globalValues
++  engineOptions: {
++    template: { njk: { autoescape: true } },
++    language: { mjml: { validationLevel: 'soft' } },
++  },
+ });
+```
+
+## 2. The `engines` list now gates loading
+
+In v1 the `engines` list was ignored — every engine was loaded regardless. In v2 **only enabled engines are instantiated**, which is what makes the peer dependencies truly optional.
+
+- List every engine you use under `engines.template` / `engines.language`.
+- Install only those engines' peer packages.
+- Rendering with a disabled engine throws `TemplateEngineUnavailableError` with a hint.
+
+Defaults are unchanged: `{ template: ['njk'], language: ['html', 'mjml', 'txt'] }`.
+
+> Note: the engine list is now **replaced**, not merged. In v1 (deepmerge) passing `template: ['hbs']` produced `['njk', 'hbs']`; in v2 you get exactly `['hbs']`.
+
+## 3. Errors are restructured
+
+The granular v1 error classes are gone, replaced by a smaller, richer set:
+
+| Removed (v1) | Use instead (v2) |
+| --- | --- |
+| `TemplateEngineError`, `TemplateLanguageError`, `TemplateLayoutError`, `TemplateContentError` | `TemplateRenderError` (rich `details`, HTTP **422**) |
+| `TemplateValidationError` | `TemplateInputError` (HTTP 400) |
+| raw `NotFoundException` | `TemplateNotFoundError` (still `instanceof NotFoundException`) |
+
+Key changes:
+
+- Render failures are now **HTTP 422** (were 500) — they're input/data errors, not server faults.
+- Each error carries `error.code` (a `TemplateErrorCode`) and `error.details` (variable, location, snippet, context keys, hint). The original error is on `error.cause`.
+- Use the `isTemplateError(err)` guard, or switch on `err.code`. Each error still extends its matching NestJS HTTP exception.
+
+```diff
+- } catch (err) {
+-   if (err instanceof TemplateEngineError) { /* ... */ }
++ } catch (err) {
++   if (isTemplateError(err)) {
++     console.error(err.code, err.details.missingVariable, err.details.contextKeys);
++   }
+ }
+```
+
+## 4. `TemplateConfigService` is now injectable
+
+It was a global static in v1; it's a normal injectable service in v2 (fixes `forRootAsync` timing). The static methods (`setOptions`, `reset`, `hasConfig`, `get`) are removed. Inject it and call instance methods:
+
+```diff
+- TemplateConfigService.getOptions();
++ constructor(private readonly config: TemplateConfigService) {}
++ this.config.getOptions();
+```
+
+## 5. `render()` no longer accepts inline content
+
+`RenderTemplateDto`'s `content` / `language` fields (which never actually worked in `render()`) are removed. To render a raw string, use `renderContent()`:
+
+```diff
+- await templates.render({ content: 'Hi {{ name }}', language: 'html', context });
++ await templates.renderContent({ content: 'Hi {{ name }}', engine: 'njk', language: 'html', context });
+```
+
+The low-level `renderEngine()` / `renderLanguage()` helpers were also removed from the services — use `renderContent()`.
+
+## 6. Output and behavior tweaks
+
+- `render()` returns `subject: string | null` (was `''`) when a template has no subject.
+- The **HTML** processor is now a pass-through. v1 ran a strict validation that could reject valid output with `"Invalid HTML content"`; that's gone.
+- **Markdown** now actually renders (via the optional `marked` peer). It was a no-op in v1.
+- Only **active** templates (`isActive: true`) are resolved by `render()`.
+
+## 7. Dependencies
+
+- **Removed required peers:** `@faker-js/faker`, `htmlparser2`. Remove them from your install if you only added them for this library.
+- **New optional peer:** `marked` — install it only if you enable the `md` language.
+- No database schema changes — your existing tables are compatible.

package/README.md

@@ -1,95 +1,97 @@
 # @ackplus/nest-dynamic-templates
 
-A powerful and flexible dynamic template rendering library for NestJS applications. Support for multiple template engines (Nunjucks, Handlebars, EJS, Pug) and content languages (HTML, MJML, Markdown, Text), with built-in database storage and layout management.
+> Database-backed, multi-engine template rendering for NestJS — with **error messages that actually tell you what went wrong**.
 
-## ✨ Features
+Store templates in your database, render them at runtime with the engine of your choice (Nunjucks, Handlebars, EJS, Pug), and post-process the output as HTML, MJML, Markdown or plain text. Built for transactional email, notifications, PDFs and any per-tenant/per-locale content.
 
-- 🔌 **Multiple Engines** - Support for Nunjucks, Handlebars, EJS, and Pug
-- 📝 **Multi-Format** - Render HTML, MJML, Markdown, or Plain Text
-- 🗄️ **Database Storage** - Store templates in your database (TypeORM support)
-- 🎨 **Layout Support** - Create reusable layouts for your templates
-- 🌍 **Scope & Locale** - Manage templates by scope (system/user/tenant) and locale (en/es/etc.)
-- 🚀 **Dynamic Rendering** - Render templates with dynamic context at runtime
+📖 **Full documentation:** https://ack-solutions.github.io/nest-dynamic-templates/
 
-## 📦 Installation
+---
 
-```bash
-npm install @ackplus/nest-dynamic-templates
-# or
-pnpm add @ackplus/nest-dynamic-templates
-# or
-yarn add @ackplus/nest-dynamic-templates
-```
+## Why this library
 
-### Peer Dependencies
+- 🧩 **Two-stage pipeline** — a *template engine* interpolates your variables, then a *language processor* turns the result into final markup. Mix and match (e.g. Nunjucks → MJML).
+- 🗄️ **Database storage** — templates and layouts live in your DB (TypeORM), versioned and editable at runtime.
+- 🌍 **Scope & locale resolution** — ship `system` defaults and let a `user`/`tenant`/`organization` override them, per locale, with automatic fallback.
+- 🪶 **Lightweight & lazy** — only the engines you enable are loaded, so you only install the peers you actually use.
+- 🛑 **Diagnostic errors** — when a render fails you get the **missing variable**, the **source line**, the **context keys you passed**, and an **actionable hint** — not a generic 500.
 
-You must install the necessary peer dependencies depending on which engines and database you use:
+## Install
 
 ```bash
-# Core dependencies
-npm install @nestjs/common @nestjs/core @nestjs/typeorm typeorm reflect-metadata
-
-# Template Engines (install at least one)
-npm install nunjucks @types/nunjucks
-# OR
-npm install handlebars
-# OR
-npm install ejs @types/ejs
-# OR
-npm install pug @types/pug
-
-# Language Support (optional)
-npm install mjml @types/mjml      # For MJML support
-npm install htmlparser2           # For HTML processing
+npm install @ackplus/nest-dynamic-templates
+# peer deps you always need:
+npm install @nestjs/typeorm typeorm reflect-metadata
 ```
 
-## 🚀 Quick Start
+Then install **only the engines you enable**:
+
+| You enable | Install |
+| --- | --- |
+| `njk` (Nunjucks, default) | `npm install nunjucks` |
+| `hbs` (Handlebars) | `npm install handlebars` |
+| `ejs` | `npm install ejs` |
+| `pug` | `npm install pug` |
+| `mjml` (email) | `npm install mjml` |
+| `md` (Markdown) | `npm install marked` |
+| `html`, `txt` | nothing — built in |
 
-### 1. Import Module
+## Quick start
 
-Import `NestDynamicTemplatesModule` into your root `AppModule`. You must configure it with `TypeORM`.
+### 1. Register the module
 
 ```typescript
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { NestDynamicTemplatesModule, TemplateEngineEnum, TemplateLanguageEnum } from '@ackplus/nest-dynamic-templates';
+import {
+  NestDynamicTemplatesModule,
+  TemplateEngineEnum,
+  TemplateLanguageEnum,
+} from '@ackplus/nest-dynamic-templates';
 
 @Module({
   imports: [
     TypeOrmModule.forRoot({
-      // ... your database config
+      type: 'postgres',
+      // ...your db config
+      autoLoadEntities: true, // picks up the library's entities automatically
     }),
     NestDynamicTemplatesModule.forRoot({
+      isGlobal: true,
       engines: {
-        template: [TemplateEngineEnum.NUNJUCKS], // Enable specific engines
-        language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML]
+        template: [TemplateEngineEnum.NUNJUCKS],
+        language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML],
       },
-      isGlobal: true, // Optional: make module global
     }),
   ],
 })
 export class AppModule {}
 ```
 
-### 2. Create a Template
+> Prefer explicit entities (e.g. for migrations)? Import `NestDynamicTemplatesEntities` and spread it into your TypeORM `entities` array.
 
-You can create templates programmatically using the `TemplateService`.
+### 2. Create a template
 
 ```typescript
 import { Injectable } from '@nestjs/common';
-import { TemplateService, TemplateEngineEnum, TemplateLanguageEnum } from '@ackplus/nest-dynamic-templates';
+import {
+  TemplateService,
+  TemplateEngineEnum,
+  TemplateLanguageEnum,
+} from '@ackplus/nest-dynamic-templates';
 
 @Injectable()
-export class MyService {
-  constructor(private readonly templateService: TemplateService) {}
+export class TemplatesSeeder {
+  constructor(private readonly templates: TemplateService) {}
 
-  async createWelcomeTemplate() {
-    await this.templateService.createTemplate({
+  seed() {
+    return this.templates.createTemplate({
       name: 'welcome-email',
-      scope: 'system', // 'system' or custom scope
+      displayName: 'Welcome email',
+      scope: 'system',
       locale: 'en',
-      subject: 'Welcome, {{ name }}!',
-      content: '<h1>Hello {{ name }}</h1><p>Welcome to our platform.</p>',
+      subject: 'Welcome, {{ firstName }}!',
+      content: '<h1>Hello {{ firstName }}</h1><p>Thanks for joining.</p>',
       engine: TemplateEngineEnum.NUNJUCKS,
       language: TemplateLanguageEnum.HTML,
       type: 'email',
@@ -98,101 +100,184 @@ export class MyService {
 }
 ```
 
-### 3. Render a Template
+### 3. Render it
+
+```typescript
+const { subject, content } = await this.templates.render({
+  name: 'welcome-email',
+  scope: 'system',
+  locale: 'en',
+  context: { firstName: 'Ada' },
+});
+// subject -> "Welcome, Ada!"
+// content -> "<h1>Hello Ada</h1><p>Thanks for joining.</p>"
+```
+
+Need to render a raw string without touching the DB? Use `renderContent()`:
 
-Render a stored template by name.
+```typescript
+const html = await this.templates.renderContent({
+  content: 'Hi {{ name }}',
+  engine: TemplateEngineEnum.NUNJUCKS,
+  language: TemplateLanguageEnum.HTML,
+  context: { name: 'World' },
+});
+```
+
+## Error handling
+
+This is the headline feature. Every render failure throws a typed error with a structured `details` payload and the original error attached as `cause`. Missing-variable failures name the variable and list the context you actually passed:
 
 ```typescript
-async renderEmail(userName: string) {
-  const result = await this.templateService.render({
-    name: 'welcome-email',
-    scope: 'system',
-    locale: 'en',
-    context: {
-      name: userName,
-    },
-  });
-
-  console.log(result.subject); // "Welcome, John!"
-  console.log(result.content); // "<h1>Hello John</h1><p>Welcome to our platform.</p>"
+import { TemplateRenderError, TemplateErrorCode, isTemplateError } from '@ackplus/nest-dynamic-templates';
+
+try {
+  await templates.render({ name: 'welcome-email', context: { email: 'a@b.com' } });
+} catch (err) {
+  if (isTemplateError(err)) {
+    console.error(err.code);             // 'TEMPLATE_RENDER_FAILED'
+    console.error(err.details.missingVariable); // 'firstName'
+    console.error(err.details.contextKeys);     // ['email']
+    console.error(err.details.location);        // { line: 1, column: 16 }
+    console.error(err.details.snippet);         // '<h1>Hello {{ firstName }}</h1>...'
+    console.error(err.details.hint);            // 'Pass "firstName" in the render context. ...'
+  }
 }
 ```
 
-## 📚 API Reference
+The thrown message reads:
+
+```
+Failed to render template "welcome-email" [njk → html, scope=system, locale=en]: variable "firstName" is undefined.
+```
 
-### TemplateService
+Each error also **extends the matching NestJS HTTP exception**, so Nest's exception filter maps the right status automatically and your existing `catch (NotFoundException)` keeps working:
 
-The main service for managing and rendering templates.
+| Error | HTTP | `code` |
+| --- | --- | --- |
+| `TemplateRenderError` | 422 | `TEMPLATE_RENDER_FAILED` |
+| `TemplateNotFoundError` | 404 | `TEMPLATE_NOT_FOUND` |
+| `TemplateInputError` | 400 | `TEMPLATE_INVALID_INPUT` |
+| `TemplateForbiddenError` | 403 | `TEMPLATE_FORBIDDEN` |
+| `TemplateConflictError` | 409 | `TEMPLATE_CONFLICT` |
+| `TemplateEngineUnavailableError` | 500 | `TEMPLATE_ENGINE_UNAVAILABLE` |
 
-#### `render(options: RenderTemplateDto)`
-Renders a template stored in the database.
+## Configuration
 
 ```typescript
-const output = await templateService.render({
-  name: 'my-template',
-  scope: 'system',
-  locale: 'en',
-  context: { foo: 'bar' },
+NestDynamicTemplatesModule.forRoot({
+  isGlobal: true,
+
+  // Only these engines are loaded. Default: { template: ['njk'], language: ['html','mjml','txt'] }
+  engines: {
+    template: [TemplateEngineEnum.NUNJUCKS, TemplateEngineEnum.HANDLEBARS],
+    language: [TemplateLanguageEnum.HTML, TemplateLanguageEnum.MJML, TemplateLanguageEnum.MARKDOWN],
+  },
+
+  // Custom filters/helpers — available in EVERY template engine.
+  filters: {
+    formatDate: (d: Date, fmt: string) => /* ... */ '',
+    formatCurrency: (n: number, ccy: string) =>
+      new Intl.NumberFormat('en-US', { style: 'currency', currency: ccy }).format(n),
+  },
+
+  // Global values injected into every render (strings, numbers, objects or functions).
+  globals: {
+    brandName: 'Acme',
+    year: () => new Date().getFullYear(),
+  },
+
+  // Raw options forwarded to the underlying engine libraries.
+  engineOptions: {
+    template: { njk: { autoescape: true, trimBlocks: true } },
+    language: { mjml: { validationLevel: 'soft' } },
+  },
 });
 ```
 
-#### `renderContent(options: RenderContentTemplateDto)`
-Renders raw content string directly without fetching from the database.
+### Async configuration
 
 ```typescript
-const html = await templateService.renderContent({
-  content: 'Hello {{ name }}',
-  engine: TemplateEngineEnum.NUNJUCKS,
-  context: { name: 'World' },
+NestDynamicTemplatesModule.forRootAsync({
+  isGlobal: true,
+  inject: [ConfigService],
+  useFactory: (config: ConfigService) => ({
+    engines: { template: ['njk'], language: ['html', 'mjml'] },
+    globals: { appUrl: config.get('APP_URL') },
+  }),
 });
 ```
 
-#### `createTemplate(data: CreateTemplateDto)`
-Creates a new system template.
+## Scope & locale resolution
+
+`render()` resolves a template by trying, in order:
+
+1. requested **scope** + requested **locale**
+2. requested **scope** + `en`
+3. **system** scope + requested locale
+4. **system** scope + `en`
+
+This lets you ship `system` defaults and override them per tenant/user and per language. Only **active** templates (`isActive: true`) are resolved. Example:
+
+```typescript
+// Falls back to the system template if this user has no override.
+await templates.render({ name: 'welcome-email', scope: 'user', scopeId: userId, locale: 'fr' });
+```
 
-#### `updateTemplate(id: string, updates: Partial<CreateTemplateDto>)`
-Updates an existing template. If you try to update a `system` template without permission, it may create a scoped override instead.
+## Template fields
 
-### TemplateLayoutService
+A template is a database row. The key fields (full reference with use cases in the [docs](https://ack-solutions.github.io/nest-dynamic-templates/reference/template-fields)):
 
-Manage reusable layouts (e.g., email wrappers with header/footer).
+| Field | Required | Default | Purpose |
+| --- | --- | --- | --- |
+| `name` | ✅ | — | Stable id you render by, e.g. `welcome-email`. |
+| `scope` | — | `system` | **Who owns this version** — `system` (shared default) or a custom owner kind like `tenant`/`user`. |
+| `scopeId` | — | `null` | **Which owner** inside the scope (e.g. the tenant id). Empty for `system`. |
+| `locale` | — | `en` | Language variant; missing locales fall back to `en`. |
+| `engine` | — | `njk` | Template engine: `njk`, `hbs`, `ejs`, `pug`. |
+| `language` | — | `null` | Output processor: `html`, `mjml`, `md`, `txt`. |
+| `subject` | — | `null` | Subject line (emails); rendered with the engine. |
+| `content` | ✅ | — | The template body. |
+| `templateLayoutName` | — | `null` | Layout to wrap this content in. |
+| `displayName` | — | — | Human-friendly label for admin UIs. |
+| `type` | — | `null` | Free category for grouping, e.g. `email`/`sms`. |
+| `previewContext` | — | `null` | Sample data for previews (not used at render time). |
+| `isActive` | — | `true` | Set `false` to disable without deleting. |
 
-#### `createLayout(data: CreateTemplateLayoutDto)`
-Create a new layout.
+**`scope` vs `scopeId`** is the part to understand: `scope` is the *kind* of owner (`system`, or your own `tenant`/`user`/…), and `scopeId` is the *exact* owner (the tenant id). Together with `name` + `locale` they uniquely identify a template, and a render falls back from a specific override to the `system` default — so you only store overrides where they differ.
+
+## Layouts
+
+Layouts are reusable wrappers (e.g. an email shell). The child content is injected where the layout references `{{ content }}`:
 
 ```typescript
-await layoutService.createLayout({
-  name: 'main-layout',
-  content: '<html><body>{{ content }}</body></html>', // {{ content }} is the placeholder
+await layouts.createTemplateLayout({
+  name: 'email-shell',
+  displayName: 'Email shell',
   engine: TemplateEngineEnum.NUNJUCKS,
+  language: TemplateLanguageEnum.HTML,
+  content: '<html><body><header>{{ brandName }}</header>{{ content }}</body></html>',
+});
+
+// Attach it to a template:
+await templates.createTemplate({
+  name: 'welcome-email',
+  templateLayoutName: 'email-shell',
+  /* ...rest... */
 });
 ```
 
-## ⚙️ Configuration Options
+## Services
 
-When importing the module, you can configure the enabled engines:
+- **`TemplateService`** — `render`, `renderContent`, `createTemplate`, `updateTemplate`, `overwriteSystemTemplate`, `deleteTemplate`, `getTemplates`, `findTemplate`, `getTemplateById`.
+- **`TemplateLayoutService`** — the same surface for layouts.
+- **`TemplateConfigService`** — read-only accessor over the resolved config.
+- **`TemplateEngineRegistryService`** — access the engine instances directly.
 
-```typescript
-NestDynamicTemplatesModule.forRoot({
-  engines: {
-    // Template Logic Engines
-    template: [
-      TemplateEngineEnum.NUNJUCKS, 
-      TemplateEngineEnum.HANDLEBARS, 
-      TemplateEngineEnum.EJS, 
-      TemplateEngineEnum.PUG
-    ],
-    // Output Language Processors
-    language: [
-      TemplateLanguageEnum.HTML, 
-      TemplateLanguageEnum.MJML, 
-      TemplateLanguageEnum.TEXT, 
-      TemplateLanguageEnum.MARKDOWN
-    ]
-  }
-})
-```
+## Migrating from v1
+
+v2 is a focused redesign. See **[MIGRATION.md](./MIGRATION.md)** for the (short) list of breaking changes and how to update — most apps only need to rename `enginesOptions` to the new flat `filters` / `globals` / `engineOptions`.
 
-## 📄 License
+## License
 
-This project is licensed under the MIT License.
+MIT © AckPlus

package/dist/index.d.ts

@@ -6,9 +6,11 @@ export * from './lib/services/template-config.service';
 export * from './lib/services/template-engine.registry';
 export * from './lib/interfaces/module-config.interface';
 export * from './lib/interfaces/template.types';
+export * from './lib/config/resolve-config';
 export * from './lib/entities/template.entity';
 export * from './lib/entities/template-layout.entity';
 export * from './lib/errors/template.errors';
+export * from './lib/errors/diagnose';
 export * from './lib/constant';
 export * from './lib/engines/template-engine';
 export * from './lib/engines/language-engine';

package/dist/index.js

@@ -24,9 +24,11 @@ __exportStar(require("./lib/services/template-config.service"), exports);
 __exportStar(require("./lib/services/template-engine.registry"), exports);
 __exportStar(require("./lib/interfaces/module-config.interface"), exports);
 __exportStar(require("./lib/interfaces/template.types"), exports);
+__exportStar(require("./lib/config/resolve-config"), exports);
 __exportStar(require("./lib/entities/template.entity"), exports);
 __exportStar(require("./lib/entities/template-layout.entity"), exports);
 __exportStar(require("./lib/errors/template.errors"), exports);
+__exportStar(require("./lib/errors/diagnose"), exports);
 __exportStar(require("./lib/constant"), exports);
 __exportStar(require("./lib/engines/template-engine"), exports);
 __exportStar(require("./lib/engines/language-engine"), exports);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,kFAAkF;AAClF,oEAAqE;AAErE,sEAAoD;AAGpD,kEAAgD;AAChD,yEAAuD;AACvD,yEAAuD;AACvD,0EAAwD;AAGxD,2EAAyD;AACzD,kEAAgD;AAGhD,iEAA+C;AAC/C,wEAAsD;AAGtD,+DAA6C;AAG7C,iDAA+B;AAG/B,gEAA8C;AAC9C,gEAA8C;AAG9C,gEAA8C;AAC9C,gEAA8C;AAC9C,wEAAsD;AACtD,gEAA8C;AAC9C,uEAAqD;AACrD,uEAAqD;AACrD,+EAA6D;AAC7D,uEAAqD;AAGxC,QAAA,4BAA4B,GAAG;IACxC,qCAAmB;IACnB,kDAAyB;CAC5B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,kFAAkF;AAClF,oEAAqE;AAErE,sEAAoD;AAGpD,kEAAgD;AAChD,yEAAuD;AACvD,yEAAuD;AACvD,0EAAwD;AAGxD,2EAAyD;AACzD,kEAAgD;AAChD,8DAA4C;AAG5C,iEAA+C;AAC/C,wEAAsD;AAGtD,+DAA6C;AAC7C,wDAAsC;AAGtC,iDAA+B;AAG/B,gEAA8C;AAC9C,gEAA8C;AAG9C,gEAA8C;AAC9C,gEAA8C;AAC9C,wEAAsD;AACtD,gEAA8C;AAC9C,uEAAqD;AACrD,uEAAqD;AACrD,+EAA6D;AAC7D,uEAAqD;AAExC,QAAA,4BAA4B,GAAG;IACxC,qCAAmB;IACnB,kDAAyB;CAC5B,CAAC"}

package/dist/lib/config/resolve-config.d.ts

@@ -0,0 +1,7 @@
+import { TemplateEngineEnum, TemplateLanguageEnum } from '../interfaces/template.types';
+import { NestDynamicTemplatesModuleConfig, ResolvedTemplatesConfig } from '../interfaces/module-config.interface';
+export declare const DEFAULT_ENGINES: {
+    template: TemplateEngineEnum[];
+    language: TemplateLanguageEnum[];
+};
+export declare function resolveConfig(config?: NestDynamicTemplatesModuleConfig): ResolvedTemplatesConfig;

package/dist/lib/config/resolve-config.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENGINES = void 0;
+exports.resolveConfig = resolveConfig;
+const template_types_1 = require("../interfaces/template.types");
+exports.DEFAULT_ENGINES = {
+    template: [template_types_1.TemplateEngineEnum.NUNJUCKS],
+    language: [
+        template_types_1.TemplateLanguageEnum.HTML,
+        template_types_1.TemplateLanguageEnum.MJML,
+        template_types_1.TemplateLanguageEnum.TEXT,
+    ],
+};
+let warnedAboutLegacy = false;
+function resolveConfig(config = {}) {
+    const legacy = mapLegacy(config);
+    return {
+        isGlobal: config.isGlobal ?? false,
+        engines: {
+            template: dedupe(config.engines?.template ?? exports.DEFAULT_ENGINES.template),
+            language: dedupe(config.engines?.language ?? exports.DEFAULT_ENGINES.language),
+        },
+        filters: { ...legacy.filters, ...config.filters },
+        globals: { ...legacy.globals, ...config.globals },
+        engineOptions: {
+            template: { ...legacy.engineOptions.template, ...config.engineOptions?.template },
+            language: { ...legacy.engineOptions.language, ...config.engineOptions?.language },
+        },
+    };
+}
+function mapLegacy(config) {
+    const legacy = config.enginesOptions;
+    if (legacy && !warnedAboutLegacy) {
+        warnedAboutLegacy = true;
+        console.warn('[nest-dynamic-templates] `enginesOptions` is deprecated. Use top-level ' +
+            '`filters`, `globals` and `engineOptions` instead. See the v2 migration guide.');
+    }
+    return {
+        filters: legacy?.filters ?? {},
+        globals: legacy?.globalValues ?? {},
+        engineOptions: {
+            template: legacy?.template ?? {},
+            language: legacy?.language ?? {},
+        },
+    };
+}
+function dedupe(items) {
+    return Array.from(new Set(items));
+}
+//# sourceMappingURL=resolve-config.js.map

package/dist/lib/config/resolve-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-config.js","sourceRoot":"","sources":["../../../src/lib/config/resolve-config.ts"],"names":[],"mappings":";;;AAyBA,sCAkBC;AA3CD,iEAAwF;AAO3E,QAAA,eAAe,GAAG;IAC3B,QAAQ,EAAE,CAAC,mCAAkB,CAAC,QAAQ,CAAyB;IAC/D,QAAQ,EAAE;QACN,qCAAoB,CAAC,IAAI;QACzB,qCAAoB,CAAC,IAAI;QACzB,qCAAoB,CAAC,IAAI;KACF;CAC9B,CAAC;AAEF,IAAI,iBAAiB,GAAG,KAAK,CAAC;AAS9B,SAAgB,aAAa,CACzB,SAA2C,EAAE;IAE7C,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAEjC,OAAO;QACH,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,KAAK;QAClC,OAAO,EAAE;YACL,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,IAAI,uBAAe,CAAC,QAAQ,CAAC;YACtE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,IAAI,uBAAe,CAAC,QAAQ,CAAC;SACzE;QACD,OAAO,EAAE,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE;QACjD,OAAO,EAAE,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE;QACjD,aAAa,EAAE;YACX,QAAQ,EAAE,EAAE,GAAG,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,GAAG,MAAM,CAAC,aAAa,EAAE,QAAQ,EAAE;YACjF,QAAQ,EAAE,EAAE,GAAG,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,GAAG,MAAM,CAAC,aAAa,EAAE,QAAQ,EAAE;SACpF;KACJ,CAAC;AACN,CAAC;AAGD,SAAS,SAAS,CAAC,MAAwC;IACvD,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC;IACrC,IAAI,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC/B,iBAAiB,GAAG,IAAI,CAAC;QAEzB,OAAO,CAAC,IAAI,CACR,yEAAyE;YACrE,+EAA+E,CACtF,CAAC;IACN,CAAC;IACD,OAAO;QACH,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,EAAE;QAC9B,OAAO,EAAE,MAAM,EAAE,YAAY,IAAI,EAAE;QACnC,aAAa,EAAE;YACX,QAAQ,EAAE,MAAM,EAAE,QAAQ,IAAI,EAAE;YAChC,QAAQ,EAAE,MAAM,EAAE,QAAQ,IAAI,EAAE;SACnC;KACJ,CAAC;AACN,CAAC;AAED,SAAS,MAAM,CAAI,KAAU;IACzB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AACtC,CAAC"}

package/dist/lib/constant.d.ts

@@ -1,2 +1,3 @@
+export declare const NEST_DYNAMIC_TEMPLATES_OPTIONS: unique symbol;
 export declare const NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG: unique symbol;
 export declare const NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER = "NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER";

package/dist/lib/constant.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER = exports.NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG = void 0;
+exports.NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER = exports.NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG = exports.NEST_DYNAMIC_TEMPLATES_OPTIONS = void 0;
+exports.NEST_DYNAMIC_TEMPLATES_OPTIONS = Symbol('NEST_DYNAMIC_TEMPLATES_OPTIONS');
 exports.NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG = Symbol('NEST_DYNAMIC_TEMPLATES_MODULE_CONFIG');
 exports.NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER = 'NEST_DYNAMIC_TEMPLATES_ASYNC_OPTIONS_PROVIDER';
 //# sourceMappingURL=constant.js.map

package/dist/lib/constant.js.map

@@ -1 +1 @@
-{"version":3,"file":"constant.js","sourceRoot":"","sources":["../../src/lib/constant.ts"],"names":[],"mappings":";;;AAAa,QAAA,oCAAoC,GAAG,MAAM,CAAC,sCAAsC,CAAC,CAAC;AACtF,QAAA,6CAA6C,GAAG,+CAA+C,CAAC"}
+{"version":3,"file":"constant.js","sourceRoot":"","sources":["../../src/lib/constant.ts"],"names":[],"mappings":";;;AACa,QAAA,8BAA8B,GAAG,MAAM,CAAC,gCAAgC,CAAC,CAAC;AAG1E,QAAA,oCAAoC,GAAG,MAAM,CAAC,sCAAsC,CAAC,CAAC;AAGtF,QAAA,6CAA6C,GAAG,+CAA+C,CAAC"}