6th seminar

seminar4/package.json

@@ -5,17 +5,25 @@
   "license": "MIT",
   "scripts": {
     "dev": "nodemon",
-    "build": "tsc && node dist"
+    "build": "tsc && node dist",
+    "db:pull": "npx prisma db pull",
+    "db:push": "npx prisma db push",
+    "generate": "npx prisma generate"
   },
   "devDependencies": {
+    "@types/bcryptjs": "^2.4.2",
     "@types/express": "^4.17.14",
+    "@types/jsonwebtoken": "^8.5.9",
     "@types/node": "^18.11.9",
     "nodemon": "^2.0.20"
   },
   "dependencies": {
     "@prisma/client": "^4.5.0",
     "@types/express-validator": "^3.0.0",
+    "bcryptjs": "^2.4.3",
     "express": "^4.18.2",
+    "express-validator": "^6.14.2",
+    "jsonwebtoken": "^8.5.1",
     "prisma": "^4.5.0"
   }
 }

seminar4/prisma/schema.prisma

@@ -8,8 +8,9 @@ datasource db {
 }
 
 model User {
-  id       Int     @id(map: "user_pk") @unique(map: "user_id_uindex") @default(autoincrement())
-  userName String
+  id       Int    @id(map: "user_pk") @unique(map: "user_id_uindex") @default(autoincrement())
+  userName String @db.VarChar(100)
   age      Int?
-  email    String? @db.VarChar(400)
-}
+  email    String @db.VarChar(400)
+  password String @db.VarChar(400)
+}

seminar4/src/constants/index.ts

@@ -0,0 +1,3 @@
+export { default as rm } from './responseMessage';
+export { default as sc } from './statusCode';
+export { default as tokenType } from './tokenType';

seminar4/src/constants/response.ts

@@ -0,0 +1,16 @@
+export const success = (status: number, message: string, data?: any) => {
+  return {
+    status,
+    success: true,
+    message,
+    data,
+  };
+};
+
+export const fail = (status: number, message: string) => {
+  return {
+    status,
+    success: false,
+    message,
+  };
+};

seminar4/src/constants/responseMessage.ts

@@ -0,0 +1,33 @@
+export default {
+  NULL_VALUE: '필요한 값이 없습니다.',
+  OUT_OF_VALUE: '파라미터 값이 잘못되었습니다.',
+  NOT_FOUND: '잘못된 경로입니다.',
+  BAD_REQUEST: '잘못된 요청입니다.',
+
+  // 회원가입 및 로그인
+  SIGNUP_SUCCESS: '회원 가입 성공',
+  SIGNUP_FAIL: '회원 가입 실패',
+  SIGNIN_SUCCESS: '로그인 성공',
+  SIGNIN_FAIL: '로그인 실패',
+  ALREADY_NICKNAME: '이미 사용중인 닉네임입니다.',
+
+  // 유저
+  READ_USER_SUCCESS: '유저 조회 성공',
+  READ_ALL_USERS_SUCCESS: '모든 유저 조회 성공',
+  UPDATE_USER_SUCCESS: '유저 수정 성공',
+  DELETE_USER_SUCCESS: '유저 탈퇴 성공',
+  DELETE_USER_FAIL: '유저 탈퇴 실패',
+  NO_USER: '탈퇴했거나 가입하지 않은 유저입니다.',
+
+  // 토큰
+  CREATE_TOKEN_SUCCESS: '토큰 재발급 성공',
+  EXPIRED_TOKEN: '토큰이 만료되었습니다.',
+  EXPIRED_ALL_TOKEN: '모든 토큰이 만료되었습니다.',
+  INVALID_TOKEN: '유효하지 않은 토큰입니다.',
+  VALID_TOKEN: '유효한 토큰입니다.',
+  EMPTY_TOKEN: '토큰 값이 없습니다.',
+
+  // 서버 내 오류
+  INTERNAL_SERVER_ERROR: '서버 내 오류',
+  INVALID_PASSWORD: '잘못된 비밀번호입니다.',
+};

seminar4/src/constants/statusCode.ts

