Clean Architecture on iOS

1┌---------------------------------------------┐
2│         Framework & Drivers (UI, DB)        │
3│  ┌-------------------------------------┐    │
4│  │    Interface Adapters (ViewModels)  │    │
5│  │  ┌-----------------------------┐    │    │
6│  │  │    Use Cases (Business)     │    │    │
7│  │  │  ┌---------------------┐    │    │    │
8│  │  │  │   Entities (Core)   │    │    │    │
9│  │  │  └---------------------┘    │    │    │
10│  │  └-------------------------┘    │    │
11│  └-------------------------------------┘    │
12└---------------------------------------------┘
13 
14    Dependency direction: Always OUTSIDE-IN →

1// ❌ WRONG: the Domain layer depends on Infrastructure
2// Domain/UseCases/FetchUsersUseCase.swift
3import CoreData  // ← A framework import in the Domain layer = RULE VIOLATION!
4 
5class FetchUsersUseCase {
6    let context: NSManagedObjectContext  // ← CoreData dependency
7 
8    func execute() -> [User] {
9        let request = NSFetchRequest<UserEntity>(entityName: "User")
10        return try! context.fetch(request).map { $0.toDomain() }
11    }
12}
13 
14// ✅ RIGHT: the Domain layer only defines a protocol
15// Domain/Protocols/UserRepositoryProtocol.swift
16protocol UserRepositoryProtocol {
17    func fetchAll() async throws -> [User]
18    func save(_ user: User) async throws
19    func delete(id: UUID) async throws
20}
21 
22// Domain/UseCases/FetchUsersUseCase.swift
23// No import - pure Swift!
24final class FetchUsersUseCase {
25    private let repository: UserRepositoryProtocol  // ← Protocol only
26 
27    init(repository: UserRepositoryProtocol) {
28        self.repository = repository
29    }
30 
31    func execute(sortBy: SortOption = .name) async throws -> [User] {
32        let users = try await repository.fetchAll()
33        return sort(users, by: sortBy)
34    }
35}

1// Domain/Entities/User.swift - PURE SWIFT, no import!
2struct User: Identifiable, Equatable, Sendable {
3    let id: UUID
4    var name: String
5    var email: String
6    var avatar: URL?
7    let createdAt: Date
8    var role: Role
9 
10    enum Role: String, Sendable {
11        case admin, editor, viewer
12    }
13 
14    // Business logic lives on the Entity
15    func validate() -> ValidationResult {
16        var errors: [String] = []
17 
18        if name.trimmingCharacters(in: .whitespaces).isEmpty {
19            errors.append("Name cannot be empty")
20        }
21        if !email.contains("@") || !email.contains(".") {
22            errors.append("Invalid email format")
23        }
24        if name.count > 100 {
25            errors.append("Name cannot be longer than 100 characters")
26        }
27 
28        return errors.isEmpty ? .valid : .invalid(errors)
29    }
30 
31    enum ValidationResult {
32        case valid
33        case invalid([String])
34    }
35}
36 
37// Domain/Entities/Product.swift
38struct Product: Identifiable, Equatable, Sendable {
39    let id: UUID
40    var name: String
41    var description: String
42    var price: Decimal
43    var stock: Int
44    var category: Category
45    let createdAt: Date
46 
47    enum Category: String, CaseIterable, Sendable {
48        case electronics, clothing, food, books
49    }
50 
51    // Business rule: stock check
52    var isAvailable: Bool { stock > 0 }
53 
54    // Business rule: discount calculation
55    func discountedPrice(percentage: Decimal) -> Decimal {
56        guard percentage > 0 && percentage <= 100 else { return price }
57        return price * (1 - percentage / 100)
58    }
59}

