@akrdevtech/lib-express-joi-validation-middleware/dist/lib/ValidatorBase.js

Joi based validation middleware for ExpressJS

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAll = exports.validateQuery = exports.validateParams = exports.validateHeaders = exports.validateCookies = exports.validateBody = void 0;
const RequestValidationMiddlewareError_1 = require("./errors/RequestValidationMiddlewareError");
const commonValidatorOptions = { abortEarly: false };
/**
  * Function to get request body validation errors
  * @param validatorSchema Joi.ObjectSchema
  * @param body Express request body
  * @param joiValidationOptions Joi.ValidationOptions
  * @returns Joi.ValidationError | undefined
  */
const getBodyValidationErrors = (validatorSchema, body, joiValidationOptions) => {
    return validatorSchema.validate(body, joiValidationOptions).error;
};
/**
 * Middleware to validate request body
 * @param validatorSchema Joi validatorSchema of the request body
 * @param joiValidationOptions Joi.ValidationOptions
 */
const validateBody = (validatorSchema, joiValidationOptions) => (req, _res, next) => {
    const { body } = req;
    const validationErrors = getBodyValidationErrors(validatorSchema, body, { ...commonValidatorOptions, ...joiValidationOptions });
    const err = {
        body: validationErrors
    };
    if (validationErrors) {
        return next(new RequestValidationMiddlewareError_1.RequestValidationMiddlewareError(err));
    }
    next();
};
exports.validateBody = validateBody;
/**
  * Function to get request cookies validation errors
  * @param validatorSchema Joi.ObjectSchema
  * @param cookies Express request cookies
  * @param joiValidationOptions Joi.ValidationOptions
  * @returns Joi.ValidationError | undefined
  */
const getCookiesValidationErrors = (validatorSchema, cookies, joiValidationOptions) => {
    return validatorSchema.validate(cookies, joiValidationOptions).error;
};
/**
 * Middleware to validate request cookies
 * @param validatorSchema Joi validatorSchema of the request cookies
 * @param joiValidationOptions Joi.ValidationOptions
 */
const validateCookies = (validatorSchema, joiValidationOptions) => (req, _res, next) => {
    const { cookies } = req;
    const validationErrors = getCookiesValidationErrors(validatorSchema, cookies, { ...commonValidatorOptions, ...joiValidationOptions });
    const err = {
        cookies: validationErrors
    };
    if (validationErrors) {
        return next(new RequestValidationMiddlewareError_1.RequestValidationMiddlewareError(err));
    }
    next();
};
exports.validateCookies = validateCookies;
/**
  * Function to get request headers validation errors
  * @param validatorSchema Joi.ObjectSchema
  * @param headers Express request headers
  * @param joiValidationOptions Joi.ValidationOptions
  * @returns Joi.ValidationError | undefined
  */
const getHeadersValidationErrors = (validatorSchema, headers, joiValidationOptions) => {
    return validatorSchema.validate(headers, joiValidationOptions).error;
};
/**
 * Middleware to validate request headers
 * @param validatorSchema Joi validatorSchema of the request headers
 * @param joiValidationOptions Joi.ValidationOptions
 */
const validateHeaders = (validatorSchema, joiValidationOptions) => (req, _res, next) => {
    const { headers } = req;
    const validationErrors = getHeadersValidationErrors(validatorSchema, headers, { ...commonValidatorOptions, ...joiValidationOptions });
    const err = {
        headers: validationErrors
    };
    if (validationErrors) {
        return next(new RequestValidationMiddlewareError_1.RequestValidationMiddlewareError(err));
    }
    next();
};
exports.validateHeaders = validateHeaders;
/**
  * Function to get request params validation errors
  * @param validatorSchema Joi.ObjectSchema
  * @param params Express request params
  * @param joiValidationOptions Joi.ValidationOptions
  * @returns Joi.ValidationError | undefined
  */
const getParamsValidationErrors = (validatorSchema, params, joiValidationOptions) => {
    return validatorSchema.validate(params, joiValidationOptions).error;
};
/**
 * Middleware to validate request params
 * @param validatorSchema Joi validatorSchema of the request params
 * @param joiValidationOptions Joi.ValidationOptions
 */
const validateParams = (validatorSchema, joiValidationOptions) => (req, _res, next) => {
    const { params } = req;
    const validationErrors = getParamsValidationErrors(validatorSchema, params, { ...commonValidatorOptions, ...joiValidationOptions });
    const err = {
        params: validationErrors
    };
    if (validationErrors) {
        return next(new RequestValidationMiddlewareError_1.RequestValidationMiddlewareError(err));
    }
    next();
};
exports.validateParams = validateParams;
/**
  * Function to get request query validation errors
  * @param validatorSchema Joi.ObjectSchema
  * @param query Express request query
  * @param joiValidationOptions Joi.ValidationOptions
  * @returns Joi.ValidationError | undefined
  */
const getQueryValidationErrors = (validatorSchema, query, joiValidationOptions) => {
    return validatorSchema.validate(query, joiValidationOptions).error;
};
/**
 * Middleware to validate request query
 * @param validatorSchema Joi validatorSchema of the request query
 * @param joiValidationOptions Joi.ValidationOptions
 */
const validateQuery = (validatorSchema, joiValidationOptions) => (req, _res, next) => {
    const { query } = req;
    const validationErrors = getQueryValidationErrors(validatorSchema, query, { ...commonValidatorOptions, ...joiValidationOptions });
    const err = {
        query: validationErrors
    };
    if (validationErrors) {
        return next(new RequestValidationMiddlewareError_1.RequestValidationMiddlewareError(err));
    }
    next();
};
exports.validateQuery = validateQuery;
/**
   * Function to get request validation errors
   * @param validatorSchema Joi.ObjectSchema
   * @param request Express request
   * @param joiValidationOptions Joi.ValidationOptions
   * @returns Joi.ValidationError | undefined
   */
const getAllValidationErrors = (validatorSchema, request, joiValidationOptions) => {
    var _a, _b, _c, _d, _e;
    const validateAllResponse = {
        body: (_a = validatorSchema.body) === null || _a === void 0 ? void 0 : _a.validate(request.body, joiValidationOptions).error,
        cookies: (_b = validatorSchema.cookies) === null || _b === void 0 ? void 0 : _b.validate(request.cookies, joiValidationOptions).error,
        headers: (_c = validatorSchema.headers) === null || _c === void 0 ? void 0 : _c.validate(request.headers, joiValidationOptions).error,
        params: (_d = validatorSchema.params) === null || _d === void 0 ? void 0 : _d.validate(request.params, joiValidationOptions).error,
        query: (_e = validatorSchema.query) === null || _e === void 0 ? void 0 : _e.validate(request.query, joiValidationOptions).error,
    };
    if (validateAllResponse.body
        || validateAllResponse.cookies
        || validateAllResponse.headers
        || validateAllResponse.params
        || validateAllResponse.query) {
        return validateAllResponse;
    }
    return undefined;
};
/**
  * Function to validate request [body,query,params,headers,cookies]
  * @param validatorSchema IValidateAllSchema
  * @param joiValidationOptions Joi.ValidationOptions
  */
const validateAll = (validatorSchema, joiValidationOptions) => (req, res, next) => {
    const validateAllResponse = getAllValidationErrors(validatorSchema, req, joiValidationOptions);
    if (validateAllResponse) {
        return next(new RequestValidationMiddlewareError_1.RequestValidationMiddlewareError(validateAllResponse));
    }
    return next();
};
exports.validateAll = validateAll;