@nathapp/nestjs-notification 2.1.1 → 2.2.0

package/UPGRADE-PLAN.md

@@ -0,0 +1,425 @@
+# @nathapp/nestjs-notification Enterprise Upgrade Plan
+
+## Overview
+
+Upgrade `@nathapp/nestjs-notification` (v2.1.4) to be more enterprise-grade, extensible, and plugin-friendly while maintaining full backwards compatibility.
+
+**Branch:** `feat/notification-enterprise-upgrade`
+**Scope:** Core library only (`packages/nestjs-notification`). No business logic, no tenant context.
+
+---
+
+## Phase 1: Pluggable Template Engine
+
+### Problem
+`TemplateLoader.resolve()` hardcodes `string-format` for variable interpolation. Apps needing conditionals, loops, or partials (e.g., Handlebars) must override the entire `resolve()` method.
+
+### Changes
+
+#### 1.1 Create `TemplateEngine` interface
+**File:** `lib/template/template-engine.ts` (NEW)
+
+```typescript
+export interface TemplateEngine {
+  /**
+   * Compile and render a template string with the given context.
+   * @param template - Raw template string (e.g., "Hello {name}" or "Hello {{name}}")
+   * @param context - Key-value pairs for interpolation
+   * @returns Rendered string
+   */
+  render(template: string, context: Record<string, any>): string;
+}
+```
+
+#### 1.2 Create `StringFormatEngine` (default)
+**File:** `lib/template/engines/string-format.engine.ts` (NEW)
+
+```typescript
+import Format from 'string-format';
+import { TemplateEngine } from '../template-engine';
+
+export class StringFormatEngine implements TemplateEngine {
+  render(template: string, context: Record<string, any>): string {
+    return Format(template, context);
+  }
+}
+```
+
+#### 1.3 Create `TEMPLATE_ENGINE` injection token
+**File:** `lib/template/constant.ts` (UPDATE)
+
+Add: `export const TEMPLATE_ENGINE = 'TEMPLATE_ENGINE';`
+
+#### 1.4 Update `TemplateLoader.resolve()` to use engine
+**File:** `lib/template/template.loader.ts` (UPDATE)
+
+- Inject `TemplateEngine` (optional, defaults to `StringFormatEngine`)
+- Replace direct `Format()` calls with `this.engine.render()`
+- `CachableTemplateLoader` same treatment
+- **Backwards compat:** If no engine injected, fall back to `StringFormatEngine` internally
+
+#### 1.5 Update `NotificationModule` to accept `templateEngine` option
+**File:** `lib/notification/notification.module.ts` (UPDATE)
+
+- Add `templateEngine?: Type<TemplateEngine> | ProviderAsyncOptions<TemplateEngine>` to module options
+- Default to `StringFormatEngine` if not provided
+- Register as provider with `TEMPLATE_ENGINE` token
+
+#### 1.6 Export new types
+**File:** `lib/template/index.ts` (UPDATE)
+**File:** `lib/index.ts` (UPDATE)
+
+Export `TemplateEngine`, `StringFormatEngine`, `TEMPLATE_ENGINE`.
+
+### Unit Tests
+
+**File:** `test/template/string-format.engine.spec.ts` (NEW)
+- `render()` with simple variables
+- `render()` with nested objects
+- `render()` with missing variables (should not throw, leave placeholder)
+
+**File:** `test/template/template-loader.spec.ts` (NEW)
+- `resolve()` uses injected `TemplateEngine`
+- `resolve()` defaults to `StringFormatEngine` when no engine provided
+- `CachableTemplateLoader.resolve()` uses engine after cache hit
+- `CachableTemplateLoader.resolve()` uses engine after cache miss
+
+### E2E Tests
+
+**File:** `test/module/notification-custom-engine.module.e2e.spec.ts` (NEW)
+- Register `NotificationModule.forRoot()` with a custom `TemplateEngine` (e.g., a mock Handlebars-like engine)
+- Verify `NotificationService.sendEmail()` renders templates through the custom engine
+- Verify default `StringFormatEngine` works when no custom engine specified
+
+---
+
+## Phase 2: Configurable Strict Mode
+
+### Problem
+When `EmailService` or `PushNotificationService` isn't configured, `NotificationService` silently returns `{ success: false }`. This hides configuration bugs.
+
+### Changes
+
+#### 2.1 Add `strict` option to module options
+**File:** `lib/notification/notification.module.ts` (UPDATE)
+
+```typescript
+export interface NotificationModuleOptions {
+  // ... existing
+  strict?: boolean; // default: true
+}
+```
+
+#### 2.2 Update `NotificationService` to respect strict mode
+**File:** `lib/notification/notification.service.ts` (UPDATE)
+
+- Inject `NOTIFICATION_OPTIONS` to read `strict` flag
+- When `strict: true` (default) and service not configured → throw `Error('EmailService is not configured. Configure emailOptions in NotificationModule or set strict: false.')`
+- When `strict: false` → keep current behaviour (return `{ success: false }`)
+
+#### 2.3 Create custom error class
+**File:** `lib/notification/errors.ts` (NEW)
+
+```typescript
+export class NotificationConfigError extends Error {
+  constructor(service: string) {
+    super(`${service} is not configured. Configure it in NotificationModule or set strict: false.`);
+    this.name = 'NotificationConfigError';
+  }
+}
+```
+
+### Unit Tests
+
+**File:** `test/notification/notification-strict.service.spec.ts` (NEW)
+- `strict: true` + no email configured → `sendEmail()` throws `NotificationConfigError`
+- `strict: true` + no push configured → `sendPushNotification()` throws `NotificationConfigError`
+- `strict: false` + no email configured → `sendEmail()` returns `{ success: false }`
+- `strict: false` + no push configured → `sendPushNotification()` returns `{ success: false }`
+- Default (no strict option) → behaves as `strict: true`
+
+### E2E Tests
+
+**File:** `test/module/notification-strict.module.e2e.spec.ts` (NEW)
+- Module with `strict: true`, no email options → calling `sendEmail` throws
+- Module with `strict: false`, no email options → calling `sendEmail` returns `{ success: false }`
+
+---
+
+## Phase 3: Unified `send()` Method
+
+### Problem
+Callers must use separate methods (`sendEmail`, `sendPushNotification`) per channel. No way to send to multiple channels in one call.
+
+### Changes
+
+#### 3.1 Create unified payload interface
+**File:** `lib/interface/payload.inteface.ts` (UPDATE - add to existing)
+
+```typescript
+export type NotificationChannel = 'email' | 'push' | 'sms';
+
+export interface NotificationPayload {
+  templateCode: string;
+  channels: NotificationChannel[];
+  options?: {
+    locale?: string;
+    fallbackLocale?: string;
+    args?: any;
+  };
+  // Channel-specific recipient data
+  email?: string;
+  userId?: string | number;
+  deviceToken?: DeviceToken;
+  phoneNumber?: string;
+  // Optional
+  attachments?: EmailAttachment[];
+}
+
+export interface NotificationResult {
+  results: Record<NotificationChannel, SendResult>;
+  /** True only if ALL channels succeeded */
+  success: boolean;
+}
+```
+
+#### 3.2 Add `send()` to `NotificationService`
+**File:** `lib/notification/notification.service.ts` (UPDATE)
+
+```typescript
+async send(payload: NotificationPayload): Promise<NotificationResult> {
+  const results: Record<string, SendResult> = {};
+
+  for (const channel of payload.channels) {
+    switch (channel) {
+      case 'email':
+        results.email = await this.sendEmail({
+          templateCode: payload.templateCode,
+          email: payload.email,
+          options: payload.options,
+          attachments: payload.attachments,
+        });
+        break;
+      case 'push':
+        results.push = await this.sendPushNotification({
+          templateCode: payload.templateCode,
+          userId: payload.userId,
+          deviceToken: payload.deviceToken,
+          options: payload.options,
+        });
+        break;
+      case 'sms':
+        // Delegate to SmsService when available
+        results.sms = { success: false, message: 'SMS not configured' };
+        break;
+    }
+  }
+
+  return {
+    results: results as Record<NotificationChannel, SendResult>,
+    success: Object.values(results).every(r => r.success),
+  };
+}
+```
+
+#### 3.3 Export new types
+**File:** `lib/interface/index.ts` (UPDATE)
+
+Export `NotificationPayload`, `NotificationResult`, `NotificationChannel`.
+
+### Unit Tests
+
+**File:** `test/notification/notification-unified-send.service.spec.ts` (NEW)
+- `send()` with `channels: ['email']` → calls `sendEmail`, returns result
+- `send()` with `channels: ['push']` → calls `sendPushNotification`, returns result
+- `send()` with `channels: ['email', 'push']` → calls both, aggregates results
+- `send()` with `channels: ['sms']` → returns `{ success: false }` for sms
+- `send()` overall `success` is `true` only when all channels succeed
+- `send()` overall `success` is `false` when any channel fails
+
+### E2E Tests
+
+**File:** `test/module/notification-unified-send.module.e2e.spec.ts` (NEW)
+- Full module with email configured → `send({ channels: ['email'] })` works end-to-end
+- Full module with email + push → `send({ channels: ['email', 'push'] })` dispatches to both
+
+---
+
+## Phase 4: Backwards-Compatible `platform` Alias
+
+### Problem
+`PushMessage.paltform` is a typo. Fixing it directly is a breaking change.
+
+### Changes
+
+#### 4.1 Add `platform` property, deprecate `paltform`
+**File:** `lib/interface/message.interface.ts` (UPDATE)
+
+```typescript
+export interface PushMessage extends BaseMessage {
+  /** @deprecated Use `platform` instead */
+  paltform?: PlatformOS;
+  platform?: PlatformOS;
+  subject: string;
+  data?: { [key: string]: string };
+}
+```
+
+#### 4.2 Update all internal usages to prefer `platform`
+**Files:** `lib/push-notification/push-notification.service.ts`, `lib/notification/notification.service.ts`
+
+```typescript
+// Resolve with fallback
+const platform = message.platform || message.paltform;
+```
+
+### Unit Tests
+
+**File:** `test/push-notification/platform-alias.spec.ts` (NEW)
+- Message with `platform: 'android'` → uses android provider
+- Message with `paltform: 'android'` (legacy) → still works
+- Message with both `platform` and `paltform` → `platform` takes precedence
+
+---
+
+## Phase 5: SMS Integration Point
+
+### Problem
+`SmsService` is abstract with no integration into `NotificationModule` or `NotificationService`.
+
+### Changes
+
+#### 5.1 Add `SmsService` injection to `NotificationService`
+**File:** `lib/notification/notification.service.ts` (UPDATE)
+
+- Add `@Optional() @Inject(SmsService) private readonly smsService: SmsService` to constructor
+- Implement `sendSms(data: SmsNotificationPayload): Promise<SendResult>` using template resolution + `smsService.send()`
+- Update `send()` unified method to use `sendSms` for SMS channel
+
+#### 5.2 Add SMS payload interface
+**File:** `lib/interface/payload.inteface.ts` (UPDATE)
+
+```typescript
+export interface SmsNotificationPayload {
+  phoneNumber: string;
+  templateCode: string;
+  options?: {
+    locale?: string;
+    fallbackLocale?: string;
+    args?: any;
+  };
+  countryIso2?: string;
+  dialCode?: string;
+}
+```
+
+#### 5.3 Add SMS options to `NotificationModule`
+**File:** `lib/notification/notification.module.ts` (UPDATE)
+
+```typescript
+export interface NotificationModuleOptions {
+  // ... existing
+  smsService?: Type<SmsService>;
+}
+```
+
+#### 5.4 Export new types
+**File:** `lib/sms/index.ts` (UPDATE)
+**File:** `lib/interface/index.ts` (UPDATE)
+
+### Unit Tests
+
+**File:** `test/notification/notification-sms.service.spec.ts` (NEW)
+- `sendSms()` with configured SMS service → resolves template, calls `smsService.send()`
+- `sendSms()` without SMS service + `strict: true` → throws
+- `sendSms()` without SMS service + `strict: false` → returns `{ success: false }`
+- `send({ channels: ['sms'] })` routes to `sendSms()`
+
+### E2E Tests
+
+**File:** `test/module/notification-sms.module.e2e.spec.ts` (NEW)
+- Register module with a mock `SmsService` implementation → `sendSms()` works
+
+---
+
+## Phase 6: Interceptors / Hooks (beforeSend, afterSend)
+
+### Problem
+No way to globally intercept notifications for logging, auditing, or message modification.
+
+### Changes
+
+#### 6.1 Create `NotificationInterceptor` interface
+**File:** `lib/notification/notification.interceptor.ts` (NEW)
+
+```typescript
+export interface NotificationContext {
+  channel: NotificationChannel;
+  templateCode: string;
+  recipient: string;
+  resolvedMessage?: { subject?: string; content: string };
+}
+
+export interface NotificationInterceptor {
+  beforeSend?(context: NotificationContext): Promise<NotificationContext> | NotificationContext;
+  afterSend?(context: NotificationContext, result: SendResult): Promise<void> | void;
+  onError?(context: NotificationContext, error: Error): Promise<void> | void;
+}
+
+export const NOTIFICATION_INTERCEPTORS = 'NOTIFICATION_INTERCEPTORS';
+```
+
+#### 6.2 Update `NotificationService` to run interceptors
+**File:** `lib/notification/notification.service.ts` (UPDATE)
+
+- Inject `@Optional() @Inject(NOTIFICATION_INTERCEPTORS) interceptors: NotificationInterceptor[]`
+- Before each send: run all `beforeSend` hooks (allows modifying context)
+- After each send: run all `afterSend` hooks
+- On error: run all `onError` hooks
+
+#### 6.3 Add `interceptors` option to module
+**File:** `lib/notification/notification.module.ts` (UPDATE)
+
+```typescript
+export interface NotificationModuleOptions {
+  // ... existing
+  interceptors?: Type<NotificationInterceptor>[];
+}
+```
+
+### Unit Tests
+
+**File:** `test/notification/notification-interceptor.spec.ts` (NEW)
+- `beforeSend` is called before provider send
+- `beforeSend` can modify context (e.g., append unsubscribe link)
+- `afterSend` is called after successful send with result
+- `onError` is called when send fails
+- Multiple interceptors run in order
+- No interceptors registered → sends normally (no errors)
+
+### E2E Tests
+
+**File:** `test/module/notification-interceptor.module.e2e.spec.ts` (NEW)
+- Register module with a logging interceptor → verify hooks called during `sendEmail()`
+
+---
+
+## Implementation Order
+
+1. **Phase 1** (Template Engine) — Foundation, no breaking changes
+2. **Phase 2** (Strict Mode) — Defaults change but existing `strict: false` opt-out available
+3. **Phase 4** (Platform Alias) — Quick fix, no breaking changes
+4. **Phase 3** (Unified Send) — New method, additive
+5. **Phase 5** (SMS Integration) — Additive
+6. **Phase 6** (Interceptors) — Additive
+
+## Breaking Changes
+
+**None.** All changes are additive or have backwards-compatible defaults:
+- `strict` defaults to `true` which IS a behaviour change, but it only surfaces existing bugs (calling unconfigured services). Can be set to `false` to restore old behaviour.
+- `paltform` is deprecated but still works.
+- `string-format` remains the default template engine.
+
+## Version
+
+This should be released as **v3.0.0** due to the `strict: true` default change (even though technically backwards compat, it changes runtime behaviour).

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export * from "./email";
+export { EMAIL_OPTIONS, EMAIL_PROVIDER, EMAIL_SERVICE, EmailOption, SmtpOption, SmtpHostOption, SmtpUriOption, CustomEmailOption, EmailService, EmailProvider, SmtpEmailProvider, EmailProviderFactory, } from "./email";
+export { PushNotificationService, FCMPushNotificationOption, PushNotificationOption, FCMPushNotificationProvider, PushNotificationProvider, PushNotificationPlatform, PlatformOS, ProviderManager, PUSH_NOTIFICATION_PROVIDERS, DefaultProviderManager, DeviceToken, TokenId, IUserTokenStore, UserTokenStore, InMemoryUserTokenStore, } from "./push-notification";
 export * from "./interface";
 export * from "./notification";
