@adaptivestone/framework 3.4.3 → 4.1.0

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;

package/services/validate/drivers/YupValidator.js

@@ -0,0 +1,103 @@
+const yup = require('yup');
+const AbstractValidator = require('./AbstractValidator');
+
+class YupValidator extends AbstractValidator {
+  get fieldsInJsonFormat() {
+    return this.constructor.convertFieldsToJson(this.body);
+  }
+
+  static convertFieldsToJson(fields) {
+    const convertedFields = {};
+    const entries = Object.entries(fields.describe().fields);
+
+    if (!entries?.length) {
+      return convertedFields;
+    }
+    const requiredFields = [];
+
+    for (const [field, fieldProp] of entries) {
+      const isRequired = fieldProp?.tests?.find(
+        (prop) => prop.name === 'required',
+      );
+      if (isRequired) {
+        requiredFields.push(field);
+      }
+    }
+
+    entries.forEach(([key, value]) => {
+      if (!convertedFields[key]) {
+        convertedFields[key] = {};
+      }
+
+      convertedFields[key] = {
+        type: value.type,
+        required: requiredFields?.includes(key),
+      };
+    });
+
+    return convertedFields;
+  }
+
+  async validateFields(data, { query, body, appInfo }) {
+    const yupSchema = this.body;
+    const { controllerValidationAbortEarly } = this.app.getConfig('validate');
+    if (yupSchema) {
+      if (typeof yupSchema.validate !== 'function') {
+        this.logger.error('request.validate should be a function');
+      }
+    }
+
+    try {
+      await yupSchema.validate(data, {
+        abortEarly: controllerValidationAbortEarly,
+        req: { query, body },
+      });
+    } catch (e) {
+      let { errors } = e;
+      // translate it
+      if (appInfo.i18n && errors) {
+        errors = errors.map((err) => appInfo.i18n.t(err, err));
+      }
+      this.logger.error(
+        `Request validation failed with message: ${e.message}. errors: ${errors}`,
+      );
+
+      const errorAnswer = {};
+      if (!e.inner || !e.inner.length) {
+        errorAnswer[e.path] = errors;
+      } else {
+        e.inner.forEach((err) => {
+          errorAnswer[err.path] = err.errors;
+          if (appInfo.i18n && err.errors) {
+            errorAnswer[err.path] = err.errors.map((err1) =>
+              appInfo.i18n.t(err1, err1, err.params),
+            );
+          }
+        });
+      }
+
+      throw new yup.ValidationError({
+        ...errorAnswer,
+      });
+    }
+  }
+
+  async castFields(data, { query, body }) {
+    const yupSchema = this.body;
+    if (yupSchema) {
+      if (typeof yupSchema.cast !== 'function') {
+        this.logger.error('request.cast should be a function');
+      }
+    }
+
+    return yupSchema.cast(data, {
+      stripUnknown: true,
+      req: { query, body },
+    });
+  }
+
+  static get loggerGroup() {
+    return 'YupValidator_';
+  }
+}
+module.exports = YupValidator;

package/tests/setup.js

@@ -56,7 +56,9 @@ beforeAll(async () => {
         nick: 'testUserNickName',
       },
     }).catch((e) => {
+      // eslint-disable-next-line no-console
       console.error(e);
+      // eslint-disable-next-line no-console
       console.info(
         'That error can happens in case you have custom user model. Please use global.testSetup.disableUserCreate flag to skip user creating',
       );

package/services/messaging/email/templates/password/html.handlebars

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>{{t('email.newPassword')}}</title>
-</head>
-<body>
-    <h1>{{t('email.greeating')}} {{username}}</h1>
-    <p>Ваш новый пароль <b>{{password}}</b> <br>
-        не забудьте его поменять в личном кабинете. <br>
-        <a href="http://{{realm}}.localhost:3000/#/login">Войти на сайт</a></p>
-</body>
-</html>

package/services/messaging/email/templates/password/subject.handlebars

@@ -1 +0,0 @@
-Новый пароль

package/services/messaging/email/templates/password/text.handlebars

@@ -1 +0,0 @@
-Добрый день {{username}}Для создание нового пароля перейдите по ссылке {{link}}