feat: qrcode app 컨트롤러, 서비스, 레포지토리, 타입 추가, 관련 API 구현

package.json

@@ -35,6 +35,7 @@
  "reflect-metadata": "^0.2.2",
  "swagger-jsdoc": "^6.2.8",
  "swagger-ui-express": "^5.0.1",
+ "uuid": "^11.1.0",
  "winston": "^3.17.0",
  "winston-daily-rotate-file": "^5.0.0"
  },

src/controllers/qr.controller.ts

@@ -0,0 +1,54 @@
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import logger from '@/configs/logger.config';
+import { QRLoginTokenService } from "@/services/qr.service";
+import { QRLoginTokenResponseDto } from "@/types/dto/responses/qrResponse.type";
+
+export class QRLoginController {
+ constructor(private qrService: QRLoginTokenService) {}
+
+ createToken: RequestHandler = async (
+ req: Request,
+ res: Response<QRLoginTokenResponseDto>,
+ next: NextFunction,
+ ) => {
+ try {
+ const user = req.user;
+ const ip = req.ip ?? '';
+ const userAgent = req.headers['user-agent'] || '';
+
+ const token = await this.qrService.create(user.id, ip, userAgent);
+
+ const response = new QRLoginTokenResponseDto(
+ true,
+ 'QR 토큰 생성 완료',
+ { token: token },
+ null
+ );
+ res.status(200).json(response);
+ } catch (error) {
+ logger.error('생성 실패:', error);
+ next(error);
+ }
+ };
+
+ getToken: RequestHandler = async (req, res, next) => {
+ try {
+ const token = req.query.token as string;
+
+ if (!token) {
+ res.status(400).json({ success: false, message: '토큰이 필요합니다.' });
+ }
+
+ const found = await this.qrService.getByToken(token);
+
+ if (!found) {
+ res.status(404).json({ success: false, message: '유효하지 않거나 만료된 토큰입니다.' });
+ }
+
+ res.status(200).json({ success: true, message: '유효한 QR 토큰입니다.', token: found });
+ } catch (error) {
+ logger.error('QR 토큰 조회 실패', error);
+ next(error);
+ }
+ };
+}

src/repositories/__test__/qr.repo.test.ts

@@ -0,0 +1,56 @@
+import { QRLoginTokenRepository } from '@/repositories/qr.repository';
+import { DBError } from '@/exception';
+import { Pool } from 'pg';
+
+const mockPool: Partial<Pool> = {
+ query: jest.fn()
+};
+
+describe('QRLoginTokenRepository', () => {
+ let repo: QRLoginTokenRepository;
+
+ beforeEach(() => {
+ repo = new QRLoginTokenRepository(mockPool as Pool);
+ });
+
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('should insert QR login token', async () => {
+ (mockPool.query as jest.Mock).mockResolvedValueOnce(undefined);
+
+ await expect(
+ repo.createQRLoginToken('token', 1, 'ip', 'agent')
+ ).resolves.not.toThrow();
+
+ expect(mockPool.query).toHaveBeenCalled();
+ });
+
+ it('should throw DBError on insert failure', async () => {
+ (mockPool.query as jest.Mock).mockRejectedValueOnce(new Error('fail'));
+
+ await expect(repo.createQRLoginToken('token', 1, 'ip', 'agent'))
+ .rejects.toThrow(DBError);
+ });
+
+ it('should return token if found', async () => {
+ (mockPool.query as jest.Mock).mockResolvedValueOnce({ rows: [{ token: 'token' }] });
+
+ const result = await repo.findQRLoginToken('token');
+ expect(result).toEqual({ token: 'token' });
+ });
+
+ it('should return null if token not found', async () => {
+ (mockPool.query as jest.Mock).mockResolvedValueOnce({ rows: [] });
+
+ const result = await repo.findQRLoginToken('token');
+ expect(result).toBeNull();
+ });
+
+ it('should throw DBError on select failure', async () => {
+ (mockPool.query as jest.Mock).mockRejectedValueOnce(new Error('fail'));
+
+ await expect(repo.findQRLoginToken('token')).rejects.toThrow(DBError);
+ });
+});

src/repositories/qr.repository.ts

