5.03 사용자 애그리거트 설계

public abstract sealed class User extends AbstractAggregateRoot<UserId>
        permits Member, Librarian {
    
    private final UserId id;
    private final Username username;
    private final HashedPassword password;
    private final Email email;
    private final FullName fullName;
    private final UserStatus status;

    protected User(UserId id, 
                  Username username, 
                  HashedPassword password, 
                  Email email, 
                  FullName fullName) {
        // 모든 사용자는 PENDING 상태로 시작합니다.
        this.id = Objects.requireNonNull(id, "User ID must not be null");
        this.username = Objects.requireNonNull(username, "Username must not be null");
        this.password = Objects.requireNonNull(password, "Password must not be null");
        this.email = Objects.requireNonNull(email, "Email must not be null");
        this.fullName = Objects.requireNonNull(fullName, "Full name must not be null");
        this.status = UserStatus.PENDING;
    }

    // 상태 확인 메서드들
    public boolean isActive() {
        return status == UserStatus.ACTIVE;
    }

    public boolean isPending() {
        return status == UserStatus.PENDING;
    }

    public boolean isWithdrawn() {
        return status == UserStatus.WITHDRAWN;
    }
}

public final class Member extends User {
    private MembershipTier currentTier;

    private Member(UserId id, 
                  Username username,
                  HashedPassword password, 
                  Email email, 
                  FullName fullName, 
                  MembershipTier initialTier) {
        super(id, username, password, email, fullName);
        this.currentTier = Objects.requireNonNull(initialTier, 
            "Initial membership tier must not be null");
    }

    // 팩토리 메서드를 통한 생성
    public static Result<Member> create(Username username,
                                      HashedPassword password,
                                      Email email,
                                      Supplier<Boolean> isEmailUnique,
                                      FullName fullName) {
        return ContractValidator.start()
                .require(isEmailUnique.get(), ErrorCodes.DUPLICATE_EMAIL, email)
                .validate()
                .map(__ -> new Member(
                        UserId.newId(),
                        username,
                        password,
                        email,
                        fullName,
                        MembershipTier.getDefaultTier()))
                .onSuccess(member -> 
                    member.registerDomainEvent(new MemberRegisteredEvent(member.getId())));
    }

    // 등급 변경 로직
    public Result<Void> changeTier(MembershipTier newTier) {
        return ContractValidator.start()
                .requireNotNull(newTier, ErrorCodes.ERROR_NULL_NEW_TIER)
                .require(!newTier.equals(currentTier), ErrorCodes.SAME_TIER)
                .validate()
                .onSuccess(__ -> {
                    MembershipTier previousTier = this.currentTier;
                    this.currentTier = newTier;
                    registerDomainEvent(new MemberTierChangedEvent(
                            this.getId(),
                            previousTier,
                            newTier,
                            newTier.isHigherThan(previousTier)
                    ));
                });
    }
}

public final class Librarian extends User {
    private String employeeId;

    private Librarian(UserId id, 
                     Username username,
                     HashedPassword password, 
                     Email email,
                     FullName fullName,
                     String employeeId) {
        super(id, username, password, email, fullName);
        this.employeeId = Objects.requireNonNull(employeeId, 
            "Employee ID must not be null");
    }

    public static Result<Librarian> create(Username username,
                                         HashedPassword password,
                                         Email email,
                                         Supplier<Boolean> isEmailUnique,
                                         FullName fullName,
                                         String employeeId) {
        return ContractValidator.start()
                .require(isEmailUnique.get(), ErrorCodes.DUPLICATE_EMAIL, email)
                .validate()
                .map(__ -> new Librarian(
                        UserId.newId(),
                        username,
                        password,
                        email,
                        fullName,
                        employeeId));
    }
}