@nathapp/nestjs-notification 1.0.0-rc.5

package/.eslintrc.js

@@ -0,0 +1,24 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 KnowYourself
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# nestjs-notification Library
+
+
+# Template Loader is using string-format to format args to value
+
+
+# For CachableTemplateLoader is using nestjs native caching which required CacheModule.Register & install cache-manager
+
+```
+npm install @nestjs/cache-manager cache-manager
+```

package/dist/email/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const EMAIL_OPTIONS = "EMAIL_OPTIONS";
+export declare const EMAIL_PROVIDER = "EMAIL_PROVIDER";
+export declare const EMAIL_SERVICE = "EMAIL_SERVICE";

package/dist/email/constant.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMAIL_SERVICE = exports.EMAIL_PROVIDER = exports.EMAIL_OPTIONS = void 0;
+exports.EMAIL_OPTIONS = 'EMAIL_OPTIONS';
+exports.EMAIL_PROVIDER = 'EMAIL_PROVIDER';
+exports.EMAIL_SERVICE = 'EMAIL_SERVICE';

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

@@ -0,0 +1,5 @@
+import { EmailModuleOptions, EmailModuleOptionsWithoutProvider } from "./email.module";
+import { EmailProvider } from "./email.provider";
+export declare class EmailProviderFactory {
+    static createProvider(options: EmailModuleOptions | EmailModuleOptionsWithoutProvider): EmailProvider;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailProviderFactory = void 0;
+const email_provider_1 = require("./email.provider");
+class EmailProviderFactory {
+    static createProvider(options) {
+        const { option: emailOption } = options;
+        const { type } = emailOption;
+        switch (type) {
+            case "smtp":
+                return new email_provider_1.SmtpEmailProvider(emailOption["options"]);
+            default:
+                throw new Error(`Invalid emailOption.type ${type}`);
+        }
+    }
+}
+exports.EmailProviderFactory = EmailProviderFactory;

package/dist/email/email.interface.d.ts

@@ -0,0 +1,23 @@
+import { Type } from "@nestjs/common";
+import { EmailProvider } from "./email.provider";
+export type EmailOption = SmtpOption | CustomEmailOption;
+export type SmtpOption = {
+    type: "smtp";
+    options: SmtpHostOption | SmtpUriOption;
+};
+export type CustomEmailOption = {
+    type: "custom";
+    provider: Type<EmailProvider>;
+};
+export interface SmtpHostOption {
+    host: string;
+    port: string;
+    secure: boolean;
+    from: string;
+    username: string;
+    password: string;
+}
+export interface SmtpUriOption {
+    url: string;
+    from: string;
+}

package/dist/email/email.interface.js

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

package/dist/email/email.module.d.ts

@@ -0,0 +1,24 @@
+import { DynamicModule, ModuleMetadata, Type } from '@nestjs/common';
+import { EmailOption } from './email.interface';
+export declare class EmailModule {
+    static forRoot(options: EmailModuleOptions): DynamicModule;
+    static forRootAsync(options: EmailModuleAsyncOptions): DynamicModule;
+    private static santitizeOptions;
+    private static createEmailProvider;
+    private static createAsyncOptionsProviders;
+    private static createAsyncOptionsProvider;
+}
+export type EmailModuleOptionsWithoutProvider = Omit<EmailModuleOptions, 'emailProvider'>;
+export interface EmailModuleOptions {
+    option: EmailOption;
+}
+export interface EmailModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    name?: string;
+    useExisting?: Type<EmailModuleOptionsFactory>;
+    useClass?: Type<EmailModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<EmailModuleOptionsWithoutProvider> | EmailModuleOptionsWithoutProvider;
+    inject?: any[];
+}
+export interface EmailModuleOptionsFactory {
+    createOptions(): EmailModuleOptionsWithoutProvider | Promise<EmailModuleOptionsWithoutProvider>;
+}

package/dist/email/email.module.js