@@ -0,0 +1,36 @@
+import { Pool } from 'pg';
+import logger from '@/configs/logger.config';
+import { DBError } from '@/exception';
+import { QRLoginToken } from '@/types/models/QRLoginToken.type';
+
+export class QRLoginTokenRepository {
+ constructor(private pool: Pool) { }
+
+ async createQRLoginToken(token: String, userId: number, ip: string, userAgent: string): Promise<void> {
+ try {
+ const query = `
+ INSERT INTO qr_login_tokens (token, user_id, created_at, expires_at, is_used, ip_address, user_agent)
+ VALUES ($1, $2, NOW(), NOW() + INTERVAL '5 minutes', false, $3, $4);
+ `;
+ await this.pool.query(query, [token, userId, ip, userAgent]);
+ } catch (error) {
+ logger.error('QRLoginToken Repo Create Error : ', error);
+ throw new DBError('QR 코드 토큰 생성 중 문제가 발생했습니다.');
+ }
+ }
+
+ async findQRLoginToken(token: string): Promise<QRLoginToken | null> {
+ try {
+ const query = `
+ SELECT *
+ FROM qr_login_tokens
+ WHERE token = $1 AND is_used = false AND expires_at > NOW();
+ `;
+ const result = await this.pool.query(query, [token]);
+ return result.rows[0] ?? null;
+ } catch (error) {
+ logger.error('QRLoginToken Repo find QR Code Error : ', error);
+ throw new DBError('QR 코드 토큰 조회 중 문제가 발생했습니다.');
+ }
+ }
+}

src/routes/index.ts

@@ -2,6 +2,7 @@ import express, { Router } from 'express';
 import UserRouter from './user.router';
 import PostRouter from './post.router';
 import NotiRouter from './noti.router';
+import QrRouter from './qr.router';
 
 const router: Router = express.Router();
 
