[E-Commerce App with REST API] (6) cookie-parser & Refresh Token으로 재발급 받기 (Access Token 차이점)

<본 블로그는 Developers Corner 의 유튜브를 참고해서 공부하며 작성하였습니다 :-)>

=> Node.js E-Commerce App with REST API: Let's Build a Real-Life Example!

 

🌷 login 시 cookie 생성하기 

Cookie 헤더를 파싱하고, 쿠키 이름에 의해 키가 지정된 객체로 req.cookies를 채움

secret 문자열을 전달하여 선택적으로 서명된(signed) 쿠키 지원을 활성화
secret 문자열은 다른 미들웨어에서 사용할 수 있도록 req.secret을 할당함

 npm i cookie-parser

 

🌷 JWT(JSON Web Token)

유저를 인증하고 식별하기 위한 토큰

토큰은 세션과는 달리 서버가 아닌 클라이언트에 저장

 

✅ Refresh token

: 새로운 access token을 재발급 받을 수 있는 유효 기간이 긴 token

: 긴 유효기간을 가지면서, Access Token이 만료됐을 때 새로 발급해주는 열쇠

 

✅ Access Token

: 인증을 위한 JWT이면서, 동시에 보안을 위해 유효기간이 매우 짧다

=> Access Token의 유효기간을 줄이고, Refresh Token이라는 새로운 토큰을 발급함으로써 해결

👀 작동 방법
1) 사용자가 로그인을 시도
2) 서버는 DB에 사용자가 저장되어 있는지 확인
3) 사용자가 존재하면 access token과 refresh token을 발급
4) 발급된 refresh token은 사용자의 id와 Token 테이블에 저장
5) 서버는 client에 access token과 refresh token을 응답
6) 사용자가 서버에 요청을 하면, 서버는 access token을 검증 후 요청한 데이터를 응답
7) Access Token이 만료된 후 사용자가 서버에 요청을 하게되면, access token의 만료됨을 응답
8) Access token의 만료를 확인한 client는 서버에 access token의 refresh를 요청
9) 서버는 만료된 access token에서 사용자의 id를 얻은 후 id로 DB에 refresh token이 유효한지 확인
10) refresh token이 유효하다면 access token을 재발급, client에 전송
11) refresh token도 만료되었다면 새로 로그인

 

 

🌷 코드

✅ controllers/userCtrl.js

const User = require("../models/User");
const bcrypt = require("bcrypt");
const asyncHandler = require("express-async-handler");
const { generateToken } = require("../config/jwtToken");
const { validateMongodbID } = require("../utils/validateMongodbID");
const { generateRefreshToken } = require("../config/refreshToken");
const jwt = require("jsonwebtoken");

// create a user
const createUser = asyncHandler(async (req, res) => {
  const { firstname, lastname, email, mobile, password } = req.body;
  const findUser = await User.findOne({ email: email });

  // email이 db에 없다면
  if (!findUser) {
    // Create a new User
    // 1) 우선 비밀번호 해쉬화(암호화)
    const hashedPassword = await bcrypt.hash(password, 10);
    // 2) 새 User 정보 만들기
    const newUser = await User.create({
      firstname, lastname, email, mobile, password: hashedPassword
    });

    res.json(newUser);
  } else {
    // User already exists
    throw new Error("User already exists");
  }
});

// login a user
const loginCheck = asyncHandler(async (req, res) => {
  const { email, password } = req.body;
  // check if user exists or not
  const findUser = await User.findOne({ email: email });

  // user 가 없다면 done
  if (!findUser) {
    throw new Error("That email is not registered!");
  }
  // Match password (기존 비밀번호와 입력한 비밀번호 체크)
  bcrypt.compare(password, findUser.password, async (err, isMatch) => {
    const refreshToken = await generateRefreshToken(findUser?._id);
    const updateUser = await User.findByIdAndUpdate(
      findUser._id, {
      refreshToken: refreshToken,
    }, {
      new: true
    }
    );
    res.cookie("refreshToken", refreshToken, {
      httpOnly: true,
      maxAge: 72 * 60 * 60 * 1000,
    });

    if (isMatch) {
      res.json({
        _id: findUser?._id,
        firstname: findUser?.firstname,
        lastname: findUser?.lastname,
        email: findUser?.email,
        mobile: findUser?.mobile,
        token: generateToken(findUser?._id)
      });
    } else {
      throw new Error("Email or Password is incorrect!");
    }
  });
});

