Book, Page 등 Entity, Storage, Repository, FileManager 생성

MemorialHouse/MHApplication/MHApplication/Source/App/SceneDelegate.swift

@@ -51,7 +51,7 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
                 HomeViewModelFactory.self,
                 object: HomeViewModelFactory(fetchMemorialHouseUseCase: fetchMemorialHouseUseCase)
             )
-        } catch let error as MHError {
+        } catch let error as MHCoreError {
             MHLogger.error("\(error.description)")
         } catch {
             MHLogger.error("\(error.localizedDescription)")

MemorialHouse/MHCore/MHCore/DIContainer.swift

@@ -13,7 +13,7 @@ public final class DIContainer {
         let key = String(describing: type)
         guard let object = objects[key] as? T else {
             MHLogger.error("\(#function): \(key)에 해당하는 object 없음")
-            throw MHError.DIContainerResolveFailure(key: key)
+            throw MHCoreError.DIContainerResolveFailure(key: key)
         }
         return object
     }

MemorialHouse/MHCore/MHCore/MHCoreError.swift

@@ -0,0 +1,12 @@
+import MHFoundation
+
+public enum MHCoreError: Error, CustomStringConvertible, Equatable {
+    case DIContainerResolveFailure(key: String)
+
+    public var description: String {
+        switch self {
+        case .DIContainerResolveFailure(let key):
+            "\(key)에 대한 dependency resolve 실패"
+        }
+    }
+}

MemorialHouse/MHCore/MHCore/MHDataError.swift

@@ -0,0 +1,51 @@
+import MHFoundation
+
+public enum MHDataError: Error, CustomStringConvertible, Equatable {
+    case noSuchEntity(key: String)
+    case createEntityFailure
+    case convertDTOFailure
+    case fetchEntityFaliure
+    case updateEntityFailure
+    case deleteEntityFailure
+    case findEntityFailure
+    case saveContextFailure
+    case directorySettingFailure
+    case fileCreationFailure
+    case fileReadingFailure
+    case fileDeletionFailure
+    case fileMovingFailure
+    case fileNotExists
+
+    public var description: String {
+        switch self {
+        case let .noSuchEntity(key):
+            "\(key)에 대한 Entity가 존재하지 않습니다"
+        case .createEntityFailure:
+            "Entity 생성 실패"
+        case .convertDTOFailure:
+            "Entity에 대한 DTO 변환 실패"
+        case .fetchEntityFaliure:
+            "Entity 가져오기 실패"
+        case .updateEntityFailure:
+            "Entity 업데이트 실패"
+        case .deleteEntityFailure:
+            "Entity 삭제 실패"
+        case .findEntityFailure:
+            "Entity 찾기 실패"
+        case .saveContextFailure:
+            "Update된 Context 저장 실패"
+        case .directorySettingFailure:
+            "디렉토리 설정 실패"
+        case .fileCreationFailure:
+            "파일 생성 실패"
+        case .fileReadingFailure:
+            "파일 읽기 실패"
+        case .fileDeletionFailure:
+            "파일 삭제 실패"
+        case .fileMovingFailure:
+            "파일 이동 실패"
+        case .fileNotExists:
+            "파일이 존재하지 않습니다"
+        }
+    }
+}

MemorialHouse/MHData/MHData/DTO/BookCoverDTO.swift

@@ -9,6 +9,15 @@ public struct BookCoverDTO {
     let category: String?
     let favorite: Bool
 
+    public init(identifier: UUID, title: String, imageURL: String?, color: String, category: String?, favorite: Bool) {
+        self.identifier = identifier
+        self.title = title
+        self.imageURL = imageURL
+        self.color = color
+        self.category = category
+        self.favorite = favorite
+    }
+
     func toBookCover() -> BookCover? {
         guard let color = BookColor(rawValue: self.color) else { return nil }
 

MemorialHouse/MHData/MHData/DTO/BookDTO.swift

@@ -0,0 +1,19 @@
+import MHFoundation
+import MHDomain
+
+public struct BookDTO {
+    let id: UUID
+    let pages: [PageDTO]
+
+    public init(id: UUID, pages: [PageDTO]) {
+        self.id = id
+        self.pages = pages
+    }
+
+    func toBook() -> Book {
+        return Book(
+            id: self.id,
+            pages: self.pages.map { $0.toPage() }
+        )
+    }
+}

MemorialHouse/MHData/MHData/DTO/MediaDescriptionDTO.swift

@@ -0,0 +1,25 @@
+import MHFoundation
+import MHDomain
+
+public struct MediaDescriptionDTO {
+    let id: UUID
+    let type: String
+    let attributes: Data?
+
+    public init(id: UUID, type: String, attributes: Data?) {
+        self.id = id
+        self.type = type
+        self.attributes = attributes
+    }
+
+    func toMediaDescription() -> MediaDescription? {
+        guard let type = MediaType(rawValue: self.type) else { return nil }
+        let attributes = try? JSONSerialization.jsonObject(with: attributes ?? Data(), options: []) as? [String: any Sendable]
+
+        return MediaDescription(
+            id: self.id,
+            type: type,
+            attributes: attributes
+        )
+    }
+}

MemorialHouse/MHData/MHData/DTO/PageDTO.swift

@@ -0,0 +1,25 @@
+import MHFoundation
+import MHDomain
+
+public struct PageDTO {
+    let id: UUID
+    let metadata: [Int: MediaDescriptionDTO]
+    let text: String
+
+    public init(id: UUID, metadata: [Int: MediaDescriptionDTO], text: String) {
+        self.id = id
+        self.metadata = metadata
+        self.text = text
+    }
+
+    func toPage() -> Page {
+        let metadata = self.metadata
+            .compactMapValues { $0.toMediaDescription() }
+
+        return Page(
+            id: self.id,
+            metadata: metadata,
+            text: self.text
+        )
+    }
+}

MemorialHouse/MHData/MHData/LocalStorage/BookCoverStorage.swift

@@ -2,8 +2,8 @@ import MHFoundation
 import MHCore
 
 public protocol BookCoverStorage {
-    func create(data: BookCoverDTO) async -> Result<Void, MHError>
-    func fetch() async -> Result<[BookCoverDTO], MHError>
-    func update(with id: UUID, data: BookCoverDTO) async -> Result<Void, MHError>
-    func delete(with id: UUID) async -> Result<Void, MHError>
+    func create(data: BookCoverDTO) async -> Result<Void, MHDataError>
+    func fetch() async -> Result<[BookCoverDTO], MHDataError>
+    func update(with id: UUID, data: BookCoverDTO) async -> Result<Void, MHDataError>
+    func delete(with id: UUID) async -> Result<Void, MHDataError>
 }

MemorialHouse/MHData/MHData/LocalStorage/BookStorage.swift

@@ -0,0 +1,9 @@
+import MHFoundation
+import MHCore
+
+public protocol BookStorage {
+    func create(data: BookDTO) async -> Result<Void, MHDataError>
+    func fetch(with id: UUID) async -> Result<BookDTO, MHDataError>
+    func update(with id: UUID, data: BookDTO) async -> Result<Void, MHDataError>
+    func delete(with id: UUID) async -> Result<Void, MHDataError>
+}

MemorialHouse/MHData/MHData/LocalStorage/CoreData/CoreDataBookCoverStorage.swift

@@ -11,71 +11,97 @@ final class CoreDataBookCoverStorage {
 }
 
 extension CoreDataBookCoverStorage: BookCoverStorage {
-    func create(data: BookCoverDTO) async -> Result<Void, MHError> {
+    func create(data: BookCoverDTO) async -> Result<Void, MHDataError> {
         let context = coreDataStorage.persistentContainer.viewContext
-        guard let entity = NSEntityDescription.entity(forEntityName: "BookCoverEntity", in: context) else {
-            return .failure(.DIContainerResolveFailure(key: "BookCoverEntity"))
+        do {
+            try await context.perform {
+                guard let entity = NSEntityDescription.entity(forEntityName: "BookCoverEntity", in: context) else {
+                    throw MHDataError.noSuchEntity(key: "BookCoverEntity")
+                }
+                let bookCover = NSManagedObject(entity: entity, insertInto: context)
+                bookCover.setValue(data.identifier, forKey: "identifier")
+                bookCover.setValue(data.title, forKey: "title")
+                bookCover.setValue(data.category, forKey: "category")
+                bookCover.setValue(data.color, forKey: "color")
+                bookCover.setValue(data.imageURL, forKey: "imageURL")
+                bookCover.setValue(data.favorite, forKey: "favorite")
+
+                try context.save()
+            }
+            return .success(())
+        } catch let error as MHDataError {
+            MHLogger.debug("Error creating book cover: \(error.description)")
+            return .failure(error)
+        } catch {
+            MHLogger.debug("Unknown Error creating book cover: \(error.localizedDescription)")
+            return .failure(.createEntityFailure)
         }
-        let bookCover = NSManagedObject(entity: entity, insertInto: context)
-        bookCover.setValue(data.identifier, forKey: "identifier")
-        bookCover.setValue(data.title, forKey: "title")
-        bookCover.setValue(data.category, forKey: "category")
-        bookCover.setValue(data.color, forKey: "color")
-        bookCover.setValue(data.imageURL, forKey: "imageURL")
-        bookCover.setValue(data.favorite, forKey: "favorite")
-
-        await coreDataStorage.saveContext()
-        return .success(())
     }
 
-    func fetch() async -> Result<[BookCoverDTO], MHError> {
+    func fetch() async -> Result<[BookCoverDTO], MHDataError> {
         let context = coreDataStorage.persistentContainer.viewContext
-        let request = BookCoverEntity.fetchRequest()
-
         do {
-            let bookCoverEntities = try context.fetch(request)
+            var bookCoverEntities: [BookCoverEntity] = []
+            try await context.perform {
+                let request = BookCoverEntity.fetchRequest()
+                bookCoverEntities = try context.fetch(request)
+            }
             let result = bookCoverEntities.compactMap { $0.toBookCoverDTO() }
-
             return .success(result)
+        } catch let error as MHDataError {
+            MHLogger.debug("Error fetching book cover: \(error.description)")
+            return .failure(error)
         } catch {
-            MHLogger.debug("Error fetching book covers: \(error.localizedDescription)")
-            return .failure(.convertDTOFailure)
+            MHLogger.debug("Unknown Error fetching book cover: \(error.localizedDescription)")
+            return .failure(.fetchEntityFaliure)
         }
     }
 
-    func update(with id: UUID, data: BookCoverDTO) async -> Result<Void, MHError> {
+    func update(with id: UUID, data: BookCoverDTO) async -> Result<Void, MHDataError> {
+        let context = coreDataStorage.persistentContainer.viewContext
         do {
-            let context = coreDataStorage.persistentContainer.viewContext
-            guard let newEntity = try getEntityByIdentifier(in: context, with: id) else {
-                return .failure(.findEntityFailure)
+            try await context.perform { [weak self] in
+                guard let newEntity = try self?.getEntityByIdentifier(in: context, with: id) else {
+                    throw MHDataError.findEntityFailure
+                }
+                newEntity.setValue(data.identifier, forKey: "identifier")
+                newEntity.setValue(data.title, forKey: "title")
+                newEntity.setValue(data.category, forKey: "category")
+                newEntity.setValue(data.color, forKey: "color")
+                newEntity.setValue(data.imageURL, forKey: "imageURL")
+                newEntity.setValue(data.favorite, forKey: "favorite")
+
+                try context.save()
             }
-            newEntity.setValue(data.identifier, forKey: "identifier")
-            newEntity.setValue(data.title, forKey: "title")
-            newEntity.setValue(data.category, forKey: "category")
-            newEntity.setValue(data.color, forKey: "color")
-            newEntity.setValue(data.imageURL, forKey: "imageURL")
-            newEntity.setValue(data.favorite, forKey: "favorite")
-
-            await coreDataStorage.saveContext()
             return .success(())
+        } catch let error as MHDataError {
+            MHLogger.debug("Error updating book cover: \(error.description)")
+            return .failure(error)
         } catch {
-            return .failure(.findEntityFailure)
+            MHLogger.debug("Unknown Error updating book cover: \(error.localizedDescription)")
+            return .failure(.updateEntityFailure)
         }
     }
 
-    func delete(with id: UUID) async -> Result<Void, MHError> {
+    func delete(with id: UUID) async -> Result<Void, MHDataError> {
+        let context = coreDataStorage.persistentContainer.viewContext
         do {
-            let context = coreDataStorage.persistentContainer.viewContext
-            guard let entity = try getEntityByIdentifier(in: context, with: id) else {
-                return .failure(.findEntityFailure)
+            try await context.perform { [weak self] in
+                guard let entity = try self?.getEntityByIdentifier(in: context, with: id) else {
+                    throw MHDataError.findEntityFailure
+                }
+
+                context.delete(entity)
+
+                try context.save()
             }
-
-            context.delete(entity)
-
-            await coreDataStorage.saveContext()
             return .success(())
+        } catch let error as MHDataError {
+            MHLogger.debug("Error deleting book cover: \(error.description)")
+            return .failure(error)
         } catch {
-            return .failure(.findEntityFailure)
+            MHLogger.debug("Unknown Error deleting book cover: \(error.localizedDescription)")
+            return .failure(.deleteEntityFailure)
         }
     }