디자인 패턴 전에 알아야 할 안티패턴 — 3편: 계층과 모듈 구조

// controller
export async function getUserHandler(req: Request) {
  return userService.getUser(req.params.id);
}
 
// service
export const userService = {
  getUser: (id: string) => userFacade.getUser(id),
};
 
// facade
export const userFacade = {
  getUser: (id: string) => userRepository.findById(id),
};
 
// repository
export const userRepository = {
  findById: (id: string) => db.query.users.findFirst({ where: eq(users.id, id) }),
};

// 읽기 경로 — 도메인 규칙이 없으므로 쿼리 모듈이 직접 조회
export const userQueries = {
  getProfile: (id: string) =>
    db.select({ id: users.id, name: users.name, grade: users.grade })
      .from(users)
      .where(eq(users.id, id)),
};
 
// 쓰기 경로 — 규칙이 있는 곳만 서비스를 거친다
export const userCommands = {
  async changeEmail(id: string, email: string) {
    const user = await userRepository.findById(id);
    user.changeEmail(email); // 검증, 중복 확인, 이벤트 발행
    await userRepository.save(user);
  },
};

// order/order.service.ts
import { userService } from "../user/user.service";
 
export const orderService = {
  async create(userId: string, items: OrderItem[]) {
    const user = await userService.find(userId);
    // ...
  },
  async countByUser(userId: string) {
    return orderRepository.count({ userId });
  },
};
 
// user/user.service.ts
import { orderService } from "../order/order.service";
 
export const userService = {
  async find(id: string) { /* ... */ },
  async getGrade(id: string) {
    const count = await orderService.countByUser(id);
    return count > 10 ? "VIP" : "NORMAL";
  },
};

// grade/grade.service.ts — user와 order를 모두 의존하는 상위 모듈
import { userService } from "../user/user.service";
import { orderService } from "../order/order.service";
 
export const gradeService = {
  async getGrade(userId: string) {
    const user = await userService.find(userId);
    if (!user) throw new UserNotFoundError(userId);
    const count = await orderService.countByUser(userId);
    return count > 10 ? "VIP" : "NORMAL";
  },
};
// user → order 의존이 사라졌다. 이제 방향은 grade → user, grade → order, order → user 한 방향뿐이다.

npx madge --circular --extensions ts src/

interface UserRepository {
  findById(id: string): Promise<User | null>;
  // 호출자가 SQL 문법과 컬럼명을 알아야 한다
  search(whereClause: string): Promise<User[]>;
}
 
// service
try {
  await userRepository.create(user);
} catch (e: any) {
  // PostgreSQL의 unique_violation 에러 코드를 서비스가 알고 있다
  if (e.code === "23505") {
    throw new Error("이미 가입된 이메일입니다");
  }
  throw e;
}

export class DuplicateEmailError extends Error {
  constructor(public readonly email: string) {
    super(`이미 가입된 이메일입니다: ${email}`);
  }
}
 
export interface UserSearchCriteria {
  nameContains?: string;
  grade?: "VIP" | "NORMAL";
  joinedAfter?: Date;
}
 
export interface UserRepository {
  findById(id: string): Promise<User | null>;
  search(criteria: UserSearchCriteria): Promise<User[]>;
  create(user: User): Promise<void>; // 중복 시 DuplicateEmailError
}
 
// 구현체 내부에서만 DB를 안다
export class PgUserRepository implements UserRepository {
  async create(user: User) {
    try {
      await db.insert(users).values(toRow(user));
    } catch (e) {
      if (isUniqueViolation(e)) throw new DuplicateEmailError(user.email);
      throw e;
    }
  }
  // ...
}

export class Order {
  id!: string;
  status!: "PENDING" | "PAID" | "SHIPPED" | "CANCELLED";
  items!: OrderItem[];
  paidAt?: Date;
}
 
export const orderService = {
  cancel(order: Order) {
    if (order.status === "SHIPPED") throw new Error("배송된 주문은 취소할 수 없습니다");
    if (order.status === "CANCELLED") throw new Error("이미 취소된 주문입니다");
    order.status = "CANCELLED";
  },
};
 
// 다른 파일 어딘가 — 규칙을 그대로 우회한다
order.status = "CANCELLED";

export class Order {
  #status: OrderStatus;
 
  constructor(
    public readonly id: string,
    status: OrderStatus,
    private readonly items: OrderItem[],
  ) {
    this.#status = status;
  }
 
  get status() {
    return this.#status;
  }
 
  cancel() {
    if (this.#status === "SHIPPED") throw new OrderAlreadyShippedError(this.id);
    if (this.#status === "CANCELLED") throw new OrderAlreadyCancelledError(this.id);
    this.#status = "CANCELLED";
  }
 
  get total() {
    return this.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
  }
}
 
// 서비스는 조율만 한다
export const orderService = {
  async cancel(orderId: string) {
    const order = await orderRepository.findById(orderId);
    order.cancel();
    await orderRepository.save(order);
  },
};

CREATE TABLE entity_attributes (
  entity_id   BIGINT,
  attr_name   VARCHAR(100),
  attr_value  VARCHAR(4000)
);

const discountRule = {
  if: { field: "order.total", op: ">", value: 100000 },
  then: { action: "applyDiscount", rate: 0.1 },
};

// 규칙은 코드, 임계값과 비율은 설정
export function calculateDiscount(order: Order, config: DiscountConfig) {
  return order.total > config.threshold ? order.total * config.rate : 0;
}

export interface StorageClient {
  upload(key: string, body: Buffer): Promise<void>;
  download(key: string): Promise<Buffer>;
  delete(key: string): Promise<void>;
  list(prefix: string): Promise<string[]>;
  createSignedUrl(key: string, ttlSeconds: number): Promise<string>;
  setLifecyclePolicy(policy: LifecyclePolicy): Promise<void>;
  replicate(targetRegion: string): Promise<void>;
  encrypt(key: string): Promise<void>;
  resizeImage(key: string, width: number): Promise<void>;
  scanVirus(key: string): Promise<ScanResult>;
}
 
export class LocalDiskStorage implements StorageClient {
  // ...
  async replicate() { throw new Error("Not supported"); }
  async setLifecyclePolicy() { throw new Error("Not supported"); }
  async resizeImage() { throw new Error("Not supported"); }
}

export interface FileReader {
  download(key: string): Promise<Buffer>;
}
 
export interface FileWriter {
  upload(key: string, body: Buffer): Promise<void>;
  delete(key: string): Promise<void>;
}
 
export interface SignedUrlIssuer {
  createSignedUrl(key: string, ttlSeconds: number): Promise<string>;
}
 
// 소비자는 필요한 역할만 의존한다
export async function getAvatarUrl(userId: string, urls: SignedUrlIssuer) {
  return urls.createSignedUrl(`avatars/${userId}`, 300);
}
 
// 구현체는 가능한 역할만 구현한다
export class S3Storage implements FileReader, FileWriter, SignedUrlIssuer { /* ... */ }
export class LocalDiskStorage implements FileReader, FileWriter { /* ... */ }