@@ -0,0 +1,95 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var EmailModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailModule = void 0;
+const common_1 = require("@nestjs/common");
+const email_service_1 = require("./email.service");
+const constant_1 = require("./constant");
+const email_provider_factory_1 = require("./email-provider.factory");
+let EmailModule = EmailModule_1 = class EmailModule {
+    static forRoot(options) {
+        options = this.santitizeOptions(options);
+        const emailProvider = this.createEmailProvider(options);
+        const emailOptions = {
+            provide: constant_1.EMAIL_OPTIONS,
+            useValue: options,
+        };
+        const emailService = {
+            provide: email_service_1.EmailService,
+            useClass: email_service_1.EmailService,
+        };
+        return {
+            module: EmailModule_1,
+            providers: [emailOptions, emailProvider, emailService],
+            exports: [constant_1.EMAIL_OPTIONS, emailService],
+        };
+    }
+    static forRootAsync(options) {
+        options = this.santitizeOptions(options);
+        const asyncOptionsProviders = this.createAsyncOptionsProviders(options);
+        const emailProvider = this.createEmailProvider(options);
+        const emailService = {
+            provide: constant_1.EMAIL_SERVICE,
+            useClass: email_service_1.EmailService,
+        };
+        return {
+            module: EmailModule_1,
+            imports: options.imports || [],
+            providers: [...asyncOptionsProviders, emailProvider, emailService],
+            exports: [constant_1.EMAIL_OPTIONS, constant_1.EMAIL_SERVICE],
+        };
+    }
+    static santitizeOptions(options) {
+        return options;
+    }
+    static createEmailProvider(options) {
+        return {
+            provide: constant_1.EMAIL_PROVIDER,
+            useFactory: (moduleOption) => {
+                if (moduleOption.option.type == "custom") {
+                    return moduleOption.option.provider;
+                }
+                return email_provider_factory_1.EmailProviderFactory.createProvider(moduleOption);
+            },
+            inject: [constant_1.EMAIL_OPTIONS],
+        };
+    }
+    static createAsyncOptionsProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: constant_1.EMAIL_OPTIONS,
+                useFactory: async (...args) => {
+                    return this.santitizeOptions((await options.useFactory(...args)));
+                },
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: constant_1.EMAIL_OPTIONS,
+            useFactory: async (optionsFactory) => this.santitizeOptions((await optionsFactory.createOptions())),
+            inject: [options.useClass || options.useExisting],
+        };
+    }
+};
+EmailModule = EmailModule_1 = __decorate([
+    (0, common_1.Module)({})
+], EmailModule);
+exports.EmailModule = EmailModule;

package/dist/email/email.provider.d.ts

@@ -0,0 +1,19 @@
+import { EmailMessage } from "../interface";
+import { SendResult } from "../interface/result.interface";
+import { SmtpOption } from "./email.interface";
+export interface IEmailProvider {
+    send(message: EmailMessage): Promise<SendResult>;
+}
+export declare abstract class EmailProvider implements IEmailProvider {
+    abstract send(message: EmailMessage): Promise<SendResult>;
+}
+export declare class SmtpEmailProvider extends EmailProvider {
+    private readonly option;
+    private readonly logger;
+    private readonly transporter;
+    constructor(option: SmtpOption["options"]);
+    send(message: EmailMessage): Promise<SendResult>;
+    private createSmtpOptions;
+    private isSmtpUriOption;
+    private createMailOption;
+}

