의존성 주입

# FastAPI: Depends를 활용한 의존성 주입
from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import Annotated

app = FastAPI()

# 1. 의존성 함수들
def get_db():
    """데이터베이스 세션 의존성"""
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

def get_current_user(
    token: str = Depends(oauth2_scheme),
    db: Session = Depends(get_db)
):
    """인증된 사용자 의존성"""
    user = decode_token(token, db)
    if not user:
        raise HTTPException(status_code=401)
    return user

# 2. 서비스 클래스 정의
class UserService:
    def __init__(self, db: Session):
        self.db = db

    def get_user(self, user_id: int):
        return self.db.query(User).filter(User.id == user_id).first()

    def create_user(self, user_data: UserCreate):
        user = User(**user_data.dict())
        self.db.add(user)
        self.db.commit()
        return user

# 3. 서비스 의존성 함수
def get_user_service(db: Session = Depends(get_db)) -> UserService:
    return UserService(db)

# Type Alias로 가독성 향상
UserServiceDep = Annotated[UserService, Depends(get_user_service)]
CurrentUserDep = Annotated[User, Depends(get_current_user)]

# 4. 엔드포인트에서 의존성 주입
@app.get("/users/{user_id}")
def read_user(
    user_id: int,
    service: UserServiceDep,           # 자동 주입
    current_user: CurrentUserDep       # 인증 체크 + 주입
):
    user = service.get_user(user_id)
    if not user:
        raise HTTPException(status_code=404)
    return user

@app.post("/users")
def create_user(
    user_data: UserCreate,
    service: UserServiceDep
):
    return service.create_user(user_data)

# 5. 테스트에서 의존성 오버라이드
from fastapi.testclient import TestClient

def override_get_db():
    return TestingSessionLocal()

def override_user_service():
    return MockUserService()

app.dependency_overrides[get_db] = override_get_db
app.dependency_overrides[get_user_service] = override_user_service

client = TestClient(app)
response = client.get("/users/1")
assert response.status_code == 200

// NestJS: 데코레이터 기반 의존성 주입
import { Injectable, Module, Controller, Get, Post, Body } from '@nestjs/common';

// 1. 인터페이스 정의
interface IUserRepository {
  findById(id: number): Promise<User | null>;
  save(user: User): Promise<User>;
}

interface IEmailService {
  send(to: string, subject: string, body: string): Promise<boolean>;
}

// 2. Repository 구현체
@Injectable()
class TypeOrmUserRepository implements IUserRepository {
  constructor(
    @InjectRepository(User)
    private userRepo: Repository<User>
  ) {}

  async findById(id: number): Promise<User | null> {
    return this.userRepo.findOne({ where: { id } });
  }

  async save(user: User): Promise<User> {
    return this.userRepo.save(user);
  }
}

// 3. Service - 생성자 주입
@Injectable()
class UserService {
  constructor(
    // 토큰 기반 주입으로 인터페이스 의존
    @Inject('USER_REPOSITORY')
    private readonly userRepo: IUserRepository,

    @Inject('EMAIL_SERVICE')
    private readonly emailService: IEmailService
  ) {}

  async registerUser(name: string, email: string): Promise<User> {
    const user = new User(name, email);
    await this.userRepo.save(user);
    await this.emailService.send(email, '환영합니다!', '가입 감사합니다.');
    return user;
  }
}

// 4. Controller
@Controller('users')
class UserController {
  constructor(private readonly userService: UserService) {}

  @Post()
  async create(@Body() dto: CreateUserDto) {
    return this.userService.registerUser(dto.name, dto.email);
  }
}

// 5. Module - 의존성 등록
@Module({
  providers: [
    UserService,
    {
      provide: 'USER_REPOSITORY',
      useClass: TypeOrmUserRepository,
    },
    {
      provide: 'EMAIL_SERVICE',
      useClass: SmtpEmailService,
    },
  ],
  controllers: [UserController],
})
class UserModule {}

// 6. 테스트 - Mock Provider
const module = await Test.createTestingModule({
  providers: [
    UserService,
    {
      provide: 'USER_REPOSITORY',
      useValue: { findById: jest.fn(), save: jest.fn() },
    },
    {
      provide: 'EMAIL_SERVICE',
      useValue: { send: jest.fn().mockResolvedValue(true) },
    },
  ],
}).compile();