# SPM bilan CryptoTracker — [Demo: Medium] > **Qiyinlik darajasi:** O'rta (Medium) > **Texnologiyalar:** Multi-Target SPM Package, Interface vs Implementation ajratilishi, Swift 6 `package` Access Modifier, Tashqi SPM qaramliklar, Kesh qatlami, Mock Testing Target. --- ## 1. Loyihaning Arxitektura Rejasi O'rta darajadagi ushbu loyihada biz kriptovalyutalar kursini real vaqt rejimida kuzatuvchi **CryptoTracker** ilovasi uchun ko'p targetli (Multi-Target) SPM modulini quramiz. Katta loyihalardagi eng asosiy muammo — tarmoq so'rovlari yoki ma'lumotlar bazasi o'zgarganda butun UI qayta kompilyatsiya bo'lishidir. Buni oldini olish uchun biz paketni 4 ta alohida targetga bo'lamiz: ``` CryptoTrackerPackage/ ├── Package.swift ├── Sources/ │ ├── CryptoTrackerInterface/ # 1. Sof Shartnoma (DTO modellar & Protocols) │ │ ├── CoinDTO.swift │ │ └── CryptoRepositoryProtocol.swift │ │ │ ├── CryptoTrackerCore/ # 2. Tarmoq va Kesh Logikasi (Implementation) │ │ ├── API/ │ │ │ └── CryptoAPIService.swift │ │ └── Cache/ │ │ └── CryptoLocalCache.swift │ │ │ ├── CryptoTrackerFeature/ # 3. SwiftUI Ekranlari & ViewModel │ │ ├── Views/ │ │ │ ├── CoinListView.swift │ │ │ └── CoinRowView.swift │ │ └── ViewModels/ │ │ └── CryptoListViewModel.swift │ │ │ └── CryptoTrackerTesting/ # 4. Mock va Stublar (Faqat testlar uchun) │ └── MockCryptoRepository.swift │ └── Tests/ └── CryptoTrackerFeatureTests/ └── CryptoListViewModelTests.swift ``` ### Targetlar o'rtasidagi munosabat (DAG - Directed Acyclic Graph):

