mvvm-architecture

MVVM Architecture Rules

Loadable Enum (Required for Async State)

Every app that performs async operations MUST include this enum as Shared/Loadable.swift:

// Shared/Loadable.swift
enum Loadable<T> {
    case notInitiated
    case loading
    case success(T)
    case failure(Error)

    var value: T? {
        if case .success(let v) = self { return v }
        return nil
    }

    var error: Error? {
        if case .failure(let e) = self { return e }
        return nil
    }

    var isLoading: Bool {
        if case .loading = self { return true }
        return false
    }
}

Rule: All async operations MUST use Loadable<T> for state tracking — never use var isLoading: Bool + var errorMessage: String?.

ViewModel Pattern (In-Memory Default)

Every ViewModel follows this exact pattern:

import SwiftUI

@Observable
@MainActor
class NotesListViewModel {
    var notes: [Note] = Note.sampleData
    var searchText = ""

    var filteredNotes: [Note] {
        if searchText.isEmpty { return notes }
        return notes.filter { $0.title.localizedCaseInsensitiveContains(searchText) }
    }

    func addNote(title: String) {
        let note = Note(title: title)
        notes.insert(note, at: 0)
    }

    func deleteNote(_ note: Note) {
        notes.removeAll { $0.id == note.id }
    }
}

ViewModel Pattern (Async Data)

When a ViewModel loads data asynchronously, use Loadable<T> and start loading in init():

import SwiftUI

@Observable
@MainActor
class NotesListViewModel {
    var notes: Loadable<[Note]> = .loading  // Start as .loading — init fires immediately
    var searchText = ""

    init() {
        Task { await loadNotes() }
    }

    var filteredNotes: [Note] {
        guard let allNotes = notes.value else { return [] }
        if searchText.isEmpty { return allNotes }
        return allNotes.filter { $0.title.localizedCaseInsensitiveContains(searchText) }
    }

    func loadNotes() async {
        notes = .loading
        do {
            notes = .success(try await fetchNotes())
        } catch {
            notes = .failure(error)
        }
    }
}