13 타입스크립트와 객체 지향

13.2 우아한형제들의 활용 방식

우아한형제들의 한 팀에서는 다음과 같은 설계 방식을 사용한다.

  • 온전히 레이아웃만 담당하는 컴포넌트 영역
  • 컴포넌트 영역 위에서 레이아웃과 비즈니스 로직을 연결해주는 커스텀 훅 영역
  • 훅 영역 위에서 객체로서 상호 협력하는 모델 영역
  • 모델 영역 위에서 API를 해석하여 모델로 전달하는 API 레이어 영역

각 영역이 어떻게 구성되었는지 살펴보자.

1. 컴포넌트 영역

우선 컴포넌트부터 살펴보자.

아래는 장바구니 관련 다이얼로그 컴포넌트 코드다.

// components/CartCloseoutDialog.tsx
import { useCartStore } from 'store/modules/cart'

const CartCloseoutDialog: React.VFC = () => {
  const cartStore = useCartStore()

  return (
    <Dialog
      opened={cartStore.PresentationTracker.isDialogOpen('closeout')}
      title="마감 세일이란?"
      onRequestClose={cartStore.PresentationTracker.closeDialog}
    >
      <div
        css={css`
          margin-top: 8px;
        `}
      >
        지점별 한정 수량으로 제공되는 할인 상품입니다. 재고 소진 시 가격이 달라질 수 있습니다.
유통기한이 다소 짧으나 좋은 품질의 상품입니다.
      </div>
    </Dialog>
  )
}

export default CartCloseoutDialog

정말 온전히 레이아웃 영역만 담당하는 것을 볼 수 있다.

그렇다면 비즈니스 로직은 useCartStore 내부 어딘가에 존재할 것이다.

전역 상태를 관리하는 스토어 내의 useCartStore를 살펴보자.

2. 커스텀 훅 영역

// store/cart.ts
class CartStore {
  public async add(target: RecommendProduct): Promise<void> {
    const response = await addToCart(
      addToCartRequest({
        auths: this.requestInfo.AuthHeaders,
        cartProducts: this.productsTracker.PurchasableProducts,
        shopID: this.shopID,
        target,
      })
    )
    return response.fork(
      (error, _, statusCode) => {
        switch (statusCode) {
          case ResponseStatus.FAILURE:
            this.presentationTracker.pushToast(error)
            break
          case ResponseStatus.CLIENT_ERROR:
            this.presentationTracker.pushToast('네트워크가 연결되지 않았습니다.')
            break
          default:
            this.presentationTracker.pushToast('연결 상태가 일시적으로 불안정합니다.')
        }
      },
      (message) => this.applyAddedProduct(target, message)
    )
  }
}

const [CartStoreProvider, useCartStore] = setupContext<CartStore>('CartStore')
export { CartStore, CartStoreProvider, useCartStore }

왜 훅이 아닌 스토어로 들어가는지 의문을 가질 수 있겠지만, 해당 스토어 객체에서 최종적으로 사용되는 setupContext는 컨텍스트와 관련된 훅을 다루는 유틸리티 함수이기 때문에 훅 영역의 로직으로 봐도 될 것이다.

즉, 장바구니에 상품을 담는 비즈니스 로직을 레이아웃과 연결해주기 위한 커스텀 훅 영역이라는 것을 확인할 수 있다.

그리고 해당 스토어 객체 내에서 addToCart를 호출하고 있다.

addToCart는 분명 API를 호출하는 함수일 것이며, 내부에서는 addToCartRequest 시리얼라이저 함수를 호출하고 있다.

addToCartRequest 시리얼라이저 함수를 살펴보자.

// serializers/cart/addToCartReqeust.ts
import { AddToCartRequest } from 'models/externals/Cart/Request'
import { IRequestHeader } from 'models/externals/lib'
import {
  RecommendProduct,
  RecommendProductItems,
} from 'models/internals/Cart/RecommendProduct'
import { Product } from 'models/internals/Stuff/Product'

interface Params {
  auths: IRequestHeader;
  cartProducts: Product[];
  shopID: number;
  target: RecommendProduct;
}

function addToCartRequest({
  auths,
  cartProducts,
  shopID,
  target,
}: Params): AddToCartRequest {
  const productAlreadyInCart = cartProducts.find(
    (product) => product.getId() === target.getId()
  )

  return {
    body: {
      items: target.getItems().map((item) => ({
        itemId: item.id,
        quantity: getItemQuantityFor(productAlreadyInCart, item),
        salePrice: item.price,
      })),
      productId: target.getId(),
      shopId: shopID,
    },
    headers: auths,
  }
}

export { addToCartRequest }

이 함수는 AddToCartRequest 타입의 객체를 반환하며, 매개변수(파라미터)로 받는 target은 RecommendProduct 타입을 가진다.

해당 타입에 대한 정의는 어디서 확인할 수 있을까?

이제 모델 영역을 살펴보자.

3. 모델 영역