package/dist/email/email.provider.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmtpEmailProvider = exports.EmailProvider = void 0;
+const common_1 = require("@nestjs/common");
+const nodemailer = __importStar(require("nodemailer"));
+class EmailProvider {
+}
+exports.EmailProvider = EmailProvider;
+class SmtpEmailProvider extends EmailProvider {
+    constructor(option) {
+        super();
+        this.option = option;
+        this.logger = new common_1.Logger(SmtpEmailProvider.name);
+        this.transporter = nodemailer.createTransport(this.createSmtpOptions());
+    }
+    async send(message) {
+        try {
+            const result = await this.transporter
+                .sendMail(this.createMailOption(message));
+            this.logger.log(`email sent. response: ${result.response}`);
+            const { messageId } = result.response;
+            return {
+                success: true,
+                requestId: result.messageId || messageId,
+            };
+        }
+        catch (err) {
+            this.logger.error(`email failed to send. `, err);
+            return {
+                success: false,
+                message: JSON.stringify(err),
+            };
+        }
+    }
+    createSmtpOptions() {
+        if (this.isSmtpUriOption(this.option)) {
+            return this.option.url;
+        }
+        const { host, port, secure, username, password } = this.option;
+        return {
+            host,
+            port: parseInt(port),
+            secure,
+            auth: {
+                user: username,
+                pass: password,
+            },
+        };
+    }
+    isSmtpUriOption(object) {
+        return "url" in object;
+    }
+    createMailOption(emailMessage) {
+        const { from } = this.option;
+        const { recipient, subject, message } = emailMessage;
+        return {
+            from,
+            to: recipient,
+            subject: subject,
+            html: message,
+        };
+    }
+}
+exports.SmtpEmailProvider = SmtpEmailProvider;

package/dist/email/email.service.d.ts

@@ -0,0 +1,8 @@
+import { EmailProvider } from './email.provider';
+import { EmailMessage } from '../interface';
+export declare class EmailService {
+    private readonly emailProvider;
+    private readonly logger;
+    constructor(emailProvider: EmailProvider);
+    send(message: EmailMessage): Promise<import("../interface/result.interface").SendResult>;
+}

package/dist/email/email.service.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var EmailService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailService = void 0;
+const common_1 = require("@nestjs/common");
+const email_provider_1 = require("./email.provider");
+const constant_1 = require("./constant");
+let EmailService = EmailService_1 = class EmailService {
+    constructor(emailProvider) {
+        this.emailProvider = emailProvider;
+        this.logger = new common_1.Logger(EmailService_1.name);
+    }
+    send(message) {
+        return this.emailProvider.send(message);
+    }
+};
+EmailService = EmailService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constant_1.EMAIL_PROVIDER)),
+    __metadata("design:paramtypes", [email_provider_1.EmailProvider])
+], EmailService);
+exports.EmailService = EmailService;

package/dist/email/index.d.ts

@@ -0,0 +1,7 @@
+import { EMAIL_OPTIONS, EMAIL_PROVIDER, EMAIL_SERVICE } from "./constant";
+import { EmailProviderFactory } from "./email-provider.factory";
+import { EmailOption, SmtpOption, SmtpHostOption, SmtpUriOption, CustomEmailOption } from "./email.interface";
+import { EmailModule, EmailModuleOptionsWithoutProvider, EmailModuleOptions, EmailModuleAsyncOptions, EmailModuleOptionsFactory } from "./email.module";
+import { EmailProvider, SmtpEmailProvider } from "./email.provider";
+import { EmailService } from "./email.service";
+export { EMAIL_OPTIONS, EMAIL_PROVIDER, EMAIL_SERVICE, EmailOption, SmtpOption, SmtpHostOption, SmtpUriOption, CustomEmailOption, EmailModule, EmailModuleOptionsWithoutProvider, EmailModuleOptions, EmailModuleAsyncOptions, EmailModuleOptionsFactory, EmailService, EmailProvider, SmtpEmailProvider, EmailProviderFactory, };

