refactor: .immediate에서 .delay로 수정 및 디바운스 작업도 같이 끝나도록 개선

Author: opficdev

DevLog/Presentation/ViewModel/SearchViewModel.swift

@@ -43,16 +43,22 @@ final class SearchViewModel: Store {
         case fetch(String)
     }
 
+    private enum SearchTaskKind: Hashable {
+        case debounce
+        case request
+    }
+
     private(set) var state: State = .init()
     private let fetchWebPagesUseCase: FetchWebPagesUseCase
     private let fetchTodosUseCase: FetchTodosUseCase
     private let fetchRecentSearchQueriesUseCase: FetchRecentSearchQueriesUseCase
     private let updateRecentSearchQueriesUseCase: UpdateRecentSearchQueriesUseCase
+    private let loadingState = LoadingState()
     let contentsLimit: Int = 5
 
     private let maxRecentQueries = 20
     private let searchDebounceDelay: Double = 0.4
-    private var searchDebounceTask: Task<Void, Never>?
+    private var searchTasks: [SearchTaskKind: Task<Void, Never>] = [:]
 
     init(
         fetchWebPagesUseCase: FetchWebPagesUseCase,
@@ -104,22 +110,16 @@ final class SearchViewModel: Store {
             state.showAllWebPages = false
             let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines)
             if trimmed.isEmpty {
-                cancelDebounce()
+                cancelSearch()
                 state.webPages = []
                 state.todos = []
-                state.isLoading = false
             } else {
-                state.isLoading = true
-                scheduleDebouncedQuery(query)
+                cancelSearch()
+                beginLoading(.immediate)
+                scheduleDebouncedFetch(trimmed)
             }
         case .applySearchQuery(let query):
-            let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines)
-            if trimmed.isEmpty {
-                state.webPages = []
-                state.todos = []
-            } else {
-                effects = [.fetch(trimmed)]
-            }
+            effects = [.fetch(query)]
         case .setShowAllTodos(let shouldShowAll):
             state.showAllTodos = shouldShowAll
         case .setShowAllWebPages(let shouldShowAll):
