[25.04.21 / TASK-148] Feature - qrcode app & QRCode 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.integration.test.ts

@@ -0,0 +1,77 @@
+import dotenv from 'dotenv';
+import { Pool } from 'pg';
+import pg from 'pg';
+import { QRLoginTokenRepository } from '@/repositories/qr.repository';
+import { v4 as uuidv4 } from 'uuid';
+
+dotenv.config();
+jest.setTimeout(30000);
+
+describe('QRLoginTokenRepository Integration Test', () => {
+  let pool: Pool;
+  let repo: QRLoginTokenRepository;
+
+  beforeAll(async () => {
+    try {
+      const testPoolConfig: pg.PoolConfig = {
+        user: process.env.POSTGRES_USER,
+        host: process.env.POSTGRES_HOST,
+        database: process.env.DATABASE_NAME,
+        password: process.env.POSTGRES_PASSWORD,
+        port: Number(process.env.POSTGRES_PORT),
+        max: 1,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 5000,
+        statement_timeout: 30000,
+      };
+
+      if (process.env.POSTGRES_HOST !== 'localhost') {
+        testPoolConfig.ssl = { 
+            rejectUnauthorized: false,
+        };
+      }
+
+      pool = new Pool(testPoolConfig);
+      await pool.query('SELECT 1'); // 연결 확인
+      console.info('QR 테스트 DB 연결 성공');
+
+      // 필요한 테이블 및 유저 존재 확인 (선택 사항)
+      const tableCheck = await pool.query(`SELECT to_regclass('qr_login_tokens')`);
+      if (!tableCheck.rows[0].to_regclass) {
+        throw new Error('qr_login_tokens 테이블이 존재하지 않습니다.');
+      }
+
+      const userCheck = await pool.query(`SELECT COUNT(*) FROM users WHERE id = $1`, [1]);
+      if (parseInt(userCheck.rows[0].count) === 0) {
+        throw new Error('user_id = 1 유저가 존재하지 않습니다.');
+      }
+
+      repo = new QRLoginTokenRepository(pool);
+    } catch (error) {
+      console.error('QR 테스트 설정 중 오류:', error);
+      throw error;
+    }
+  });
+
+  afterAll(async () => {
+    await pool.end();
+  });
+
+  it('should insert and retrieve QR token', async () => {
+    const token = uuidv4();
+    const userId = 1;
+    const ip = '127.0.0.1';
+    const userAgent = 'test-agent';
+
+    await repo.createQRLoginToken(token, userId, ip, userAgent);
+    const result = await repo.findQRLoginToken(token);
+
+    expect(result).not.toBeNull();
+    expect(result?.token).toBe(token);
+  });
+
+  it('should return null for expired or used token', async () => {
+    const result = await repo.findQRLoginToken('invalid-token');
+    expect(result).toBeNull();
+  });
+});

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:
+ *       200:
+ *         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;