• RemoteWeatherDataSource.swift: Implementation of weather data source using remote APIs.

Local: Contains data sources for fetching data from local files.

• LocalWeatherDataSource.swift: Implementation of weather data source using local JSON files.

Repositories: Coordinates between data sources and domain layer, transforming data as needed.

• WeatherRepositoryImpl.swift: Implementation of weather repository.

Infrastructure

Network: Manages network communication details.

• APIClient.swift: Handles HTTP requests and responses.
• HTTPMethod.swift: Enum for HTTP methods.
• WeatherAPIConfiguration.swift: Constructs URLs for API endpoints.

Configuration: Manages application configurations.

• AppConfiguration.swift: Implementation of configuration protocol.

Utilities: Contains shared utilities and helpers.

• JSONLoader.swift: Utility for loading JSON from local files.

Interfaces: Defines protocols for infrastructure components.

• JSONLoaderProtocol.swift: Protocol for JSON loader.
• APIClientProtocol.swift: Protocol for API client.
• ConfigurationProtocol.swift: Protocol for configuration.

Dependency Injection

The project leverages dependency injection to manage dependencies between layers. This ensures loose coupling and enhances testability. Dependencies are injected through initializers, allowing for easy substitution of implementations during testing.

Example Initialization

import SwiftUI

@main
struct ExampleMVVMApp: App {
    var body: some Scene {
        WindowGroup {
            let apiClient = APIClient()
            let appConfiguration = AppConfiguration()
            let apiConfiguration = WeatherAPIConfiguration(configuration: appConfiguration)
            let remoteDataSource = RemoteWeatherDataSource(apiClient: apiClient, apiConfiguration: apiConfiguration)
            
            let jsonLoader = JSONLoader()
            let localDataSource = LocalWeatherDataSource(jsonLoader: jsonLoader, configuration: appConfiguration)
            
            let useLocalData = false // Change this to true to use local data
            let dataSource: WeatherDataSource = useLocalData ? localDataSource : remoteDataSource
            
            let repository = WeatherRepositoryImpl(dataSource: dataSource)
            let fetchWeatherUseCase = FetchWeatherUseCase(repository: repository)
            let viewModel = WeatherViewModel(fetchWeatherUseCase: fetchWeatherUseCase)
            
            WeatherView(viewModel: viewModel)
        }
    }
}

🚀 Swift: Async/Await vs GCD vs Completion Handler (coming soon)

This guide shows a side-by-side comparison of three ways to handle asynchronous tasks in Swift:

• ✅ Async/Await (Modern Style)
• ⚠️ GCD (Grand Central Dispatch - Middle Style)
• ❌ Completion Handler (Old Style)

🛠 Example Side-by-Side

🔸 Completion Handler (Old Style)

func fetchData(completion: @escaping (Result<String, Error>) -> Void) {
    guard let url = URL(string: "https://example.com") else { return }

    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let data = data, let result = String(data: data, encoding: .utf8) else { return }
        completion(.success(result))
    }.resume()
}

// Usage
fetchData { result in
    switch result {
    case .success(let data):
        print("Data: \(data)")
    case .failure(let error):
        print("Error: \(error)")
    }
}

• ❌ Hard to read if there are many steps
• ❌ Must pass closures everywhere
• ❌ Error handling is manual

🔸 GCD (Middle Style)

func fetchData() {
    guard let url = URL(string: "https://example.com") else { return }

    DispatchQueue.global().async {
        if let data = try? Data(contentsOf: url),
           let result = String(data: data, encoding: .utf8) {

            DispatchQueue.main.async {
                print("Data: \(result)")
            }
        } else {
            DispatchQueue.main.async {
                print("Error fetching data")
            }
        }
    }
}

// Usage
fetchData()

• ⚠️ Better but you must manually handle queues
• ⚠️ Still a bit messy
• ⚠️ You must remember to come back to the main thread

🔸 Async/Await (Modern Style)

func fetchData() async throws -> String {
    guard let url = URL(string: "https://example.com") else { throw URLError(.badURL) }

    let (data, _) = try await URLSession.shared.data(from: url)
    guard let result = String(data: data, encoding: .utf8) else { throw URLError(.cannotDecodeContentData) }

    return result
}

// Usage
Task {
    do {
        let data = try await fetchData()
        print("Data: \(data)")
    } catch {
        print("Error: \(error)")
    }
}

• ✅ Super clean
• ✅ No need to manage threads
• ✅ Swift pauses and resumes automatically
• ✅ Easier error handling with try / catch

SwiftUI_CleanArchitecture_Demo

SwiftUI sample app demonstrating Clean Architecture, MVVM, use cases, FactoryKit DI, and GitHub REST API integration on iOS.