Feature/profile

MovieBooking/App/Reducer/AppReducer.swift

@@ -15,9 +15,7 @@ struct AppReducer {
   enum State {
     case splash(SplashFeature.State)
     case auth(AuthCoordinator.State)
-    case mainTab(MainTabReducer.State)
-
-
+    case mainTab(MainTabFeature.State)
 
     init() {
       self = .splash(.init())
@@ -35,20 +33,20 @@ struct AppReducer {
     case presentMain
   }
 
-
   @CasePathable
   enum ScopeAction {
     case splash(SplashFeature.Action)
     case auth(AuthCoordinator.Action)
-    case mainTab(MainTabReducer.Action)
+    case mainTab(MainTabFeature.Action)
   }
 
+
   @Dependency(\.continuousClock) var clock
 
   public var body: some Reducer<State, Action> {
     Reduce { state, action in
       switch action {
-      case .view(let viewAction):
+        case .view(let viewAction):
           return handleViewAction(&state, action: viewAction)
 
         case .scope(let scopeAction):
@@ -62,7 +60,7 @@ struct AppReducer {
       AuthCoordinator()
     }
     .ifCaseLet(\.mainTab, action: \.scope.mainTab) {
-      MainTabReducer()
+      MainTabFeature()
     }
   }
 }
@@ -73,15 +71,14 @@ extension AppReducer {
     action: View
   ) -> Effect<Action> {
     switch action {
-      // MARK: - 로그인 화면으로
-    case .presentAuth:
-      state = .auth(.init())
-      return .none
+        // MARK: - 로그인 화면으로
+      case .presentAuth:
+        state = .auth(.init())
+        return .none
 
-    case .presentMain:
+      case .presentMain:
         state = .mainTab(.init())
-      return .none
-
+        return .send(.scope(.mainTab(.scope(.movieList(.fetchMovie)))))
     }
   }
 
@@ -92,23 +89,26 @@ extension AppReducer {
   ) -> Effect<Action> {
     switch action {
       case .splash(.navigation(.presentLogin)):
-      return .run { send in
-        try await clock.sleep(for: .seconds(1))
-        await send(.view(.presentAuth))
-      }
-
-    case .splash(.navigation(.presentMain)):
-      return .run { send in
-        try await clock.sleep(for: .seconds(1))
-        await send(.view(.presentMain))
-      }
-
-
-    case .auth(.navigation(.presentMain)):
-      return .send(.view(.presentMain),  animation: .easeIn)
+        return .run { send in
+          try await clock.sleep(for: .seconds(1))
+          await send(.view(.presentAuth))
+        }
+
+      case .splash(.navigation(.presentMain)):
+        return .run { send in
+          try await clock.sleep(for: .seconds(1))
+          await send(.view(.presentMain))
+        }
+
+      case .auth(.navigation(.presentMain)):
+        return .send(.view(.presentMain), animation: .easeIn)
+
+      case .mainTab(.navigation(.backToLogin)):
+        return .run { send in
+          await send(.view(.presentAuth), animation: .easeIn)
+        }
+      default: return .none
 
-    default:
-      return .none
     }
   }
 }

MovieBooking/App/View/AppView.swift

@@ -10,27 +10,25 @@ import SwiftUI
 import ComposableArchitecture
 
 struct AppView: View {
-  @Perception.Bindable var store: StoreOf<AppReducer>
+  var store: StoreOf<AppReducer>
 
   var body: some View {
-    WithPerceptionTracking {
-      SwitchStore(store) { state in
-        switch state {
-          case .splash:
-            if let store = store.scope(state: \.splash, action: \.scope.splash) {
-              SplashView(store: store)
-            }
+    SwitchStore(store) { state in
+      switch state {
+        case .splash:
+          if let store = store.scope(state: \.splash, action: \.scope.splash) {
+            SplashView(store: store)
+          }
 
-          case .auth:
-            if let store = store.scope(state: \.auth, action: \.scope.auth) {
-              AuthCoordinatorView(store: store)
-            }
+        case .auth:
+          if let store = store.scope(state: \.auth, action: \.scope.auth) {
+            AuthCoordinatorView(store: store)
+          }
 
-          case .mainTab:
-            if let store = store.scope(state: \.mainTab, action: \.scope.mainTab) {
-              MainTabView(store: store)
-            }
-        }
+        case .mainTab:
+          if let store = store.scope(state: \.mainTab, action: \.scope.mainTab) {
+            MainTabView(store: store)
+          }
       }
     }
   }

MovieBooking/DesignSystem/Color/Colors.swift

@@ -18,4 +18,5 @@ public extension ShapeStyle where Self == Color {
   static var indigo500: Color { .init(hex: "6C4EFF") }
   static var statusError: Color { .init(hex: "D32F2F")}
   static var gray500: Color { .init(hex: "9E9E9E")}
+  static var lavenderPurple: Color { .init(hex: "C4B5FD")}
 }

MovieBooking/Domain/Entity/Error/Common/CommonError.swift

@@ -7,39 +7,42 @@
 
 import Foundation
 
-/// 공통 에러 (네트워크 등 전역에서 공유되는 경우에만 사용)
+/// 공통 에러 (정말 공통으로 사용되는 에러만)
+///
+/// ⚠️ 주의: 특정 도메인에 속하는 에러는 각 도메인 에러를 사용하세요
+/// - 네트워크 에러 → NetworkError
+/// - 데이터 에러 → DataError
+/// - 유효성 검사 에러 → ValidationError
+/// - 시스템 에러 → SystemError
 public enum CommonError: Error, Equatable {
-  case networkUnavailable
-  case requestTimeout
-  case serverError(statusCode: Int)
-  case rateLimited(retryAfter: TimeInterval?)
+  /// 알 수 없는 에러 (최후의 수단)
   case unknown(message: String? = nil)
+
+  /// 취소된 작업
+  case cancelled
+
+  /// 지원되지 않는 기능
+  case unsupported(feature: String? = nil)
 }
 
 // MARK: - 사용자 메시지 (UI friendly)
 extension CommonError: LocalizedError {
   public var errorDescription: String? {
     switch self {
-    case .networkUnavailable:
-      return "네트워크 연결을 확인해주세요."
-
-    case .requestTimeout:
-      return "요청 시간이 초과되었습니다. 다시 시도해주세요."
-
-    case .serverError(let statusCode):
-      return "서버 오류가 발생했습니다(코드: \(statusCode)). 잠시 후 다시 시도해주세요."
-
-    case .rateLimited(let retryAfter):
-      if let seconds = retryAfter {
-        return "요청이 너무 많습니다. \(Int(seconds))초 후 다시 시도해주세요."
-      }
-      return "요청이 너무 많습니다. 잠시 후 다시 시도해주세요."
-
     case .unknown(let message):
       if let message = message {
         return "알 수 없는 오류가 발생했습니다: \(message)"
       }
       return "알 수 없는 오류가 발생했습니다. 잠시 후 다시 시도해주세요."
+
+    case .cancelled:
+      return "작업이 취소되었습니다."
+
+    case .unsupported(let feature):
+      if let feature = feature {
+        return "\(feature) 기능은 지원되지 않습니다."
+      }
+      return "지원되지 않는 기능입니다."
     }
   }
 }

MovieBooking/Domain/Entity/Error/Data/DataError.swift

@@ -0,0 +1,42 @@
+//
+//  DataError.swift
+//  MovieBooking
+//
+//  Created by Wonji Suh  on 10/17/25.
+//
+
+import Foundation
+
+/// 데이터 관련 에러
+public enum DataError: Error, Equatable {
+  case notFound(resource: String? = nil)
+  case dataCorrupted
+  case serializationFailed
+  case decodingFailed
+  case encodingFailed
+}
+
+// MARK: - 사용자 메시지 (UI friendly)
+extension DataError: LocalizedError {
+  public var errorDescription: String? {
+    switch self {
+    case .notFound(let resource):
+      if let resource = resource {
+        return "\(resource)을(를) 찾을 수 없습니다."
+      }
+      return "요청한 데이터를 찾을 수 없습니다."
+
+    case .dataCorrupted:
+      return "데이터가 손상되었습니다. 다시 시도해주세요."
+
+    case .serializationFailed:
+      return "데이터 변환 중 오류가 발생했습니다."
+
+    case .decodingFailed:
+      return "데이터 처리 중 오류가 발생했습니다."
+
+    case .encodingFailed:
+      return "데이터 저장 중 오류가 발생했습니다."
+    }
+  }
+}

MovieBooking/Domain/Entity/Error/System/SystemError.swift

@@ -0,0 +1,51 @@
+//
+//  SystemError.swift
+//  MovieBooking
+//
+//  Created by Wonji Suh  on 10/17/25.
+//
+
+import Foundation
+
+/// 시스템 관련 에러
+public enum SystemError: Error, Equatable {
+  case dependencyUnavailable(service: String? = nil)
+  case configurationError
+  case insufficientPermissions(permission: String? = nil)
+  case resourceExhausted(resource: String? = nil)
+  case serviceUnavailable(service: String? = nil)
+}
+
+// MARK: - 사용자 메시지 (UI friendly)
+extension SystemError: LocalizedError {
+  public var errorDescription: String? {
+    switch self {
+    case .dependencyUnavailable(let service):
+      if let service = service {
+        return "\(service) 서비스를 사용할 수 없습니다. 잠시 후 다시 시도해주세요."
+      }
+      return "서비스를 사용할 수 없습니다. 잠시 후 다시 시도해주세요."
+
+    case .configurationError:
+      return "앱 설정에 문제가 있습니다. 앱을 재시작해주세요."
+
+    case .insufficientPermissions(let permission):
+      if let permission = permission {
+        return "\(permission) 권한이 필요합니다. 설정에서 권한을 허용해주세요."
+      }
+      return "권한이 필요합니다. 설정에서 권한을 허용해주세요."
+
+    case .resourceExhausted(let resource):
+      if let resource = resource {
+        return "\(resource) 리소스가 부족합니다. 잠시 후 다시 시도해주세요."
+      }
+      return "시스템 리소스가 부족합니다. 잠시 후 다시 시도해주세요."
+
+    case .serviceUnavailable(let service):
+      if let service = service {
+        return "\(service) 서비스가 일시적으로 사용할 수 없습니다."
+      }
+      return "서비스가 일시적으로 사용할 수 없습니다."
+    }
+  }
+}

MovieBooking/Domain/Entity/Error/Validation/ValidationError.swift

@@ -0,0 +1,74 @@
+//
+//  ValidationError.swift
+//  MovieBooking
+//
+//  Created by Wonji Suh  on 10/17/25.
+//
+
+import Foundation
+
+/// 유효성 검사 관련 에러
+public enum ValidationError: Error, Equatable {
+  case validationFailed(fields: [String])
+  case invalidInput(field: String, reason: String? = nil)
+  case requiredFieldMissing(field: String)
+  case invalidFormat(field: String, expectedFormat: String? = nil)
+  case outOfRange(field: String, min: Any? = nil, max: Any? = nil)
+
+  // Equatable 구현을 위해 Any 대신 String으로 처리
+  public static func == (lhs: ValidationError, rhs: ValidationError) -> Bool {
+    switch (lhs, rhs) {
+    case (.validationFailed(let lFields), .validationFailed(let rFields)):
+      return lFields == rFields
+    case (.invalidInput(let lField, let lReason), .invalidInput(let rField, let rReason)):
+      return lField == rField && lReason == rReason
+    case (.requiredFieldMissing(let lField), .requiredFieldMissing(let rField)):
+      return lField == rField
+    case (.invalidFormat(let lField, let lFormat), .invalidFormat(let rField, let rFormat)):
+      return lField == rField && lFormat == rFormat
+    case (.outOfRange(let lField, _, _), .outOfRange(let rField, _, _)):
+      return lField == rField // min, max는 비교에서 제외
+    default:
+      return false
+    }
+  }
+}
+
+// MARK: - 사용자 메시지 (UI friendly)
+extension ValidationError: LocalizedError {
+  public var errorDescription: String? {
+    switch self {
+    case .validationFailed(let fields):
+      if fields.isEmpty {
+        return "입력값이 올바르지 않습니다."
+      }
+      return "\(fields.joined(separator: ", ")) 항목을 확인해주세요."
+
+    case .invalidInput(let field, let reason):
+      if let reason = reason {
+        return "\(field): \(reason)"
+      }
+      return "\(field) 항목이 올바르지 않습니다."
+
+    case .requiredFieldMissing(let field):
+      return "\(field)은(는) 필수 입력 항목입니다."
+
+    case .invalidFormat(let field, let expectedFormat):
+      if let format = expectedFormat {
+        return "\(field)의 형식이 올바르지 않습니다. (\(format) 형식으로 입력해주세요)"
+      }
+      return "\(field)의 형식이 올바르지 않습니다."
+
+    case .outOfRange(let field, let min, let max):
+      var message = "\(field)의 값이 범위를 벗어났습니다."
+      if let min = min, let max = max {
+        message += " (\(min) ~ \(max) 사이의 값을 입력해주세요)"
+      } else if let min = min {
+        message += " (\(min) 이상의 값을 입력해주세요)"
+      } else if let max = max {
+        message += " (\(max) 이하의 값을 입력해주세요)"
+      }
+      return message
+    }
+  }
+}