path: courses/express-node/joi.md

- **fileName**: joi
- **Created on**: 2024-08-19 19:07:00

looking for joi validator for express js installation npm i joi

Code Example:

import express from "express";
import Joi from "joi";

const app = express();
app.use(express.json())


// starting creating schema using joi
const schemaSaveRoute = Joi.object({ // this is the schema for the user
    username: Joi.string().required().min(3).max(30).alphanum(),
    age: Joi.number().required()
})


app.get("/", (req, res) => {
    res.status(200).json({ massage: "welcome from yossef "});
});

app.post("/save", (req, res) => {
    const result = schemaSaveRoute.validate(req.body); // check for error if found return them 
    console.log(result);
    if(result.error) { // check if there any error return the error
        return res.status(400).json({ errors : Array(result.error.details)})
    }
    return res.status(200).json({massage: "has access to the end point"});
})


app.listen(3000, () => {
    console.log("runinng in port:", 3000)
})

- const result = schemaSaveRoute.validate(req.body); // check for error if found return them
- so what this line do every schema from Joi have and function called validate and gave req.body as param for the funciton now the function get the req body and checck for the schema if match return the value only like this

{ value: { username: 'yossef', age: 2342 } } // this is the output from the console

- else if found an error show this console

{
  value: { username: 'yossef' },
  error: [Error [ValidationError]: "age" is required] {
    _original: { username: 'yossef' },
    details: [ [Object] ]
  }
}

using for advanced way

import joi from 'joi';
import { generalFields } from '../../Utlis/GeneralFields.js';



export const updateUserScehma = joi.object({
    name:joi.string().min(2).max(50),
    phone: generalFields.phone,
    headline:joi.string().min(3).max(100),
    gender:joi.string()
}).required()



export const recoverUserScehma = joi.object({
    token:generalFields.token
}).required()

1
export const acceptconnectionScehma = joi.object({
    userId:generalFields.id,
    connection:joi.string().valid('accept','reject')
}).required()


// general fields
import joi from "joi";
import { Types } from "mongoose";

// check if the value is a valid ObjectId
const checkObjectId = (value, helper) => {
  return Types.ObjectId.isValid(value)
    ? true
    : helper.message("Invalid ObjectId");
};

// General Fields for the application
export const generalFields = {
  name: joi.string().required(),
  description: joi.string().required(),
  id: joi.string().custom(checkObjectId).required(),
  gender:joi.string().valid('male','female'),
  email: joi
    .string()
    .email({ minDomainSegments: 2, tlds: { allow: ["com", "net"] } })
    .required(),
  password: joi
    .string()
    .pattern(/^\w{8,}$/)
    .messages({ "string.pattern.base": "Password length should be atleast 8" })
    .required(),
  confirmPassword: joi
    .string()
    .required()
    .messages({ "any.only": "confirm password not matching new password" }),
  age: joi.number().integer().required(),
  phone: joi
    .string()
    .pattern(/^(\+2)?01[0125][0-9]{8}$/)
    .messages({ "string.pattern.base": "please Enter a valid phone Number" })
};

adding validation(schema) give it the schema and check for param and query and body and file for all checks for the validation

/** 
 * @param {object} schema - Joi schema object
 * @return {function} Middleware for the next function
 * description: Middleware to validate the inputs
 * */
const validation = (schema) => {
    return (req,res,next)=>{
        // indestruct the inputs
        const inputs = {...req.body,...req.params,...req.query}
        if(req.file || req.files)
        {
            inputs.file = req.file || req.files
        }
        // abortearly false to return all the errors
        const validationResult = schema.validate(inputs,{abortEarly:false})

        // check if there is errors
        if(validationResult.error)
        {
            return res.status(409).json({status:'failed',errors:validationResult.error.details.map(err=>err.message)})
        }
        return next()
    }
}
export default validation;

using with end point

import validation from "./validation.mjs" // adding the validation function for all checks for validate
import userSchema from "./UserSchema.mjs"

app.post("/save", validation(userSchema),(req, res) => {
    return res.status(200).json({massage: "has access to the end point"});
})

now how this works first there is afunction for validation its work for all query, body, param check for all second call the function for validate the build in any schema joi and give the inputs{ req.body, req.query, req.param} any one from this and after this gone check for the inputs and the validateScame if match then very thing is good else gone return a error object insdie the validationResult after this return error massage and return the error in validateResult.error and done else don't return any error object that mean that the schema i equl to the inputs and passing and going for the next middleware if found

option in joi:

continue:[[]]
before:jwt.md