-export * from "./push-notification";
 export * from "./sms";
 export * from "./template";
+export * from "./whatsapp";

package/dist/index.js

@@ -14,10 +14,28 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./email"), exports);
+exports.InMemoryUserTokenStore = exports.UserTokenStore = exports.DefaultProviderManager = exports.PUSH_NOTIFICATION_PROVIDERS = exports.ProviderManager = exports.PlatformOS = exports.PushNotificationProvider = exports.FCMPushNotificationProvider = exports.PushNotificationService = exports.EmailProviderFactory = exports.SmtpEmailProvider = exports.EmailProvider = exports.EmailService = exports.EMAIL_SERVICE = exports.EMAIL_PROVIDER = exports.EMAIL_OPTIONS = void 0;
+var email_1 = require("./email");
+Object.defineProperty(exports, "EMAIL_OPTIONS", { enumerable: true, get: function () { return email_1.EMAIL_OPTIONS; } });
+Object.defineProperty(exports, "EMAIL_PROVIDER", { enumerable: true, get: function () { return email_1.EMAIL_PROVIDER; } });
+Object.defineProperty(exports, "EMAIL_SERVICE", { enumerable: true, get: function () { return email_1.EMAIL_SERVICE; } });
+Object.defineProperty(exports, "EmailService", { enumerable: true, get: function () { return email_1.EmailService; } });
+Object.defineProperty(exports, "EmailProvider", { enumerable: true, get: function () { return email_1.EmailProvider; } });
+Object.defineProperty(exports, "SmtpEmailProvider", { enumerable: true, get: function () { return email_1.SmtpEmailProvider; } });
+Object.defineProperty(exports, "EmailProviderFactory", { enumerable: true, get: function () { return email_1.EmailProviderFactory; } });
+var push_notification_1 = require("./push-notification");
+Object.defineProperty(exports, "PushNotificationService", { enumerable: true, get: function () { return push_notification_1.PushNotificationService; } });
+Object.defineProperty(exports, "FCMPushNotificationProvider", { enumerable: true, get: function () { return push_notification_1.FCMPushNotificationProvider; } });
+Object.defineProperty(exports, "PushNotificationProvider", { enumerable: true, get: function () { return push_notification_1.PushNotificationProvider; } });
+Object.defineProperty(exports, "PlatformOS", { enumerable: true, get: function () { return push_notification_1.PlatformOS; } });
+Object.defineProperty(exports, "ProviderManager", { enumerable: true, get: function () { return push_notification_1.ProviderManager; } });
+Object.defineProperty(exports, "PUSH_NOTIFICATION_PROVIDERS", { enumerable: true, get: function () { return push_notification_1.PUSH_NOTIFICATION_PROVIDERS; } });
+Object.defineProperty(exports, "DefaultProviderManager", { enumerable: true, get: function () { return push_notification_1.DefaultProviderManager; } });
+Object.defineProperty(exports, "UserTokenStore", { enumerable: true, get: function () { return push_notification_1.UserTokenStore; } });
+Object.defineProperty(exports, "InMemoryUserTokenStore", { enumerable: true, get: function () { return push_notification_1.InMemoryUserTokenStore; } });
 __exportStar(require("./interface"), exports);
 __exportStar(require("./notification"), exports);
