@adaptivestone/framework 3.4.2 → 4.0.0

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,152 @@ 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;
+  }
+
+  /**
+   * Render template
+   * @param {object} type and fullpath
+   * @param {object} templateData
+   * @returns string
+   */
+  static async #renderTemplate({ 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`);
+    }
   }
 
   /**
    * Send email
-   * @param to
-   * @param [from = mailConfig.from]
+   * @param {string} to email send to
+   * @param {string} [from = mailConfig.from]
+   * @param {object} [aditionalNodemailerOptions = {}] additional option to nodemailer
    * @return {Promise}
    */
-  async send(to, from) {
+  async send(to, from = null, aditionalNodemailerOptions = {}) {
+    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.#renderTemplate(templates.html, templateDataToRender),
+        this.constructor.#renderTemplate(
+          templates.subject,
+          templateDataToRender,
+        ),
+        this.constructor.#renderTemplate(templates.text, templateDataToRender),
+        this.constructor.#renderTemplate(templates.style),
+      ]);
+
+    juice.tableElements = ['TABLE'];
+
+    const juiceResourcesAsync = promisify(juice.juiceResources);
+
+    const inlinedHTML = await juiceResourcesAsync(htmlRendered, {
+      preserveImportant: true,
+      webResources: mailConfig.webResources,
+      extraCss,
+    });
+
+    return this.constructor.sendRaw(
+      this.app,
+      to,
+      subjectRendered,
+      inlinedHTML,
+      textRendered,
+      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 transporter.sendMail({
+      from,
+      to,
+      subject,
+      text,
+      html,
+      ...additionalNodeMailerOption,
     });
-
-    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,
-      },
-    });
-  }
-
-  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

package/services/validate/ValidateService.js

