expressjs-field-validator

Request field validator for expressjs

• Installation
• How To Use
• Getting Started
  • Defining a Field
    • Available Options
      • isRequired()
      • isArray()
      • isObject()
      • isNumber()
      • isEmail()
      • isBoolean()
      • isDate()
      • dateFormat(format)
      • minimumNumber(min)
      • maximumNumber(max)
      • minimumLength(min)
      • maximumLength(max)
      • shouldInclude(inclues)
      • shouldExclude(excludes)
      • isMobileNumberWithCountryCode(countryCode)
      • isMobileNumberWithCountryCodeMandatory()
      • isMobileNumberWithMinimumLength(min)
      • isMobileNumberWithMaximumLength(max)
      • addChild(child)
      • addChildren(children)
      • sendErrorMessage(message)
      • end() :bangbang::bangbang: Mandatory
  • Creating a validation middleware
    • Available Options
      • isToBeRejected()
      • isToBeForwarded()
        • checkService
        • skipService
      • sendErrorCode(errorCode)
      • debug(isDebugEnabled)
      • addParams(paramList)
      • done() :bangbang::bangbang: Mandatory
• Dealing with nested objects
  • Request body
  • Validation

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

  ```js 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

}); ```