1// Domain/UseCases/FetchProductsUseCase.swift
2protocol FetchProductsUseCaseProtocol: Sendable {
3    func execute(filter: ProductFilter?) async throws -> [Product]
4}
5 
6struct ProductFilter: Sendable {
7    var category: Product.Category?
8    var minPrice: Decimal?
9    var maxPrice: Decimal?
10    var inStockOnly: Bool = true
11}
12 
13final class FetchProductsUseCase: FetchProductsUseCaseProtocol {
14    private let repository: ProductRepositoryProtocol
15 
16    init(repository: ProductRepositoryProtocol) {
17        self.repository = repository
18    }
19 
20    func execute(filter: ProductFilter? = nil) async throws -> [Product] {
21        var products = try await repository.fetchAll()
22 
23        if let filter {
24            if let category = filter.category {
25                products = products.filter { $0.category == category }
26            }
27            if let minPrice = filter.minPrice {
28                products = products.filter { $0.price >= minPrice }
29            }
30            if let maxPrice = filter.maxPrice {
31                products = products.filter { $0.price <= maxPrice }
32            }
33            if filter.inStockOnly {
34                products = products.filter { $0.isAvailable }
35            }
36        }
37 
38        return products.sorted { $0.createdAt > $1.createdAt }
39    }
40}
41 
42// Each Use Case does ONE thing - keep it under 50 lines!
43final class AddToCartUseCase {
44    private let cartRepository: CartRepositoryProtocol
45    private let productRepository: ProductRepositoryProtocol
46 
47    init(cart: CartRepositoryProtocol, product: ProductRepositoryProtocol) {
48        self.cartRepository = cart
49        self.productRepository = product
50    }
51 
52    func execute(productId: UUID, quantity: Int) async throws {
53        let product = try await productRepository.fetch(id: productId)
54 
55        guard product.isAvailable else {
56            throw DomainError.outOfStock
57        }
58        guard product.stock >= quantity else {
59            throw DomainError.insufficientStock(available: product.stock)
60        }
61 
62        try await cartRepository.addItem(productId: productId, quantity: quantity)
63    }
64}

1// Presentation/ViewModels/ProductListViewModel.swift
2@MainActor
3final class ProductListViewModel: ObservableObject {
4    @Published private(set) var products: [ProductDisplayItem] = []
5    @Published private(set) var isLoading = false
6    @Published private(set) var error: String?
7    @Published var selectedCategory: Product.Category?
8 
9    private let fetchProductsUseCase: FetchProductsUseCaseProtocol
10 
11    // Dependency Injection via init
12    init(fetchProductsUseCase: FetchProductsUseCaseProtocol) {
13        self.fetchProductsUseCase = fetchProductsUseCase
14    }
15 
16    func loadProducts() async {
17        isLoading = true
18        error = nil
19 
20        do {
21            let filter = ProductFilter(category: selectedCategory)
22            let domainProducts = try await fetchProductsUseCase.execute(filter: filter)
23 
24            // Domain → Presentation mapping
25            products = domainProducts.map { product in
26                ProductDisplayItem(
27                    id: product.id,
28                    name: product.name,
29                    formattedPrice: formatPrice(product.price),
30                    availability: product.isAvailable ? "In stock" : "Out of stock",
31                    availabilityColor: product.isAvailable ? .green : .red,
32                    categoryBadge: product.category.rawValue.capitalized
33                )
34            }
35        } catch {
36            self.error = mapError(error)
37        }
38 
39        isLoading = false
40    }
41 
42    // UI-specific formatting
43    private func formatPrice(_ price: Decimal) -> String {
44        let formatter = NumberFormatter()
45        formatter.numberStyle = .currency
46        formatter.currencyCode = "TRY"
47        return formatter.string(from: price as NSDecimalNumber) ?? "\(price) ₺"
48    }
49 
50    private func mapError(_ error: Error) -> String {
51        switch error {
52        case DomainError.outOfStock: return "Product is out of stock"
53        case is URLError: return "Check your internet connection"
54        default: return "An unexpected error occurred"
55        }
56    }
57}
58 
59// Presentation model - UI-specific
60struct ProductDisplayItem: Identifiable {
61    let id: UUID
62    let name: String
63    let formattedPrice: String
64    let availability: String
65    let availabilityColor: Color
66    let categoryBadge: String
67}