// models/Cart.ts
export interface AddToCartRequest {
  body: {
    shopId: number;
    items: { itemId: number; quantity: number; salePrice: number }[];
    productId: number;
  },
  headers: IRequestHeader;
}

/**
 * 추천 상품 관련 class
 */
export class RecommendProduct {
  public getId(): number {
    return this.id
  }

  public getName(): string {
    return this.name
  }

  public getThumbnail(): string {
    return this.thumbnailImageUrl
  }

  public getPrice(): RecommendProductPrice {
    return this.price
  }

  public getCalculatedPrice(): number {
    const price = this.getPrice()
    return price.sale?.price ?? price.origin
  }

  public getItems(): RecommendProductItem[] {
    return this.items
  }

  public getType(): string {
    return this.type
  }

  public getRef(): string {
    return this.ref
  }

  constructor(init: ICartRecommendProductResponse) {
    this.id = init.id
    this.name = init.displayName
    this.thumbnailImageUrl = init.thumbnailImageUrl
    this.price = {
      sale: init.displayDiscounted
        ? {
            price: Math.floor(init.salePrice),
            percent: init.discountPercent,
          }
        : null,
      origin: Math.floor(init.retailPrice),
    }
    this.type = init.saleUnit
    this.items = init.items.map((item) => {
      return {
        id: item.id,
        minQuantity: item.minCount,
        price: Math.floor(item.salePrice),
      }
    })
    this.ref = init.productRef
  }

  private id: number
  private name: string
  private thumnailImageUrl: string
  private price: RecommendProductPrice
  private items: RecommendProductItem[]
  private type: string
  private ref: string
}

RecommendProduct는 클래스로 표현된 객체로 추천 상품을 나타내며, 이 객체는 다른 컴포넌트 및 모델 객체와 함께 협력하게 된다.

마지막으로 훅에서 실제로 실행되는 addToCart 함수를 살펴보자.

4. API 레이어 영역

// apis/Cart.ts
// APIResponse는 데이터 로드에 성공한 상태와 실패한 상태의 반환 값을 제네릭하게 표현해주는 API 응답 객체이다
// (APIResponse<OK, Error>)
interface APIResponse<OK, Error> {
  // API 응답에 성공한 경우의 데이터 형식
  ok: OK;

  // API 응답에 실패한 경우의 에러 형식
  error: Error;
}

export const addToCart = async (
  param: AddToCartRequest
): Promise<APIResponse<string, string>> => {
  return (await GatewayAPI.post<IAddCartResponse>('/v3/cart', param)).map(
    (data) => data.message
  )
}

지금까지 살펴본 예시는 대규모 서비스를 구성하는 프로젝트의 극히 일부분에 불과하므로 생략된 코드가 많고 역할이 세세하게 분배되어 있어 정확히 어떤 객체 또는 함수가 컴포넌트·훅·모델·API 레이어 영역에 포함된 것인지 판단하기 어렵다.

하지만 앞의 예시만으로도 어떤 식으로 각 객체에 적절한 역할과 책임을 할당하여 올바른 협력을 구성하고 설계해야 하는지를 이해할 수 있을 것이다.


많이 하는 착각 중 하나가 객체 지향 구현 자체를 클래스라고 생각하는 것이다.

전혀 그렇지 않다.

클래스는 객체를 표현하는 방법의 도구일 뿐이다.

컴포넌트를 함수형으로 선언하든 클래스형으로 선언하든 모두 객체를 나타낸다.

그렇다면 어떤 방식을 사용하는 게 나을까?

리액트 훅이 나온 순간부터 함수 컴포넌트의 사용률이 높아졌으며, 실제로 리액트 공식 문서에서도 함수 컴포넌트를 권장하고 있다.

애플리케이션의 설계는 트레이드오프의 결과물이며 우리는 둘 중 상황에 맞는 적절한 방법을 선택해야 한다.

실제로 틀에서 찍어내듯 일관된 템플릿에 맞춘 컴포넌트를 많이 생성해야 할 때는 클래스 컴포넌트 방식을 따를 때도 있다.

예를 들어 페이지 템플릿을 클래스 컴포넌트로 만들어서 공통으로 정의되어야 할 행동(예: 내비게이션의 뒤로가기 버튼을 눌렀을 때의 동작 등)을 abstract 메서드로 만들어 사용하기도 한다.

한편으론 ‘해당 행동을 단순히 props로 넘겨도 되지 않을까’라고 생각할 수도 있다.

공통으로 쓰이는 템플릿을 클래스 컴포넌트로 정의한다면 해당 코드에 익숙한 개발자는 빠르고 쉽게 컴포넌트를 만들어낼 것이다.

그러나 상속 구조가 복잡해지면 코드 해석이 어려워지고 디버깅도 힘들어진다.

특히 새로운 팀원은 설계를 이해하는 데 시간이 오래 걸릴 수 있다.

따라서 프로젝트에 어떤 방식이 가장 적합한지를 심도 있게 고민하면서 설계해야 한다.