@@ -133,10 +133,14 @@ final class SearchViewModel: Store {
     func run(_ effect: SideEffect) {
         switch effect {
         case .fetch(let query):
-            Task {
+            searchTasks[.request]?.cancel()
+            let requestTask = Task { [weak self] in
+                guard let self else { return }
                 do {
-                    send(.setLoading(true))
-                    defer { send(.setLoading(false)) }
+                    defer {
+                        self.searchTasks[.request] = nil
+                        self.endLoading(.immediate)
+                    }
                     let searchesTodoOnly = searchesTodoOnly(query)
                     async let todos = fetchTodosUseCase.execute(TodoQuery(keyword: query), cursor: nil)
                     async let webPageItems = fetchWebPageItems(
@@ -145,12 +149,15 @@ final class SearchViewModel: Store {
                     )
                     let todoItems = try await todos.items.compactMap { TodoListItem(from: $0) }
                     let resolvedWebPageItems = try await webPageItems
+                    if Task.isCancelled { return }
                     send(.fetchTodos(todoItems))
                     send(.fetchWebPage(resolvedWebPageItems))
                 } catch {
+                    if error is CancellationError { return }
                     send(.setAlert(true))
                 }
             }
+            searchTasks[.request] = requestTask
         }
     }
 }
@@ -165,21 +172,36 @@ private extension SearchViewModel {
         state.showAlert = isPresented
     }
 
-    func scheduleDebouncedQuery(_ query: String) {
-        searchDebounceTask?.cancel()
-        searchDebounceTask = Task { [weak self] in
+    func scheduleDebouncedFetch(_ query: String) {
+        searchTasks[.debounce]?.cancel()
+        let debounceTask = Task { [weak self] in
             guard let self else { return }
             try? await Task.sleep(for: .seconds(searchDebounceDelay))
             if Task.isCancelled { return }
             await MainActor.run {
+                self.searchTasks[.debounce] = nil
                 self.send(.applySearchQuery(query))
             }
         }
+        searchTasks[.debounce] = debounceTask
+    }
+
+    func cancelSearch() {
+        searchTasks.values.forEach { $0.cancel() }
+        searchTasks = [:]
+        endLoading(.immediate)
     }
 
-    func cancelDebounce() {
-        searchDebounceTask?.cancel()
-        searchDebounceTask = nil
+    func beginLoading(_ mode: LoadingState.Mode) {
+        loadingState.begin(mode: mode) { [weak self] isLoading in
+            self?.send(.setLoading(isLoading))
+        }
+    }
+
+    func endLoading(_ mode: LoadingState.Mode) {
+        loadingState.end(mode: mode) { [weak self] isLoading in
+            self?.send(.setLoading(isLoading))
+        }
     }
 
     func searchesTodoOnly(_ query: String) -> Bool {

DevLog/Presentation/ViewModel/TodoListViewModel.swift

@@ -52,7 +52,7 @@ final class TodoListViewModel: Store {
         case upsertTodo(Todo)
 
         // Run
-        case setSearchQuery(String)
+        case triggerSearch(String)
         case fetchSearchResults([TodoListItem])
         case didToggleCompleted(TodoListItem)
         case didTogglePinned(TodoListItem)
@@ -74,9 +74,12 @@ final class TodoListViewModel: Store {
         case togglePinned(TodoListItem)
     }
 
+    private enum SearchTaskKind: Hashable {
+        case debounce
+        case request
+    }
+
     private(set) var state: State
-    private let searchDebounceDelay: Double = 0.4
-    private var searchDebounceTask: Task<Void, Never>?
     private let fetchTodosUseCase: FetchTodosUseCase
     private let fetchTodoByIdUseCase: FetchTodoByIdUseCase
     private let upsertTodoUseCase: UpsertTodoUseCase
@@ -85,6 +88,8 @@ final class TodoListViewModel: Store {
     private let loadingState = LoadingState()
     private var undoDeleteTodoId: String?
     private var nextCursor: TodoCursor?
+    private var searchTasks: [SearchTaskKind: Task<Void, Never>] = [:]
+    private let searchDebounceDelay: Double = 0.4
 
     init(
         fetchTodosUseCase: FetchTodosUseCase,
@@ -129,7 +134,7 @@ final class TodoListViewModel: Store {
         case .onAppear, .loadNextPage, .setSearchText, .setToast, .upsertTodo:
             effects = reduceByView(action, state: &state)
 
-        case .setSearchQuery, .fetchSearchResults, .didToggleCompleted, .didTogglePinned,
+        case .triggerSearch, .fetchSearchResults, .didToggleCompleted, .didTogglePinned,
                 .restoreTodo, .setLoading, .appendTodos, .resetPagination, .setHasMore:
             effects = reduceByRun(action, state: &state)
         }
@@ -142,10 +147,10 @@ final class TodoListViewModel: Store {
     func run(_ effect: SideEffect) {
         switch effect {
         case .fetch:
-            beginLoading(.immediate)
+            beginLoading(.delayed)
             Task {
                 do {
-                    defer { endLoading(.immediate) }
+                    defer { endLoading(.delayed) }
                     let page = try await fetchTodosUseCase.execute(state.query, cursor: nil)
                     send(.resetPagination)
                     send(.appendTodos(page.items.compactMap { TodoListItem(from: $0) }, nextCursor: page.nextCursor))
@@ -156,10 +161,10 @@ final class TodoListViewModel: Store {
                 }
             }
         case .loadNextPage:
-            beginLoading(.immediate)
+            beginLoading(.delayed)
             Task {
                 do {
-                    defer { endLoading(.immediate) }
+                    defer { endLoading(.delayed) }
                     let page = try await fetchTodosUseCase.execute(state.query, cursor: nextCursor)
                     send(.appendTodos(page.items.compactMap { TodoListItem(from: $0) }, nextCursor: page.nextCursor))
                     let hasMore = page.items.count == state.query.pageSize && page.nextCursor != nil
@@ -169,17 +174,24 @@ final class TodoListViewModel: Store {
                 }
             }
         case .search(let keyword):
-            beginLoading(.immediate)
-            Task {
+            searchTasks[.request]?.cancel()
+            let requestTask = Task { [weak self] in
+                guard let self else { return }
                 do {
-                    defer { endLoading(.immediate) }
+                    defer {
+                        self.searchTasks[.request] = nil
+                        self.endLoading(.immediate)
+                    }
                     let query = TodoQuery(category: state.category, keyword: keyword)
                     let page = try await fetchTodosUseCase.execute(query, cursor: nil)
+                    if Task.isCancelled { return }
                     send(.fetchSearchResults(page.items.compactMap { TodoListItem(from: $0) }))
                 } catch {
+                    if error is CancellationError { return }
                     send(.setAlert(true))
                 }
             }
+            searchTasks[.request] = requestTask
         case .upsert(let item):
             beginLoading(.delayed)
             Task {
@@ -242,7 +254,7 @@ final class TodoListViewModel: Store {
             beginLoading(.delayed)
             Task {
                 // endLoading(.delayed)를 defer로 두지 않는 이유
-                // send(.refresh)가 같은 턴에서 beginLoading(.immediate)를 먼저 올린 뒤
+                // send(.refresh)가 같은 턴에서 beginLoading(.delayed)를 먼저 올린 뒤
                 // delayed 로딩을 내려야 같은 isLoading이 끊기지 않기 때문
                 do {
                     try await undoDeleteTodoUseCase.execute(todoId)
@@ -298,7 +310,7 @@ private extension TodoListViewModel {
         case .setIsSearching(let value):
             state.isSearching = value
             if !value {
-                cancelDebounce()
+                cancelSearch()
                 state.searchText = ""
                 state.searchResults = []
                 state.showAllSearchResults = false
@@ -332,12 +344,12 @@ private extension TodoListViewModel {
             state.showAllSearchResults = false
             let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
             if trimmed.isEmpty {
-                cancelDebounce()
+                cancelSearch()
                 state.searchResults = []
-                state.isLoading = false
             } else {
-                state.isLoading = true
-                scheduleDebouncedQuery(text)
+                cancelSearch()
+                beginLoading(.immediate)
+                scheduleDebouncedSearch(trimmed)
             }
         case .setToast(let isPresented):
             setToast(&state, isPresented: isPresented)
@@ -352,13 +364,8 @@ private extension TodoListViewModel {
 
     func reduceByRun(_ action: Action, state: inout State) -> [SideEffect] {
         switch action {
-        case .setSearchQuery(let query):
-            let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines)
-            if trimmed.isEmpty {
-                state.searchResults = []
-            } else {
-                return [.search(trimmed)]
-            }
+        case .triggerSearch(let query):
+            return [.search(query)]
         case .fetchSearchResults(let items):
             state.searchResults = items
         case .didToggleCompleted(let todo):
@@ -418,21 +425,24 @@ private extension TodoListViewModel {
         state.showToast = isPresented
     }
 
-    func scheduleDebouncedQuery(_ query: String) {
-        searchDebounceTask?.cancel()
-        searchDebounceTask = Task { [weak self] in
+    func scheduleDebouncedSearch(_ query: String) {
+        searchTasks[.debounce]?.cancel()
+        let debounceTask = Task { [weak self] in
             guard let self else { return }
             try? await Task.sleep(for: .seconds(searchDebounceDelay))
             if Task.isCancelled { return }
             await MainActor.run {
-                self.send(.setSearchQuery(query))
+                self.searchTasks[.debounce] = nil
+                self.send(.triggerSearch(query))
             }
         }
+        searchTasks[.debounce] = debounceTask
     }
 
-    func cancelDebounce() {
-        searchDebounceTask?.cancel()
-        searchDebounceTask = nil
+    func cancelSearch() {
+        searchTasks.values.forEach { $0.cancel() }
+        searchTasks = [:]
+        endLoading(.immediate)
     }
 
     private func beginLoading(_ mode: LoadingState.Mode) {