package/dist/email/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailProviderFactory = exports.SmtpEmailProvider = exports.EmailProvider = exports.EmailService = exports.EmailModule = exports.EMAIL_SERVICE = exports.EMAIL_PROVIDER = exports.EMAIL_OPTIONS = void 0;
+const constant_1 = require("./constant");
+Object.defineProperty(exports, "EMAIL_OPTIONS", { enumerable: true, get: function () { return constant_1.EMAIL_OPTIONS; } });
+Object.defineProperty(exports, "EMAIL_PROVIDER", { enumerable: true, get: function () { return constant_1.EMAIL_PROVIDER; } });
+Object.defineProperty(exports, "EMAIL_SERVICE", { enumerable: true, get: function () { return constant_1.EMAIL_SERVICE; } });
+const email_provider_factory_1 = require("./email-provider.factory");
+Object.defineProperty(exports, "EmailProviderFactory", { enumerable: true, get: function () { return email_provider_factory_1.EmailProviderFactory; } });
+const email_module_1 = require("./email.module");
+Object.defineProperty(exports, "EmailModule", { enumerable: true, get: function () { return email_module_1.EmailModule; } });
+const email_provider_1 = require("./email.provider");
+Object.defineProperty(exports, "EmailProvider", { enumerable: true, get: function () { return email_provider_1.EmailProvider; } });
+Object.defineProperty(exports, "SmtpEmailProvider", { enumerable: true, get: function () { return email_provider_1.SmtpEmailProvider; } });
+const email_service_1 = require("./email.service");
+Object.defineProperty(exports, "EmailService", { enumerable: true, get: function () { return email_service_1.EmailService; } });

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./email";
+export * from "./interface";
+export * from "./notification";
+export * from "./sms";
+export * from "./template";

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./notification"), exports);
+__exportStar(require("./sms"), exports);
+__exportStar(require("./template"), exports);

package/dist/interface/index.d.ts

@@ -0,0 +1,2 @@
+import { BaseMessage, SmsMessage, EmailMessage, PushMessage, Message } from "./message.interface";
+export { BaseMessage, SmsMessage, EmailMessage, PushMessage, Message, };

package/dist/interface/index.js

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

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

@@ -0,0 +1,15 @@
+export interface BaseMessage {
+    recipient: string;
+    message: string;
+}
+export interface SmsMessage extends BaseMessage {
+    countryIso2?: string;
+    dialCode?: string;
+}
+export interface EmailMessage extends BaseMessage {
+    subject: string;
+}
+export interface PushMessage extends BaseMessage {
+    subject: string;
+}
+export type Message = SmsMessage | EmailMessage | PushMessage;

package/dist/interface/message.interface.js

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

package/dist/interface/result.interface.d.ts

@@ -0,0 +1,6 @@
+export interface SendResult {
+    success: boolean;
+    message?: string;
+    requestId?: string;
+    extra?: any;
+}

package/dist/interface/result.interface.js

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

package/dist/notification/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const NOTIFICATION_OPTIONS = "NOTIFICATION_OPTIONS";
+export declare const NOTIFICATION_SERVICE = "NOTIFICATION_SERVICE";
+export declare const TEMPLATE_SERVICE = "TEMPLATE_SERVICE";

package/dist/notification/constant.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_SERVICE = exports.NOTIFICATION_SERVICE = exports.NOTIFICATION_OPTIONS = void 0;
+exports.NOTIFICATION_OPTIONS = "NOTIFICATION_OPTIONS";
+exports.NOTIFICATION_SERVICE = "NOTIFICATION_SERVICE";
+exports.TEMPLATE_SERVICE = "TEMPLATE_SERVICE";

package/dist/notification/index.d.ts

@@ -0,0 +1,4 @@
+import { NOTIFICATION_OPTIONS, NOTIFICATION_SERVICE, TEMPLATE_SERVICE } from "./constant";
+import { NotificationModule, NotificationModuleAsyncOptions, NotificationModuleOptions, NotificationModuleOptionsFactory } from "./notification.module";
+import { NotificationService } from "./notification.service";
+export { NOTIFICATION_OPTIONS, NOTIFICATION_SERVICE, TEMPLATE_SERVICE, NotificationModule, NotificationModuleOptions, NotificationModuleAsyncOptions, NotificationModuleOptionsFactory, NotificationService, };

package/dist/notification/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });
+Object.defineProperty(exports, "TEMPLATE_SERVICE", { enumerable: true, get: function () { return constant_1.TEMPLATE_SERVICE; } });
+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; } });

package/dist/notification/notification.module.d.ts

