nalexn/clean-architecture-swiftui
Clean Architecture Swiftui
This is a demonstration and template project that applies Clean Architecture principles to SwiftUI application development. It implements a layered architecture that separates presentation, business logic, and data access into independent layers, with unidirectional data flow managed through a single immutable app store that serves as the sole source of truth for all screens.
The project distinguishes itself through its implementation of interactor-driven business logic, where all domain rules and workflows live in stateless objects that receive requests and update the central store. Dependencies are injected into the SwiftUI view hierarchy through the environment rather than manual wiring, and data access is hidden behind repository protocol abstractions so business logic never depends on concrete persistence or networking implementations. Navigation is handled programmatically through Combine publishers that broadcast state changes, enabling decoupled screen transitions and deep link handling.
The template includes an asynchronous HTTP client built on Swift's async/await concurrency model, local data persistence using SwiftData, and isolated unit and UI testing of each architectural layer by mocking dependencies through protocols. The project serves as both a reference implementation and a reusable starting point for building SwiftUI applications with Clean Architecture patterns.
Features
- Clean Architecture SwiftUI Applications - Demonstrates Clean Architecture principles applied to SwiftUI application development with layered separation.
- SwiftUI Templates - Serves as a reusable template for building SwiftUI apps with Clean Architecture, the primary purpose of the repository.
- Repository Pattern with Swap Support - Hides data origin behind protocols so the business layer can swap real and mocked data sources without changing code.
- Repository Protocol Abstractions - Hides data access behind repository protocols so business logic never depends on concrete implementations.
- SwiftUI Clean Architecture Sample Applications - Serves as a demonstration project applying Clean Architecture to SwiftUI with SwiftData persistence and networking.
- Stateless Interactor Business Logics - Places all domain rules and workflows into stateless interactor objects that update the central store.
- Environment-Based Injections - Implements a dependency injection pattern using SwiftUI's environment, a key architectural feature of the project.
- Dependency Injection Providers - Provides services and state to views through SwiftUI's environment, eliminating manual dependency injection wiring.
- Environment Dependency Injections - Injects dependencies into the SwiftUI view hierarchy through the environment rather than manual wiring.
- Protocol-Oriented Injection - Decouples app layers by abstracting data access behind repository protocols and injecting dependencies through SwiftUI's environment.
- Logic and Presentation Separation - Separates UI code from business rules so each layer can be developed, tested, and maintained independently.
- Single-Source-of-Truth Modeling - Holds the entire application state in one observable object as the single source of truth.
- Unidirectional Data Flow Architectures - Implements unidirectional data flow with a central immutable store updated by interactors and read by views.
- Centralized State Stores - Keeps the entire application state in one observable object that acts as the single source of truth for all screens.
- Layered Architectures - Separates presentation, business logic, and data access into independent layers for isolated development and testing.
- Global State Stores - Centralizes the entire application state in a single immutable store, updated by interactors and read by views.
- Business Logic Encapsulations - Encapsulates all domain rules and workflows into stateless interactor objects that update the central state.
- Unidirectional State Management - Manages global application state through a single immutable store with unidirectional data flow.
- SwiftData Persistence Examples - Provides a concrete example of SwiftData persistence integrated into a Clean Architecture SwiftUI app.
- Programmatic Navigation - Controls screen transitions and deep-link handling through code rather than relying on SwiftUI's built-in navigation.
- Deep Link Navigators - Controls screen transitions and handles deep links through code using Combine publishers and centralized navigation state.
- Multi-View - Implements multi-view deep linking that transitions through the entire view chain to the target screen.
- SwiftUI Deep Link Parsers - Provides deep link parsing that toggles SwiftUI binding state for programmatic navigation to target views.
- Local Data Persistence - Stores and retrieves structured data on the device using SwiftData local persistence.
- Environment-Injected Navigation States - Injects a centralized navigation state object into the SwiftUI environment for shared access across views.
- Asynchronous HTTP Clients - Ships an async/await HTTP client for fetching and sending data to remote servers.
- Swift Async-Await Networking Layers - Provides a concrete async/await networking layer for SwiftUI apps.
- Isolated Layer Testing - Enables unit testing of presentation, business logic, and data access independently by mocking dependencies through protocols.
- Interactor and View Testings - Provides full test coverage for both business logic interactors and SwiftUI views through isolated testing.
- Combine-Based Navigations - Ships a Combine-based navigation system that broadcasts state changes for decoupled screen transitions.
- Combine Publisher Navigations - Implements programmatic navigation using Combine publishers for decoupled screen transitions.
- Architecture Patterns - Demonstrates production-ready SwiftUI with clean architecture.
- Example Applications - Clean architecture production setup demo.
- Open Source Applications - Example project demonstrating clean architecture principles.
