Swift Programming Language, Protocol-Oriented Architecture & Concurrency Masterclass

// 1. Immutable Sendable Domain Model
struct Article: Identifiable, Codable, Sendable {
    let id: UUID
    let title: String
    let content: String
}

// 2. Protocol Contract with Swift Concurrency
protocol ArticleRepository: Sendable {
    func getArticle(id: UUID) async throws -> Article
}

// 3. Thread-Safe Actor with Internal Cache (Data Race Free)
actor RemoteArticleRepository: ArticleRepository {
    private var memoryCache: [UUID: Article] = [:]
    private let session: URLSession

    init(session: URLSession = .shared) {
        self.session = session
    }

    func getArticle(id: UUID) async throws -> Article {
        // Return cached instance if available
        if let cached = memoryCache[id] {
            return cached
        }

        // Asynchronous Network Fetch
        let url = URL(string: "https://api.example.com/articles/\(id.uuidString)")!
        let (data, response) = try await session.data(from: url)

        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }

        let article = try JSONDecoder().decode(Article.self, from: data)
        memoryCache[id] = article
        return article
    }
}

// 4. Structured Concurrency Execution via TaskGroup
func fetchMultipleArticles(ids: [UUID], repository: ArticleRepository) async throws -> [Article] {
    try await withThrowingTaskGroup(of: Article.self) { group in
        for id in ids {
            group.addTask {
                try await repository.getArticle(id: id)
            }
        }

        var results: [Article] = []
        for try await article in group {
            results.append(article)
        }
        return results
    }
}