@@ -0,0 +1,23 @@
+import { DynamicModule, ModuleMetadata, Type } from '@nestjs/common';
+import { EmailModuleOptions } from '../email';
+import { TemplateLoader } from '../template';
+export declare class NotificationModule {
+    static forRoot(options: NotificationModuleOptions): DynamicModule;
+    private static santitizeOptions;
+    private static createAsyncOptionsProviders;
+    private static createAsyncOptionsProvider;
+}
+export interface NotificationModuleOptions {
+    emailOptions?: EmailModuleOptions;
+    templateLoader: Type<TemplateLoader>;
+}
+export interface NotificationModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    name?: string;
+    useExisting?: Type<NotificationModuleOptionsFactory>;
+    useClass?: Type<NotificationModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<NotificationModuleOptions> | NotificationModuleOptions;
+    inject?: any[];
+}
+export interface NotificationModuleOptionsFactory {
+    createOptions(): NotificationModuleOptions | Promise<NotificationModuleOptions>;
+}

package/dist/notification/notification.module.js

@@ -0,0 +1,83 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var NotificationModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationModule = void 0;
+const common_1 = require("@nestjs/common");
+const email_1 = require("../email");
+const constant_1 = require("./constant");
+const template_1 = require("../template");
+const template_service_1 = require("../template/template.service");
+const notification_service_1 = require("./notification.service");
+let NotificationModule = NotificationModule_1 = class NotificationModule {
+    static forRoot(options) {
+        options = this.santitizeOptions(options);
+        const modules = [];
+        const { emailOptions } = options;
+        if (emailOptions) {
+            modules.push(email_1.EmailModule.forRoot(emailOptions));
+        }
+        const moduleOptions = {
+            provide: constant_1.NOTIFICATION_OPTIONS,
+            useValue: options,
+        };
+        const templateLoader = {
+            provide: template_1.TEMPLATE_LOADER,
+            useClass: options.templateLoader || template_1.FakeTemplateLoader,
+        };
+        const templateService = {
+            provide: template_service_1.TemplateService,
+            useClass: template_service_1.TemplateService
+        };
+        const notificationService = {
+            provide: notification_service_1.NotificationService,
+            useClass: notification_service_1.NotificationService,
+        };
+        return {
+            module: NotificationModule_1,
+            imports: [...modules],
+            providers: [moduleOptions, templateLoader, templateService, notificationService],
+            exports: [...modules, constant_1.NOTIFICATION_OPTIONS, template_1.TEMPLATE_LOADER, templateService, notificationService],
+        };
+    }
+    static santitizeOptions(options) {
+        return options;
+    }
+    static createAsyncOptionsProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: constant_1.NOTIFICATION_OPTIONS,
+                useFactory: async (...args) => {
+                    return this.santitizeOptions((await options.useFactory(...args)));
+                },
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: constant_1.NOTIFICATION_OPTIONS,
+            useFactory: async (optionsFactory) => this.santitizeOptions((await optionsFactory.createOptions())),
+            inject: [options.useClass || options.useExisting],
+        };
+    }
+};
+NotificationModule = NotificationModule_1 = __decorate([
+    (0, common_1.Module)({})
+], NotificationModule);
+exports.NotificationModule = NotificationModule;

package/dist/notification/notification.service.d.ts

@@ -0,0 +1,10 @@
+import { ResolveOption, TemplateLoader } from "../template";
+import { EmailService } from "../email";
+import { SendResult } from "../interface/result.interface";
+export declare class NotificationService {
+    private readonly templateLoader;
+    private readonly emailService;
+    private readonly logger;
+    constructor(templateLoader: TemplateLoader, emailService: EmailService);
+    sendEmail(templateCode: string, email: string, resolveOption: ResolveOption): Promise<SendResult>;
+}

package/dist/notification/notification.service.js

