Storage 기능 비동기 처리 적용

Dietto/Dietto/Apps/DIContainer.swift

@@ -10,17 +10,29 @@ import Observation
 @Observable
 final class DIContainer {
     private let alanUsecase: AlanUsecase
-    private let interestsUsecase: InterestsUsecase
     private let pedometerUsecase: PedometerUsecase
-    private let userStorageUsecase: UserStorageUsecase
-    private let weightHistoryUsecase: WeightHistoryUsecase
+    private var interestsUsecase: InterestsUsecase
+    private var userStorageUsecase: UserStorageUsecase
+    private var weightHistoryUsecase: WeightHistoryUsecase
 
     init() {
         self.alanUsecase = AlanUsecaseImpl(repository: NetworkRepositoryImpl())
         self.pedometerUsecase = PedometerUsecaseImpl(pedometer: PedometerRepositoryImpl())
-        self.interestsUsecase = InterestsUsecaseImpl(repository: StorageRepositoryImpl<InterestsDTO>())
-        self.userStorageUsecase = UserStorageUsecaseImpl(storage: StorageRepositoryImpl<UserDTO>())
-        self.weightHistoryUsecase = WeightHistoryUsecaseImpl(repository: StorageRepositoryImpl<WeightDTO>())
+
+//        self.interestsUsecase = InterestsUsecaseImpl(repository: StorageRepositoryImpl<InterestsDTO>())
+//        self.userStorageUsecase = UserStorageUsecaseImpl(storage: StorageRepositoryImpl<UserDTO>())
+//        self.weightHistoryUsecase = WeightHistoryUsecaseImpl(repository: StorageRepositoryImpl<WeightDTO>())
+
+        self.interestsUsecase = InterestsUsecaseImpl(repository: AnotherStorageRepositoryImpl<InterestsDTO>())
+        self.userStorageUsecase = UserStorageUsecaseImpl(storage: AnotherStorageRepositoryImpl<UserDTO>())
+        self.weightHistoryUsecase = WeightHistoryUsecaseImpl(repository: AnotherStorageRepositoryImpl<WeightDTO>())
+
+//        Task.detached(priority: .background) { [weak self] in
+//            self?.interestsUsecase = InterestsUsecaseImpl(repository: AnotherStorageRepositoryImpl<InterestsDTO>())
+//            self?.userStorageUsecase = UserStorageUsecaseImpl(storage: AnotherStorageRepositoryImpl<UserDTO>())
+//            self?.weightHistoryUsecase = WeightHistoryUsecaseImpl(repository: AnotherStorageRepositoryImpl<WeightDTO>())
+//        }
+
     }
 
     func getHomeViewModel() -> HomeViewModel {

Dietto/Dietto/Data/Repository/AnotherStorageRepository.swift

@@ -0,0 +1,77 @@
+//
+//  AnotherStorageRepository.swift
+//  Dietto
+//
+//  Created by 안정흠 on 5/31/25.
+//
+
+
+//
+//  AnotherStorageRepository.swift
+//  Dietto
+//
+//  Created by 안정흠 on 5/31/25.
+//
+
+import Foundation
+import SwiftData
+
+enum StorageError: String, Error {
+    case insertError
+    case updateError
+    case fetchError
+    case deleteError
+}
+
+protocol AnotherStorageRepository {
+    associatedtype T: PersistentModel
+
+    func insertData(data: T) async throws
+    func updateData(predicate: Predicate<T>, updateBlock: @escaping (T) -> Void) async throws
+    func fetchData(where predicate: Predicate<T>?, sort: [SortDescriptor<T>]) async throws -> [T]
+    func deleteData(where predicate: Predicate<T>) async throws
+    func deleteAll() async throws
+}
+@ModelActor
+actor AnotherStorageRepositoryImpl<T: PersistentModel>: AnotherStorageRepository {
+
+    init() {
+        let configure = ModelConfiguration("\(T.self)") // 이름 지정
+        do {
+            let modelContainer = try ModelContainer(for: T.self, configurations: configure)
+            self.init(modelContainer: modelContainer)
+        } catch {
+            fatalError(error.localizedDescription)
+        }
+    }
+
+    func insertData(data: T) async throws {
+        modelContext.insert(data)
+        try modelContext.save()
+    }
+
+    func updateData(predicate: Predicate<T>, updateBlock: @escaping (T) -> Void) async throws {
+        let descriptor = FetchDescriptor<T>(predicate: predicate)
+        guard let result = try modelContext.fetch(descriptor).first else { throw StorageError.updateError }
+        updateBlock(result)
+        try modelContext.save()
+    }
+
+    func fetchData(where predicate: Predicate<T>? = nil, sort: [SortDescriptor<T>] = []) async throws -> [T] {
+        let descriptor = FetchDescriptor<T>(predicate: predicate, sortBy: sort)
+        return try modelContext.fetch(descriptor)
+    }
+
+    func deleteData(where predicate: Predicate<T>) async throws {
+        try modelContext.delete(model: T.self, where: predicate)
+        try modelContext.save()
+    }
+
+    func deleteAll() async throws {
+        let data = try await fetchData()
+        for item in data {
+            modelContext.delete(item)
+        }
+        try modelContext.save()
+    }
+}

Dietto/Dietto/Domain/Usecases/InterestsUsecase.swift

@@ -8,42 +8,44 @@
 import Foundation
 
 protocol InterestsUsecase {
-    func insertInterests(_ interests: InterestEntity)
-    func deleteInterests(_ interests: InterestEntity)
-    func fetchInterests() -> [InterestEntity]
+    func insertInterests(_ interests: InterestEntity) async throws
+    func deleteInterests(_ interests: InterestEntity) async throws
+    func fetchInterests() async throws -> [InterestEntity]
 }
 
-final class InterestsUsecaseImpl<Repository: StorageRepository>: InterestsUsecase where Repository.T == InterestsDTO {
+final class InterestsUsecaseImpl<Repository: AnotherStorageRepository>: InterestsUsecase where Repository.T == InterestsDTO {
     private let repository: Repository
 
     init(repository: Repository) {
         self.repository = repository
     }
 
-    func insertInterests(_ interests: InterestEntity) {
-        repository.insertData(data: InterestsDTO(title: interests.title))
+    func insertInterests(_ interests: InterestEntity) async throws {
+        do { try await repository.insertData(data: InterestsDTO(title: interests.title)) }
+        catch {
+            print(#function, error.localizedDescription)
+            throw StorageError.insertError
+        }
     }
 
-    func deleteInterests(_ interests: InterestEntity) {
-        do {
-            let title = interests.title
-            let predicate = #Predicate<InterestsDTO> { $0.title == title }
-            try repository.deleteData(where: predicate)
-        }
+    func deleteInterests(_ interests: InterestEntity) async throws {
+        let title = interests.title
+        let predicate = #Predicate<InterestsDTO> { $0.title == title }
+        do { try await repository.deleteData(where: predicate) }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
+            print(#function, error.localizedDescription)
+            throw StorageError.deleteError
         }
-
     }
 
-    func fetchInterests() -> [InterestEntity] {
+    func fetchInterests() async throws -> [InterestEntity] {
         do {
-            let result = try repository.fetchData(where: nil, sort: [])
+            let result = try await repository.fetchData(where: nil, sort: [])
             return result.map{InterestEntity(title: $0.title)}
         }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
-            return []
+            print(#function, error.localizedDescription)
+            throw StorageError.fetchError
         }
     }
 }

Dietto/Dietto/Domain/Usecases/UserStorageUsecase.swift

@@ -10,24 +10,24 @@ import Combine
 
 protocol UserStorageUsecase {
     var changeEvent: CurrentValueSubject<Void, Never> { get }
-    
-    func createUserData(_ user: UserEntity)
-    func getUserData() -> UserEntity?
-    func updateUserDefaultData(id: UUID, name: String, gender: Gender, height: Int)
-    func updateGoal(id: UUID, weight: Int, distance: Int)
-    func updateCurrentWeight(id: UUID, currentWeight: Int)
-    func deleteUserData()
+
+    func createUserData(_ user: UserEntity) async throws
+    func getUserData() async throws -> UserEntity
+    func updateUserDefaultData(id: UUID, name: String, gender: Gender, height: Int) async throws
+    func updateGoal(id: UUID, weight: Int, distance: Int) async throws
+    func updateCurrentWeight(id: UUID, currentWeight: Int) async throws
+    func deleteUserData() async throws
 }
 
-final class UserStorageUsecaseImpl<Repository: StorageRepository>: UserStorageUsecase where Repository.T == UserDTO {
+final class UserStorageUsecaseImpl<Repository: AnotherStorageRepository>: UserStorageUsecase where Repository.T == UserDTO {
     private let storage: Repository
     var changeEvent: CurrentValueSubject<Void, Never> = .init(())
 
     init(storage: Repository) {
         self.storage = storage
     }
 
-    func createUserData(_ user: UserEntity) {
+    func createUserData(_ user: UserEntity) async throws {
         let data = UserDTO(
             id: user.id,
             name: user.name,
@@ -38,13 +38,17 @@ final class UserStorageUsecaseImpl<Repository: StorageRepository>: UserStorageUs
             targetWeight: user.targetWeight,
             targetDistance: user.targetDistance,
         )
-        storage.insertData(data: data)
+        do { try await storage.insertData(data: data) }
+        catch {
+            print(#function, error.localizedDescription)
+            throw StorageError.insertError
+        }
     }
 
-    func getUserData() -> UserEntity? {
+    func getUserData() async throws -> UserEntity {
         do {
-            let users = try storage.fetchData(where: nil, sort: [])
-            guard let user = users.first else { return nil }
+            let users = try await storage.fetchData(where: nil, sort: [])
+            guard let user = users.first else { throw StorageError.fetchError }
             // UserDTO → UserEntity 변환
             return UserEntity(
                 id: user.id,
@@ -56,63 +60,63 @@ final class UserStorageUsecaseImpl<Repository: StorageRepository>: UserStorageUs
                 targetWeight: user.targetWeight,
                 targetDistance: user.targetDistance,
             )
-        } catch {
-            print("\(#function) : \(error.localizedDescription)")
-            return nil
+        }
+        catch {
+            print(#function, error.localizedDescription)
+            throw StorageError.fetchError
         }
     }
 
-    func updateUserDefaultData(id: UUID, name: String, gender: Gender, height: Int) {
-        let predicate = #Predicate<UserDTO> { $0.id == id }
+    func updateUserDefaultData(id: UUID, name: String, gender: Gender, height: Int) async throws {
         do {
-            try storage.updateData(predicate: predicate) { dto in
+            let predicate = #Predicate<UserDTO> { $0.id == id }
+            try await storage.updateData(predicate: predicate) { dto in
                 dto.name = name
                 dto.gender = gender.rawValue
                 dto.height = height
             }
             changeEvent.send()
         }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
+            print(#function, error.localizedDescription)
+            throw StorageError.updateError
         }
     }
 
-    func updateGoal(id: UUID, weight: Int, distance: Int) {
-        let predicate = #Predicate<UserDTO> { $0.id == id }
+    func updateGoal(id: UUID, weight: Int, distance: Int) async throws {
         do {
-            try storage.updateData(predicate: predicate) { dto in
+            let predicate = #Predicate<UserDTO> { $0.id == id }
+            try await storage.updateData(predicate: predicate) { dto in
                 dto.targetWeight = weight
                 dto.targetDistance = distance
             }
             changeEvent.send()
         }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
+            print(#function, error.localizedDescription)
+            throw StorageError.updateError
         }
     }
 
-    func updateCurrentWeight(id: UUID, currentWeight: Int) {
-        let predicate = #Predicate<UserDTO> { $0.id == id }
+    func updateCurrentWeight(id: UUID, currentWeight: Int) async throws {
         do {
-            try storage.updateData(predicate: predicate) { dto in
+            let predicate = #Predicate<UserDTO> { $0.id == id }
+            try await storage.updateData(predicate: predicate) { dto in
                 dto.currentWeight = currentWeight
             }
             changeEvent.send()
         }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
+            print(#function, error.localizedDescription)
+            throw StorageError.deleteError
         }
     }
 
-    func deleteUserData() {
-        do {
-            try storage.deleteAll()
-        }
+    func deleteUserData() async throws {
+        do { try await storage.deleteAll() }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
+            print(#function, error.localizedDescription)
+            throw StorageError.deleteError
         }
-
     }
-
-
 }

Dietto/Dietto/Domain/Usecases/WeightHistoryUsecase.swift

@@ -8,39 +8,42 @@
 import Foundation
 
 protocol WeightHistoryUsecase {
-    func addNewWeight(weight: Int, date: Date)
-    func getWeightHistory(chartRange: ChartTimeType) -> [WeightEntity]
-    func updateWeightByDate(weight: Int, date: Date)
-    func deleteAllWeightHistory()
+    func addNewWeight(weight: Int, date: Date) async throws
+    func getWeightHistory(chartRange: ChartTimeType) async throws -> [WeightEntity]
+    func deleteAllWeightHistory() async throws
+    func updateWeightByDate(weight: Int, date: Date) async throws
 }
 
-final class WeightHistoryUsecaseImpl<Repository: StorageRepository>: WeightHistoryUsecase where Repository.T == WeightDTO {
+final class WeightHistoryUsecaseImpl<Repository: AnotherStorageRepository>: WeightHistoryUsecase where Repository.T == WeightDTO {
     private let storage: Repository
 
     init(repository: Repository) {
         self.storage = repository
     }
-    func addNewWeight(weight: Int, date: Date) {
-        storage.insertData(data: WeightDTO(date: date, scale: weight))
+    func addNewWeight(weight: Int, date: Date) async throws {
+        do { try await storage.insertData(data: WeightDTO(date: date, scale: weight)) }
+        catch {
+            print(#function, error.localizedDescription)
+            throw StorageError.insertError
+        }
     }
 
-    func getWeightHistory(chartRange: ChartTimeType) -> [WeightEntity] {
-        let predicate = getDateRange(range: chartRange)
-
+    func getWeightHistory(chartRange: ChartTimeType) async throws -> [WeightEntity] {
         do {
-            let result = try storage.fetchData(where: predicate, sort: [])
+            let predicate = getDateRange(range: chartRange)
+            let result = try await storage.fetchData(where: predicate, sort: [])
             return result.map{$0.convertEntity()}
         }
         catch {
-            print("\(#function) : \(error.localizedDescription)")
-            return []
+            print(#function, error.localizedDescription)
+            throw StorageError.fetchError
         }
     }
-    
-    func updateWeightByDate(weight: Int, date: Date) {
+
+  func updateWeightByDate(weight: Int, date: Date) async throws {
         do {
             let predicate = #Predicate<WeightDTO> { $0.date == date }
-            try storage.updateData(predicate: predicate) { dto in
+            try await storage.updateData(predicate: predicate) { dto in
                 dto.scale = weight
             }
         }
@@ -49,14 +52,14 @@ final class WeightHistoryUsecaseImpl<Repository: StorageRepository>: WeightHisto
         }
     }
 
-    func deleteAllWeightHistory() {
-        do {
-            try storage.deleteAll()
-        }
+    func deleteAllWeightHistory() async throws {
+        do { try await storage.deleteAll()}
         catch {
-            print("\(#function) : \(error.localizedDescription)")
+            print(#function, error.localizedDescription)
+            throw StorageError.deleteError
         }
     }
+
 
     private func getDateRange(range: ChartTimeType) -> Predicate<WeightDTO> {
         let now = Date()