1// Data/Repositories/ProductRepository.swift
2final class ProductRepository: ProductRepositoryProtocol {
3    private let apiClient: APIClientProtocol
4    private let cache: CacheProtocol
5 
6    init(apiClient: APIClientProtocol, cache: CacheProtocol) {
7        self.apiClient = apiClient
8        self.cache = cache
9    }
10 
11    func fetchAll() async throws -> [Product] {
12        // Check the cache first
13        if let cached: [Product] = cache.get(key: "products") {
14            return cached
15        }
16 
17        // Fetch from the API
18        let response: ProductListResponse = try await apiClient.request(
19            endpoint: .products
20        )
21 
22        // DTO → Domain Entity conversion
23        let products = response.items.map { dto in
24            Product(
25                id: dto.id,
26                name: dto.name,
27                description: dto.desc,
28                price: Decimal(dto.priceInCents) / 100,
29                stock: dto.stockCount,
30                category: Product.Category(rawValue: dto.category) ?? .electronics,
31                createdAt: dto.createdAt
32            )
33        }
34 
35        // Save to cache
36        cache.set(key: "products", value: products, expiry: .minutes(5))
37 
38        return products
39    }
40 
41    func fetch(id: UUID) async throws -> Product {
42        // Cache first, then the API...
43        let response: ProductDTO = try await apiClient.request(endpoint: .product(id: id))
44        return response.toDomain()
45    }
46}

1// App/DI/DependencyContainer.swift
2@MainActor
3final class DependencyContainer {
4    static let shared = DependencyContainer()
5 
6    // Infrastructure
7    private lazy var apiClient: APIClientProtocol = URLSessionAPIClient()
8    private lazy var cache: CacheProtocol = InMemoryCache()
9 
10    // Repositories
11    private lazy var productRepository: ProductRepositoryProtocol = {
12        ProductRepository(apiClient: apiClient, cache: cache)
13    }()
14 
15    // Use Cases
16    func makeFetchProductsUseCase() -> FetchProductsUseCaseProtocol {
17        FetchProductsUseCase(repository: productRepository)
18    }
19 
20    // ViewModels
21    func makeProductListViewModel() -> ProductListViewModel {
22        ProductListViewModel(fetchProductsUseCase: makeFetchProductsUseCase())
23    }
24}
25 
26// Usage in SwiftUI
27struct ProductListView: View {
28    @StateObject private var viewModel = DependencyContainer.shared.makeProductListViewModel()
29 
30    var body: some View {
31        List(viewModel.products) { item in
32            ProductRow(item: item)
33        }
34        .task { await viewModel.loadProducts() }
35    }
36}

1// Tests/UseCases/FetchProductsUseCaseTests.swift
2final class FetchProductsUseCaseTests: XCTestCase {
3 
4    func test_execute_returnsFilteredProducts() async throws {
5        // Arrange - mock repository
6        let mockRepo = MockProductRepository()
7        mockRepo.stubbedProducts = [
8            Product(id: UUID(), name: "iPhone", description: "", price: 100, stock: 5, category: .electronics, createdAt: Date()),
9            Product(id: UUID(), name: "T-Shirt", description: "", price: 50, stock: 0, category: .clothing, createdAt: Date()),
10        ]
11 
12        let sut = FetchProductsUseCase(repository: mockRepo)
13 
14        // Act
15        let filter = ProductFilter(category: .electronics, inStockOnly: true)
16        let result = try await sut.execute(filter: filter)
17 
18        // Assert
19        XCTAssertEqual(result.count, 1)
20        XCTAssertEqual(result.first?.name, "iPhone")
21    }
22}
23 
24// Mock - fully controllable
25class MockProductRepository: ProductRepositoryProtocol {
26    var stubbedProducts: [Product] = []
27    var fetchAllCallCount = 0
28 
29    func fetchAll() async throws -> [Product] {
30        fetchAllCallCount += 1
31        return stubbedProducts
32    }
33 
34    func fetch(id: UUID) async throws -> Product {
35        guard let product = stubbedProducts.first(where: { $0.id == id }) else {
36            throw DomainError.notFound
37        }
38        return product
39    }
40}