@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const common_1 = require("@nestjs/common");
+const template_1 = require("../template");
+const email_1 = require("../email");
+let NotificationService = class NotificationService {
+    constructor(templateLoader, emailService) {
+        this.templateLoader = templateLoader;
+        this.emailService = emailService;
+        this.logger = new common_1.Logger(NotificationService.name);
+    }
+    async sendEmail(templateCode, email, resolveOption) {
+        if (!this.emailService) {
+            this.logger.error("Email Service is load configure..please configure the email option");
+            return null;
+        }
+        const templateMessage = await this.templateLoader.resolve(templateCode, resolveOption);
+        if (!templateMessage) {
+            this.logger.error(`Template ${templateCode} Load Failed. Please make sure the template has set`);
+            return null;
+        }
+        return this.emailService.send({
+            recipient: email,
+            subject: templateMessage.subject || "",
+            message: templateMessage.content,
+        });
+    }
+};
+NotificationService = __decorate([
+    __param(0, (0, common_1.Inject)(template_1.TEMPLATE_LOADER)),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(email_1.EmailService)),
+    __metadata("design:paramtypes", [template_1.TemplateLoader,
+        email_1.EmailService])
+], NotificationService);
+exports.NotificationService = NotificationService;

package/dist/sms/index.d.ts

@@ -0,0 +1,2 @@
+import { SmsService } from "./sms.service";
+export { SmsService };

package/dist/sms/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmsService = void 0;
+const sms_service_1 = require("./sms.service");
+Object.defineProperty(exports, "SmsService", { enumerable: true, get: function () { return sms_service_1.SmsService; } });

package/dist/sms/sms.service.d.ts

@@ -0,0 +1,8 @@
+import { Message } from "../interface";
+import { SendResult } from "../interface/result.interface";
+export interface ISmsService {
+    send(message: Message): Promise<SendResult>;
+}
+export declare abstract class SmsService implements ISmsService {
+    abstract send(message: Message): Promise<SendResult>;
+}

package/dist/sms/sms.service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmsService = void 0;
+class SmsService {
+}
+exports.SmsService = SmsService;

package/dist/template/constant.d.ts

@@ -0,0 +1 @@
+export declare const TEMPLATE_LOADER = "TEMPLATE_LOADER";

package/dist/template/constant.js

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

package/dist/template/fake-template.loader.d.ts

@@ -0,0 +1,6 @@
+import { MessageTemplate, TemplateLoader } from "./template.loader";
+export declare class FakeTemplateLoader extends TemplateLoader {
+    private readonly logger;
+    constructor();
+    getTemplate(templateCode: string, locale: string, fallbackLocale?: string): Promise<MessageTemplate>;
+}

package/dist/template/fake-template.loader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeTemplateLoader = void 0;
+const common_1 = require("@nestjs/common");
+const template_loader_1 = require("./template.loader");
+class FakeTemplateLoader extends template_loader_1.TemplateLoader {
+    constructor() {
+        super();
+        this.logger = new common_1.Logger(FakeTemplateLoader.name);
+        this.logger.warn("this is a fake template loader. is mainly for testing purposes only. please make sure you are using it correctly");
+    }
+    getTemplate(templateCode, locale, fallbackLocale) {
+        return new Promise((resolve, reject) => {
+            resolve({
+                code: templateCode,
+                content: `${templateCode} content`,
+                subject: `${templateCode} subject`,
+                locale,
+            });
+        });
+    }
+}
+exports.FakeTemplateLoader = FakeTemplateLoader;

package/dist/template/index.d.ts

@@ -0,0 +1,5 @@
+import { TEMPLATE_LOADER } from "./constant";
+import { FakeTemplateLoader } from "./fake-template.loader";
+import { CacheOptions, MessageTemplate, ResolveOption, TemplateLoader, CachableTemplateLoader } from "./template.loader";
+import { TemplateService } from "./template.service";
+export { CacheOptions, MessageTemplate, ResolveOption, TemplateLoader, CachableTemplateLoader, TEMPLATE_LOADER, TemplateService, FakeTemplateLoader, };

