[#79] 웹페이지 데이터를 디바운싱을 적용한 키워드 입력에 따라 불러오는 로직을 추가한다 (#99)

* feat: 검색 쿼리에 대해 디바운스 400ms 적용

* refactor: 메서드 파라미터를 배열 -> OrderedSet으로 변경

* ui: 새 컨텐츠 작성 시 웹페이지를 추가할 수 있도록 UI 개선

* feat: 웹페이지 데이터를 url에서 각종 메타 데이터까지 확대 및 저장 및 불러오기 수정

* style: 액션 명 변경

* feat: 얼럿을 통해 웹페이지를 저장할 수 있도록 추가

* refactor: 얼럿 로직 정리

* ui: 타이틀 좌측 정렬 및 최대 2줄까지 허용

* ui: 터치 영역 최대화

* fix: tmp URL 대신 캐시 디렉토리에 저장되도록 변경하여 이미지가 날라가는 현상 해결

Author: opficdev

DevLog/Data/Mapper/WebPageMapping.swift

@@ -5,9 +5,23 @@
 //  Created by 최윤진 on 2/19/26.
 //
 
+import Foundation
+
 extension WebPageResponse {
-    func toDomain() -> WebPage {
-        WebPage(
+    func toDomain() throws -> WebPage {
+        guard let url = URL(string: url) else {
+            throw DataError.invalidData("WebPageResponse.url is invalid: \(url)")
+        }
+        guard let displayURL = URL(string: displayURL) else {
+            throw DataError.invalidData("WebPageResponse.displayURL is invalid: \(displayURL)")
+        }
+        let imageURL: URL?
+        if !self.imageURL.isEmpty {
+            imageURL = URL(string: self.imageURL)
+        } else {
+            imageURL = nil
+        }
+        return WebPage(
             title: title,
             url: url,
             displayURL: displayURL,

DevLog/Data/Repository/WebPageRepositoryImpl.swift

@@ -17,32 +17,28 @@ final class WebPageRepositoryImpl: WebPageRepository {
         self.metadataService = metadataService
     }
 
-    func fetch() async throws -> [WebPage] {
-        let responses = try await webPageService.fetchWebPages()
-        let indexedResponses = responses.enumerated().map { ($0.offset, $0.element) }
-
-        return try await withThrowingTaskGroup(of: (Int, WebPageResponse?).self) { group in
-            for (index, response) in indexedResponses {
-                group.addTask {
-                    let metadata = try? await self.metadataService.fetchMetadata(from: response)
-                    return (index, metadata)
-                }
-            }
-
-            var results: [WebPageResponse?] = Array(repeating: nil, count: responses.count)
-            for try await (index, metadata) in group {
-                results[index] = metadata
-            }
-
-            return results.compactMap { $0?.toDomain() }
-        }
+    func fetch(_ query: String) async throws -> [WebPage] {
+        try await webPageService
+            .fetchWebPages(query)
+            .compactMap { try? $0.toDomain() }
     }
 
     func upsert(_ urlString: String) async throws -> WebPage {
-        try await webPageService.upsertWebPage(urlString)
-        let response = WebPageURLResponse(urlString: urlString)
-        let metadata = try await metadataService.fetchMetadata(from: response)
-        return metadata.toDomain()
+        let metadata = try await metadataService.fetchMetadata(from: urlString)
+        let request = WebPageRequest(
+            title: metadata.title,
+            url: urlString,
+            displayURL: metadata.displayURL,
+            imageURL: metadata.imageURL
+        )
+        try await webPageService.upsertWebPage(request)
+        let response = WebPageResponse(
+            title: request.title,
+            url: request.url,
+            displayURL: request.displayURL,
+            imageURL: request.imageURL
+        )
+        return try response.toDomain()
     }
 
     func delete(_ urlString: String) async throws {

DevLog/Domain/Protocol/WebPageRepository.swift

@@ -6,7 +6,7 @@
 //
 
 protocol WebPageRepository {
-    func fetch() async throws -> [WebPage]
+    func fetch(_ query: String) async throws -> [WebPage]
     func upsert(_ urlString: String) async throws -> WebPage
     func delete(_ urlString: String) async throws
 }

DevLog/Domain/UseCase/WebPage/Fetch/FetchWebPagesUseCase.swift

@@ -6,5 +6,5 @@
 //
 
 protocol FetchWebPagesUseCase {
-    func execute() async throws -> [WebPage]
+    func execute(_ query: String) async throws -> [WebPage]
 }

DevLog/Domain/UseCase/WebPage/Fetch/FetchWebPagesUseCaseImpl.swift

@@ -12,7 +12,7 @@ final class FetchWebPagesUseCaseImpl: FetchWebPagesUseCase {
         self.repository = repository
     }
 
-    func execute() async throws -> [WebPage] {
-        try await repository.fetch()
+    func execute(_ query: String) async throws -> [WebPage] {
+        try await repository.fetch(query)
     }
 }

DevLog/Infra/DTO/WebPageDTO.swift

@@ -0,0 +1,23 @@
+//
+//  WebPageResponse.swift
+//  DevLog
+//
+//  Created by 최윤진 on 2/9/26.
+//
+
+import FirebaseFirestore
+
+struct WebPageRequest: Encodable {
+    let title: String
+    let url: String
+    let displayURL: String
+    let imageURL: String
+}
+
+struct WebPageResponse: Decodable {
+    @DocumentID var id: String?
+    let title: String
+    let url: String
+    let displayURL: String
+    let imageURL: String
+}

DevLog/Infra/DTO/WebPageMetadataResponse.swift

@@ -0,0 +1,12 @@
+//
+//  WebPageMetadataResponse.swift
+//  DevLog
+//
+//  Created by 최윤진 on 2/20/26.
+//
+
+struct WebPageMetadataResponse {
+    let title: String
+    let displayURL: String
+    let imageURL: String
+}

DevLog/Infra/DTO/WebPageResponse.swift

@@ -7,14 +7,15 @@
 
 import Foundation
 import LinkPresentation
+import UIKit
 
 final class WebPageMetadataService {
     private let logger = Logger(category: "WebPageMetadataService")
-    func fetchMetadata(from response: WebPageURLResponse) async throws -> WebPageResponse {
-        logger.info("Fetching metadata for URL: \(response.urlString)")
+    func fetchMetadata(from urlString: String) async throws -> WebPageMetadataResponse {
+        logger.info("Fetching metadata for URL: \(urlString)")
 
-        guard let url = URL(string: response.urlString) else {
-            logger.error("Invalid URL: \(response.urlString)")
+        guard let url = URL(string: urlString) else {
+            logger.error("Invalid URL: \(urlString)")
             throw URLError(.badURL)
         }
 
@@ -26,11 +27,10 @@ final class WebPageMetadataService {
             let imageURL = try await extractImageURL(from: metadata.imageProvider, url: url)
 
             logger.info("Successfully fetched metadata for: \(metadata.title ?? "Unknown")")
-            return WebPageResponse(
-                title: metadata.title,
-                url: url,
-                displayURL: metadata.url ?? url,
-                imageURL: imageURL
+            return WebPageMetadataResponse(
+                title: metadata.title ?? "",
+                displayURL: (metadata.url ?? url).absoluteString,
+                imageURL: imageURL?.absoluteString ?? ""
             )
         } catch {
             logger.error("Failed to fetch metadata", error: error)
@@ -43,30 +43,58 @@ final class WebPageMetadataService {
 
         return try await withCheckedThrowingContinuation { continuation in
             imageProvider.loadObject(ofClass: UIImage.self) { image, error in
-                guard let image = image as? UIImage,
-                      let data = image.jpegData(compressionQuality: 1.0) else {
-                    continuation.resume(returning: nil)
+                if let error {
+                    continuation.resume(throwing: error)
                     return
                 }
 
-                guard let fileName = url.absoluteString.addingPercentEncoding(
-                    withAllowedCharacters: .alphanumerics
-                ) else {
+                guard let image = image as? UIImage,
+                      let data = image.jpegData(compressionQuality: 1.0) else {
                     continuation.resume(returning: nil)
                     return
                 }
 
-                let tempURL = FileManager.default.temporaryDirectory
-                    .appendingPathComponent(fileName)
-                    .appendingPathExtension("jpeg")
-
                 do {
-                    try data.write(to: tempURL)
-                    continuation.resume(returning: tempURL)
+                    let fileURL = try Self.cacheFileURL(for: url)
+                    Task.detached { [data, fileURL] in
+                        do {
+                            if FileManager.default.fileExists(atPath: fileURL.path) {
+                                if let existingData = try? Data(contentsOf: fileURL),
+                                   UIImage(data: existingData) != nil {
+                                    continuation.resume(returning: fileURL)
+                                    return
+                                }
+                            }
+                            try data.write(to: fileURL, options: [.atomic])
+                            continuation.resume(returning: fileURL)
+                        } catch {
+                            continuation.resume(throwing: error)
+                        }
+                    }
                 } catch {
                     continuation.resume(throwing: error)
                 }
             }
         }
     }
+
+    private static func cacheFileURL(for url: URL) throws -> URL {
+        let cachesDir = try FileManager.default.url(
+            for: .cachesDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )
+        let imageDir = cachesDir.appendingPathComponent("webPageImages", isDirectory: true)
+        if !FileManager.default.fileExists(atPath: imageDir.path) {
+            try FileManager.default.createDirectory(at: imageDir, withIntermediateDirectories: true)
+        }
+
+        let fileName = url.absoluteString
+            .addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? UUID().uuidString
+
+        return imageDir
+            .appendingPathComponent(fileName)
+            .appendingPathExtension("jpeg")
+    }
 }