Architecture

/// Central dependency injection container
/// Builds and owns all app-wide singletons and factories
@MainActor
@available(iOS 17.0, *)
public final class CompositionRoot {
    
    // MARK: - Singletons
    
    /// SwiftData model container
    public let modelContainer: ModelContainer
    
    /// HTTP client with interceptors
    public let httpClient: any HTTPClient

    /// Keychain storage
    public let keychainStore: KeychainStore

    /// Auth client (SessionManager wrapper in production, MockAuthClient in DEBUG)
    public let sessionManager: any AuthClient

    /// LLM client (ProxyLLMClient when configured, EchoLLMClient otherwise)
    public let llmClient: any LLMClient
    // ...
}

// View-model factories live in CompositionRoot+Factories.swift:
extension CompositionRoot {
    /// Create ChatViewModel with injected dependencies
    public func makeChatViewModel(conversationID: UUID) -> ChatViewModel {
        ChatViewModel(
            conversationID: conversationID,
            messageRepository: messageRepository,
            llmClient: llmClient,
            paymentsStatusProvider: PaymentsStatusAdapter(paymentsClient: paymentsClient)
        )
    }
}

/// Main authentication client protocol
@available(iOS 17.0, *)
@preconcurrency
public protocol AuthClient: Sendable {
    /// Sign in with Apple ID
    func signInWithApple() async throws -> AuthUser
    
    /// Sign in with Google
    func signInWithGoogle() async throws -> AuthUser
    // ...
}

// Implementations:
// - SessionManager (production actor; wrapped to AuthClient via SessionManagerWrapper)
// - MockAuthClient (DEBUG-only fallback)

Core            → (no dependencies)
TestSupport     → (no dependencies, test-only)
DesignSystem    → (no dependencies)
Networking      → Core
Storage         → Core, Networking
Localization    → Core
Payments        → Core
FeatureRating   → Core, DesignSystem
Auth            → Core, Networking, Storage
FeatureChat     → Core, Storage, DesignSystem, Localization
AI              → Core, Networking, FeatureChat   (re-exports FeatureChat)
FeatureSettings → Core, Storage, Auth, Payments, DesignSystem, Localization

1. User types message → ChatView
2. ChatView calls → ChatViewModel.send()
3. ChatViewModel:
   - Appends message → MessageRepository
   - Streams AI response → LLMClient.streamResponse(messages:)
   - Mutates @Observable state on the main actor
4. View automatically re-renders

1. User enters credentials → SignInView
2. View calls → AuthViewModel.signIn()
3. AuthViewModel calls → AuthClient.signInWithEmail(email:password:)
4. SessionManager (the AuthClient):
   - Calls Supabase API
   - Persists tokens → Keychain (via SessionStore)
   - Returns AuthUser, emits via authStates()
5. LaunchRouter observes the auth state change
6. Navigation switches to authenticated content

@MainActor
@Observable
public final class ChatViewModel {
    private let messageRepository: any MessageRepository
    private let llmClient: any LLMClient
    ...
}

/// Send the current input text.
public func send() async {
    // 1. Validate input (skip empty/whitespace)
    // 2. Append the user message via MessageRepository
    // 3. Stream the AI reply: llmClient.streamResponse(messages:)
    // 4. Mutate @Observable state on the main actor as tokens arrive
}

xcodebuild test \
  -project SwiftAIBoilerplatePro.xcodeproj \
  -scheme SwiftAIBoilerplatePro \
  -destination 'platform=iOS Simulator,name=iPhone 17 Pro,OS=26.2' \
  CODE_SIGNING_ALLOWED=NO

func testSendStreamsReply() async throws {
    let viewModel = ChatViewModel(
        conversationID: UUID(),
        messageRepository: messageRepository,
        llmClient: EchoLLMClient() // dev fallback echoes the prompt
    )
    viewModel.inputText = "Hello"

    await viewModel.send()

    XCTAssertFalse(viewModel.messages.isEmpty)
}

@MainActor
func testCompositionRoot() throws {
    let authConfig = AuthConfig(
        supabaseURL: URL(string: "https://test.supabase.co")!,
        supabaseAnonKey: "test_anon_key"
    )
    let paymentsConfig = PaymentsConfig(
        apiKey: "test_api_key",
        entitlementID: "test_entitlement"
    )
    let composition = try CompositionRoot(
        authConfig: authConfig,
        paymentsConfig: paymentsConfig
    )

    // Dependencies are wired
    XCTAssertNotNil(composition.httpClient)
    XCTAssertNotNil(composition.sessionManager)

    // Factories produce view models
    let chatVM = composition.makeChatViewModel(conversationID: UUID())
    XCTAssertNotNil(chatVM)
}

func testChatFlow() throws {
    let app = XCUIApplication()
    app.launchEnvironment["UI_TESTING"] = "1"
    app.launch()

    app.buttons["Start Chat"].tap()

    let textField = app.textFields["messageInput"]
    textField.tap()
    textField.typeText("Hello AI")
    app.buttons["send"].tap()

    XCTAssertTrue(app.staticTexts["Hello AI"].waitForExistence(timeout: 5))
}

// Want to use Firebase instead of Supabase? Conform to the AuthClient protocol.
final class FirebaseAuthClient: AuthClient {
    func signInWithEmail(email: String, password: String) async throws -> AuthUser {
        // Firebase implementation
    }
    // ... signInWithApple, signInWithGoogle, signOut, currentUser, authStates, etc.
}

// Then wire it in CompositionRoot:
self.sessionManager = FirebaseAuthClient(...)