package/dist/template/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeTemplateLoader = exports.TemplateService = exports.TEMPLATE_LOADER = exports.CachableTemplateLoader = exports.TemplateLoader = exports.MessageTemplate = void 0;
+const constant_1 = require("./constant");
+Object.defineProperty(exports, "TEMPLATE_LOADER", { enumerable: true, get: function () { return constant_1.TEMPLATE_LOADER; } });
+const fake_template_loader_1 = require("./fake-template.loader");
+Object.defineProperty(exports, "FakeTemplateLoader", { enumerable: true, get: function () { return fake_template_loader_1.FakeTemplateLoader; } });
+const template_loader_1 = require("./template.loader");
+Object.defineProperty(exports, "MessageTemplate", { enumerable: true, get: function () { return template_loader_1.MessageTemplate; } });
+Object.defineProperty(exports, "TemplateLoader", { enumerable: true, get: function () { return template_loader_1.TemplateLoader; } });
+Object.defineProperty(exports, "CachableTemplateLoader", { enumerable: true, get: function () { return template_loader_1.CachableTemplateLoader; } });
+const template_service_1 = require("./template.service");
+Object.defineProperty(exports, "TemplateService", { enumerable: true, get: function () { return template_service_1.TemplateService; } });

package/dist/template/template.loader.d.ts

@@ -0,0 +1,29 @@
+import { Cache } from "cache-manager";
+export interface CacheOptions {
+    cacheKey: string;
+    ttl: number;
+}
+export declare class MessageTemplate {
+    code: string;
+    locale?: string;
+    subject?: string;
+    content: string;
+}
+export interface ResolveOption {
+    locale?: string;
+    fallbackLocale?: string;
+    args?: Array<({
+        [k: string]: any;
+    } | string)>;
+}
+export declare abstract class TemplateLoader {
+    abstract getTemplate(templateCode: string, locale: string, fallbackLocale?: string): Promise<MessageTemplate>;
+    resolve(templateCode: string, options?: ResolveOption): Promise<MessageTemplate>;
+}
+export declare abstract class CachableTemplateLoader extends TemplateLoader {
+    private cacheManager;
+    private readonly cacheOptions;
+    constructor(cacheManager: Cache, cacheOptions?: CacheOptions);
+    resolve(templateCode: string, options?: ResolveOption): Promise<MessageTemplate>;
+    protected getTemplateCacheKey(templateCode: string, locale: string): string;
+}

package/dist/template/template.loader.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachableTemplateLoader = exports.TemplateLoader = exports.MessageTemplate = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const cache_manager_1 = require("@nestjs/cache-manager");
+const common_1 = require("@nestjs/common");
+const DEFAULT_EXPIRATION_MS = 10 * 60 * 1000;
+const DEFAULT_CACHE_KEY = "MESSAGE_TEMPLATE_CACHE.";
+class MessageTemplate {
+}
+exports.MessageTemplate = MessageTemplate;
+class TemplateLoader {
+    async resolve(templateCode, options = {}) {
+        const { fallbackLocale, args, locale } = options;
+        const unresolveTemplate = await this.getTemplate(templateCode, locale, fallbackLocale);
+        const { subject, content } = unresolveTemplate;
+        return {
+            ...unresolveTemplate,
+            subject: subject && (0, string_format_1.default)(subject, args),
+            content: content && (0, string_format_1.default)(content, args),
+        };
+    }
+}
+exports.TemplateLoader = TemplateLoader;
+let CachableTemplateLoader = class CachableTemplateLoader extends TemplateLoader {
+    constructor(cacheManager, cacheOptions) {
+        super();
+        this.cacheManager = cacheManager;
+        this.cacheOptions = Object.assign({
+            cacheKey: DEFAULT_CACHE_KEY,
+            ttl: DEFAULT_EXPIRATION_MS,
+        }, cacheOptions);
+    }
+    async resolve(templateCode, options = {}) {
+        const { fallbackLocale, args, locale } = options;
+        const { ttl } = this.cacheOptions;
+        const TEMPLATE_CACHE_KEY = this.getTemplateCacheKey(templateCode, locale);
+        const cachedItem = await this.cacheManager.get(TEMPLATE_CACHE_KEY);
+        let unresolveTemplate;
+        if (cachedItem) {
+            unresolveTemplate = cachedItem;
+        }
+        else {
+            unresolveTemplate = await this.getTemplate(templateCode, locale, fallbackLocale);
+            await this.cacheManager.set(TEMPLATE_CACHE_KEY, unresolveTemplate, ttl);
+        }
+        const { subject, content } = unresolveTemplate;
+        return {
+            ...unresolveTemplate,
+            subject: subject && (0, string_format_1.default)(subject, args),
+            content: content && (0, string_format_1.default)(content, args),
+        };
+    }
+    getTemplateCacheKey(templateCode, locale) {
+        const { cacheKey, ttl } = this.cacheOptions;
+        return `${cacheKey}.${templateCode}.${locale}`;
+    }
+};
+CachableTemplateLoader = __decorate([
+    __param(0, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),
+    __metadata("design:paramtypes", [Object, Object])
+], CachableTemplateLoader);
+exports.CachableTemplateLoader = CachableTemplateLoader;