@@ -12,4 +13,6 @@ router.use('/ping', (req, res) => {
 router.use('/', UserRouter);
 router.use('/', PostRouter);
 router.use('/', NotiRouter);
+router.use('/', QrRouter);
+
 export default router;

src/routes/qr.router.ts

@@ -0,0 +1,50 @@
+import express, { Router } from 'express';
+import pool from '@/configs/db.config';
+
+import { authMiddleware } from '@/middlewares/auth.middleware';
+import { QRLoginTokenRepository } from '@/repositories/qr.repository';
+import { QRLoginTokenService } from '@/services/qr.service';
+import { QRLoginController } from '@/controllers/qr.controller';
+
+const router: Router = express.Router();
+
+const qrRepository = new QRLoginTokenRepository(pool);
+const qrService = new QRLoginTokenService(qrRepository);
+const qrController = new QRLoginController(qrService);
+
+/**
+ * @swagger
+ * /api/qr-login:
+ * post:
+ * summary: QR 로그인 토큰 생성
+ * tags: [QRLogin]
+ * security:
+ * - bearerAuth: []
+ * responses:
+ * 201:
+ * description: QR 로그인 토큰 생성 성공
+ */
+router.post('/qr-login', authMiddleware.login, qrController.createToken);
+
+/**
+ * @swagger
+ * /api/qr-login:
+ * get:
+ * summary: QR 로그인 토큰 조회
+ * tags: [QRLogin]
+ * parameters:
+ * - in: query
+ * name: token
+ * required: true
+ * schema:
+ * type: string
+ * description: 조회할 QR 토큰
+ * responses:
+ * 200:
+ * description: 유효한 토큰
+ * 404:
+ * description: 토큰 없음 or 만료
+ */
+router.get('/qr-login', qrController.getToken);
+
+export default router;

src/services/__test__/qr.service.test.ts

@@ -0,0 +1,83 @@
+import { QRLoginTokenService } from '@/services/qr.service';
+import { QRLoginTokenRepository } from '@/repositories/qr.repository';
+import { DBError } from '@/exception';
+import { QRLoginToken } from '@/types/models/QRLoginToken.type';
+
+jest.mock('@/repositories/qr.repository');
+
+describe('QRLoginTokenService', () => {
+ let service: QRLoginTokenService;
+ let repo: jest.Mocked<QRLoginTokenRepository>;
+
+ beforeEach(() => {
+ const repoInstance = new QRLoginTokenRepository({} as any)
+ repo = repoInstance as jest.Mocked<QRLoginTokenRepository>;
+ service = new QRLoginTokenService(repo);
+ });
+
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('create', () => {
+ it('QR 토큰을 생성하고 반환해야 한다', async () => {
+ const userId = 1;
+ const ip = '127.0.0.1';
+ const userAgent = 'Chrome';
+ const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+ const token = await service.create(userId, ip, userAgent);
+
+ expect(token).toMatch(uuidRegex);
+ expect(repo.createQRLoginToken).toHaveBeenCalledWith(token, userId, ip, userAgent);
+ });
+
+ it('QR 토큰 생성 중 오류 발생 시 예외 발생', async () => {
+ const userId = 1;
+ const ip = '127.0.0.1';
+ const userAgent = 'Mozilla';
+ repo.createQRLoginToken.mockRejectedValueOnce(new DBError('생성 실패'));
+
+ await expect(service.create(userId, ip, userAgent)).rejects.toThrow('생성 실패');
+ expect(repo.createQRLoginToken).toHaveBeenCalled();
+ });
+ });
+
+ describe('getByToken', () => {
+ const mockToken = 'sample-token';
+ const mockQRToken: QRLoginToken = {
+ token: mockToken,
+ user: 1,
+ created_at: new Date(),
+ expires_at: new Date(Date.now() + 1000 * 60 * 5),
+ is_used: false,
+ ip_address: '127.0.0.1',
+ user_agent: 'Chrome',
+ };
+
+ it('유효한 토큰 조회 시 QRLoginToken 반환', async () => {
+ repo.findQRLoginToken.mockResolvedValue(mockQRToken);
+
+ const result = await service.getByToken(mockToken);
+
+ expect(result).toEqual(mockQRToken);
+ expect(repo.findQRLoginToken).toHaveBeenCalledWith(mockToken);
+ });
+
+ it('토큰이 없을 경우 null 반환', async () => {
+ repo.findQRLoginToken.mockResolvedValue(null);
+
+ const result = await service.getByToken(mockToken);
+
+ expect(result).toBeNull();
+ expect(repo.findQRLoginToken).toHaveBeenCalledWith(mockToken);
+ });
+
+ it('토큰 조회 중 오류 발생 시 예외 발생', async () => {
+ repo.findQRLoginToken.mockRejectedValueOnce(new DBError('조회 실패'));
+
+ await expect(service.getByToken(mockToken)).rejects.toThrow('조회 실패');
+ expect(repo.findQRLoginToken).toHaveBeenCalledWith(mockToken);
+ });
+ });
+});

src/services/qr.service.ts

@@ -0,0 +1,17 @@
+import { QRLoginTokenRepository } from "@/repositories/qr.repository";
+import { QRLoginToken } from "@/types/models/QRLoginToken.type";
+import { randomUUID } from "crypto";
+
+export class QRLoginTokenService {
+ constructor(private qrRepo: QRLoginTokenRepository) {}
+
+ async create(userId: number, ip: string, userAgent: string): Promise<string> {
+ const token = randomUUID();
+ await this.qrRepo.createQRLoginToken(token, userId, ip, userAgent);
+ return token;
+ }
+
+ async getByToken(token: string): Promise<QRLoginToken | null> {
+ return await this.qrRepo.findQRLoginToken(token);
+ }
+}

src/types/dto/responses/qrResponse.type.ts

@@ -0,0 +1,7 @@
+import { BaseResponseDto } from '@/types/dto/responses/baseResponse.type';
+
+interface QRLoginTokenResponseData {
+ token: string;
+ }
+
+export class QRLoginTokenResponseDto extends BaseResponseDto<QRLoginTokenResponseData> { }

src/types/models/QRLoginToken.type.ts

@@ -0,0 +1,9 @@
+export interface QRLoginToken {
+ token: string;
+ user: number;
+ created_at: Date;
+ expires_at: Date;
+ is_used: boolean;
+ ip_address: string;
+ user_agent: string;
+}