// Handle refresh token
const handleRefreshToken = asyncHandler(async (req, res) => {
  try {
    const cookie = req.cookies;
    // refresh token 없음!
    if (!cookie?.refreshToken) {
      throw new Error("No Refresh Token in cookies");
    }
    // refresh token 생성!
    const refreshToken = cookie.refreshToken;
    const user = await User.findOne({ refreshToken });

    if (!user) {
      throw new Error("No Refresh token present in db or not matched");
    }
    // refresh token을 secret key 기반으로 생성
    jwt.verify(refreshToken, process.env.SECRET, (err, decoded) => {
      if (err || user.id !== decoded.id) {
        throw new Error("There is something wrong with refresh token");
      }
      // access Token 발급
      const accessToken = generateToken(user?._id);
      res.json({ accessToken });
    });
  } catch (error) {
    throw new Error(error);
  }
});

// Update a user
const updateUser = asyncHandler(async (req, res) => {
  const { _id } = req.user;
  validateMongodbID(_id);

  try {
    const updateUser = await User.findByIdAndUpdate(
      _id,
      {
        firstname: req?.body?.firstname,
        lastname: req?.body?.lastname,
        email: req?.body?.email,
        mobile: req?.body?.mobile,
      }, {
      new: true,
    }
    );
    res.json(updateUser);
  } catch (error) {
    throw new Error(error);
  }
});


// get all users
const getAllUsers = asyncHandler(async (req, res) => {
  try {
    const getUser = await User.find();
    res.json({ getUser });
  } catch (error) {
    throw new Error(error);
  }
});

// get a single users
const getAUsers = asyncHandler(async (req, res) => {
  const { id } = req.params;
  validateMongodbID(id);

  try {
    const getUser = await User.findById(id);
    res.json({ getUser });
  } catch (error) {
    throw new Error(error);
  }
});

// delete a user
const deleteAUser = asyncHandler(async (req, res) => {
  const { id } = req.params;
  validateMongodbID(id);

  try {
    const deleteAUser = await User.findByIdAndDelete(id);
    res.json({ deleteAUser });
  } catch (error) {
    throw new Error(error);
  }
});

// block user
const blockUser = asyncHandler(async (req, res) => {
  const { id } = req.params;
  validateMongodbID(id);

  try {
    const block = await User.findByIdAndUpdate(
      id,
      {
        isBlocked: true,
      },
      {
        new: true,
      }
    );
    res.json(block);
    // res.json({
    //   message : "User blocked"
    // });
  } catch (error) {
    throw new Error(error);
  }
});

const unblockUser = asyncHandler(async (req, res) => {
  const { id } = req.params;
  validateMongodbID(id);

  try {
    const unblock = await User.findByIdAndUpdate(
      id,
      {
        isBlocked: false,
      },
      {
        new: true,
      }
    );
    res.json({
      message: "User unblocked"
    });
  } catch (error) {
    throw new Error(error);
  }
});


module.exports = {
  createUser,
  loginCheck,
  getAllUsers,
  getAUsers,
  deleteAUser,
  updateUser,
  blockUser,
  unblockUser,
  handleRefreshToken
};

 

✅ routes/authRoute.js

const express = require("express");
const router = express.Router();
const { createUser, loginCheck, getAllUsers, getAUsers, deleteAUser, updateUser, blockUser, unblockUser, handleRefreshToken } = require("../controllers/userCtrl");
const { authMiddleware, isAdmin } = require("../middlewares/authMiddleware");

router.post("/register", createUser);
router.post("/login", loginCheck);

router.get("/all-users", getAllUsers);
router.get("/refresh", handleRefreshToken);
router.get("/:id", authMiddleware, isAdmin, getAUsers);

router.delete("/:id", deleteAUser);

router.put("/edit-user", authMiddleware, updateUser);
router.put("/block-user/:id", authMiddleware, isAdmin, blockUser);
router.put("/unblock-user/:id", authMiddleware, isAdmin, unblockUser);


module.exports = router;

 

✅ config/jwtToken.js

const jwt = require("jsonwebtoken");
const generateToken = (id) => {
    return jwt.sign({id}, process.env.SECRET, {expiresIn : "1d"});
};

module.exports = {
    generateToken
};