@@ -0,0 +1,15 @@
+export default {
+  OK: 200, // 목록, 상세, 수정 성공
+  CREATED: 201, // POST나 PUT으로 데이터 등록할 경우 사용
+  // 어떠한 생성 작업을 요청받아 생성 작업을 성공
+  ACCEPTED: 202, // 요청은 받았지만, 아직 동작을 수행하지 않은 상태로 요청이 적절함을 의미한다.
+  NO_CONTENT: 204, // 요청이 성공은 했지만 응답할 콘텐츠가 없을 경우를 뜻한다.
+  BAD_REQUEST: 400, // 클라이언트가 올바르지 못한 요청을 보내고 있음을 의미
+  UNAUTHORIZED: 401, // 로그인을 하지 않아 권한이 없음. 권한 인증 요구
+  FORBIDDEN: 403, // 요청이 서버에 의해 거부 되었음을 의미. 금지된 페이지
+  NOT_FOUND: 404, // 요청한 URL을 찾을 수 없음을 의미
+  CONFLICT: 409, // 클라이언트 요청에 대해 서버에서 충돌 요소가 발생 할수 있음을 의미
+  INTERNAL_SERVER_ERROR: 500, // 서버에 오류가 발생하여 응답 할 수 없음을 의미
+  SERVICE_UNAVAILABLE: 503, // 현재 서버가 유지보수 등의 이유로 일시적인 사용 불가함을 의미
+  DB_ERROR: 600,
+};

seminar4/src/constants/tokenType.ts

@@ -0,0 +1,4 @@
+export default {
+  TOKEN_EXPIRED: -3,
+  TOKEN_INVALID: -2,
+};

seminar4/src/controller/userController.ts

@@ -1,5 +1,10 @@
 import { Request, Response } from 'express';
+import { validationResult } from 'express-validator';
+import { rm, sc } from '../constants';
+import { fail, success } from '../constants/response';
 import { UserCreateDTO } from '../DTO/userDTO';
