@storyous/mailer 1.0.0

package/README.md

@@ -0,0 +1,21 @@
+# `mailer`
+
+## Usage
+
+``` typescript
+import mailer from '@storyous/mailer';
+
+const sender = mailer.createSender({
+    from: 'test@storyous.cz',
+    to: 'test@storyous.cz',
+    template: 'some.template',
+    defaultLang: 'cs',
+});
+
+ await sender.send({
+            bcc: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            cc: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            replyTo: 'dev@storyous.cz',
+            lang: 'en',
+        });
+```

package/__tests__/mailer.test.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = __importDefault(require("@storyous/test-utils"));
+const assert_1 = __importDefault(require("assert"));
+const mocha_1 = require("mocha");
+const lib_1 = __importDefault(require("../lib"));
+const defaultOptions = {
+    from: 'test@storyous.cz',
+    to: 'test@storyous.cz',
+    template: 'some.template',
+    defaultLang: 'cs',
+};
+const sender = lib_1.default.createSender(defaultOptions);
+(0, mocha_1.describe)('packages/mailer', () => {
+    test_utils_1.default.init(undefined, undefined, lib_1.default);
+    (0, mocha_1.it)('should send email', async () => {
+        await sender.send({
+            to: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            bcc: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            cc: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            replyTo: 'dev@storyous.cz',
+        });
+        const sentEmails = test_utils_1.default.getSentMails();
+        assert_1.default.deepStrictEqual(sentEmails.length, 1);
+    });
+    (0, mocha_1.it)('should send email with person lang', async () => {
+        await sender.send({
+            person: { lang: 'cs' },
+        });
+        const sentEmails = test_utils_1.default.getSentMails();
+        assert_1.default.deepStrictEqual(sentEmails.length, 1);
+    });
+    (0, mocha_1.it)('should send email with lang', async () => {
+        await sender.send({
+            lang: 'cs',
+        });
+        const sentEmails = test_utils_1.default.getSentMails();
+        assert_1.default.deepStrictEqual(sentEmails.length, 1);
+    });
+    (0, mocha_1.it)('should throw exception when options are empty', async () => {
+        try {
+            await lib_1.default.sendMail({});
+            assert_1.default.fail('The method must throw an exception.');
+        }
+        catch (e) {
+            assert_1.default.deepStrictEqual(e.message, 'I need to know who this email is being sent to :-(');
+        }
+    });
+    (0, mocha_1.it)('should throw exception when transporter is not initialized', async () => {
+        lib_1.default._transporter = undefined;
+        try {
+            await lib_1.default.sendMail({});
+            assert_1.default.fail('The method must throw an exception.');
+        }
+        catch (e) {
+            assert_1.default.deepStrictEqual(e.message, 'The transporter is not initialized yet! Use createSender before.');
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/__tests__/mailer.test.ts

@@ -0,0 +1,62 @@
+import testUtils from '@storyous/test-utils';
+import assert from 'assert';
+import { describe, it } from 'mocha';
+import mailer from '../lib';
+
+const defaultOptions = {
+    from: 'test@storyous.cz',
+    to: 'test@storyous.cz',
+    template: 'some.template',
+    defaultLang: 'cs',
+};
+const sender = mailer.createSender(defaultOptions);
+
+describe('packages/mailer', () => {
+    testUtils.init(undefined, undefined, mailer);
+
+    it('should send email', async () => {
+        await sender.send({
+            to: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            bcc: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            cc: ['dev@storyous.cz', 'dev2@storyous.cz'],
+            replyTo: 'dev@storyous.cz',
+        });
+        const sentEmails = testUtils.getSentMails();
+        assert.deepStrictEqual(sentEmails.length, 1);
+    });
+
+    it('should send email with person lang', async () => {
+        await sender.send({
+            person: { lang: 'cs' },
+        });
+        const sentEmails = testUtils.getSentMails();
+        assert.deepStrictEqual(sentEmails.length, 1);
+    });
+
+    it('should send email with lang', async () => {
+        await sender.send({
+            lang: 'cs',
+        });
+        const sentEmails = testUtils.getSentMails();
+        assert.deepStrictEqual(sentEmails.length, 1);
+    });
+
+    it('should throw exception when options are empty', async () => {
+        try {
+            await mailer.sendMail({});
+            assert.fail('The method must throw an exception.');
+        } catch (e: any) {
+            assert.deepStrictEqual(e.message, 'I need to know who this email is being sent to :-(');
+        }
+    });
+
+    it('should throw exception when transporter is not initialized', async () => {
+        mailer._transporter = undefined;
+        try {
+            await mailer.sendMail({});
+            assert.fail('The method must throw an exception.');
+        } catch (e: any) {
+            assert.deepStrictEqual(e.message, 'The transporter is not initialized yet! Use createSender before.');
+        }
+    });
+});

package/lib/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nodemailer_1 = require("nodemailer");
+const mailSender_1 = require("./mailSender");
+const mailer = {
+    _transporter: undefined,
+    _logger: undefined,
+    /**
+     * RFC 2822 standard
+     * @type RegExp
+     */
+    _emailAddressRegexp: /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/,
+    createSender(options, logger) {
+        this._transporter = (0, nodemailer_1.createTransport)(options);
+        this._logger = logger;
+        return new mailSender_1.MailSender(options, this.sendMail.bind(this));
+    },
+    async sendMail(mailOptions) {
+        return new Promise((resolve, reject) => {
+            if (!this._transporter) {
+                throw new Error('The transporter is not initialized yet! Use createSender before.');
+            }
+            this._transporter.sendMail(mailOptions, (err, info) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this._logSentMail(mailOptions, info || {});
+                    resolve(info);
+                }
+            });
+        });
+    },
+    _logSentMail(mailOptions, resultInfo) {
+        const extractEmail = this._extractEmail.bind(this);
+        let { to } = mailOptions;
+        if (typeof mailOptions.to === 'string') {
+            to = mailOptions.to?.split(',').map(extractEmail);
+        }
+        const logMetaInfo = {
+            subject: mailOptions.subject,
+            to,
+        };
+        if (resultInfo?.accepted?.length) {
+            logMetaInfo.accepted = resultInfo.accepted.map(extractEmail);
+        }
+        if (resultInfo?.rejected?.length) {
+            logMetaInfo.rejected = resultInfo.rejected.map(extractEmail);
+        }
+        if (resultInfo?.pending?.length) {
+            logMetaInfo.pending = resultInfo.pending.map(extractEmail);
+        }
+        this._logger?.info('Mail sent', logMetaInfo);
+    },
+    _extractEmail(emailText) {
+        const result = emailText.match(this._emailAddressRegexp);
+        return result ? result[0] : '';
+    },
+};
+exports.default = mailer;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.ts

@@ -0,0 +1,75 @@
+import { createTransport, Transporter } from 'nodemailer';
+import { Options } from 'nodemailer/lib/mailer';
+import { Logger } from 'winston';
+import { IDefaultMailOptions, MailSender } from './mailSender';
+
+const mailer = {
+    _transporter: <Transporter|undefined> undefined,
+    _logger: <Logger|undefined> undefined,
+
+    /**
+     * RFC 2822 standard
+     * @type RegExp
+     */
+    _emailAddressRegexp: /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/,
+
+    createSender (options: IDefaultMailOptions, logger?: Logger) {
+        this._transporter = createTransport(options);
+        this._logger = logger;
+
+        return new MailSender(options, this.sendMail.bind(this));
+    },
+
+    async sendMail (mailOptions: Options): Promise<any> {
+        return new Promise((resolve, reject) => {
+            if (!this._transporter) {
+                throw new Error('The transporter is not initialized yet! Use createSender before.');
+            }
+
+            this._transporter.sendMail(mailOptions, (err: any, info: unknown) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    this._logSentMail(mailOptions, info || {});
+                    resolve(info);
+                }
+            });
+        });
+    },
+
+    _logSentMail (mailOptions: Options, resultInfo: any) {
+        const extractEmail = this._extractEmail.bind(this);
+
+        let { to } = mailOptions;
+        if (typeof mailOptions.to === 'string') {
+            to = mailOptions.to?.split(',').map(extractEmail);
+        }
+
+        const logMetaInfo: any = {
+            subject: mailOptions.subject,
+            to,
+        };
+
+        if (resultInfo?.accepted?.length) {
+            logMetaInfo.accepted = resultInfo.accepted.map(extractEmail);
+        }
+
+        if (resultInfo?.rejected?.length) {
+            logMetaInfo.rejected = resultInfo.rejected.map(extractEmail);
+        }
+
+        if (resultInfo?.pending?.length) {
+            logMetaInfo.pending = resultInfo.pending.map(extractEmail);
+        }
+
+        this._logger?.info('Mail sent', logMetaInfo);
+    },
+
+    _extractEmail (emailText: string) {
+        const result = emailText.match(this._emailAddressRegexp);
+        return result ? result[0] : '';
+    },
+
+};
+
+export default mailer;

package/lib/mailSender.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailSender = void 0;
+const errors_1 = require("@storyous/errors");
+const handlebars_1 = __importDefault(require("handlebars"));
+const lodash_1 = require("lodash");
+/**
+ * Provides shortcut for sending email
+ */
+class MailSender {
+    constructor(options, sendFunction) {
+        this._getTemplate = (params) => {
+            const compiledTemplate = handlebars_1.default.compile(params.template)(params);
+            const separatorRegexp = /<!--\s*\/([a-zA-Z0-9]+)\s*-->/;
+            const templatePieces = compiledTemplate.split(separatorRegexp);
+            templatePieces.shift(); // remove first blank string
+            if (templatePieces.length % 2 !== 0) {
+                throw errors_1.AppError.internal('The template is not valid.');
+            }
+            const template = {};
+            for (let i = 0; i < templatePieces.length; i += 2) {
+                template[templatePieces[i]] = templatePieces[i + 1];
+            }
+            if (template.subject) {
+                template.subject = template.subject.trim();
+            }
+            return template;
+        };
+        this._sendFunction = sendFunction;
+        this._sendTo = options.to;
+        this._sendFrom = options.from;
+        this._template = options.template;
+        this._defaultLang = options.defaultLang;
+    }
+    async send(params) {
+        params = this._completeParams(params);
+        const template = this._getTemplate(params);
+        const mailOptions = {
+            html: template.html,
+            text: template.text,
+            subject: template.subject,
+            to: params.to,
+            from: this._sendFrom,
+            replyTo: params.replyTo,
+            bcc: params.bcc,
+            cc: params.cc,
+        };
+        if (Array.isArray(mailOptions.to)) {
+            mailOptions.to = mailOptions.to.join(',');
+        }
+        if (Array.isArray(mailOptions.bcc)) {
+            mailOptions.bcc = mailOptions.bcc.join(',');
+        }
+        if (Array.isArray(mailOptions.cc)) {
+            mailOptions.cc = mailOptions.cc.join(',');
+        }
+        return this._sendFunction(mailOptions);
+    }
+    _completeParams(params) {
+        return (0, lodash_1.extend)({}, params, {
+            lang: this._getLanguageFromParams(params),
+            to: params.to || this._sendTo,
+            from: params.from || this._sendFrom,
+            template: params.template || this._template,
+        });
+    }
+    _getLanguageFromParams(params) {
+        if (params.lang) {
+            return params.lang;
+        }
+        if (params?.person?.lang) {
+            return params.person.lang;
+        }
+        return this._defaultLang;
+    }
+}
+exports.MailSender = MailSender;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mailSender.ts

@@ -0,0 +1,125 @@
+import { AppError } from '@storyous/errors';
+import handlebars from 'handlebars';
+import { extend } from 'lodash';
+import { Address, Options } from 'nodemailer/lib/mailer';
+
+export interface ISendMailOptions {
+    bcc?: string | string[],
+    cc?: string | string[],
+    from?: string,
+    lang?: string,
+    replyTo?: string | Address,
+    template?: string,
+    to?: string | string[],
+    person?: {
+        lang?: string
+    },
+}
+
+export interface IDefaultMailOptions {
+    from: string,
+    to: string|string[],
+    template: string,
+    defaultLang: string
+}
+
+/**
+ * Provides shortcut for sending email
+ */
+export class MailSender {
+
+    private readonly _sendFunction: any;
+
+    private readonly _sendTo: string|string[];
+
+    private readonly _sendFrom: string;
+
+    private readonly _template: string;
+
+    private readonly _defaultLang: string;
+
+    constructor (options: IDefaultMailOptions, sendFunction: any) {
+        this._sendFunction = sendFunction;
+        this._sendTo = options.to;
+        this._sendFrom = options.from;
+        this._template = options.template;
+        this._defaultLang = options.defaultLang;
+    }
+
+    async send (params: ISendMailOptions) {
+        params = this._completeParams(params);
+        const template = this._getTemplate(params);
+
+        const mailOptions: Options = {
+            html: template.html,
+            text: template.text,
+            subject: template.subject,
+            to: params.to,
+            from: this._sendFrom,
+            replyTo: params.replyTo,
+            bcc: params.bcc,
+            cc: params.cc,
+        };
+
+        if (Array.isArray(mailOptions.to)) {
+            mailOptions.to = mailOptions.to.join(',');
+        }
+
+        if (Array.isArray(mailOptions.bcc)) {
+            mailOptions.bcc = mailOptions.bcc.join(',');
+        }
+
+        if (Array.isArray(mailOptions.cc)) {
+            mailOptions.cc = mailOptions.cc.join(',');
+        }
+
+        return this._sendFunction(mailOptions);
+    }
+
+    private _completeParams (params: ISendMailOptions) {
+        return extend({}, params, {
+            lang: this._getLanguageFromParams(params),
+            to: params.to || this._sendTo,
+            from: params.from || this._sendFrom,
+            template: params.template || this._template,
+        });
+    }
+
+    private _getLanguageFromParams (params: ISendMailOptions): string {
+
+        if (params.lang) {
+            return params.lang;
+        }
+
+        if (params?.person?.lang) {
+            return params.person.lang;
+        }
+
+        return this._defaultLang;
+    }
+
+    private _getTemplate = (params: ISendMailOptions) => {
+
+        const compiledTemplate = handlebars.compile(params.template)(params);
+
+        const separatorRegexp = /<!--\s*\/([a-zA-Z0-9]+)\s*-->/;
+        const templatePieces = compiledTemplate.split(separatorRegexp);
+
+        templatePieces.shift(); // remove first blank string
+
+        if (templatePieces.length % 2 !== 0) {
+            throw AppError.internal('The template is not valid.');
+        }
+
+        const template: any = {};
+        for (let i = 0; i < templatePieces.length; i += 2) {
+            template[templatePieces[i]] = templatePieces[i + 1];
+        }
+
+        if (template.subject) {
+            template.subject = template.subject.trim();
+        }
+
+        return template;
+    };
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@storyous/mailer",
+  "version": "1.0.0",
+  "description": "",
+  "homepage": "https://github.com/Storyous/mono-utils#readme",
+  "license": "ISC",
+  "main": "lib/index.ts",
+  "scripts": {
+    "start": "tsc",
+    "build": "tsc && npm publish"
+  },
+  "mocha": {
+    "recursive": true,
+    "timeout": 15000,
+    "extension": [
+      "ts"
+    ],
+    "exit": true,
+    "require": "ts-node/register"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Storyous/mono-utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Storyous/mono-utils/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@storyous/errors": "^1.0.0",
+    "handlebars": "^4.7.7",
+    "lodash": "^4.17.21",
+    "nodemailer": "^6.7.3",
+    "winston": "^3.7.2"
+  },
+  "devDependencies": {
+    "@storyous/test-utils": "^1.0.0"
+  },
+  "gitHead": "2ba0209d33ac7cd2fd1136a9123134f656750102"
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": "../../tsconfig.json",
+
+    "include": [
+        "lib",
+        "__tests__"
+    ]
+}