🔥TIL #6. 모듈화와 MVC 패턴 #2

지난 포스팅에 이어 이번에는 project에서 모듈화하는 방법을 다룬다. 앞에서 다루었던 모듈을 다시 보자.

1. server.js
2. app.js
3. Router
4. Controller
5. Service
6. Model

위에서 부터 아래방향으로 Database에 가까워지면 각 layer는 아래 layer만 의존한다.

node.js 시리즈의 앞부분에서 진행한 project(사용자와 포스팅)를 기준으로 모듈화를 적용해 보자.

server.js

require('dotenv').config()
const { PORT } = process.env
const http = require('http')
const app = require('./app') 
const server = http.createServer(app) // Server 는 express 앱에 의존성을 가집니다.
const prisma = require('./prisma')

const start = async () => {
  try {
    server.listen(PORT, () => console.log(`Server is listening on ${PORT}`))
  } catch (err) {
    console.error(err)
    await prisma.$disconnect()
  }
}

server.js 는 app.js로부터 express app을 가져와 server를 실행한다. prisma는 server 종료시 disconnect 처리를 해야 하기에 model layer를 의존하지만 그 외 용도로 사용하지 않는다.

app.js

const express = require('express')
const routes = require('./routes')
const logger = require('morgan')('dev')
const app = express()

app.use(express.json())
app.use(logger)
app.use(routes) // Route 에 의존성을 가집니다.

app.use((err, req, res, next) => {
  const { status, message } = err
  console.error(err)
  res.status(status || 500).json({ message })
})

module.exports = app

app.js 는 Route layer를 의존하며 다음 기능을 담당한다.

• Express app 생성
• app 사용시 필수적인 middleware(json parser, logger, route, error) 추가

Routes

index.js

const express = require('express')
const router = express.Router() // express 라우팅 기능을 사용하기 위해서 router 객체가 필요합니다.
const UserRouter = require('./UserRouter') 

router.use('/users', UserRouter) // '/users' 엔드포인트를 처리하기 위해 UserRouter 를 붙여줍니다.

module.exports = router // 이렇게 내보낸 router 는 express app 의 미들웨어로 사용됩니다.

Routes에는 user, article 관련 route가 생성될 것이다. app.js 입장에선 한번의 require로 Routes 정보를 얻어야 simple 하므로 이를 위해 index.js를 app.js가 의존할 대상으로 만든다. index.js는 express.Router 객체를 만들어 제공하며 이 router는 같은 Routes 폴더에 있는 route 들을 의존한다.

userRouter.js

const express = require('express')
const router = express.Router()
const { UserController } = require('../controllers') 
// Route 는 오직 Controller 에만 의존 합니다.

router.post('/login', UserController.logIn) // '/users/login' 핸들링 하는 컨트롤러 함수
router.post('/signup', UserController.signUp) // '/users/signUp' 핸들링 하는 컨트롤러 함수

module.exports = router // 이렇게 내보내면 부모 router 에 자동으로 연결됩니다.

user와 관련된 request 처리 로직을 관리한다. router 를 만들어 세부적인 api 및 요청 처리를 주입하고 이를 index.js가 사용할 수 있도록 exports 한다.
요청 처리는 Controller layer가 담당하며 userRouter는 userController 를 의존.

Controllers

index.js

const UserController = require('./UserController')

module.exports = {
  UserController,
}

Routes/index.js와 마찬가지로 Routes가 Controller를 의존하는 입구와 같은 역할이다.

userController.js

const { AUTH_TOKEN_SALT } = process.env
const bcrypt = require('bcrypt')
const jwt = require('jsonwebtoken')
// Controller 는 오직 Service 레이어에만 의존합니다.
const { UserService } = require('../services') 
// 자주 사용되는 로직은 utils 로 빼서 모듈로 관리합니다.
const { errorGenerator } = require('../utils')

// 아래 정의된 함수는 지난 수업시간에 다룬 내용 입니다.
const signUp = async (req, res, next) => {
  try {
    const { email, password } = req.body

    const foundUser = await UserService.findUser({ email })
    if (foundUser) errorGenerator({ statusCode: 409, message: 'duplicated' })

    const hashedPassword = await bcrypt.hash(password, 10)

    const createdUser = await UserService.createUser({
      email,
      password: hashedPassword,
    })

    res.status(201).json({
      message: 'user created',
      user_id: createdUser.id,
    })
  } catch (err) {
    next(err)
  }
}

const logIn = async (req, res, next) => {
  try {
    const { email, password: inputPassword } = req.body

    const foundUser = await UserService.findUser({ email })

    if (!foundUser)
      errorGenerator({ statusCode: 400, message: 'client input invalid' })

    const { id, password: hashedPassword } = foundUser
    const isValidPassword = await bcrypt.compare(inputPassword, hashedPassword)

    if (!isValidPassword)
      errorGenerator({ statusCode: 400, message: 'client input invalid' })

    const token = jwt.sign({ id }, AUTH_TOKEN_SALT, { expiresIn: '1h' })
    res.status(200).json({ message: 'login success!', token })
  } catch (err) {
    next(err)
  }
}

module.exports = {
  logIn,
  signUp,
}

Controller는 request에 대한 response 를 담당한다. Model 제어 권한을 갖는 Service를 의존하며 Service를 통한 Database CRUD를 제외한 모든 처리를 담당.

Services

index.js

const UserService = require('./UserService')

module.exports = {
  UserService,
}

타 module index.js와 사용의도 동일.

userService.js

const prisma = require('../prisma') // Service 로직은 오직 Model(=Prisma) 에만 의존합니다.
const { makeDataForCreate } = require('../utils')

const createUser = (fields) => {
  const data = makeDataForCreate(fields)
  return prisma.users.create({ data })
}

const findUser = (field) => {
  const [uniqueKey] = Object.keys(field)

  const isKeyId = uniqueKey === 'id'
  const value = isKeyId ? Number(field[uniqueKey]) : field[uniqueKey]

  return prisma.users.findOne({ where: { [uniqueKey]: value } })
}

module.exports = {
  createUser,
  findUser,
}

Database에 대한 제어를 하므로 prisma를 의존한다. database에 대한 CRUD 를 담당한다.

prisma(= Model)

index.js

const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient()

module.exports = prisma 
// 이렇게 인스턴스화 된 prisma 는 Service 레이어에서 데이터베이스에 접근하는 로직에 사용됩니다.