@@ -0,0 +1,161 @@
+const yup = require('yup');
+const YupValidator = require('./drivers/YupValidator');
+const CustomValidator = require('./drivers/CustomValidator');
+const Base = require('../../modules/Base');
+
+class ValidateService extends Base {
+  constructor(app, validator) {
+    super(app);
+    this.validator = validator
+      ? this.constructor.getDriverByValidatorBody(app, validator)
+      : null;
+  }
+
+  static drivers = {
+    YupValidator,
+    CustomValidator,
+  };
+
+  static isValidatorExists(validator) {
+    if (!(validator instanceof Object)) {
+      return false;
+    }
+
+    return Object.values(this.drivers).some(
+      (driver) => validator instanceof driver,
+    );
+  }
+
+  static getDriverByValidatorBody(app, body) {
+    if (this.isValidatorExists(body)) {
+      return body;
+    }
+    if (yup.isSchema(body)) {
+      const yupValidator = new YupValidator(app, body);
+      return yupValidator;
+    }
+    const customValidator = new CustomValidator(app, body);
+    return customValidator;
+  }
+
+  /**
+   * Filter middlewares by route path and select all parameters
+   */
+  static filterRelatedParametersByRoute(middlewares, method, path) {
+    const middlewaresParams = middlewares
+      .filter(
+        (middleware) =>
+          middleware.method.toLowerCase() === method.toLowerCase() &&
+          middleware.fullPath.toLowerCase() === path.toLowerCase(),
+      )
+      ?.map((middleware) => {
+        const instance = new middleware.MiddlewareFunction(
+          this.app,
+          middleware.params,
+        );
+
+        return instance.relatedReqParameters;
+      });
+
+    return middlewaresParams;
+  }
+
+  /**
+   * Group all middleware(routes + controller) parameters
+   */
+  static getMiddlewareParams(
+    controllerMiddlewares,
+    AllrouteMiddlewares,
+    options,
+  ) {
+    const { method, path } = options;
+    const routeMiddlewaresParams = this.filterRelatedParametersByRoute(
+      AllrouteMiddlewares,
+      method,
+      path,
+    );
+
+    const controllerMiddlewaresParams = this.filterRelatedParametersByRoute(
+      controllerMiddlewares,
+      method,
+      path,
+    );
+
+    return {
+      request: [
+        ...controllerMiddlewaresParams.map((x) => x.request),
+        ...routeMiddlewaresParams.map((x) => x.request),
+      ],
+      query: [
+        ...controllerMiddlewaresParams.map((x) => x.query),
+        ...routeMiddlewaresParams.map((x) => x.query),
+      ],
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async validateSchema(req, validator, data) {
+    if (!validator) {
+      return {};
+    }
+
+    await validator.validateFields(data, req);
+
+    return validator.castFields(data, req);
+  }
+
+  async validateArrayOfSchemas(req, validators, data) {
+    const result = [];
+
+    for (const validator of validators) {
+      const formatedValidator = this.constructor.getDriverByValidatorBody(
+        this.app,
+        validator,
+      );
+      result.push(this.validateSchema(req, formatedValidator, data));
+    }
+
+    return Promise.all(result);
+  }
+
+  /**
+   * Validate req data. For example req.body, req.query
+   */
+  async validateReqData(req, options) {
+    const { selectedReqData, additionalMiddlewareFieldsData } = options;
+    const {
+      middlewaresInfo,
+      routeMiddlewaresReg,
+      options: routeOptions,
+    } = additionalMiddlewareFieldsData;
+
+    let validatedFields = await this.validateSchema(
+      req,
+      this.validator,
+      selectedReqData,
+    );
+    const additionalMiddlewareSchemas = this.constructor.getMiddlewareParams(
+      middlewaresInfo,
+      routeMiddlewaresReg,
+      routeOptions,
+    )[routeOptions.prefix];
+
+    if (additionalMiddlewareSchemas.length) {
+      const middlewareValidatedFields = await this.validateArrayOfSchemas(
+        req,
+        additionalMiddlewareSchemas,
+        selectedReqData,
+      );
+
+      validatedFields = Object.assign(
+        {},
+        validatedFields,
+        ...middlewareValidatedFields,
+      );
+    }
+
+    return validatedFields;
+  }
+}
+
+module.exports = ValidateService;

package/services/validate/ValidateService.test.js

@@ -0,0 +1,105 @@
+const yup = require('yup');
+const ValidateService = require('./ValidateService');
+const YupValidator = require('./drivers/YupValidator');
+const CustomValidator = require('./drivers/CustomValidator');
+
+describe('validate service', () => {
+  describe('validateSchema funtion', () => {
+    const data = {
+      name: '1213123123',
+    };
+    const req = {};
+
+    it('returns an empty object if no validator is provided', async () => {
+      expect.assertions(1);
+      const result = await new ValidateService(
+        global.server.app,
+        new YupValidator(
+          global.server.app,
+          yup.object().shape({ name: '123' }),
+        ),
+      ).validateSchema(req, undefined, data);
+      expect(result).toStrictEqual({});
+    });
+
+    it('calls validateFields and castFields if validator is provided', async () => {
+      expect.assertions(1);
+      const validator = new YupValidator(
+        global.server.app,
+        yup.object().shape({ name: yup.string() }),
+      );
+      const result = await new ValidateService(
+        global.server.app,
+        {},
+      ).validateSchema(req, validator, data);
+      expect(result).toStrictEqual({
+        name: '1213123123',
+      });
+    });
+  });
+
+  describe('isValidatorExists funtion', () => {
+    it('returns false for non-object input', () => {
+      expect.assertions(1);
+      const validator = 'not an object';
+      const result = ValidateService.isValidatorExists(validator);
+      expect(result).toBe(false);
+    });
+
+    it('returns true if validator is an instance of one of the drivers', () => {
+      expect.assertions(1);
+      const validator = new ValidateService.drivers.YupValidator();
+      const result = ValidateService.isValidatorExists(validator);
+      expect(result).toBe(true);
+    });
+
+    it('returns false if validator is not an instance of any of the drivers', () => {
+      expect.assertions(1);
+      const validator = {};
+      const result = ValidateService.isValidatorExists(validator);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getDriverByValidatorBody', () => {
+    it('should return the body if it is already a validator', () => {
+      expect.assertions(1);
+      const body = new YupValidator(
+        global.server.app,
+        yup.object().shape({ name: yup.string() }),
+      );
+
+      const validator = ValidateService.getDriverByValidatorBody(
+        global.server.app,
+        body,
+      );
+
+      expect(validator).toStrictEqual(body);
+    });
+
+    it('should return a YupValidator instance if the body is a Yup schema', () => {
+      expect.assertions(1);
+      const body = yup.object().shape({
+        name: '1234',
+      });
+
+      const validator = ValidateService.getDriverByValidatorBody(
+        global.server.app,
+        body,
+      );
+
+      expect(validator).toBeInstanceOf(YupValidator);
+    });
+
+    it('should return CustomValidator if the body is neither a validator nor a Yup schema', () => {
+      expect.assertions(1);
+      const body = 'string';
+      const validator = ValidateService.getDriverByValidatorBody(
+        global.server.app,
+        body,
+      );
+
+      expect(validator).toBeInstanceOf(CustomValidator);
+    });
+  });
+});

package/services/validate/drivers/AbstractValidator.js

@@ -0,0 +1,37 @@
+const Base = require('../../../modules/Base');
+
+class AbstractValidator extends Base {
+  constructor(app, body) {
+    super(app);
+    this.body = body;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  static convertFieldsToJson(fields) {
+    // IMPLENT;
+    return {};
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get fieldsInJsonFormat() {
+    // IMPLENT;
+    return {};
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async validateFields() {
+    // IMPLENT;
+    return true;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async castFields() {
+    // IMPLENT;
+    return true;
+  }
+
+  static get loggerGroup() {
+    return 'AbstractValidator_';
+  }
+}
+module.exports = AbstractValidator;

package/services/validate/drivers/CustomValidator.js

@@ -0,0 +1,52 @@
+const yup = require('yup');
+
+const AbstractValidator = require('./AbstractValidator');
+
+class CustomValidator extends AbstractValidator {
+  async validateFields(data, { query, body, appInfo }) {
+    if (this.body) {
+      if (typeof this.body.validate !== 'function') {
+        this.logger.error('request.validate should be a function');
+      }
+    }
+    try {
+      await this.body.validate(data, {
+        req: {
+          query,
+          body,
+          appInfo,
+        },
+      });
+    } catch (e) {
+      this.logger.warn(`CustomValidator validateFields ${e}`);
+      if (e.path) {
+        throw new yup.ValidationError({
+          [e.path]: e.message,
+        });
+      }
+      throw new Error(e);
+    }
+  }
+
+  async castFields(data, { query, body, appInfo }) {
+    if (this.body) {
+      if (typeof this.body.cast !== 'function') {
+        this.logger.error('request.validate should be a function');
+      }
+    }
+
+    return this.body.cast(data, {
+      req: {
+        query,
+        body,
+        appInfo,
+      },
+    });
+  }
+
+  static get loggerGroup() {
+    return 'CustomValidator_';
+  }
+}
+
+module.exports = CustomValidator;