SwiftUI Architecture Patterns for Production Apps

// iOS 17+: prefer @Observable — lower overhead than ObservableObject
@Observable
final class FeedViewModel {
    var items: [FeedItem] = []
    var isLoading = false
    private let repository: FeedRepository

    init(repository: FeedRepository) {
        self.repository = repository
    }

    func load() async {
        isLoading = true
        defer { isLoading = false }
        items = await repository.fetchFeed()
    }
}

// iOS 16 and earlier: ObservableObject + @Published
final class FeedViewModelLegacy: ObservableObject {
    @Published var items: [FeedItem] = []
    @Published var isLoading = false
    // ...
}

// Scope environment narrowly — only views that need auth state subscribe
struct AuthenticatedRootView: View {
    @State private var authState = AuthViewModel()

    var body: some View {
        FeedView()
            .environment(authState)   // @Observable, only propagates to consumers
    }
}

// View only re-evaluates when properties it actually reads change
struct ProfileBadgeView: View {
    @Environment(AuthViewModel.self) var auth
    var body: some View {
        Text(auth.displayName)   // Only subscribes to displayName
    }
}

// NavigationStack with typed path — enables programmatic deep linking
@Observable
final class AppRouter {
    var path: [AppRoute] = []

    func push(_ route: AppRoute) { path.append(route) }
    func pop() { path.removeLast() }
    func popToRoot() { path.removeAll() }
}

enum AppRoute: Hashable {
    case detail(Item.ID)
    case settings
    case onboarding
}

struct RootView: View {
    @State private var router = AppRouter()

    var body: some View {
        NavigationStack(path: $router.path) {
            FeedView()
                .navigationDestination(for: AppRoute.self) { route in
                    switch route {
                    case .detail(let id): DetailView(id: id)
                    case .settings: SettingsView()
                    case .onboarding: OnboardingView()
                    }
                }
        }
        .environment(router)
    }
}

// Package.swift structure
// MyApp (Xcode target) → depends on features
// Features depend on shared packages only, never on each other

Packages/
  FeatureFeed/          // Feed list, detail, filter logic
  FeatureProfile/       // Profile view, edit, settings
  FeatureOnboarding/    // Onboarding screens and state
  SharedUI/             // Design system components, tokens
  SharedData/           // Models, repositories, SwiftData schemas
  SharedNetworking/     // API clients, auth adapters
  SharedTesting/        // Factories, test helpers, fake implementations

// Dependency rule: Features → Shared packages only
// Shared packages do not depend on features

// Separate persistence model from display model
// SwiftData @Model (persistence)
@Model
final class ItemRecord {
    var id: UUID
    var rawTitle: String
    var createdAt: Date
    // ...
}

// Display model (value type, derivation from record)
struct ItemDisplay: Identifiable {
    let id: UUID
    let title: String         // Formatted, trimmed
    let relativeDate: String  // "2 hours ago"
}

// Repository converts between layers
struct ItemRepository {
    func fetchDisplay(context: ModelContext) async -> [ItemDisplay] {
        let records = try context.fetch(FetchDescriptor<ItemRecord>())
        return records.map { r in
            ItemDisplay(id: r.id, title: r.rawTitle.trimmingCharacters(in: .whitespaces), relativeDate: r.createdAt.relativeDescription)
        }
    }
}

// Use protocols + fake implementations for testable ViewModels
protocol FeedRepository: Sendable {
    func fetchFeed() async -> [FeedItem]
}

struct FakeFeedRepository: FeedRepository {
    let canned: [FeedItem]
    func fetchFeed() async -> [FeedItem] { canned }
}

// Test ViewModel state transitions directly
final class FeedViewModelTests: XCTestCase {
    func testLoadsItems() async {
        let vm = FeedViewModel(repository: FakeFeedRepository(canned: [.sample]))
        await vm.load()
        XCTAssertEqual(vm.items.count, 1)
        XCTAssertFalse(vm.isLoading)
    }

    func testEmptyState() async {
        let vm = FeedViewModel(repository: FakeFeedRepository(canned: []))
        await vm.load()
        XCTAssertTrue(vm.items.isEmpty)
    }
}