feature: 인가 미들 웨어 분리, 인증 로직은 서비스로 합병, 그에 따른 타입을 포함한 전체 리펙토링

Author: Nuung

src/controllers/user.controller.ts

@@ -1,9 +1,10 @@
 import { NextFunction, Request, Response, RequestHandler, CookieOptions } from 'express';
 import logger from '@/configs/logger.config';
-import { EmptyResponseDto, LoginResponseDto, UserWithTokenDto } from '@/types';
+import { EmptyResponseDto, LoginResponseDto } from '@/types';
 import { QRLoginTokenResponseDto } from '@/types/dto/responses/qrResponse.type';
 import { UserService } from '@/services/user.service';
-import { InvalidTokenError, TokenExpiredError } from '@/exception/token.exception';
+import { QRTokenExpiredError, QRTokenInvalidError } from '@/exception/token.exception';
+import { fetchVelogApi } from '@/modules/velog/velog.api';
 
 type Token10 = string & { __lengthBrand: 10 };
 
@@ -30,12 +31,15 @@ export class UserController {
 
   login: RequestHandler = async (req: Request, res: Response<LoginResponseDto>, next: NextFunction): Promise<void> => {
     try {
-      const { id, email, profile, username } = req.user;
-      const { accessToken, refreshToken } = req.tokens;
 
-      const userWithToken: UserWithTokenDto = { id, email, accessToken, refreshToken };
-      const isExistUser = await this.userService.handleUserTokensByVelogUUID(userWithToken);
+      // 1. 외부 API (velog) 호출로 실존 하는 토큰 & 사용자 인지 검증
+      const { accessToken, refreshToken } = req.body;
+      const velogUser = await fetchVelogApi(accessToken, refreshToken);
 
+      // 2. 우리쪽 DB에 사용자 존재 여부 체크 후 로그인 바로 진행 또는 사용자 생성 후 로그인 진행
+      const user = await this.userService.handleUserTokensByVelogUUID(velogUser, accessToken, refreshToken);
+
+      // 3. 로그이 완료 후 쿠키 세팅
       res.clearCookie('access_token', this.cookieOption());
       res.clearCookie('refresh_token', this.cookieOption());
 
@@ -45,7 +49,7 @@ export class UserController {
       const response = new LoginResponseDto(
         true,
         '로그인에 성공하였습니다.',
-        { id: isExistUser.id, username, profile },
+        { id: user.id, username: velogUser.username, profile: velogUser.profile },
         null,
       );
 
@@ -118,7 +122,7 @@ export class UserController {
       const ip = typeof req.headers['x-forwarded-for'] === 'string' ? req.headers['x-forwarded-for'].split(',')[0].trim() : req.ip ?? '';
       const userAgent = req.headers['user-agent'] || '';
 
-      const token = await this.userService.create(user.id, ip, userAgent);
+      const token = await this.userService.createUserQRToken(user.id, ip, userAgent);
       const typedToken = token as Token10;
 
       const response = new QRLoginTokenResponseDto(
@@ -138,22 +142,19 @@ export class UserController {
     try {
       const token = req.query.token as string;
       if (!token) {
-        throw new InvalidTokenError('토큰이 필요합니다.');
+        throw new QRTokenInvalidError('토큰이 필요합니다.');
       }
 
-      const found = await this.userService.useToken(token);
-      if (!found) {
-        throw new TokenExpiredError();
+      const userLoginToken = await this.userService.useToken(token);
+      if (!userLoginToken) {
+        throw new QRTokenExpiredError();
       }
-      
-      const { decryptedAccessToken, decryptedRefreshToken } = 
-        await this.userService.findUserAndTokensByVelogUUID(found.user.toString());
 
       res.clearCookie('access_token', this.cookieOption());
       res.clearCookie('refresh_token', this.cookieOption());
 
-      res.cookie('access_token', decryptedAccessToken, this.cookieOption());
-      res.cookie('refresh_token', decryptedRefreshToken, this.cookieOption());
+      res.cookie('access_token', userLoginToken.decryptedAccessToken, this.cookieOption());
+      res.cookie('refresh_token', userLoginToken.decryptedRefreshToken, this.cookieOption());
 
       res.redirect('/main');
     } catch (error) {

src/exception/index.ts

@@ -1,6 +1,6 @@
 export { CustomError } from './custom.exception';
 export { DBError } from './db.exception';
-export { TokenError, TokenExpiredError, InvalidTokenError } from './token.exception';
+export { TokenError, TokenExpiredError, InvalidTokenError, QRTokenExpiredError, QRTokenInvalidError } from './token.exception';
 export { UnauthorizedError } from './unauthorized.exception';
 export { BadRequestError } from './badRequest.exception';
 export { NotFoundError } from './notFound.exception';

src/exception/token.exception.ts

@@ -1,4 +1,5 @@
 import { CustomError } from './custom.exception';
+import { BadRequestError } from './badRequest.exception';
 import { UnauthorizedError } from './unauthorized.exception';
 
 export class TokenError extends CustomError {
@@ -18,3 +19,19 @@ export class InvalidTokenError extends UnauthorizedError {
     super(message, 'INVALID_TOKEN');
   }
 }
+
+/* ===================================================
+아래 부터는 QRToken 에 관한 에러
+=================================================== */
+
+export class QRTokenExpiredError extends BadRequestError {
+  constructor(message = 'QR 토큰이 만료되었습니다') {
+    super(message, 'TOKEN_EXPIRED');
+  }
+}
+
+export class QRTokenInvalidError extends BadRequestError {
+  constructor(message = '유효하지 않은 QR 토큰입니다') {
+    super(message, 'INVALID_TOKEN');
+  }
+}

src/middlewares/auth.middleware.ts

@@ -1,10 +1,9 @@
 import { NextFunction, Request, Response } from 'express';
-import axios from 'axios';
 import { isUUID } from 'class-validator';
 import logger from '@/configs/logger.config';
 import pool from '@/configs/db.config';
-import { DBError, InvalidTokenError } from '@/exception';
-import { VELOG_API_URL, VELOG_QUERIES } from '@/constants/velog.constans';
+import { InvalidTokenError } from '@/exception';
+import { VelogJWTPayload, User } from '@/types';
 
 /**
  * 요청에서 토큰을 추출하는 함수
@@ -22,60 +21,23 @@ const extractTokens = (req: Request): { accessToken: string; refreshToken: strin
   return { accessToken, refreshToken };
 };
 
-/**
- * Velog API를 통해 사용자 정보를 조회합니다.
- * @param query - GraphQL 쿼리 문자열
- * @param accessToken - Velog access token
- * @throws {Error} API 호출 실패 시
- * @returns Promise<VelogUserLoginResponse | null>
- */
-const fetchVelogApi = async (query: string, accessToken: string, refreshToken: string) => {
-  try {
-    const response = await axios.post(
-      VELOG_API_URL,
-      { query, variables: {} },
-      {
-        headers: {
-          authority: 'v3.velog.io',
-          origin: 'https://velog.io',
-          'content-type': 'application/json',
-          cookie: `access_token=${accessToken}; refresh_token=${refreshToken}`,
-        },
-      },
-    );
-
-    const result = response.data;
-
-    if (result.errors) {
-      logger.error('GraphQL Errors : ', result.errors);
-      throw new InvalidTokenError('Velog API 인증에 실패했습니다.');
-    }
-
-    return result.data.currentUser || null;
-  } catch (error) {
-    logger.error('Velog API 호출 중 오류 : ', error);
-    throw new InvalidTokenError('Velog API 인증에 실패했습니다.');
-  }
-};
-
 /**
  * JWT 토큰에서 페이로드를 추출하고 디코딩하는 함수
+ * 이건 진짜 velog 에서 사용하는 걸 그대로 가져온 함수임!
  * @param token - 디코딩할 JWT 토큰 문자열
- * @returns JSON 객체로 디코딩된 페이로드
+ * @returns {VelogJWTPayload}
  * @throws {Error} 토큰이 잘못되었거나 디코딩할 수 없는 경우
  * @example
  * const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
  * const payload = extractPayload(token);
  * // 반환값: { sub: "1234567890" }
  */
-const extractPayload = (token: string) => JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+const extractPayload = (token: string): VelogJWTPayload => JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
 
 /**
- *  Bearer 토큰을 검증한뒤 최초 로그인이라면 Velog 사용자를 인증을, 아니라면 기존 사용자를 인증하여 user정보를 Request 객체에 담는 함수
- * @param query - 사용자 정보를 조회할 GraphQL 쿼리
- * @returns
+ *  Bearer 토큰을 검증한뒤 user정보를 Request 객체에 담는 인가 함수
  */
-const verifyBearerTokens = (query?: string) => {
+const verifyBearerTokens = () => {
   return async (req: Request, res: Response, next: NextFunction) => {
     try {
       const { accessToken, refreshToken } = extractTokens(req);
@@ -84,23 +46,12 @@ const verifyBearerTokens = (query?: string) => {
         throw new InvalidTokenError('accessToken과 refreshToken의 입력이 올바르지 않습니다');
       }
 
-      let user = null;
-      if (query) {
-        user = await fetchVelogApi(query, accessToken, refreshToken);
-        if (!user) {
-          throw new InvalidTokenError('유효하지 않은 토큰입니다.');
-        }
-      } else {
-        const payload = extractPayload(accessToken);
-        if (!payload.user_id || !isUUID(payload.user_id)) {
-          throw new InvalidTokenError('유효하지 않은 토큰 페이로드 입니다.');
-        }
-
-        user = (await pool.query('SELECT * FROM "users_user" WHERE velog_uuid = $1', [payload.user_id])).rows[0];
-        if (!user) {
-          throw new DBError('사용자를 찾을 수 없습니다.');
-        }
+      const payload = extractPayload(accessToken);
+      if (!payload.user_id || !isUUID(payload.user_id)) {
+        throw new InvalidTokenError('유효하지 않은 토큰 페이로드 입니다.');
       }
+
+      const user = (await pool.query('SELECT * FROM "users_user" WHERE velog_uuid = $1', [payload.user_id])).rows[0] as User;
       req.user = user;
       req.tokens = { accessToken, refreshToken };
 
@@ -114,10 +65,8 @@ const verifyBearerTokens = (query?: string) => {
 
 /**
  * 사용자 인증을 위한 미들웨어 모음
- * @property {Function} login - 최초 로그인 시 Velog API를 호출하는 인증 미들웨어
- * @property {Function} verify - 기존 유저를 인증하는 미들웨어
+ * @property {Function} verify
  */
 export const authMiddleware = {
-  login: verifyBearerTokens(VELOG_QUERIES.LOGIN),
   verify: verifyBearerTokens(),
 };

src/modules/token_encryption/aes_encryption.ts

@@ -1,10 +1,15 @@
 import crypto from 'crypto';
 
+export interface TokenEncryptionService {
+  encrypt(plaintext: string): string;
+  decrypt(encryptedData: string): string;
+}
+
 /**
  * AES 암호화/복호화 유틸리티 클래스
  * AES-256-CBC 알고리즘을 사용하여 데이터를 암호화하고 복호화합니다.
  */
-class AESEncryption {
+class AESEncryption implements TokenEncryptionService {
   private readonly key: Buffer;
 
   /**

src/modules/velog/velog.api.ts

@@ -0,0 +1,52 @@
+import axios from 'axios';
+
+import logger from '@/configs/logger.config';
+import { InvalidTokenError } from '@/exception';
+import { VELOG_API_URL, VELOG_QUERIES } from '@/modules/velog/velog.constans';
+import { VelogUserCurrentResponse } from './velog.type';
+
+/**
+ * Velog API를 통해 사용자 정보를 조회합니다.
+ * @param accessToken - Velog access token
+ * @param refreshToken - Velog refresh token
+ * @throws {Error} API 호출 실패 시
+ * @returns Promise<VelogUserLoginResponse | null>
+ */
+export const fetchVelogApi = async (accessToken: string, refreshToken: string): Promise<VelogUserCurrentResponse> => {
+  try {
+    const response = await axios.post(
+      VELOG_API_URL,
+      { VELOG_QUERIES, variables: {} },
+      {
+        headers: {
+          authority: 'v3.velog.io',
+          origin: 'https://velog.io',
+          'content-type': 'application/json',
+          cookie: `access_token=${accessToken}; refresh_token=${refreshToken}`,
+        },
+      },
+    );
+
+    const result = response.data;
+
+    if (result.errors) {
+      logger.error('GraphQL Errors : ', result.errors);
+      throw new InvalidTokenError('Velog API 인증에 실패했습니다.');
+    }
+
+    if (!result.data.currentUser) {
+      logger.error('Velog API 응답에 currentUser 정보가 없습니다.');
+      throw new InvalidTokenError('Velog 사용자 정보를 가져오지 못했습니다.');
+    }
+
+    // email이 undefined인 경우 null로 변환
+    const currentUser = result.data.currentUser;
+    return {
+      ...currentUser,
+      email: currentUser.email ?? null
+    };
+  } catch (error) {
+    logger.error('Velog API 호출 중 오류 : ', error);
+    throw new InvalidTokenError('Velog API 인증에 실패했습니다.');
+  }
+};

src/constants/velog.constans.ts src/modules/velog/velog.constans.tssrc/constants/velog.constans.ts renamed to src/modules/velog/velog.constans.ts

@@ -0,0 +1,24 @@
+
+/**
+ * Velog 쪽에서 사용하는 토큰을 사용할때 실제 payload 값
+ */
+export interface VelogJWTPayload {
+  user_id: string;  // UUID 값, key를 바꿀 순 없음
+  iat: number;  // issued at timestamp
+  exp: number;  // expiration timestamp
+  iss: string;  // issuer
+  sub: string;  // subject
+}
+
+
+/**
+ * Velog 쪽에서 사용하는, 실제 currentUser API 호출시 주는 값 중 일부분
+ */
+export interface VelogUserCurrentResponse {
+  id: string;  // 이는 실제로 uuid를 줌
+  username: string;
+  email: string | null;
+  profile: {
+    thumbnail: string;
+  };
+}

src/modules/velog/velog.type.ts

@@ -8,7 +8,7 @@ import logger from '@/configs/logger.config';
 dotenv.config();
 jest.setTimeout(5000);
 
-describe('QRLoginTokenRepository 통합 테스트', () => {
+describe('UserRepository QR 토큰 통합 테스트', () => {
   let testPool: Pool;
   let repo: UserRepository;
 
@@ -53,13 +53,13 @@ describe('QRLoginTokenRepository 통합 테스트', () => {
         `,
         [TEST_DATA.USER_ID]
       );
-  
+
       await new Promise(resolve => setTimeout(resolve, 1000));
-  
+
       if (testPool) {
         await testPool.end();
       }
-  
+
       await new Promise(resolve => setTimeout(resolve, 1000));
       logger.info('테스트 DB 연결 종료 및 테스트 데이터 정리 완료');
     } catch (error) {
@@ -79,9 +79,12 @@ describe('QRLoginTokenRepository 통합 테스트', () => {
       // 토큰이 존재함을 확인하고 타입 단언
       expect(foundToken).not.toBeNull();
       const nonNullToken = foundToken as NonNullable<typeof foundToken>;
-      
+
       expect(nonNullToken.token).toBe(token);
+      expect(Number(nonNullToken.user_id)).toBe(TEST_DATA.USER_ID);
       expect(nonNullToken.is_used).toBe(false);
+      expect(nonNullToken.ip_address).toBe(ip);
+      expect(nonNullToken.user_agent).toBe(userAgent);
       expect(new Date(nonNullToken.expires_at).getTime()).toBeGreaterThan(new Date(nonNullToken.created_at).getTime());
     });
 
@@ -100,11 +103,16 @@ describe('QRLoginTokenRepository 통합 테스트', () => {
       const userAgent = 'test-agent';
 
       await repo.createQRLoginToken(token, TEST_DATA.USER_ID, ip, userAgent);
-      await repo.markTokenUsed(token);
 
-      const found = await repo.findQRLoginToken(token);
+      // 토큰 조회 후 user_id를 얻어 updateQRLoginTokenToUse 호출
+      const foundToken = await repo.findQRLoginToken(token);
+      expect(foundToken).not.toBeNull();
 
-      expect(found).toBeNull();
+      await repo.updateQRLoginTokenToUse(TEST_DATA.USER_ID);
+
+      // 토큰이 is_used=true로 변경되었으므로 findQRLoginToken에서 null 반환 예상
+      const afterUpdate = await repo.findQRLoginToken(token);
+      expect(afterUpdate).toBeNull();
     });
   });
 
@@ -145,4 +153,4 @@ describe('QRLoginTokenRepository 통합 테스트', () => {
       expect(found).toBeNull();
     });
   });
-});
+});