-__exportStar(require("./push-notification"), exports);
 __exportStar(require("./sms"), exports);
 __exportStar(require("./template"), exports);
+__exportStar(require("./whatsapp"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,8CAA4B;AAC5B,iDAA+B;AAC/B,sDAAoC;AACpC,wCAAsB;AACtB,6CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AACA,iCAaiB;AAZf,sGAAA,aAAa,OAAA;AACb,uGAAA,cAAc,OAAA;AACd,sGAAA,aAAa,OAAA;AAMb,qGAAA,YAAY,OAAA;AACZ,sGAAA,aAAa,OAAA;AACb,0GAAA,iBAAiB,OAAA;AACjB,6GAAA,oBAAoB,OAAA;AAItB,yDAgB6B;AAf3B,4HAAA,uBAAuB,OAAA;AAGvB,gIAAA,2BAA2B,OAAA;AAC3B,6HAAA,wBAAwB,OAAA;AAExB,+GAAA,UAAU,OAAA;AACV,oHAAA,eAAe,OAAA;AACf,gIAAA,2BAA2B,OAAA;AAC3B,2HAAA,sBAAsB,OAAA;AAItB,mHAAA,cAAc,OAAA;AACd,2HAAA,sBAAsB,OAAA;AAIxB,8CAA4B;AAC5B,iDAA+B;AAC/B,wCAAsB;AACtB,6CAA2B;AAC3B,6CAA2B"}

package/dist/interface/index.d.ts

@@ -1,4 +1,4 @@
-import { BaseMessage, SmsMessage, EmailMessage, PushMessage, Message, PushMessageOnly, EmailAttachment } from "./message.interface";
-import { EmailNotificationPayload, PushNotificationPayload } from "./payload.inteface";
+import { BaseMessage, SmsMessage, EmailMessage, PushMessage, WhatsAppMessage, Message, PushMessageOnly, EmailAttachment } from "./message.interface";
+import { EmailNotificationPayload, PushNotificationPayload, SmsNotificationPayload, WhatsAppNotificationPayload, NotificationPayload, NotificationResult, NotificationChannel } from "./payload.inteface";
 import { BatchSendResult, SendResult } from "./result.interface";
-export { BaseMessage, SmsMessage, EmailMessage, PushMessage, PushMessageOnly, Message, SendResult, BatchSendResult, EmailAttachment, EmailNotificationPayload, PushNotificationPayload, };
+export { BaseMessage, SmsMessage, EmailMessage, PushMessage, WhatsAppMessage, PushMessageOnly, Message, SendResult, BatchSendResult, EmailAttachment, EmailNotificationPayload, PushNotificationPayload, SmsNotificationPayload, WhatsAppNotificationPayload, NotificationPayload, NotificationResult, NotificationChannel, };

package/dist/interface/message.interface.d.ts

@@ -19,10 +19,18 @@ export interface EmailMessage extends BaseMessage {
 }
 export interface PushMessage extends BaseMessage {
     paltform?: PlatformOS;
+    platform?: PlatformOS;
     subject: string;
     data?: {
         [key: string]: string;
     };
 }
-export type PushMessageOnly = Omit<PushMessage, "recipient" | "paltform">;
-export type Message = SmsMessage | EmailMessage | PushMessage;
+export interface WhatsAppMessage extends BaseMessage {
+    templateName?: string;
+    languageCode?: string;
+    headerParams?: string[];
+    bodyParams?: string[];
+    mediaUrl?: string;
+}
+export type PushMessageOnly = Omit<PushMessage, "recipient" | "paltform" | "platform">;
+export type Message = SmsMessage | EmailMessage | PushMessage | WhatsAppMessage;

package/dist/interface/payload.inteface.d.ts

@@ -20,3 +20,54 @@ export interface PushNotificationPayload {
         args?: any;
     };
 }
+export type NotificationChannel = 'email' | 'push' | 'sms' | 'whatsapp';
+export interface NotificationPayload {
+    templateCode: string;
+    channels: NotificationChannel[];
+    fallback?: NotificationChannel[];
+    options?: {
+        locale?: string;
+        fallbackLocale?: string;
+        args?: any;
+    };
+    email?: string;
+    userId?: string | number;
+    deviceToken?: DeviceToken;
+    phoneNumber?: string;
+    whatsappTemplateName?: string;
+    mediaUrl?: string;
+    attachments?: EmailAttachment[];
+}
+export interface SendResult {
+    success: boolean;
+    message?: string;
+    error?: any;
+}
+export interface SmsNotificationPayload {
+    phoneNumber: string;
+    templateCode: string;
+    options?: {
+        locale?: string;
+        fallbackLocale?: string;
+        args?: any;
+    };
+    countryIso2?: string;
+    dialCode?: string;
+}
+export interface WhatsAppNotificationPayload {
+    phoneNumber: string;
+    templateCode: string;
+    options?: {
+        locale?: string;
+        fallbackLocale?: string;
+        args?: any;
+    };
+    whatsappTemplateName?: string;
+    mediaUrl?: string;
+}
+export interface NotificationResult {
+    results: Partial<Record<NotificationChannel, SendResult>>;
+    success: boolean;
+    fallbackAttempted?: NotificationChannel[];
+    fallbackSucceeded?: NotificationChannel;
+}

package/dist/notification/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class NotificationConfigError extends Error {
+    constructor(service: string);
+}

package/dist/notification/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationConfigError = void 0;
+class NotificationConfigError extends Error {
+    constructor(service) {
+        super(`${service} is not configured. Configure it in NotificationModule or set strict: false.`);
+        this.name = 'NotificationConfigError';
+    }
+}
+exports.NotificationConfigError = NotificationConfigError;
+//# sourceMappingURL=errors.js.map

package/dist/notification/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../lib/notification/errors.ts"],"names":[],"mappings":";;;AAAA,MAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAe;QACzB,KAAK,CAAC,GAAG,OAAO,8EAA8E,CAAC,CAAC;QAChG,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AALD,0DAKC"}

package/dist/notification/index.d.ts

@@ -1,4 +1,8 @@
 import { NOTIFICATION_OPTIONS, NOTIFICATION_SERVICE, TEMPLATE_SERVICE } from "./constant";
-import { NotificationModule, NotificationModuleOptions } from "./notification.module";
+import { NotificationModule, NotificationModuleAsyncOptions, NotificationModuleOptions, NotificationModuleOptionsFactory } from "./notification.module";
 import { NotificationService } from "./notification.service";
-export { NOTIFICATION_OPTIONS, NOTIFICATION_SERVICE, TEMPLATE_SERVICE, NotificationModule, NotificationModuleOptions, NotificationService, };
+import { NotificationConfigError } from "./errors";
+import { NotificationInterceptor, NotificationContext, NOTIFICATION_INTERCEPTORS } from "./notification.interceptor";
+import { ProviderConfig, ChannelProviderMap } from "./provider-config";
+import { NotificationProviderFactory } from "./notification-provider.factory";
+export { NOTIFICATION_OPTIONS, NOTIFICATION_SERVICE, TEMPLATE_SERVICE, NotificationModule, NotificationModuleOptions, NotificationModuleAsyncOptions, NotificationModuleOptionsFactory, NotificationService, NotificationConfigError, NotificationInterceptor, NotificationContext, NOTIFICATION_INTERCEPTORS, ProviderConfig, ChannelProviderMap, NotificationProviderFactory, };

package/dist/notification/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationService = exports.NotificationModule = exports.TEMPLATE_SERVICE = exports.NOTIFICATION_SERVICE = exports.NOTIFICATION_OPTIONS = void 0;
+exports.NotificationProviderFactory = exports.NOTIFICATION_INTERCEPTORS = exports.NotificationConfigError = exports.NotificationService = exports.NotificationModule = exports.TEMPLATE_SERVICE = exports.NOTIFICATION_SERVICE = exports.NOTIFICATION_OPTIONS = void 0;
 const constant_1 = require("./constant");
 Object.defineProperty(exports, "NOTIFICATION_OPTIONS", { enumerable: true, get: function () { return constant_1.NOTIFICATION_OPTIONS; } });
 Object.defineProperty(exports, "NOTIFICATION_SERVICE", { enumerable: true, get: function () { return constant_1.NOTIFICATION_SERVICE; } });
@@ -9,4 +9,10 @@ const notification_module_1 = require("./notification.module");
 Object.defineProperty(exports, "NotificationModule", { enumerable: true, get: function () { return notification_module_1.NotificationModule; } });
 const notification_service_1 = require("./notification.service");
 Object.defineProperty(exports, "NotificationService", { enumerable: true, get: function () { return notification_service_1.NotificationService; } });
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "NotificationConfigError", { enumerable: true, get: function () { return errors_1.NotificationConfigError; } });
+const notification_interceptor_1 = require("./notification.interceptor");
+Object.defineProperty(exports, "NOTIFICATION_INTERCEPTORS", { enumerable: true, get: function () { return notification_interceptor_1.NOTIFICATION_INTERCEPTORS; } });
+const notification_provider_factory_1 = require("./notification-provider.factory");
+Object.defineProperty(exports, "NotificationProviderFactory", { enumerable: true, get: function () { return notification_provider_factory_1.NotificationProviderFactory; } });
 //# sourceMappingURL=index.js.map

