base-common-utils/validation/SchemaValidation.js

var Ajv = require('ajv');
var ajv = new Ajv({ v5: true, $data: true, allErrors: true, jsonPointers: true });
// Ajv options allErrors and jsonPointers are required
require('ajv-keywords')(ajv /*, {singleError: true} */);
require('ajv-errors')(ajv);
const coreUtils = require('../CoreUtils');
const sendResponse = require('../exception/SendResponse');
 
validateRequest = (schema,dto) => {
    const log = require('../index').Logger;
    var validate = ajv.compile(schema);
    var valid = validate(dto);
    if (!valid) {
        // log.error('dto validation failed');
        let validationResponse = validate.errors; // processed errors
        log.error('raw dto errors:: ' + JSON.stringify(validationResponse));
        let customErrorResponse= createErrorResponse(validationResponse);
        return sendResponse.validationException(customErrorResponse);
    } else {
      log.debug('dto validation passed');
      return null;
    } 
}  

createErrorResponse = (validationResponse) => {
    var errors = [];
    var error;
    //console.info('createErrorResponse:' + JSON.stringify(validationResponse));
    validationResponse.forEach(function (errorRow) {
      if (errorRow.dataPath) {
        if (errorRow.keyword === 'required') {
          let property = errorRow.params.missingProperty
          error = {
            "message": "Key_" + coreUtils.convertUCfirst(property) + "CannotBeBlank",
            "field": errorRow.dataPath + "/"+ property
          }
        } else {
        error = {
          "message": errorRow.message,
          "field": errorRow.dataPath.slice(1)
        }
        }

        errors.push(error);
      } else {
        let internalErrorRow = errorRow; 
          if (internalErrorRow.keyword === 'dependencies') {
            let firstProperty = internalErrorRow.params.property
            let secondProperty = internalErrorRow.params.missingProperty
            error = {
              "message": "Key_" + coreUtils.convertUCfirst(firstProperty) +
                "And" + coreUtils.convertUCfirst(secondProperty) + "NotToBeEmpty",
              "field": firstProperty + "," + secondProperty
            }
           
          }
          if (internalErrorRow.keyword === 'required') {
            let property = internalErrorRow.params.missingProperty
            error = {
              "message": "Key_" + coreUtils.convertUCfirst(property) + "CannotBeBlank",
              "field": property
            }
          }
          if (internalErrorRow.keyword === 'additionalProperties') {
            let property = internalErrorRow.params.additionalProperty
            error = {
              "message": "Key_" + coreUtils.convertUCfirst(property) + "isNotRequired",
              "field": property
            }
          }
          errors.push(error);
      }
    });
    return errors;
  }
module.exports = {
    validateRequest
  }