[회원가입, 로그인 API 인증하기] Node JS using JWT & MongoDB

👩‍💻 백엔드(Back-End)/Node js

[회원가입, 로그인 API 인증하기] Node JS using JWT & MongoDB

징징알파카 2023. 2. 25. 23:43

728x90

https://www.youtube.com/watch?v=ZEg03f1o_vQ&list=LL&index=6

아~ 넘 어렵다

⭐ 파일 구조

⭐ 세부 파일

🌻config/db.config.js

module.exports = {
    db : "mongodb+srv://~~~~~~~"
}

🌻controllers/user.controller.js

'use strict';

// 비밀번호를 암호화해서 저장하기
const bcryptjs = require("bcryptjs");
const userSesrvice = require("../services/user.services");

exports.register = (req, res, next) => {
    const {password} = req.body;
    // 솔트 + 비밀번호를 해시로 암호화
    const salt = bcryptjs.genSaltSync(10);
    // 비동기 방식 파라미터, 암호화에 사용되는 Salt
    req.body.password = bcryptjs.hashSync(password, salt);

    userSesrvice.register(req.body, (error, result) => {
        if(error) {
            return next(error);
        }
        return res.status(200).send({
            message : "Success",
            data : result,
        });
    });
};

exports.login = (req, res, next) => {
    const { username, password } = req.body;

    userSesrvice.login({ username, password }, (error, result) => {
        if(error) {
            return next(error);
        }
        return res.status(200).send({
            message : "Success",
            data : result,
        });
    })
}

exports.userProfile = (req, res, next) => {
    if (req.user) {
        res.send(req.user);
        next();
    } else {
       return res.status(401).json({ message: 'Invalid token' });
    }
};

🌻middlewares/auth.js

'use strict';

const dotenv = require('dotenv');
// JWT(JSON Web Token - JSON 웹 토큰)은 두 개체 사이에서 안전하게 클레임을 전달(표현)
// 1) HEADER(헤더) typ : 토큰의 타입을 지정(JWT), alg : 해싱 알고리즘을 지정
// 2) PAYLOAD(내용) - 사용되는 정보의 한 조각을 클레임(claim)
// 3) VERIFY SIGNATURE(서명) : header + payload 정보를 비밀키로 해쉬를 하여 생성!
const jwt = require("jsonwebtoken");
dotenv.config();
// 로그인 시 해당 id, pw와 일치하는 요청이 들어오면 access token과 refresh token을 발급
// 발급된 token은 클라이언트에서 요청을 보낼 때마다 
// headers에 authorization: 'bearer ' + accessToken 방식으로 넘겨받아 해당 요청의 token이 유효한지 검사

function authenticateToken(req, res, next) {
    // access token의 유효성 검사
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[0];

    if (token == null) {
        console.log("잘못된 token이다!!!")
        return res.sendStatus(401);
    }
    // verify를 통해 값 decode
    jwt.verify(token, "Snippet_SecretKEY", (err, user) => {
        if(err) return res.sendStatus(403);
        req.user = user;
        next();
    });
};

function generateAccessToken(username) {
    // sign 메소드를 통해 access token 발급 (process.env.ACCESS_TOKEN_SECRET)
    return jwt.sign({data : username},"Snippet_SecretKEY", {
        expiresIn : "1h"
    });
};

module.exports = {
    authenticateToken,
    generateAccessToken,
};

🌻middlewares/errors.js

function errorHandler(err, req, res, next) {
    if(typeof err === "string") {
        // 400(잘못된 요청): 서버가 요청의 구문을 인식하지 못했다
        return res.status(400).json({message : err});
    }
    if(typeof err === "ValidationError") {
        return res.status(400).json({message : err.message});
    }
    if(typeof err === "UnauthorizedError") {
        // 401(권한 없음): 이 요청은 인증이 필요
        return res.status(401).json({message : err.message});
    }
    // 500 (내부 서버 오류): 서버에 오류가 발생하여 요청을 수행할 수 없다
    return res.status(500).json({message : err.message});
};

module.exports = {
    errorHandler,
};

🌻models/user.mode.js

const mongoose = require("mongoose");
const {Schema} = mongoose;
// Mongoose 스키마 내의 고유한 필드에 대한 사전 저장 유효성 검사를 추가하는 플러그인
const uniqueValidator = require("mongoose-unique-validator");