package/dist/notification/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/notification/index.ts"],"names":[],"mappings":";;;AAAA,yCAA0F;AAKxF,qGALO,+BAAoB,OAKP;AACpB,qGAN6B,+BAAoB,OAM7B;AACpB,iGAPmD,2BAAgB,OAOnD;AANlB,+DAAwJ;AAOtJ,mGAPO,wCAAkB,OAOP;AANpB,iEAA6D;AAU3D,oGAVO,0CAAmB,OAUP"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/notification/index.ts"],"names":[],"mappings":";;;AAAA,yCAA0F;AASxF,qGATO,+BAAoB,OASP;AACpB,qGAV6B,+BAAoB,OAU7B;AACpB,iGAXmD,2BAAgB,OAWnD;AAVlB,+DAAwJ;AAWtJ,mGAXO,wCAAkB,OAWP;AAVpB,iEAA6D;AAc3D,oGAdO,0CAAmB,OAcP;AAbrB,qCAAmD;AAcjD,wGAdO,gCAAuB,OAcP;AAbzB,yEAAqH;AAgBnH,0GAhBqD,oDAAyB,OAgBrD;AAd3B,mFAA8E;AAiB5E,4GAjBO,2DAA2B,OAiBP"}

package/dist/notification/notification-provider.factory.d.ts

