@adaptivestone/framework 3.4.3 → 4.1.0

package/services/http/middleware/I18n.js

@@ -0,0 +1,119 @@
+const i18next = require('i18next');
+const BackendFS = require('i18next-fs-backend');
+const Backend = require('i18next-chained-backend');
+
+const AbstractMiddleware = require('./AbstractMiddleware');
+
+class I18n extends AbstractMiddleware {
+  constructor(app, params) {
+    super(app, params);
+    const I18NConfig = this.app.getConfig('i18n');
+    this.i18n = {
+      t: (text) => text,
+      language: I18NConfig.fallbackLng,
+    };
+    this.cache = {};
+
+    if (I18NConfig.enabled) {
+      this.logger.info('Enabling i18n support');
+      this.i18n = i18next;
+      i18next.use(Backend).init({
+        backend: {
+          backends: [
+            BackendFS,
+            //  BackendFS,
+          ],
+          backendOptions: [
+            // {
+            //  loadPath: __dirname + '/../../locales/{{lng}}/{{ns}}.json',
+            //   addPath: __dirname + '/../../locales/{{lng}}/{{ns}}.missing.json'
+            // },
+            {
+              loadPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.json`,
+              addPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.missing.json`,
+            },
+          ],
+        },
+        fallbackLng: I18NConfig.fallbackLng,
+        preload: I18NConfig.preload,
+        saveMissing: I18NConfig.saveMissing,
+        debug: I18NConfig.debug,
+      });
+    }
+
+    this.enabled = I18NConfig.enabled;
+    this.lookupQuerystring = I18NConfig.lookupQuerystring;
+    this.supportedLngs = I18NConfig.supportedLngs;
+    this.fallbackLng = I18NConfig.fallbackLng;
+  }
+
+  static get description() {
+    return 'Provide language detection and translation';
+  }
+
+  async middleware(req, res, next) {
+    let i18n;
+
+    if (this.enabled) {
+      let lang = this.detectLang(req);
+      if (!lang || this.supportedLngs.indexOf(lang) === -1) {
+        this.logger.verbose(
+          `Language "${lang}" is not supported or not detected. Using fallback on ${this.fallbackLng}`,
+        );
+        lang = this.fallbackLng;
+      }
+
+      if (!this.cache[lang]) {
+        this.cache[lang] = i18next.cloneInstance({
+          initImmediate: false,
+          lng: lang,
+        });
+      }
+      i18n = this.cache[lang];
+    }
+
+    if (!i18n) {
+      i18n = this.i18n;
+    }
+
+    req.appInfo.i18n = i18n;
+    req.i18n = new Proxy(req.appInfo.i18n, {
+      get: (target, prop) => {
+        this.logger.warn('Please not use "req.i18n" Use "req.appInfo.i18n"');
+        return target[prop];
+      },
+    });
+
+    return next();
+  }
+
+  detectors = {
+    XLang: (req) => req.get('X-Lang'), // grab from header
+    query: (req) => (req.query ? req.query[this.lookupQuerystring] : false), // grab from query
+    user: (req) => req.appInfo?.user?.locale, // what if we have a user and user have a defined locale?
+  };
+
+  detectorOrder = ['XLang', 'query', 'user'];
+
+  detectLang(req, isUseShortCode = true) {
+    let lang = '';
+    for (const detectorName of this.detectorOrder) {
+      const lng = this.detectors[detectorName](req);
+      if (!lng) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      if (i18next.services.languageUtils.isSupportedCode(lng)) {
+        if (isUseShortCode) {
+          lang = i18next.services.languageUtils.getLanguagePartFromCode(lng);
+        } else {
+          lang = lng;
+        }
+        break;
+      }
+    }
+    return lang;
+  }
+}
+
+module.exports = I18n;

package/services/http/middleware/I18n.test.js