const userSchema = new Schema ({
    username : {
        type : String,
        required : true
    },
    email : {
        type : String,
        required : true,
        unique : true
    },
    password : {
        type : String,
        required : true
    },
    date : {
        type : Date,
        default : Date.now()
    }
});

userSchema.set("toJSON", {
    transform : (document, returnedObject) => {
        returnedObject.id = returnedObject._id.toString();
        // _id, _v, password 전역 스키마 설정을 등록하여 삭제
        delete returnedObject._id;
        delete returnedObject.__v;
        delete returnedObject.password;
    },
});

// unique의 존재 유무도 파악
userSchema.plugin(uniqueValidator, { message : "Email 이미 사용 중"});

// schema를 사용하는 model
const User = mongoose.model("user", userSchema);
module.exports = User;

🌻models/user.mode.js

'use strict';

const userController = require("../controllers/user.controller");

const express = require("express");
const router = express.Router();

router.post("/register", userController.register);
router.post("/login", userController.login);
router.post("/userProfile", userController.userProfile);

module.exports = router;

🌻services/user.services.js

'use strict';


const User = require("../models/user.model");
const bcrypt = require("bcryptjs");
const auth = require("../middlewares/auth.js")

async function login({ username, password }, callback) {
    const user = await User.findOne({ username });

    if (user != null) {
        // client가 입력한 password와 user.passward와 일치한지 확인
        if (bcrypt.compareSync(password, user.password)) {
            // accessToken 생성기 (middleware에서 발행)
            const token = auth.generateAccessToken(username);
            return callback(null, {...user.toJSON(), token});
        }
        else {
            return callback({
                message : "일치하지 않은 아이디와 비밀번호입니다.",
            });
        }
    } else {
        return callback({
            message : "일치하지 않은 아이디와 비밀번호입니다.",
        });
    }
}

async function register(params, callback) {
    const user = new User(params);

    if(params.username === undefined) {
        return callback({message : "아이디 입력해주세요"});
    }

    
    user.save()
        .then((response) => {
            return callback(null, response);
        })
        .catch((error) => {
            return callback(error);
        });
}

module.exports = {
    login,
    register,
};

🌻app.js

'use strict';

const express = require("express");
const mongoose = require("mongoose");
const dbConfig = require("./config/db.config");

const dotenv = require('dotenv');
dotenv.config();

const auth = require("./middlewares/auth");
const errors = require("./middlewares/errors");

const {unless} = require("express-unless");

const app = express();

// 데이터베이스에 요청
mongoose.Promise = global.Promise;
mongoose.connect(dbConfig.db, {
    // useNewUrlParser, useUnifiedTopology 옵션은 서버 실행 시 발생되는 오류를 제거
    useNewUrlParser : true,
    useUnifiedTopology : true
}).then(
    () => {
        console.log("db 연결 성공")
    },
    (error) => {
        console.log("db 연결 안됨 : " + error);
    } 
);

// authenticateToken : 미들웨어 - 보호된 경로에 액세스하기 전에 토큰을 인증

auth.authenticateToken.unless = unless
console.log(auth.authenticateToken.unless);
app.use(auth.authenticateToken.unless({
    path: [
        { url: '/users/login', methods: ['POST']},
        { url: '/users/register', methods: ['POST']}
    ]
}));

// 클라이언트로 부터 받은 http 요청 메시지 형식에서 body데이터를 해석
app.use(express.json());

app.use("/users", require("./routes/user.routes"));

app.use(errors.errorHandler);

app.listen(process.env.PORT || 4000, function() {
    console.log("🚀 시작해볼까!")
})

🌻package.json

{
  "name": "mangement",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "bcryptjs": "^2.4.3",
    "dotenv": "^16.0.3",
    "express": "^4.18.2",
    "express-unless": "^2.1.3",
    "jsonwebtoken": "^9.0.0",
    "mongoose": "^6.9.2",
    "mongoose-unique-validator": "^3.1.0"
  }
}

⭐ 결과

🌻register 회원가입하기

🌻login 로그인 하기

🌻user 확인하기

: login 했을 때 token을 authorization의 value 값에 넣어서 확인하기!!!

728x90

저작자표시