sergdort/ModernCleanArchitectureSwiftUI
ModernCleanArchitectureSwiftUI
This project is a reference implementation and template for a modular iOS application using SwiftUI and Clean Architecture. It provides a structure organized into independent layers to decouple the user interface and external frameworks from core business logic.
The architecture incorporates Domain-Driven Design to manage complexity by organizing code into independent modules based on business domains. This approach enforces strict dependency boundaries and improves build times.
The project implements a plugin-based data layer that hides API and database implementations behind gateways to allow swapping data sources without modifying business rules. It also features a centralized routing coordinator to abstract the navigation hierarchy, keeping individual feature modules independent of the overall application flow.
Features
- Modular iOS Architectures - Provides a modular architecture for native iOS applications to improve build times and isolate feature dependencies.
- Clean Architecture Frameworks - Provides a reference implementation of Clean Architecture that decouples business logic from infrastructure and presentation layers.
- Domain Model Isolation - Encapsulates core business rules and data models into a dedicated layer to isolate them from infrastructure concerns.
- Layered Architectures - Organizes code into independent layers to isolate core application logic from user interfaces and external frameworks.
- App Navigation Coordinators - Implements a centralized routing coordinator to abstract the navigation hierarchy and keep feature modules independent.
- iOS App Navigation Routing - Centralizes navigation logic to keep individual feature modules independent of the overall application flow.
- Clean Architecture SwiftUI Applications - Provides a reference implementation of SwiftUI applications using a layered Clean Architecture to decouple UI from business logic.
- SwiftUI Clean Architecture Sample Applications - Provides a reference implementation of Clean Architecture for SwiftUI applications, decoupling business logic from infrastructure.
- Business Entities - Encapsulates business rules into a dedicated layer to prevent infrastructure concerns from polluting the domain model.
- Domain-Driven Designs - Structures the application around core business domains to manage complexity and separate logic from technical implementation.
- Feature Modularity - Divides the codebase into independent feature modules based on business domains to enforce strict dependency boundaries.
- Module-Based Navigation - Centralizes routing logic to keep individual feature modules independent of the overall application navigation flow.
- Gateway Abstractions - Implements a plugin-based data layer that hides API and database implementations behind gateways.
- Data Source Extensions - Abstracts data sources behind gateways to allow swapping API or database implementations without affecting business rules.
- Build-Time Optimization Patterns - Reduces build times by isolating feature logic and user interfaces into independent modules.
- Coordinator Navigation Patterns - Implements a centralized routing coordinator to abstract the navigation hierarchy and keep feature modules independent.
- Interface-Agnostic Modules - Decouples UI patterns from business logic within independent modules to enable varied architectural choices for different screens.
- UI Architectures & Patterns - Allows different UI architectural patterns to be used for different screens within independent feature modules.
- Plugin-Based Architectures - Hides concrete API and database implementations behind abstract gateway interfaces to allow swapping data sources.
- Datasource Plugin Architectures - Hides data source implementations behind gateways to allow swapping APIs or databases without modifying business rules.
- Architecture Patterns - Example project demonstrating clean architecture with reactive streams.
