How to use express-validator - 10 common examples

});
    }).catch((err) => {
      console.log("Post Category error:", err);
    });
  });

  /**********************************************
  /
  / Add a new Post
  /
  / Second parameter an array of validations
  /
  /*********************************************/
  app.post('/posts/new', [
    check('postTitle', 'Title must not be empty').isLength({ min: 1 }),
    check('postContent', "Don't you want to include some content?").isLength({ min: 1 })
  ], (req, res) => {
    // Check user redirect if not logged in
    const currentUser = req.user;
    let loggedin = "";

    if (currentUser === null) {
      return res.redirect('/login');
    } else {
      loggedin = "loggedin";
    }

    // Validate this request
    const errors = validationResult(req); // Validate the req obj

    // Check for errors
    if (!errors.isEmpty()) {

const user = await User.findById(req.user.id).select('-password');
    res.json(user);
  } catch (err) {
    console.error(err.message);
    res.status(500).send('Server Error');
  }
});

// @route    POST api/auth
// @desc     Authenticate user & get token
// @access   Public
router.post(
  '/',
  [
    check('email', 'Please include a valid email').isEmail(),
    check('password', 'Password is required').exists()
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { email, password } = req.body;

    try {
      let user = await User.findOne({ email });

      if (!user) {
        return res
          .status(400)
          .json({ errors: [{ msg: 'Invalid Credentials' }] });

filename(req, file, cb) {
    cb(null, `${uuidV4()}.${file.mimetype.split('/')[1]}`);
  },
});

const upload = multer({
  storage,
  limits: {
    fileSize: 10 * 1024 * 1024, // 10 MiB
  },
});

router.get(
  '/:descriptionArticleTitle',
  [
    param('descriptionArticleTitle')
      .trim()
      .custom(v => Article.validateTitle(v)),
  ],
  [
    sanitizeParam('descriptionArticleTitle').trim(),
  ],
  middlewares.validate(),
  async (req, res, next) => {
    try {
      const mediaFile = await MediaFile.findOne({
        include: [{
          association: MediaFile.associations.descriptionArticle,
          where: {
            namespaceId: Namespace.Known.FILE.id,
            title: req.params.descriptionArticleTitle,
          },

var app = express(opts)
var server

// Instantiate Singleton Manager (which lists all blog files)
Manager.instance.init()
app.set('config', config.getConfigByWebsite())

app.use(flash())
app.use(cookieParser())
app.use(passport.initialize())
app.use(passport.session())
app.use(
  bodyParser.urlencoded({limit: '1gb', extended: true, parameterLimit: 50000})
)
app.use(expressValidator())
app.use(csrf({cookie: {secure: config.cookie.secure}}))
app.use(function(req, res, next) {
  if (req.url.indexOf('/abe/') > -1) {
    res.locals._csrf = req.csrfToken()
  }
  next()
})

app.use(bodyParser.json({limit: '1gb'}))

if (config.security === true) {
  app.use(helmet())
  app.use(
    helmet.csp({
      directives: {
        defaultSrc: ["'self'"],

deleteServiceInstance() {
        return [
            param('instance_id', 'Missing instance_id').exists(),
            query('service_id', 'Missing service_id').exists(),
            query('plan_id', 'Missing plan_id').exists(),
                (request, response, next) => {
                const errors = validationResult(request);
                if (!errors.isEmpty()) {
                    this.sendJSONResponse(response, 400, { error: JSON.stringify(errors) });
                    return;
                }

                // Validate serviceId and planId
                var plan = this.serviceBroker.getPlanForService(request.query.service_id, request.query.plan_id);
                if (!plan) {
                    // Just throw a warning in case the broker was restarted so the IDs changed
                    console.warn('Could not find service %s, plan %s', request.query.service_id, request.query.plan_id);
                }

// Register Action
  app.post(
    '/api/users/register',
    [
      check('login')
        .isInt()
        .exists()
        .isLength({ max: 20 }),
      check('password')
        .exists()
        .isLength({ max: 255 }),
      check('name')
        .exists()
        .isString()
        .isLength({ max: 255 }),
      check('surname')
        .exists()
        .isString()
        .isLength({ max: 255 }),
      check('email')
        .exists()
        .isEmail()
        .isLength({ max: 255 }),
    ],
    users.register,
  );

  // Login Action
  app.post(
    '/api/users/login',
    [
      check('login')

title: 'Add new user',
                profile: {},
                page: 'users',
                admin: admin,
                csrfToken: req.csrfToken()
            });
        } else {
            req.flash('error', 'Only administrators can add new users');
            res.render('blank');
        }
    }
});

// Register or update an user
protected.post('/profile/:id(' + conf.usernameRegex + ')?', csrfProtection, [
    check('name')
        .trim()
        .isLength({
        min: 2,
        max: undefined
    })
        .withMessage('Name too short')
        .isLength({
        min: 0,
        max: 64
    })
        .withMessage('Name too long'),
    check('emoji')
        .trim()
        .isLength({
        min: 0,
        max: 8

transactions.getSenderdata,
  );

  // Return Sender's Authorization Key Actions
  app.post(
    '/api/transactions/authorizationKey',
    checkAuth,
    checkToken,
    [
      check('id_sender')
        .exists()
        .isInt(),
      check('recipient_id')
        .exists()
        .isInt(),
      check('amount_money')
        .isNumeric()
        .exists(),
      check('transfer_title')
        .exists()
        .isString()
        .isLength({ max: 35 }),
    ],
    transactions.getAuthorizationKey,
  );
};

const jwt = require('jsonwebtoken');
const config = require('config');
const { check, validationResult } = require('express-validator/check');

const User = require('../../models/User');

// @route    POST api/users
// @desc     Register user
// @access   Public
router.post(
  '/',
  [
    check('name', 'Name is required')
      .not()
      .isEmpty(),
    check('email', 'Please include a valid email').isEmail(),
    check(
      'password',
      'Please enter a password with 6 or more characters'
    ).isLength({ min: 6 })
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { name, email, password } = req.body;

    try {
      let user = await User.findOne({ email });

/* GET Login/Registration page. */
router.get("/", function (req, res) {
    res.render("signIn", { user : req.user });
});

router.get("/register", function(req, res) {
    res.render("register", { });
});

/* Registers a user with the information received from a POST request.*/
router.post("/register", [
    check("username").not().isEmpty().withMessage("cannot be empty"),
    check("password").not().isEmpty().withMessage("cannot be empty"),
    check("email").not().isEmpty().withMessage("cannot be empty"),
    check("confirmpassword").not().isEmpty().withMessage("cannot be empty"),
    check("email").isEmail().withMessage("must be a valid email address"),
    check("password", "passwords must be at least 5 characters long and contain one number")
        .isLength({ min: 5 })
        .matches(/\d/),
    check("confirmpassword").custom((value, { req }) => value === req.body.password).withMessage("must match the password field")
],function(req, res) {

    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        const errs = errors.array()[0];
        output = errs.param + " " + errs.msg;
        return res.render("signIn", { reg:output });
    }

    let user = new User({
        username: req.body.username,
        email: req.body.email,