+import { UserSignInDTO } from '../interfaces/UserSignInDTO';
+import jwtHandler from '../modules/jwtHandler';
 import { userService } from '../service';
 
 const getUserById = async (req: Request, res: Response) => {
@@ -13,14 +18,37 @@ const getUserById = async (req: Request, res: Response) => {
   return res.status(200).json({ status: 200, message: '유저 조회 성공', data });
 };
 
+// const createUser = async (req: Request, res: Response) => {
+//   const userCreateDTO: UserCreateDTO = req.body;
+//   const data = await userService.createUser(userCreateDTO);
+
+//   if (!data) {
+//     return res.status(404).json({ status: 404, message: 'NOT_FOUND' });
+//   }
+//   return res.status(200).json({ status: 200, message: '유저 생성 성공', data });
+// };
+
 const createUser = async (req: Request, res: Response) => {
-  const userCreateDTO: UserCreateDTO = req.body;
-  const data = await userService.createUser(userCreateDTO);
+  //? validation의 결과를 바탕으로 분기 처리
+  const error = validationResult(req);
+  if (!error.isEmpty()) {
+    return res.status(sc.BAD_REQUEST).send(fail(sc.BAD_REQUEST, rm.BAD_REQUEST));
+  }
+  //? 기존 비구조화 할당 방식 -> DTO의 형태
+  const userCreateDto: UserCreateDTO = req.body;
+  const data = await userService.createUser(userCreateDto);
 
   if (!data) {
-    return res.status(404).json({ status: 404, message: 'NOT_FOUND' });
+    return res.status(sc.BAD_REQUEST).send(fail(sc.BAD_REQUEST, rm.SIGNUP_FAIL));
   }
-  return res.status(200).json({ status: 200, message: '유저 생성 성공', data });
+  const accessToken = jwtHandler.sign(data.id);
+
+  const result = {
+    id: data.id,
+    name: data.userName,
+    accessToken,
+  };
+  return res.status(sc.CREATED).send(success(sc.CREATED, rm.SIGNUP_SUCCESS, data));
 };
 
 const getAllUser = async (req: Request, res: Response) => {
@@ -54,12 +82,43 @@ const deleteUser = async (req: Request, res: Response) => {
   }
   return res.status(200).json({ status: 200, message: '유저 삭제 성공', data });
 };
+
+const signInUser = async (req: Request, res: Response) => {
+  const error = validationResult(req);
+  if (!error.isEmpty()) {
+    return res.status(sc.BAD_REQUEST).send(fail(sc.BAD_REQUEST, rm.BAD_REQUEST));
+  }
+
+  const userSignInDto: UserSignInDTO = req.body;
+
+  try {
+    const userId = await userService.signIn(userSignInDto);
+
+    if (!userId) return res.status(sc.NOT_FOUND).send(fail(sc.NOT_FOUND, rm.NOT_FOUND));
+    else if (userId === sc.UNAUTHORIZED) return res.status(sc.UNAUTHORIZED).send(fail(sc.UNAUTHORIZED, rm.INVALID_PASSWORD));
+
+    const accessToken = jwtHandler.sign(userId);
+
+    const result = {
+      id: userId,
+      accessToken,
+    };
+
+    res.status(sc.OK).send(success(sc.OK, rm.SIGNIN_SUCCESS, result));
+  } catch (e) {
+    console.log(error);
+    //? 서버 내부에서 오류 발생
+    res.status(sc.INTERNAL_SERVER_ERROR).send(fail(sc.INTERNAL_SERVER_ERROR, rm.INTERNAL_SERVER_ERROR));
+  }
+};
+
 const userController = {
   getUserById,
   createUser,
   getAllUser,
   updateUser,
   deleteUser,
+  signInUser,
 };
 
 export default userController;

seminar4/src/interfaces/UserCreateDTO.ts

@@ -0,0 +1,6 @@
+export interface UserCreateDTO {
+  name: string;
+  age: number;
+  email: string;
+  password: string;
+}

seminar4/src/interfaces/UserSignInDTO.ts

@@ -0,0 +1,4 @@
+export interface UserSignInDTO {
+  email: string;
+  password: string;
+}

seminar4/src/middlewares/auth.ts

@@ -0,0 +1,30 @@
+import { NextFunction, Request, Response } from 'express';
+import { JwtPayload } from 'jsonwebtoken';
+import { rm, sc } from '../constants';
+import { fail } from '../constants/response';
+import tokenType from '../constants/tokenType';
+import jwtHandler from '../modules/jwtHandler';
+
+export default async (req: Request, res: Response, next: NextFunction) => {
+  const token = req.headers.authorization?.split(' ').reverse()[0]; //? Bearer ~~ 에서 토큰만 파싱
+  if (!token) return res.status(sc.UNAUTHORIZED).send(fail(sc.UNAUTHORIZED, rm.EMPTY_TOKEN));
+
+  try {
+    const decoded = jwtHandler.verify(token); //? jwtHandler에서 만들어둔 verify로 토큰 검사
+
+    //? 토큰 에러 분기 처리
+    if (decoded === tokenType.TOKEN_EXPIRED) return res.status(sc.UNAUTHORIZED).send(fail(sc.UNAUTHORIZED, rm.EXPIRED_TOKEN));
+    if (decoded === tokenType.TOKEN_INVALID) return res.status(sc.UNAUTHORIZED).send(fail(sc.UNAUTHORIZED, rm.INVALID_TOKEN));
+
+    //? decode한 후 담겨있는 userId를 꺼내옴
+    const userId: number = (decoded as JwtPayload).userId;
+    if (!userId) return res.status(sc.UNAUTHORIZED).send(fail(sc.UNAUTHORIZED, rm.INVALID_TOKEN));
+
+    //? 얻어낸 userId 를 Request Body 내 userId 필드에 담고, 다음 미들웨어로 넘김( next() )
+    req.body.userId = userId;
+    next();
+  } catch (error) {
+    console.log(error);
+    res.status(sc.INTERNAL_SERVER_ERROR).send(fail(sc.INTERNAL_SERVER_ERROR, rm.INTERNAL_SERVER_ERROR));
+  }
+};

seminar4/src/middlewares/index.ts

@@ -0,0 +1 @@
+export { default as auth } from './auth';

seminar4/src/modules/jwtHandler.ts

@@ -0,0 +1,37 @@
+// src/modules/jwtHandler.ts
+import jwt from 'jsonwebtoken';
+import { tokenType } from '../constants';
+
+//* 받아온 userId를 담는 access token 생성
+const sign = (userId: number) => {
+  const payload = {
+    userId,
+  };
+
+  const accessToken = jwt.sign(payload, process.env.JWT_SECRET as string, { expiresIn: '2h' });
+  return accessToken;
+};
+
+//* token 검사!
+const verify = (token: string) => {
+  let decoded: string | jwt.JwtPayload;
+
+  try {
+    decoded = jwt.verify(token, process.env.JWT_SECRET as string);
+  } catch (error: any) {
+    if (error.message === 'jwt expired') {
+      return tokenType.TOKEN_EXPIRED;
+    } else if (error.message === 'invalid token') {
+      return tokenType.TOKEN_INVALID;
+    } else {
+      return tokenType.TOKEN_INVALID;
+    }
+  }
+
+  return decoded;
+};
+
+export default {
+  sign,
+  verify,
+};

seminar4/src/router/userRouter.ts

@@ -1,14 +1,15 @@
 import { Router } from 'express';
 import { userController } from '../controller';
 import { body } from 'express-validator';
+import { auth } from '../middlewares';
 const { validatorErrorChecker } = require('../middlewares/validator');
 const router: Router = Router();
 
-router.get('/:userId', userController.getUserById);
+router.get('/:userId', auth, userController.getUserById);
 
-router.post('/', body('name').notEmpty(), validatorErrorChecker, userController.createUser);
+router.post('/', [body('name').notEmpty(), body('email').notEmpty(), body('password').isLength({ min: 6 })], userController.createUser);
 router.get('/', userController.getAllUser);
 router.patch('/:userId', body('name').notEmpty(), validatorErrorChecker, userController.updateUser);
 router.delete('/:userId', userController.deleteUser);
-
+router.post('/signin', [body('email').notEmpty(), body('email').isEmail(), body('password').notEmpty(), body('password').isLength({ min: 6 })], userController.signInUser);
 export default router;

seminar4/src/service/userService.ts

@@ -1,5 +1,8 @@
 import { UserCreateDTO } from '../DTO/userDTO';
 import { PrismaClient } from '@prisma/client';
+import bcrypt from 'bcryptjs';
+import { sc } from '../constants';
+import { UserSignInDTO } from '../interfaces/UserSignInDTO';
 const prisma = new PrismaClient();
 
 //* userId로 유저 조회
@@ -13,15 +16,53 @@ const getUserById = async (userId: number) => {
   return user;
 };
 
-const createUser = async (userCreateDTO: UserCreateDTO) => {
-  const user = await prisma.user.create({
+const signIn = async (userSignInDto: UserSignInDTO) => {
+  try {
+    const user = await prisma.user.findFirst({
+      where: {
+        email: userSignInDto.email,
+      },
+    });
+    if (!user) return null;
+
+    //? bcrypt가 DB에 저장된 기존 password와 넘겨 받은 password를 대조하고,
+    //? match false시 401을 리턴
+    const isMatch = await bcrypt.compare(userSignInDto.password, user.password);
+    if (!isMatch) return sc.UNAUTHORIZED;
+
+    return user.id;
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+};
+
+// const createUser = async (userCreateDTO: UserCreateDTO) => {
+//   const user = await prisma.user.create({
+//     data: {
+//       userName: userCreateDTO.name,
+//       age: userCreateDTO.age,
+//       email: userCreateDTO.email,
+//     },
+//   });
+//   return user;
+// };
+
+const createUser = async (userCreateDto: UserCreateDTO) => {
+  //? 넘겨받은 password를 bcrypt의 도움을 받아 암호화
+  const salt = await bcrypt.genSalt(10); //^ 매우 작은 임의의 랜덤 텍스트 salt
+  const password = await bcrypt.hash(userCreateDto.password, salt); //^ 위에서 랜덤을 생성한 salt를 이용해 암호화
+
+  const data = await prisma.user.create({
     data: {
-      userName: userCreateDTO.name,
-      age: userCreateDTO.age,
-      email: userCreateDTO.email,
+      userName: userCreateDto?.name,
+      age: userCreateDto?.age,
+      email: userCreateDto.email,
+      password,
     },
   });
-  return user;
+
+  return data;
 };
 
 const getAllUser = async () => {
@@ -52,6 +93,7 @@ const userService = {
   getAllUser,
   updateUser,
   deleteUser,
+  signIn,
 };
 
 export default userService;