I am trying to verify a logged In user token in my MERN. However, I am getting "undefined" on client-side as API response.
When I hit the endpoint http://127.0.0.1:1000/api/v1/users/login in postman to login a user and this endpoint http://127.0.0.1:1000/api/v1/users/verify to verify a user's token, the token is returned.
But when I do the same in my react app, the token returns undefined. I have spent hours debugging it but unable to figure it out.
Please I need help.
Here is my React (client side) code:
axios.defaults.withCredentials = true;
function Welcome() {
const [user, setUser] = useState("");
const sendRequest = async () => {
const res = await axios
.get("http://127.0.0.1:1000/api/v1/users/verify", {
withCredentials: true,
})
.catch((err) => console.log(err));
const data = await res.data;
return data;
};
React.useEffect(() => {
sendRequest().then((response) => console.log(response.data));
}, []);
return <div>Welcome</div>;
}
Here is my login endpoint.
exports.loginUser = async (req, res) => {
const { name, password } = req.body;
let existingUser;
try {
existingUser = await User.findOne({ name: name });
} catch (err) {
return new Error(err);
}
if (!existingUser) {
return res.status(400).json({ status: "fail", message: "user not found" });
}
const isPasswordCorrect = bcrypt.compareSync(password, existingUser.password);
if (!isPasswordCorrect) {
return res
.status(400)
.json({ status: "fail", message: "invalid email or password" });
}
const token = jwt.sign({ id: existingUser._id }, process.env.JWT_SECRET, {
expiresIn: process.env.JWT_EXPIRES_IN,
});
res.cookie("jwt", token, {
path: "/",
expires: new Date(Date.now() + 1000 * 70),
httpOnly: true,
sameSite: "lax",
});
return res
.status(200)
.json({ message: "Succesfully loggedIn", user: existingUser, token });
};
Here is my verifyToken endpoint
exports.verifyToken = (req, res, next) => {
const cookies = req.headers.cookie;
const token = cookies.split("=")[1];
if (!token) {
res.status(404).json({ message: "no token found" });
}
jwt.verify(String(token), process.env.JWT_SECRET, (err, user) => {
if (err) {
return res.status(400).json({ message: "Invalid token" });
}
req.id = user.id;
});
next();
};
router.route("/verify").get(verifyToken, getUser);//endpoint
exports.getUser = async (req, res, next) => {
const userId = req.id;
let user;
try {
user = await User.findById(userId, "-password");
} catch (err) {
return new Error(err);
}
if (!user) {
return res.status(404).json({ status: "fail", message: "user not found" });
}
return res.status(200).json({ user });
};
Related
AxiosConfig.js
import axios from "axios";
import { store } from "./redux/store";
import { login, logout } from "./redux/slices/user";
const baseURL = process.env.NEXT_PUBLIC_API_URL;
axios.defaults.baseURL = baseURL;
export const axiosInstance = axios.create({
withCredentials: true,
headers: {
"Content-Type": "application/json",
"Access-Control-Allow-Origin": "*",
accept: "application/json",
},
});
axiosInstance.interceptors.request.use(
(config) => {
return config;
},
(error) => {
return Promise.reject(error);
}
);
axiosInstance.interceptors.response.use(
(response) => {
return response;
},
async (error) => {
const originalRequest = error?.config;
if (error?.response?.status === 401 && !originalRequest.sent) {
originalRequest.sent = true;
const response = await axios.get("/auth/refresh", {
withCredentials: true,
});
if (response.error.status === 403) {
store.dispatch(logout());
}
store.dispatch(login({ user: response.data.user }));
return axiosInstance(originalRequest);
}
return Promise.reject(error);
}
);
VerifyJwt.js
export const verifyToken = (req, res, next) => {
try {
const accessToken = req.cookies.accessToken;
if (!accessToken)
return res.status(403).json({
message: "Not authenticated, no token provided",
});
jwt.verify(accessToken, process.env.ACCESS_SECRET_KEY, (err, decoded) => {
if (err)
return res.status(401).json({
message: "Not logged in, invalid token",
});
req.user = decoded.id;
next();
});
} catch (e) {
res
.status(500)
.json({ message: "Something went wrong while verifying jwt" });
}
};
routes/video.js
import express from "express";
import { unAuthVerify, verifyToken } from "../middlewares/verifyJwt.js";
import {
deleteVideo,
dislikeVideo,
getVideoDetails,
getVideos,
likeVideo,
updateVideo,
uploadVideo,
} from "../controllers/videos.js";
const router = express.Router();
router.get("/", getVideos);
router.post("/", verifyToken, uploadVideo);
router.get("/:id", unAuthVerify, getVideoDetails);
router.put("/:id", verifyToken, updateVideo);
router.delete("/:id", verifyToken, deleteVideo);
router.put("/like/:id", verifyToken, likeVideo);
router.put("/dislike/:id", verifyToken, dislikeVideo);
export default router;
RefreshToken.js
export const refreshToken = async (req, res) => {
const refreshToken = req.cookies.refreshToken;
try {
if (refreshToken) {
jwt.verify(
refreshToken,
process.env.REFRESH_SECRET_KEY,
async (err, decoded) => {
if (err) {
return res.status(403).json({
message: "Invalid token/not logged in",
});
}
const accessToken = jwt.sign(
{ id: decoded.id },
process.env.ACCESS_SECRET_KEY,
{
expiresIn: "1m",
}
);
const foundUser = await db.query(
"SELECT * FROM channels WHERE id = $1",
[decoded.id]
);
if (foundUser.rows.length <= 0) {
return res.status(400).json({
message: "User/Channel not found",
});
}
const { password, ...others } = foundUser.rows[0];
if (foundUser.rows.length > 0) {
res.cookie("accessToken", accessToken, {
httpOnly: true,
secure: true,
});
return res.status(200).json({
user: others,
});
}
}
);
} else {
return res.status(403).json({
message: "Invalid token/not logged in",
});
}
} catch (e) {
console.log(e);
res.status(500).json({
message: "Something went wrong.Please try again",
});
}
};
Video.jsx
const handleLike = async (id) => {
if (!isLoggedIn) {
toast.error("You need to login to like a video");
return;
}
if (likedByMe) {
toast.success("You have already liked this video");
return;
}
try {
await axiosInstance.put(`/videos/like/${id}`);
setLikes((prev) => prev + 1);
if (likedByMe === false) {
setDisLikes((prev) => prev - 1);
}
setLikedByMe(true);
} catch (e) {
console.log("Something went wrong while liking video", e);
toast.error(e.response.data.message); //I am getting this error first and the app is
crashing and only then axios interceptors call refresh token endpoint)
}
};
I am trying to refresh token in axios interceptor and get new access token. For example, if suppose I try to dislike or like any video and my access token expires at that time, I will get 401 message that token has expired, but I thought before getting this response in client side that is happening inside catch block, axios interceptor will call refresh token since it is 404 message and the client will get new access token and then the dislike or like api request will happen again. But in my app, I am getting that error message and it's crashing the app, shouldn't axios interceptor handle it silently? That 404 aunthorized message is getting catched by catch block in client side and errors pops up
I can notice that your route is named video.js but you're sending a PUT request to videos/ (plural). Is that a typo, or that's the cause of your issue?
everyone. I'm trying to set a cookie using epress for 24 hours. Setting also works (developer tools). For example, if I now go into standby mode and return to the application, click on something that triggers a request 'load all articles of a user', then the token is undefinded and the cookie is said to be not set. How can I fix this?
In Debugger I see the access_token cookie. So this is there, but when I check 'verifyToken.js' I get an undefined.
ladeAlleArtikelEinesUsers:
const ladeAlleArtikelEinesUsers = async (artikelId) => {
try {
await axiosInstance
.post(`/artikel/finde/${artikelId}`, { withCredentials: true })
.then(async (res) => {
//TOKEN is undefined here
if (res.data.error) {
signOut(auth)
.then(() => {
dispatch(logout());
navigate("/Login");
})
.catch((error) => {
console.log(error);
});
} else {
setArtikelEinesUsers(res.data);
setOeffneArtikelEinesUsersDialog(true);
}
});
} catch (error) {
console.log(error);
}
};
verifyToken.js
export const verifyToken = (req, res, next) => {
const token = req.cookies.access_token;
console.log("TOKEN: " + token ); //UNDEFINED
if (!token) {
return res.status(200).send({
error: true,
msg: "Authentication Failed.",
});
}
jwt.verify(token, process.env.JWT, (err, user) => {
if (err) {
return res.status(200).send({
error: true,
msg: "Authentication Failed.",
});
}
req.user = user;
next();
});
};
route
router.post("/finde/:id", verifyToken, EinArtikel);
Working with a mern application. I am passing token in authorization header. The issue is whenever I use put or patch method from frontend, token is undefined. Get, Post, Delete requests are working fine. Api is working fine with postman too.
frontend action ->
export const approveClient = (id) => async (dispatch) => {
try {
const config = {
headers: {
Authorization: `${localStorage.getItem("token")}`,
},
};
dispatch({ type: adminConstants.APPROVECLIENT_REQUEST });
const res = await axios.put(`/admin/approveClient/${id}`, config);
dispatch({
type: adminConstants.APPROVECLIENT_SUCCESS,
payload: res.data,
});
} catch (error) {
dispatch({
type: adminConstants.APPROVECLIENT_FAIL,
payload: error.response.data,
});
}
};
Backend middleware function ->
const isAuthenticated = async (req, res, next) => {
try {
const token = req.headers.authorization;
if (!token) {
return res.status(401).json({ success: false, message: "Not logged in" });
}
const decoded = jwt.verify(token, process.env.JWT_SECRET);
const user = await User.findById(decoded._id);
const client = await Client.findById(decoded._id);
const admin = await Admin.findById(decoded._id);
if (user) {
req.user = user;
}
if (client) {
req.user = client;
}
if (admin) {
req.user = admin;
}
next();
} catch (error) {
res.status(500).json({ success: false, message: error.message });
}
};
Cookie is generated in API but not Cookies not being stored in the browser,
I fing some solution but it did not work for me . Can anybody answer my query .Please
This is Login route from API ROUTE
const express=require("express");
const router = express.Router();
const { body } = require('express-validator');
const { register ,login} = require("../controllers/auth");
router.post("/login",[
body('email',"Email is not valid").isEmail(),
body('password',"password must contain at least 5 characters"),
],login)
This is Controller of Login route FROM BACKEND and it is connected to login route
const cookie = require('cookie-parser')
const express = require("express");
const User = require("../models/users");
const { validationResult } = require('express-validator');
const bcryptjs = require("bcryptjs")
const jwt = require("jsonwebtoken")
const login = async (req, res, next) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({ errors: errors.array() });
}
const { password, email } = req.body
try {
let user = await User.findOne({ email });
if (!user) {
success = false
return res.status(400).json({ error: "Please try to login with correct credentials" });
}
let comparePassword = await bcryptjs.compare(password, user.password)
if (!comparePassword) {
return res.status(400).json("Incorrect Login credentials")
}
let data = {
user: {
id: user.id
}
}
let token = await jwt.sign({ data, isAdmin: user.isAdmin }, process.env.SECRET_KEY)
res.cookie("access_token", token, {
expires: new Date(Date.now() + 2589000),
httpOnly: true
});
res.status(201).json({user,token});
} catch (error) {
res.status(500).json({ status: "server error", message: error.message })
}
}
This is the middlewear of and and its for authentication and autherization of user
const jwt = require("jsonwebtoken");
const verifyToken = (req, res, next) => {
const token = req.cookies.access_token;
if (!token) {
return res.status(403).json({
status: "user not authenticated",
});
}
try {
jwt.verify(token,process.env.SECRET_KEY, (err, user) => {
if (err)
return res.json({ status: "Invalid Token", message: err.message });
req.user = user;
next();
});
} catch (error) {
res
.status(500)
.send({ status: "Internal server error", message: error.message });
}
};
I´m storing the user token in the localstorage after a user logs in, and i would like to know how i can use this token that is in the localstorage to fetch the user info.
backend login.js
module.exports.login = async (req, res) => {
const { email, password } = req.body;
try {
const user = await User.findOne({ email: email });
if (!user) return res.status(404).json({ message: "Usuário não cadastrado!" });
const isMatch = bcrypt.compare(password, user.password);
if (!isMatch) return res.status(400).json({ message: "Email e/ou senha incorretos." });
const token = tokenGenereator(user._id);
return res.status(200).json({ result: user, token });
} catch (error) {
console.log(error)
}
};
frontend login.js
export const login = (data, history) => {
return async (dispatch) => {
try {
const userData = await api.login(data);
localStorage.setItem("userToken", JSON.stringify(userData.data.token));
dispatch(
setUser({
fullname: userData.data.fullname,
email: userData.data.email,
isAuth: true,
})
);
history.push("/home");
} catch (error) {
if (error.response && error.response.data.message) {
dispatch(
setNotification({
variant: "danger",
message: error.response.data.message,
})
);
}
}
};
};
I pass the token to the backend
// i would pass the jwt to the function as a parameter
export const fetchUser = (data) => {
return async (dispatch) => {
const user = await api.getUserData(data);
console.log(user);
};
};
And i recieve
module.exports.getCurrentUser = async (req, res) => {
const { token } = req.body;
// i dont know what to do from here...
};