--- ## 2. Ko'p Targetli `Package.swift` Manifesti Ushbu manifestda bitta SPM to'plami ichida qanday qilib 4 ta mustaqil target yaratish va ularning o'zaro bog'liqliklarini chegaralash ko'rsatilgan: ```swift // swift-tools-version: 6.0 import PackageDescription let package = Package( name: "CryptoTrackerPackage", platforms: [ .iOS(.v17), .macOS(.v14) ], products: [ // Asosiy ilova UI uchun faqat Feature kutubxonasini import qiladi .library(name: "CryptoTrackerFeature", targets: ["CryptoTrackerFeature"]), // Bog'lanishlar uchun Interface .library(name: "CryptoTrackerInterface", targets: ["CryptoTrackerInterface"]), // Haqiqiy implementatsiya (DI konteyneri uchun) .library(name: "CryptoTrackerCore", targets: ["CryptoTrackerCore"]), // Testlar uchun mocklar kutubxonasi .library(name: "CryptoTrackerTesting", targets: ["CryptoTrackerTesting"]) ], dependencies: [ // Tashqi rasmiy Apple algoritmlari (masalan, swift-collections) .package(url: "https://github.com/apple/swift-collections.git", .upToNextMajor(from: "1.1.0")) ], targets: [ // ── TARGET 1: INTERFACE (Hech narsaga bog'liq emas!) ── .target( name: "CryptoTrackerInterface", dependencies: [], swiftSettings: [ .enableUpcomingFeature("StrictConcurrency"), .swiftLanguageMode(.v6) ] ), // ── TARGET 2: CORE (API va Kesh) ── .target( name: "CryptoTrackerCore", dependencies: [ "CryptoTrackerInterface", .product(name: "OrderedCollections", package: "swift-collections") ], swiftSettings: [ .enableUpcomingFeature("StrictConcurrency"), .swiftLanguageMode(.v6) ] ), // ── TARGET 3: FEATURE (UI & ViewModel) ── .target( name: "CryptoTrackerFeature", dependencies: [ "CryptoTrackerInterface" // DIQQAT: Core'ga emas, Interface'ga bog'langan! ], swiftSettings: [ .enableUpcomingFeature("StrictConcurrency"), .swiftLanguageMode(.v6) ] ), // ── TARGET 4: TESTING HELPERS (Mocklar) ── .target( name: "CryptoTrackerTesting", dependencies: [ "CryptoTrackerInterface" ], swiftSettings: [ .enableUpcomingFeature("StrictConcurrency"), .swiftLanguageMode(.v6) ] ), // ── TARGET 5: UNIT TESTS ── .testTarget( name: "CryptoTrackerFeatureTests", dependencies: [ "CryptoTrackerFeature", "CryptoTrackerTesting" ] ) ] ) ``` --- ## 3. Kodlarni Yozish: Qadam-baqadam ### 3.1. Target 1: `CryptoTrackerInterface` Ushbu modulda faqat biznes shartnomalari (Contracts) joylashadi: ```swift // Sources/CryptoTrackerInterface/CoinDTO.swift import Foundation public struct CoinDTO: Identifiable, Sendable, Codable, Equatable { public let id: String public let symbol: String public let name: String public let priceUSD: Decimal public let change24h: Double public init(id: String, symbol: String, name: String, priceUSD: Decimal, change24h: Double) { self.id = id self.symbol = symbol self.name = name self.priceUSD = priceUSD self.change24h = change24h } } ``` ```swift // Sources/CryptoTrackerInterface/CryptoRepositoryProtocol.swift import Foundation public protocol CryptoRepositoryProtocol: Sendable { /// Barcha tangalar ro'yxatini olish (tarmoqdan yoki keshdan) func fetchTopCoins(forceRefresh: Bool) async throws -> [CoinDTO] /// Bitta tanga haqida batafsil ma'lumot func fetchCoinDetails(id: String) async throws -> CoinDTO } ``` --- ### 3.2. Target 2: `CryptoTrackerCore` Ushbu modulda haqiqiy tarmoq so'rovlari va lokal kesh mexanizmi yoziladi: ```swift // Sources/CryptoTrackerCore/Cache/CryptoLocalCache.swift import Foundation import CryptoTrackerInterface // Swift 6 'package' modifikatori: faqat shu paket ichidagi boshqa targetlar ko'radi! package actor CryptoLocalCache { private var inMemoryCache: [String: CoinDTO] = [:] package init() {} package func save(coins: [CoinDTO]) { for coin in coins { inMemoryCache[coin.id] = coin } } package func getAll() -> [CoinDTO] { Array(inMemoryCache.values) } } ``` ```swift // Sources/CryptoTrackerCore/API/RealCryptoRepository.swift import Foundation import CryptoTrackerInterface public final class RealCryptoRepository: CryptoRepositoryProtocol { private let cache = CryptoLocalCache() private let session: URLSession public init(session: URLSession = .shared) { self.session = session } public func fetchTopCoins(forceRefresh: Bool) async throws -> [CoinDTO] { if !forceRefresh { let cached = await cache.getAll() if !cached.isEmpty { return cached } } // Haqiqiy CoinGecko yoki Binance API URL guard let url = URL(string: "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd") else { throw URLError(.badURL) } let (data, response) = try await session.data(from: url) guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else { throw URLError(.badServerResponse) } // JSON parsing... (Demo sifatida statik DTO qaytarish namunasi) let coins = [ CoinDTO(id: "bitcoin", symbol: "BTC", name: "Bitcoin", priceUSD: 68450.00, change24h: 3.45), CoinDTO(id: "ethereum", symbol: "ETH", name: "Ethereum", priceUSD: 3620.50, change24h: -1.20), CoinDTO(id: "solana", symbol: "SOL", name: "Solana", priceUSD: 182.30, change24h: 8.75) ] await cache.save(coins: coins) return coins } public func fetchCoinDetails(id: String) async throws -> CoinDTO { let all = try await fetchTopCoins(forceRefresh: false) guard let coin = all.first(where: { $0.id == id }) else { throw URLError(.resourceUnavailable) } return coin } } ``` --- ### 3.3. Target 3: `CryptoTrackerFeature` (SwiftUI & ViewModel) Bu yerda eng muhim qoida: `CryptoTrackerFeature` o'z ichida `CryptoTrackerCore` ni **import qilmaydi**! U faqat `CryptoTrackerInterface` bilan muloqot qiladi: ```swift // Sources/CryptoTrackerFeature/ViewModels/CryptoListViewModel.swift import SwiftUI import Observation import CryptoTrackerInterface // Faqat interfeys! @Observable @MainActor public final class CryptoListViewModel { public private(set) var coins: [CoinDTO] = [] public private(set) var isLoading: Bool = false public var errorMessage: String? = nil // Protokol orqali ineksiya qilinadi private let repository: any CryptoRepositoryProtocol public init(repository: any CryptoRepositoryProtocol) { self.repository = repository } public func loadCoins(forceRefresh: Bool = false) async { isLoading = true errorMessage = nil do { self.coins = try await repository.fetchTopCoins(forceRefresh: forceRefresh) } catch { self.errorMessage = "Ma'lumotlarni yuklab bo'lmadi: \(error.localizedDescription)" } isLoading = false } } ``` ```swift // Sources/CryptoTrackerFeature/Views/CoinListView.swift import SwiftUI import CryptoTrackerInterface public struct CoinListView: View { @State private var viewModel: CryptoListViewModel public init(repository: any CryptoRepositoryProtocol) { _viewModel = State(initialValue: CryptoListViewModel(repository: repository)) } public var body: some View { NavigationStack { List(viewModel.coins) { coin in HStack { VStack(alignment: .leading, spacing: 4) { Text(coin.name).font(.headline) Text(coin.symbol).font(.caption).foregroundColor(.secondary) } Spacer() VStack(alignment: .trailing, spacing: 4) { Text("$\(coin.priceUSD)").font(.headline) Text(String(format: "%+.2f%%", coin.change24h)) .font(.caption) .foregroundColor(coin.change24h >= 0 ? .green : .red) } } } .navigationTitle("CryptoTracker (SPM)") .refreshable { await viewModel.loadCoins(forceRefresh: true) } .task { await viewModel.loadCoins() } } } } ``` --- ### 3.4. Target 4: `CryptoTrackerTesting` (Mocklar) ```swift // Sources/CryptoTrackerTesting/MockCryptoRepository.swift import Foundation import CryptoTrackerInterface public final class MockCryptoRepository: CryptoRepositoryProtocol, @unchecked Sendable { public var stubbedCoins: [CoinDTO] = [] public var shouldThrowError: Bool = false public init(stubbedCoins: [CoinDTO] = []) { self.stubbedCoins = stubbedCoins } public func fetchTopCoins(forceRefresh: Bool) async throws -> [CoinDTO] { if shouldThrowError { throw URLError(.notConnectedToInternet) } return stubbedCoins } public func fetchCoinDetails(id: String) async throws -> CoinDTO { if let coin = stubbedCoins.first(where: { $0.id == id }) { return coin } throw URLError(.resourceUnavailable) } } ``` --- ## 4. Izolyatsiyalangan Unit Testlar `Tests/CryptoTrackerFeatureTests/CryptoListViewModelTests.swift` faylida test yozamiz: ```swift import XCTest @testable import CryptoTrackerFeature import CryptoTrackerTesting import CryptoTrackerInterface @MainActor final class CryptoListViewModelTests: XCTestCase { func testLoadCoins_Success_PopulatesCoins() async { // Given: Mock ma'lumotlar bilan tayyorlash let mockRepo = MockCryptoRepository(stubbedCoins: [ CoinDTO(id: "ton", symbol: "TON", name: "Toncoin", priceUSD: 5.40, change24h: 12.4) ]) let vm = CryptoListViewModel(repository: mockRepo) // When: Yuklash await vm.loadCoins() // Then: Natijani tekshirish XCTAssertEqual(vm.coins.count, 1) XCTAssertEqual(vm.coins.first?.symbol, "TON") XCTAssertNil(vm.errorMessage) XCTAssertFalse(vm.isLoading) } func testLoadCoins_Failure_SetsErrorMessage() async { // Given: Xatolik qaytaruvchi mock let mockRepo = MockCryptoRepository() mockRepo.shouldThrowError = true let vm = CryptoListViewModel(repository: mockRepo) // When await vm.loadCoins() // Then XCTAssertTrue(vm.coins.isEmpty) XCTAssertNotNil(vm.errorMessage) } } ``` ### Testni terminalda ishga tushirish: ```bash swift test --filter CryptoTrackerFeatureTests ``` Natija: ``` Executed 2 tests, with 0 failures in 0.051 seconds. ``` --- ## 5. Asosiy App Targetida Barchasini Birlashtirish (Dependency Injection) Asosiy iOS ilovangiz (`CryptoApp.swift`): ```swift import SwiftUI import CryptoTrackerFeature import CryptoTrackerCore @main struct CryptoApp: App { // Haqiqiy repository bitta joyda initsializatsiya qilinadi private let repository = RealCryptoRepository() var body: some Scene { WindowGroup { CoinListView(repository: repository) } } } ``` --- ## 6. Medium Demo Xulosasi | Muammo | Monolitda | Bizning Ko'p Targetli SPM Arxitekturamizda | | :--- | :--- | :--- | | **Tarmoq kodi o'zgarsa** | Butun UI va ViewModel recompile bo'ladi | Faqat `CryptoTrackerCore` qayta yig'iladi (UI keshdan olinadi!) | | **Testlar tezligi** | Simulyator kutish bilan 25–40 sekund | `MockCryptoRepository` bilan **0.05 sekund** | | **Kodni yashirish** | Hamma narsa bir-birini ko'radi | `CryptoLocalCache` faqat paket ichiga yashirilgan (`package` keyword) |