[#289] Todo 카테고리를 유저가 CRUD 할 수 있도록 개선한다

.swiftlint.yml

@@ -3,3 +3,5 @@ disabled_rules:
   - multiple_closures_with_trailing_closure
   - trailing_whitespace
   - type_body_length
+  - cyclomatic_complexity
+  - function_body_length

DevLog/App/Assembler/DataAssembler.swift

@@ -28,7 +28,14 @@ final class DataAssembler: Assembler {
 
         container.register(TodoRepository.self) {
             TodoRepositoryImpl(
-                todoService: container.resolve(TodoService.self)
+                todoService: container.resolve(TodoService.self),
+                todoCategoryService: container.resolve(TodoCategoryService.self)
+            )
+        }
+
+        container.register(TodoCategoryRepository.self) {
+            TodoCategoryRepositoryImpl(
+                todoCategoryService: container.resolve(TodoCategoryService.self)
             )
         }
 
@@ -67,7 +74,10 @@ final class DataAssembler: Assembler {
         }
 
         container.register(PushNotificationRepository.self) {
-            PushNotificationRepositoryImpl(pushNotificationService: container.resolve(PushNotificationService.self))
+            PushNotificationRepositoryImpl(
+                pushNotificationService: container.resolve(PushNotificationService.self),
+                todoCategoryService: container.resolve(TodoCategoryService.self)
+            )
         }
 
         container.register(WebPageRepository.self) {

DevLog/App/Assembler/DomainAssembler.swift

@@ -11,6 +11,7 @@ final class DomainAssembler: Assembler {
         registerConnectivityUseCases(container)
         registerAuthProviderUseCases(container)
         registerTodoUseCases(container)
+        registerTodoCategoryUseCases(container)
         registerUserDataUseCases(container)
         registerPushNotificationUseCases(container)
         registerWebPageUseCases(container)
@@ -85,6 +86,20 @@ private extension DomainAssembler {
         }
     }
 
+    func registerTodoCategoryUseCases(_ container: DIContainer) {
+        container.register(FetchTodoCategoryPreferencesUseCase.self) {
+            FetchTodoCategoryPreferencesUseCaseImpl(
+                container.resolve(TodoCategoryRepository.self)
+            )
+        }
+
+        container.register(UpdateTodoCategoryPreferencesUseCase.self) {
+            UpdateTodoCategoryPreferencesUseCaseImpl(
+                container.resolve(TodoCategoryRepository.self)
+            )
+        }
+    }
+
     func registerUserDataUseCases(_ container: DIContainer) {
         container.register(FetchUserDataUseCase.self) {
             FetchUserDataUseCaseImpl(container.resolve(UserDataRepository.self))

DevLog/App/Assembler/InfraAssembler.swift

@@ -36,6 +36,10 @@ final class InfraAssembler: Assembler {
             TodoService()
         }
 
+        container.register(TodoCategoryService.self) {
+            TodoCategoryService()
+        }
+
         container.register(UserService.self) {
             UserService()
         }

DevLog/Data/DTO/PushNotificationResponse.swift

@@ -14,5 +14,5 @@ struct PushNotificationResponse {
     let receivedAt: Date
     let isRead: Bool
     let todoId: String
-    let todoCategory: String
+    let todoCategory: TodoCategoryResponse
 }

DevLog/Data/DTO/TodoCategoryResponse.swift

@@ -0,0 +1,13 @@
+//
+//  TodoCategoryResponse.swift
+//  DevLog
+//
+//  Created by opfic on 3/30/26.
+//
+
+import Foundation
+
+enum TodoCategoryResponse {
+    case raw(String)
+    case decoded(TodoCategory)
+}

DevLog/Data/DTO/TodoDTO.swift

@@ -20,7 +20,7 @@ struct TodoRequest: Encodable {
     let completedAt: Date?
     let dueDate: Date?
     let tags: [String]
-    let category: TodoCategory
+    let category: String
 }
 
 struct TodoResponse {
@@ -36,5 +36,5 @@ struct TodoResponse {
     let completedAt: Date?
     let dueDate: Date?
     let tags: [String]
-    let category: String
+    let category: TodoCategoryResponse
 }

DevLog/Data/DTO/TodoReferenceResponse.swift

@@ -0,0 +1,15 @@
+//
+//  TodoReferenceResponse.swift
+//  DevLog
+//
+//  Created by opfic on 3/30/26.
+//
+
+import Foundation
+
+struct TodoReferenceResponse {
+    let id: String
+    let number: Int
+    let title: String
+    let category: TodoCategoryResponse
+}

DevLog/Data/Mapper/PushNotificationMapping.swift

@@ -7,8 +7,15 @@
 
 extension PushNotificationResponse {
     func toDomain() throws -> PushNotification {
-        guard let todoCategory = TodoCategory(rawValue: self.todoCategory) else {
-            throw DataError.invalidData("PushNotificationResponse.todoCategory is invalid: \(self.todoCategory)")
+        let todoCategory: TodoCategory
+
+        switch self.todoCategory {
+        case .decoded(let category):
+            todoCategory = category
+        case .raw(let category):
+            throw DataError.invalidData(
+                "PushNotificationResponse.todoCategory must be resolved before toDomain(): \(category)"
+            )
         }
 
         return PushNotification(

DevLog/Data/Mapper/TodoMapping.swift

@@ -20,15 +20,20 @@ extension TodoRequest {
             completedAt: entity.completedAt,
             dueDate: entity.dueDate,
             tags: entity.tags,
-            category: entity.category
+            category: entity.category.storageValue
         )
     }
 }
 
 extension TodoResponse {
     func toDomain() throws -> Todo {
-        guard let category = TodoCategory(rawValue: self.category) else {
-            throw DataError.invalidData("TodoResponse.category is invalid: \(self.category)")
+        let todoCategory: TodoCategory
+
+        switch category {
+        case .decoded(let category):
+            todoCategory = category
+        case .raw(let category):
+            throw DataError.invalidData("TodoResponse.category must be resolved before toDomain(): \(category)")
         }
 
         return Todo(
@@ -44,7 +49,7 @@ extension TodoResponse {
             completedAt: self.completedAt,
             dueDate: self.dueDate,
             tags: self.tags,
-            category: category
+            category: todoCategory
         )
     }
 }

DevLog/Data/Repository/PushNotificationRepositoryImpl.swift

@@ -9,25 +9,30 @@ import Foundation
 import Combine
 
 final class PushNotificationRepositoryImpl: PushNotificationRepository {
-    private let service: PushNotificationService
+    private let pushNotificationService: PushNotificationService
+    private let todoCategoryService: TodoCategoryService
 
-    init(pushNotificationService: PushNotificationService) {
-        self.service = pushNotificationService
+    init(
+        pushNotificationService: PushNotificationService,
+        todoCategoryService: TodoCategoryService
+    ) {
+        self.pushNotificationService = pushNotificationService
+        self.todoCategoryService = todoCategoryService
     }
 
     /// 푸시 알림 On/Off 설정
     func fetchPushNotificationEnabled() async throws -> Bool {
-        return try await service.fetchPushNotificationEnabled()
+        return try await pushNotificationService.fetchPushNotificationEnabled()
     }
 
     /// 푸시 알림 시간 설정
     func fetchPushNotificationTime() async throws -> DateComponents {
-        return try await service.fetchPushNotificationTime()
+        return try await pushNotificationService.fetchPushNotificationTime()
     }
 
     /// 푸시 알림 설정 업데이트
     func updatePushNotificationSettings(_ settings: PushNotificationSettings) async throws {
-        try await service.updatePushNotificationSettings(
+        try await pushNotificationService.updatePushNotificationSettings(
             isEnabled: settings.isEnabled, components: settings.scheduledTime
         )
     }
@@ -38,35 +43,125 @@ final class PushNotificationRepositoryImpl: PushNotificationRepository {
         cursor: PushNotificationCursor?
     ) async throws -> PushNotificationPage {
         let cursorDTO = cursor.map { PushNotificationCursorDTO.fromDomain($0) }
-        let response = try await service.requestNotifications(query, cursor: cursorDTO)
-        return try response.toDomain()
+        async let responseTask = pushNotificationService.requestNotifications(query, cursor: cursorDTO)
+        async let preferencesTask = todoCategoryService.fetchPreferences()
+
+        let (response, preferences) = try await (responseTask, preferencesTask)
+        return try resolvePage(from: response, with: preferences)
     }
 
     func observeNotifications(
         _ query: PushNotificationQuery,
         limit: Int
     ) throws -> AnyPublisher<PushNotificationPage, Error> {
-        try service.observeNotifications(query, limit: limit)
-            .tryMap { try $0.toDomain() }
+        let subject = PassthroughSubject<PushNotificationPage, Error>()
+        var cancellable: AnyCancellable?
+
+        cancellable = try pushNotificationService.observeNotifications(query, limit: limit)
+            .sink(
+                receiveCompletion: { completion in
+                    switch completion {
+                    case .finished:
+                        subject.send(completion: .finished)
+                    case .failure(let error):
+                        subject.send(completion: .failure(error))
+                    }
+                },
+                receiveValue: { [weak self] response in
+                    guard let self else { return }
+
+                    Task {
+                        do {
+                            let preferences = try await self.todoCategoryService.fetchPreferences()
+                            let page = try self.resolvePage(from: response, with: preferences)
+                            subject.send(page)
+                        } catch {
+                            subject.send(completion: .failure(error))
+                        }
+                    }
+                }
+            )
+
+        return subject
+            .handleEvents(receiveCancel: { cancellable?.cancel() })
             .eraseToAnyPublisher()
     }
 
     func observeUnreadPushCount() throws -> AnyPublisher<Int, Error> {
-        try service.observeUnreadPushCount()
+        try pushNotificationService.observeUnreadPushCount()
             .eraseToAnyPublisher()
     }
 
     // 푸시 알림 기록 삭제
     func deleteNotification(_ notificationID: String) async throws {
-        try await service.deleteNotification(notificationID)
+        try await pushNotificationService.deleteNotification(notificationID)
     }
 
     func undoDeleteNotification(_ notificationID: String) async throws {
-        try await service.undoDeleteNotification(notificationID)
+        try await pushNotificationService.undoDeleteNotification(notificationID)
     }
 
     // 푸시 알림 읽음/안읽음 토글
     func toggleNotificationRead(_ todoId: String) async throws {
-        try await service.toggleNotificationRead(todoId)
+        try await pushNotificationService.toggleNotificationRead(todoId)
+    }
+}
+
+private extension PushNotificationRepositoryImpl {
+    func resolvePage(
+        from response: PushNotificationPageResponse,
+        with preferences: [TodoCategoryPreference]
+    ) throws -> PushNotificationPage {
+        let userTodoCategories: [UserTodoCategory] = preferences.compactMap { preference in
+            guard case .user(let userTodoCategory) = preference.category else {
+                return nil
+            }
+
+            return userTodoCategory
+        }
+
+        let responses = try response.items.map {
+            try resolve($0, userTodoCategories: userTodoCategories)
+        }
+
+        return try PushNotificationPageResponse(
+            items: responses,
+            nextCursor: response.nextCursor
+        ).toDomain()
+    }
+
+    // resolvePage() 메서드에서만 사용됨
+    private func resolve(
+        _ response: PushNotificationResponse,
+        userTodoCategories: [UserTodoCategory]
+    ) throws -> PushNotificationResponse {
+        let id: String
+        switch response.todoCategory {
+        case .raw(let rawValue):
+            id = rawValue
+        case .decoded:
+            return response
+        }
+
+        let todoCategory: TodoCategory
+        if let systemTodoCategory = SystemTodoCategory(rawValue: id) {
+            todoCategory = .system(systemTodoCategory)
+        } else if let userTodoCategory = userTodoCategories.first(where: {
+            $0.id == id
+        }) {
+            todoCategory = .user(userTodoCategory)
+        } else {
+            throw DataError.invalidData("PushNotificationResponse.todoCategory is invalid: \(id)")
+        }
+
+        return PushNotificationResponse(
+            id: response.id,
+            title: response.title,
+            body: response.body,
+            receivedAt: response.receivedAt,
+            isRead: response.isRead,
+            todoId: response.todoId,
+            todoCategory: .decoded(todoCategory)
+        )
     }
 }

DevLog/Data/Repository/TodoCategoryRepositoryImpl.swift

@@ -0,0 +1,22 @@
+//
+//  TodoCategoryRepositoryImpl.swift
+//  DevLog
+//
+//  Created by opfic on 3/30/26.
+//
+
+final class TodoCategoryRepositoryImpl: TodoCategoryRepository {
+    private let todoCategoryService: TodoCategoryService
+
+    init(todoCategoryService: TodoCategoryService) {
+        self.todoCategoryService = todoCategoryService
+    }
+
+    func fetchPreferences() async throws -> [TodoCategoryPreference] {
+        try await todoCategoryService.fetchPreferences()
+    }
+
+    func updatePreferences(_ preferences: [TodoCategoryPreference]) async throws {
+        try await todoCategoryService.updatePreferences(preferences)
+    }
+}