@@ -0,0 +1,77 @@
+const I18n = require('./I18n');
+
+describe('i18n middleware methods', () => {
+  let middleware;
+  beforeAll(() => {
+    middleware = new I18n(global.server.app);
+  });
+  it('have description fields', async () => {
+    expect.assertions(1);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('detectors should works correctly', async () => {
+    expect.assertions(5);
+    const request = {
+      get: () => 'en',
+      query: {
+        [middleware.lookupQuerystring]: 'es',
+      },
+    };
+    let lang = await middleware.detectLang(request);
+    expect(lang).toBe('en');
+
+    request.appInfo = {
+      user: {
+        locale: 'be',
+      },
+    };
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('en');
+    request.get = () => null;
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('es');
+
+    delete request.query;
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('be');
+
+    request.query = {
+      [middleware.lookupQuerystring]: 'en-GB',
+    };
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('en');
+  });
+
+  it('middleware that works', async () => {
+    expect.assertions(4);
+    const nextFunction = jest.fn(() => {});
+    const req = {
+      get: () => 'en',
+      appInfo: {},
+    };
+    await middleware.middleware(req, {}, nextFunction);
+    expect(nextFunction).toHaveBeenCalledWith();
+    expect(req.appInfo.i18n).toBeDefined();
+    expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
+    expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
+  });
+
+  it('middleware disabled', async () => {
+    expect.assertions(4);
+    global.server.app.updateConfig('i18n', { enabled: false });
+    middleware = new I18n(global.server.app);
+
+    const nextFunction = jest.fn(() => {});
+    const req = {
+      get: () => 'en',
+      appInfo: {},
+    };
+    await middleware.middleware(req, {}, nextFunction);
+    expect(nextFunction).toHaveBeenCalledWith();
+    expect(req.appInfo.i18n).toBeDefined();
+    expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
+    expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
+    global.server.app.updateConfig('i18n', { enabled: true });
+  });
+});

package/services/http/middleware/Pagination.js

@@ -0,0 +1,56 @@
+const yup = require('yup');
+const AbstractMiddleware = require('./AbstractMiddleware');
+/**
+ * Middleware for reusing pagination
+ */
+class Pagination extends AbstractMiddleware {
+  static get description() {
+    return 'Pagination middleware. You can use limit=10 and maxLimit=100 parameters';
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get relatedQueryParameters() {
+    return yup.object().shape({
+      page: yup.number(),
+      limit: yup.number(),
+    });
+  }
+
+  async middleware(req, res, next) {
+    let { limit, maxLimit } = this.params;
+
+    limit = typeof limit === 'number' ? parseInt(limit, 10) : 10;
+    maxLimit = typeof maxLimit === 'number' ? parseInt(maxLimit, 10) : 100;
+
+    req.appInfo.pagination = {};
+    req.appInfo.pagination.page =
+      typeof req?.query?.page === 'string'
+        ? parseInt(req?.query?.page, 10) || 1
+        : 1;
+
+    req.appInfo.pagination.limit =
+      typeof req?.query?.limit === 'string'
+        ? parseInt(req?.query?.limit, 10) || 0
+        : limit;
+
+    if (req.appInfo.pagination.limit > maxLimit) {
+      req.appInfo.pagination.limit = maxLimit;
+    }
+
+    if (req.appInfo.pagination.page < 1) {
+      req.appInfo.pagination.page = 1;
+    }
+
+    if (req.appInfo.pagination.limit < 0) {
+      req.appInfo.pagination.limit = 0;
+    }
+
+    req.appInfo.pagination.skip =
+      req.appInfo.pagination.page * req.appInfo.pagination.limit -
+      req.appInfo.pagination.limit;
+
+    return next();
+  }
+}
+
+module.exports = Pagination;

package/services/http/middleware/PrepareAppInfo.test.js

@@ -0,0 +1,22 @@
+const PrepareAppInfo = require('./PrepareAppInfo');
+
+describe('prepareAppInfo methods', () => {
+  it('have description fields', async () => {
+    expect.assertions(1);
+    const middleware = new PrepareAppInfo(global.server.app);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('middleware that works', async () => {
+    expect.assertions(3);
+    const middleware = new PrepareAppInfo(global.server.app);
+    const nextFunction = jest.fn(() => {});
+    const req = {};
+    await middleware.middleware(req, {}, nextFunction);
+    expect(nextFunction).toHaveBeenCalledWith();
+    expect(req.appInfo).toBeDefined();
+    req.appInfo.test = 5;
+    await middleware.middleware(req, {}, nextFunction);
+    expect(req.appInfo.test).toBe(5);
+  });
+});

package/services/http/middleware/{Middlewares.test.js → RateLimiter.test.js}

@@ -1,6 +1,6 @@
 const RateLimiter = require('./RateLimiter');
 
-describe('middlewares methods', () => {
+describe('rate limiter methods', () => {
   it('can create redis rateLimiter', async () => {
     expect.assertions(1);
 

package/services/http/middleware/RequestLogger.js

@@ -0,0 +1,22 @@
+const AbstractMiddleware = require('./AbstractMiddleware');
+
+class RequestLogger extends AbstractMiddleware {
+  static get description() {
+    return 'Log info about the request';
+  }
+
+  async middleware(req, res, next) {
+    const startTime = Date.now();
+    const text = `Request is  [${req.method}] ${req.url}`;
+    this.logger.info(text);
+    res.on('finish', () => {
+      const duration = Date.now() - startTime;
+      this.logger.info(
+        `Finished ${text}. Status: ${res.statusCode}. Duration ${duration} ms`,
+      );
+    });
+    next();
+  }
+}
+
+module.exports = RequestLogger;

package/services/http/middleware/RequestParser.js

@@ -0,0 +1,36 @@
+const formidable = require('formidable');
+
+const AbstractMiddleware = require('./AbstractMiddleware');
+
+class RequestParser extends AbstractMiddleware {
+  static get description() {
+    return 'Parses incoming request. Based on Formidable library';
+  }
+
+  async middleware(req, res, next) {
+    const time = Date.now();
+    this.logger.verbose(`Parsing request`);
+    // TODO update this to https://github.com/node-formidable/formidable/issues/412#issuecomment-1367914268 in node v20 (in 2023?)
+
+    const form = formidable(this.params); // not in construstor as reuse formidable affects performance
+    form.parse(req, (err, fields, files) => {
+      this.logger.verbose(
+        `Parsing multipart/formdata request DONE ${Date.now() - time}ms`,
+      );
+      if (err) {
+        this.logger.error(`Parsing failed ${err}`);
+        return next(err);
+      }
+
+      req.body = {
+        // todo avoid body in next versions
+        ...req.body,
+        ...fields,
+        ...files,
+      };
+      return next();
+    });
+  }
+}
+
+module.exports = RequestParser;

package/services/messaging/email/index.js

@@ -1,21 +1,29 @@
-const fs = require('fs');
-const EmailTemplate = require('email-templates');
+const fs = require('node:fs');
+const path = require('node:path');
+const { promisify } = require('node:util');
 const nodemailer = require('nodemailer');
 const sendMail = require('nodemailer-sendmail-transport');
 const stub = require('nodemailer-stub-transport');
+const pug = require('pug');
+const juice = require('juice');
+const { convert } = require('html-to-text');
 
 const mailTransports = {
   sendMail,
   stub,
   smtp: (data) => data,
 };
-const path = require('path');
 const Base = require('../../../modules/Base');
 
-// const i18next = require('i18next');
-
 class Mail extends Base {
-  constructor(app, template, templateData, i18n) {
+  /**
+   * Construct mail class
+   * @param {object} app
+   * @param {string} template template name
+   * @param {object} [templateData={}] data to render in template. Object with value that available inside template
+   * @param {object} [i18n] data to render in template
+   */
+  constructor(app, template, templateData = {}, i18n = null) {
     super(app);
     if (!path.isAbsolute(template)) {
       if (
@@ -38,60 +46,172 @@ class Mail extends Base {
       }
     }
     this.templateData = templateData;
-    this.i18n = i18n;
-    this.locale = this.i18n.language;
+    this.i18n = i18n ?? {
+      t: (str) => str,
+      locale: 'en', // todo change it to config
+    };
+    this.locale = this.i18n?.language;
   }
 
   /**
-   * Send email
-   * @param to
-   * @param [from = mailConfig.from]
+   * Render template
+   * @param {object} type and fullpath
+   * @param {object} templateData
+   * @returns string
+   */
+  static async #renderTemplateFile({ type, fullPath } = {}, templateData = {}) {
+    if (!type) {
+      return null;
+    }
+
+    switch (type) {
+      case 'html':
+      case 'text':
+      case 'css':
+        return fs.promises.readFile(fullPath, { encoding: 'utf8' });
+      case 'pug': {
+        const compiledFunction = pug.compileFile(fullPath);
+        return compiledFunction(templateData);
+      }
+      default:
+        throw new Error(`Template type ${type} is not supported`);
+    }
+  }
+
+  /**
+   * Render template
    * @return {Promise}
    */
-  async send(to, from) {
+  async renderTemplate() {
+    const files = await fs.promises.readdir(this.template);
+    const templates = {};
+    for (const file of files) {
+      const [name, extension] = file.split('.');
+      templates[name] = {
+        type: extension,
+        fullPath: path.join(this.template, file),
+      };
+    }
+
+    if (!templates.html || !templates.subject) {
+      throw new Error(
+        'Template HTML and Subject must be provided. Please follow documentation for details https://framework.adaptivestone.com/docs/email',
+      );
+    }
     const mailConfig = this.app.getConfig('mail');
+
+    const templateDataToRender = {
+      locale: this.locale,
+      t: this.i18n.t.bind(this.i18n),
+      ...mailConfig.globalVariablesToTemplates,
+      ...this.templateData,
+    };
+
+    const [htmlRendered, subjectRendered, textRendered, extraCss] =
+      await Promise.all([
+        this.constructor.#renderTemplateFile(
+          templates.html,
+          templateDataToRender,
+        ),
+        this.constructor.#renderTemplateFile(
+          templates.subject,
+          templateDataToRender,
+        ),
+        this.constructor.#renderTemplateFile(
+          templates.text,
+          templateDataToRender,
+        ),
+        this.constructor.#renderTemplateFile(templates.style),
+      ]);
+
+    juice.tableElements = ['TABLE'];
+
+    const juiceResourcesAsync = promisify(juice.juiceResources);
+
+    const inlinedHTML = await juiceResourcesAsync(htmlRendered, {
+      preserveImportant: true,
+      webResources: mailConfig.webResources,
+      extraCss,
+    });
+    return {
+      htmlRaw: htmlRendered,
+      subject: subjectRendered,
+      text: textRendered,
+      inlinedHTML,
+    };
+  }
+
+  /**
+   * Send email
+   * @param {string} to email send to
+   * @param {string} [from = mailConfig.from]
+   * @param {object} [aditionalNodemailerOptions = {}] additional option to nodemailer
+   * @return {Promise}
+   */
+  async send(to, from = null, aditionalNodemailerOptions = {}) {
+    const { subject, text, inlinedHTML } = await this.renderTemplate();
+
+    return this.constructor.sendRaw(
+      this.app,
+      to,
+      subject,
+      inlinedHTML,
+      text,
+      from,
+      aditionalNodemailerOptions,
+    );
+  }
+
+  /**
+   * Send provided text (html) to email. Low level function. All data should be prepared before sending (like inline styles)
+   * @param {objetc} app application
+   * @param {string} to send to
+   * @param {string} subject email topic
+   * @param {string} html hmlt body of emain
+   * @param {string} [text] if not provided will be generated from html string
+   * @param {string} [from = mailConfig.from] from. If not provided will be grabbed from config
+   * @param {object} [additionalNodeMailerOption = {}] any otipns to pass to nodemailer  https://nodemailer.com/message/
+   */
+  static async sendRaw(
+    app,
+    to,
+    subject,
+    html,
+    text = null,
+    from = null,
+    additionalNodeMailerOption = {},
+  ) {
+    if (!app || !to || !subject || !html) {
+      throw new Error('App, to, subject and html is required fields.');
+    }
+    const mailConfig = app.getConfig('mail');
     if (!from) {
       // eslint-disable-next-line no-param-reassign
       from = mailConfig.from;
     }
-    const { siteDomain } = this.app.getConfig('http');
+
+    if (!text) {
+      // eslint-disable-next-line no-param-reassign
+      text = convert(html, {
+        selectors: [{ selector: 'img', format: 'skip' }],
+      });
+    }
     const transportConfig = mailConfig.transports[mailConfig.transport];
     const transport = mailTransports[mailConfig.transport];
     const transporter = nodemailer.createTransport(transport(transportConfig));
 
-    const email = new EmailTemplate({
-      message: {
-        from,
-      },
-      send: true,
-      preview: false,
-      transport: transporter,
-      juiceResources: {
-        webResources: mailConfig.webResources,
-      },
-    });
-
-    return email.send({
-      template: this.template,
-      message: {
-        to,
-      },
-      locals: {
-        locale: this.locale,
-        serverDomain: mailConfig.myDomain,
-        siteDomain,
-        t: this.i18n.t.bind(this.i18n),
-        ...this.templateData,
-      },
+    return transporter.sendMail({
+      from,
+      to,
+      subject,
+      text,
+      html,
+      ...additionalNodeMailerOption,
     });
   }
 
-  render() {
-    // TODO for debug
-  }
-
   static get loggerGroup() {
-    return 'messaging';
+    return 'email_';
   }
 }
 

package/services/messaging/email/resources/.gitkeep

@@ -0,0 +1 @@
+This folder for you resources to inline