Expressjs-field-validator NPM

expressjs-field-validator

Request field validator for expressjs

Installation

$ npm install expressjs-field-validator

How To Use

 const { 
  validateBody,
  validateParam,
  validateQuery,
  param,
} = require('expressjs-field-validator');

router.post('/users/:id',
validateParam().addParams([
  param('id').isNumber().end()
]).done(),
validateBody().addParams([
  param('userId').isNumber().end()
]).done(),
validateQuery().addParams([
  param('userName').isRequired().end()
]).done(),
validateHeader().addParams([
  param('Authorization').isRequired().end()
]).done(),
(req, res, next) => {

  // Main Service Here

});

Getting Started

Defining a Field

Use param(<field Name>) to define a field. It should end with end()

param('userName').isRequired().end()

Defines a field userName which is mandatory.

Available Options

isRequired()

Field is mandatory

isArray()

Expects array

isObject()

Expects object

isNumber()

Expects number

isEmail()

Expects email

isBoolean()

Expects boolean value

isDate()

Expects a date with default format YYYY-MM-DD

dateFormat(format)

format Mandatory String specify date format, supported

YYYY-MM-DD
DD-MM-YYYY
MM-DD-YYYY
YYYY/MM/DD
DD/MM/YYYY
MM/DD/YYYY

minimumNumber(min)

min Mandatory Number Expects number and must be greater than or equal to min

maximumNumber(max)

max Mandatory Number Expects number and must be less than or equal to max

minimumLength(min)

min Mandatory Number Expects number/string and length must be less than or equal to min

maximumLength(max)

max Mandatory Number Expects number/string and length must be less than or equal to max

shouldInclude(inclues)

inclues Mandatory Array Expects number/string and must be one of given array includes

shouldExclude(excludes)

excludes Mandatory Array Expects number/string and must not be one of given array excludes

isMobileNumberWithCountryCode(countryCode)

countryCode Mandatory String Expects mobile number with or without countryCode

isMobileNumberWithCountryCodeMandatory()

Expects mobile number which should starts with the country code set with isMobileNumberWithCountryCode

isMobileNumberWithMinimumLength(min)

min Mandatory Number Minimum length of mobile number without country code

isMobileNumberWithMaximumLength(max)

max Mandatory Number Maximum length of mobile number without country code

customValidator(function)

function Mandatory Function A function with arguments (value, req, error) value is the value of the field req request object error function with takes error message, should be called on error

(value, req, error) => {
  if (value !== 100) {
    error('Invalid value customValidator');
  }
}

addChild(child)

child Mandatory field definition object Add a child object for arrays and objects

addChildren(children)

children Mandatory Array of field definition objects Add a list of children objects for arrays and objects

sendErrorMessage(message)

message Mandatory String Custom message to be send back in case of validation failure

// Default message
{
    "error": [
        {
            "location": "body.sort",
            "param": "sort",
            "message": "Invalid Field Error"
        }
    ]
}
// Custom message
{
    "error": [
        {
            "location": "body.sort",
            "param": "sort",
            "message": "<Your Custom Error Message>"
        }
    ]
}

end() :bangbang::bangbang: Mandatory

Ends a param definition

Creating a validation middleware

validateBody() Validate body
validateParam() Validate param
validateQuery() Validate query
validateHeader() Validate header

Available Options

isToBeRejected()

Defines the validation failure event - Server returns http status code set via sendErrorCode (default 422), :heavy_exclamation_mark: will not proceed to the next middleware Response body

{
    "error": [
        {
            "location": "body.sort",
            "param": "sort",
            "message": "Invalid Field Error"
        }
    ]
}

isToBeForwarded()

Defines the validation failure event - Error is set to request.locals.data and error code to request.locals.statusCode, :white_check_mark: will proceed to the next middleware Error object Response body

{
    "error": [
        {
            "location": "body.sort",
            "param": "sort",
            "message": "Invalid Field Error"
        }
    ]
}

checkService

  const { checkService } = require('expressjs-field-validator');

Pass middleware to checkService, which must be skipped if isToBeForwarded enabled and validation errors are found

router.get('/users/:id',
validateBody().isToBeForwarded().sendErrorCode(500).debug(false).addParams([
  param('id').isRequired().isNumber().end()
]).done(),
checkService((req, res, next) => {

  // This middleware is skipped if id is empty or not a number
  
}),
(req, res, next) => {

  // This middleware Will not be skipped, error data will be availble here - req.locals.data and status code - request.locals.statusCode here 
  
});

skipService

manually invoke forward mode, if this is set from any middleware, the middlewares wrapped inside checkService won't be executed

 const { skipService } = require('expressjs-field-validator');

router.get('/users/:id',
(req, res, next) => {

  skipService(req, 'SOME-ERROR');
  next();
  
}),
 
checkService((req, res, next) => {

  // This middleware is skipped
  
}),
(req, res, next) => {

  // This middleware Will not be skipped, error data will be availble here - req.locals.data and status code - request.locals.statusCode here 
  
});

sendErrorCode(errorCode)

errorCode Mandatory Error code which should be rejected

debug(isDebugEnabled)

isDebugEnabled Mandatory Pass true for development environments, the error object will contain more details about error Error object

{
    "error": [
        {
            "location": "body.sort",
            "param": "sort",
            "message": "Invalid Field Error :: somevalueforsort Must Be A Boolean" // More details on error
        }
    ]
}

addParams(paramList)

paramList Mandatory Array of field definition objects

validateBody().addParams([
  // Add List of definition here
  param('field1').isRequired().end(),
]).done()

Definintion of a field here : Defining a Field

done() :bangbang::bangbang: Mandatory

Ends a validation definition

Dealing with nested objects

Request body

{
  "field1": "Value", // String, Mandatory
  "field2": [ // array, Mandatory
    { "field21": "44443" }, // object Optional, number mandatory
    { "field21": "44443" }
  ],
  "field3": { // Object Optional
    "field31": "true", // Boolean Mandatory
    "field32": "String" // String Mandatory
  },
  "field4": [ // array, Mandatory
    123, 445, 3434 // Number Optional
  ],
}

Should send http status code 500 in case of error

Validation

router.post('/users/:id',
validateBody().isToBeRejected().sendErrorCode(500).addParams([
  param('field1').isRequired().end(), // Use end() to end a definition
  param('field2').isRequired().isArray().isRequired().addChild(
    param('field2-array').isObject().addChild( // field2-array is for tracking, you can give any name here
      param('field21').isNumber().isRequired().end()
    ).end()
  ).end(),
  param('field3').isObject().addChildren([
    param('field31').isBoolean().isRequired().end(),
    param('field32').isRequired().end()
  ]).end(),
  param('field4').isRequired().isArray().isRequired().addChild(
    param('field4-array').isNumber().end()
  ).end(),
]).done(), // Use done() to end a validation
validateParam().isToBeRejected().sendErrorCode(500).addParams([
  param('field1').isRequired().end(), // Use end() to end a definition
]).done(), // Use done() to end a validation
// define validateQuery(), 
// define validateHeader(),
(req, res, next) => {

  // Main Service Here

});