@@ -0,0 +1,5 @@
+import { ProviderConfig, ChannelProviderMap } from './provider-config';
+export declare class NotificationProviderFactory {
+    private static readonly logger;
+    static create<C extends keyof ChannelProviderMap>(config: ProviderConfig<C>): ChannelProviderMap[C];
+}

package/dist/notification/notification-provider.factory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProviderFactory = void 0;
+const common_1 = require("@nestjs/common");
+const email_1 = require("../email");
+const push_notification_1 = require("../push-notification");
+const sms_1 = require("../sms");
+const whatsapp_1 = require("../whatsapp");
+const CHANNEL_BASE_CLASSES = {
+    email: email_1.EmailProvider,
+    push: push_notification_1.PushNotificationProvider,
+    sms: sms_1.SmsService,
+    whatsapp: whatsapp_1.WhatsAppService,
+};
+class NotificationProviderFactory {
+    static create(config) {
+        const { channel, provider, options } = config;
+        const baseClass = CHANNEL_BASE_CLASSES[channel];
+        if (!baseClass) {
+            throw new Error(`Unknown notification channel: ${channel}`);
+        }
+        const instance = new provider(options);
+        if (!(instance instanceof baseClass)) {
+            throw new Error(`${provider.name} is not a valid ${channel} provider. ` +
+                `Expected ${baseClass.name} subclass.`);
+        }
+        this.logger.log(`Created ${channel} provider: ${provider.name}`);
+        return instance;
+    }
+}
+exports.NotificationProviderFactory = NotificationProviderFactory;
+NotificationProviderFactory.logger = new common_1.Logger(NotificationProviderFactory.name);
+//# sourceMappingURL=notification-provider.factory.js.map

