제14강: API 개발과 문서화

포스트 컨트롤러

// controllers/postController.ts
import { Request, Response, NextFunction } from 'express';
import { PostService } from '../services/postService';
import { ApiResponse } from '../types/api';
import { validatePost } from '../validators/postValidator';
import { cache } from '../middleware/cache';

export class PostController {
    constructor(private postService: PostService) {}

    /**
     * @swagger
     * /api/posts:
     *   get:
     *     summary: 포스트 목록 조회
     *     tags: [Posts]
     *     parameters:
     *       - in: query
     *         name: page
     *         schema:
     *           type: integer
     *           default: 1
     *       - in: query
     *         name: limit
     *         schema:
     *           type: integer
     *           default: 10
     *       - in: query
     *         name: category
     *         schema:
     *           type: string
     *       - in: query
     *         name: tags
     *         schema:
     *           type: array
     *           items:
     *             type: string
     *       - in: query
     *         name: status
     *         schema:
     *           type: string
     *           enum: [draft, published, archived]
     *     responses:
     *       200:
     *         description: 포스트 목록
     *         content:
     *           application/json:
     *             schema:
     *               $ref: '#/components/schemas/PostListResponse'
     */
    @cache({ ttl: 300 }) // 5분 캐싱
    async getPosts(req: Request, res: Response, next: NextFunction) {
        try {
            const {
                page = 1,
                limit = 10,
                category,
                tags,
                status = 'published',
                sort = '-publishedAt'
            } = req.query;

            const filters = {
                status,
                ...(category && { category }),
                ...(tags && { tags: { $in: Array.isArray(tags) ? tags : [tags] } })
            };

            const posts = await this.postService.findPosts({
                filters,
                page: Number(page),
                limit: Number(limit),
                sort
            });

            const response: ApiResponse = {
                success: true,
                data: posts.data,
                meta: {
                    page: posts.page,
                    limit: posts.limit,
                    total: posts.total
                }
            };

            res.json(response);
        } catch (error) {
            next(error);
        }
    }

    /**
     * @swagger
     * /api/posts:
     *   post:
     *     summary: 새 포스트 작성
     *     tags: [Posts]
     *     security:
     *       - bearerAuth: []
     *     requestBody:
     *       required: true
     *       content:
     *         application/json:
     *           schema:
     *             $ref: '#/components/schemas/CreatePostRequest'
     *     responses:
     *       201:
     *         description: 생성된 포스트
     *       400:
     *         description: 유효성 검사 실패
     *       401:
     *         description: 인증 필요
     */
    async createPost(req: Request, res: Response, next: NextFunction) {
        try {
            const validation = validatePost(req.body);
            if (!validation.valid) {
                return res.status(400).json({
                    success: false,
                    error: {
                        code: 'VALIDATION_ERROR',
                        message: 'Invalid post data',
                        details: validation.errors
                    }
                });
            }

            const post = await this.postService.createPost({
                ...req.body,
                authorId: req.user.id
            });

            res.status(201).json({
                success: true,
                data: post
            });
        } catch (error) {
            next(error);
        }
    }

    /**
     * @swagger
     * /api/posts/{id}:
     *   get:
     *     summary: 포스트 상세 조회
     *     tags: [Posts]
     *     parameters:
     *       - in: path
     *         name: id
     *         required: true
     *         schema:
     *           type: string
     *     responses:
     *       200:
     *         description: 포스트 상세
     *       404:
     *         description: 포스트를 찾을 수 없음
     */
    async getPost(req: Request, res: Response, next: NextFunction) {
        try {
            const { id } = req.params;
            const post = await this.postService.findPostById(id);

            if (!post) {
                return res.status(404).json({
                    success: false,
                    error: {
                        code: 'NOT_FOUND',
                        message: 'Post not found'
                    }
                });
            }

            // 조회수 증가 (비동기로 처리)
            this.postService.incrementViewCount(id).catch(console.error);

            res.json({
                success: true,
                data: post
            });
        } catch (error) {
            next(error);
        }
    }

    // 나머지 CRUD 메서드들...
}