package/dist/template/template.service.d.ts

@@ -0,0 +1,6 @@
+import { MessageTemplate, ResolveOption, TemplateLoader } from "./template.loader";
+export declare class TemplateService {
+    private readonly templateLoader;
+    constructor(templateLoader: TemplateLoader);
+    resolveTemplate(code: string, options?: ResolveOption): Promise<MessageTemplate>;
+}

package/dist/template/template.service.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateService = void 0;
+const common_1 = require("@nestjs/common");
+const template_loader_1 = require("./template.loader");
+const constant_1 = require("./constant");
+let TemplateService = class TemplateService {
+    constructor(templateLoader) {
+        this.templateLoader = templateLoader;
+    }
+    resolveTemplate(code, options = {}) {
+        return this.templateLoader.resolve(code, options);
+    }
+};
+TemplateService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constant_1.TEMPLATE_LOADER)),
+    __metadata("design:paramtypes", [template_loader_1.TemplateLoader])
+], TemplateService);
+exports.TemplateService = TemplateService;

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./dist";

package/index.js

@@ -0,0 +1,6 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+exports.__esModule = true;
+__export(require("./dist"));

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@nathapp/nestjs-notification",
+  "version": "1.0.0-rc.5",
+  "description": "Notification Module",
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.json",
+    "precommit": "lint-staged",
+    "test": "jest --config ./test/jest-test.json",
+    "test:cov": "jest --config ./test/jest-test.json --coverage",
+    "test:watch": "jest --config ./test/jest-test.json --watch",
+    "lint": "eslint -c .eslintrc.js"
+  },
+  "author": "William Khoo",
+  "license": "ISC",
+  "engines": {
+    "node": ">=16"
+  },
+  "devDependencies": {
+    "@golevelup/ts-jest": "^0.3.7",
+    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/testing": "^10.0.0",
+    "@types/jest": "^29.5.2",
+    "@types/node": "^17.0.22",
+    "@types/nodemailer": "^6.4.11",
+    "@types/string-format": "^2.0.1",
+    "@types/supertest": "^2.0.12",
+    "@typescript-eslint/eslint-plugin": "^4",
+    "@typescript-eslint/parser": "^4",
+    "eslint": "*",
+    "eslint-config-prettier": "^6",
+    "eslint-plugin-prettier": "^3",
+    "jest": "^29.5.0",
+    "prettier": "^2",
+    "supertest": "^6.3.3",
+    "ts-jest": "^29.1.0",
+    "typescript": "^4"
+  },
+  "types": "./index.d.ts",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "dependencies": {
+    "nodemailer": "^6.9.6",
+    "string-format": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/cache-manager": "^2.1.0",
+    "@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0",
+    "@nestjs/core": "^8.0.0 || ^9.0.0 || ^10.0.0",
+    "cache-manager": "^5.0.0",
+    "class-transformer": "*",
+    "class-validator": "*",
+    "rxjs": "*"
+  }
+}