package/dist/notification/notification-provider.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-provider.factory.js","sourceRoot":"","sources":["../../lib/notification/notification-provider.factory.ts"],"names":[],"mappings":";;;AAAA,2CAAwC;AAExC,oCAAyC;AACzC,4DAAgE;AAChE,gCAAoC;AACpC,0CAA8C;AAK9C,MAAM,oBAAoB,GAA6B;IACrD,KAAK,EAAE,qBAAa;IACpB,IAAI,EAAE,4CAAwB;IAC9B,GAAG,EAAE,gBAAU;IACf,QAAQ,EAAE,0BAAe;CAC1B,CAAC;AAKF,MAAa,2BAA2B;IAoBtC,MAAM,CAAC,MAAM,CACX,MAAyB;QAEzB,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;QAC9C,MAAM,SAAS,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAEhD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,iCAAiC,OAAO,EAAE,CAAC,CAAC;QAC9D,CAAC;QAGD,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC;QAGvC,IAAI,CAAC,CAAC,QAAQ,YAAY,SAAS,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CACb,GAAG,QAAQ,CAAC,IAAI,mBAAmB,OAAO,aAAa;gBACvD,YAAY,SAAS,CAAC,IAAI,YAAY,CACvC,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,OAAO,cAAc,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QACjE,OAAO,QAAiC,CAAC;IAC3C,CAAC;;AA3CH,kEA4CC;AA3CyB,kCAAM,GAAG,IAAI,eAAM,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC"}