Express 프로덕션 아키텍처: 3레이어

src/
├── controllers/    # HTTP 요청/응답 변환
├── services/       # 비즈니스 로직
├── repositories/   # 데이터 액세스
├── middlewares/    # 인증·로깅·에러
├── routes/         # URL → controller 매핑
└── utils/

// controllers/post.controller.ts
import { Request, Response, NextFunction } from 'express';
import { PostService } from '@/services/post.service';

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

  list = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const { page = 1, limit = 20 } = req.query;
      const result = await this.postService.list({
        page: Number(page), limit: Number(limit),
      });
      res.json(result);
    } catch (err) { next(err); }
  };

  create = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const userId = req.user!.id;  // 인증 미들웨어가 주입
      const post = await this.postService.create(userId, req.body);
      res.status(201).json(post);
    } catch (err) { next(err); }
  };
}

// services/post.service.ts
import { z } from 'zod';
import { PostRepository } from '@/repositories/post.repository';
import { ForbiddenError, ValidationError } from '@/utils/errors';

const CreatePostSchema = z.object({
  title: z.string().min(1).max(200),
  content: z.string().min(1),
  tags: z.array(z.string()).max(10),
});

export class PostService {
  constructor(private repo: PostRepository) {}

  async list({ page, limit }: { page: number; limit: number }) {
    const offset = (page - 1) * limit;
    const [items, total] = await Promise.all([
      this.repo.findMany({ offset, limit }),
      this.repo.count(),
    ]);
    return { items, total, page, limit, totalPages: Math.ceil(total / limit) };
  }

  async create(userId: string, data: unknown) {
    const parsed = CreatePostSchema.safeParse(data);
    if (!parsed.success) throw new ValidationError(parsed.error);
    return this.repo.create({ ...parsed.data, authorId: userId });
  }

  async update(userId: string, postId: string, data: unknown) {
    const post = await this.repo.findById(postId);
    if (!post) throw new NotFoundError('Post');
    if (post.authorId !== userId) throw new ForbiddenError();
    return this.repo.update(postId, data);
  }
}

// repositories/post.repository.ts
import { PrismaClient } from '@prisma/client';

export class PostRepository {
  constructor(private prisma: PrismaClient) {}

  findMany({ offset, limit }: { offset: number; limit: number }) {
    return this.prisma.post.findMany({
      skip: offset, take: limit,
      orderBy: { createdAt: 'desc' },
      include: { author: { select: { id: true, name: true } } },
    });
  }

  count() { return this.prisma.post.count(); }
  findById(id: string) { return this.prisma.post.findUnique({ where: { id } }); }
  create(data: any) { return this.prisma.post.create({ data }); }
  update(id: string, data: any) { return this.prisma.post.update({ where: { id }, data }); }
}

// container.ts
import { PrismaClient } from '@prisma/client';
import { PostRepository } from './repositories/post.repository';
import { PostService } from './services/post.service';
import { PostController } from './controllers/post.controller';

const prisma = new PrismaClient();

const postRepo = new PostRepository(prisma);
const postService = new PostService(postRepo);
export const postController = new PostController(postService);


// routes/post.routes.ts
import { Router } from 'express';
import { postController } from '@/container';
import { authenticate } from '@/middlewares/auth';

const router = Router();
router.get('/', postController.list);
router.post('/', authenticate, postController.create);
export default router;