pointfreeco/swift-composable-architecture
Swift Composable Architecture
This is a Swift state management framework and application logic library designed for building applications with a single source of truth and unidirectional data flow. It provides a Redux-inspired architecture that separates business logic from side effects and user interfaces to ensure predictable application behavior across multiple screens.
The framework focuses on modularity by allowing complex features to be decomposed into smaller, isolated components. This enables the development of UI-independent business logic that can be extracted into separate modules to improve compilation speed and maintainability.
It covers several high-level capability areas, including state-driven navigation and routing, dependency injection via client abstraction, and deterministic testing of state transitions and effects. The system also includes utilities for asynchronous task management and side-effect isolation.
Features
- Application Logic Libraries - Provides a library for composing complex application features into smaller, isolated, and testable modules.
- Unidirectional Data Flow Architectures - Implements a unidirectional data flow where actions trigger reducers to produce new immutable states.
- Cross-Screen Coordination - The framework coordinates data using value types and shares state across multiple screens so mutations are immediately observed.
- Abstraction Layers - Uses a client abstraction layer to decouple business logic from system services for consistent testing.
- Side Effect Management - Implements architectural strategies to isolate and control operations that interact with the outside world.
- Modular Architecture Patterns - Implements a modular architectural pattern that separates business logic from side effects and UI for deterministic behavior.
- Centralized State Containers - Provides a centralized state container that acts as a single source of truth with predictable mutations.
- Hierarchical State Composition - Implements a hierarchical state structure where large application states are composed of smaller, nested feature states.
- Core Business Logic - Separates core business logic into standalone modules that remain independent of the user interface.
- External Service Wrappers - Wraps external dependencies like timers and file systems to ensure predictable behavior during tests and previews.
- Dependency Registration Systems - Centralizes the registration and retrieval of dependencies across application layers to avoid manual passing.
- Dependency Injection - Decouples business logic from external services using a client wrapper layer for easier mocking and testing.
- Side Effect Handlers - Isolates side effects by returning descriptions of work to an external runtime, keeping business logic pure.
- State-Driven Application Architectures - Structures Swift apps with a consistent state management pattern to ensure business logic remains predictable.
- State Management Frameworks - Provides a comprehensive framework for building Swift applications using a single source of truth and unidirectional data flow.
- Type-Safe State Management - Uses immutable value types for the entire application state to ensure predictable mutations and transitions.
- Side Effect Isolation - The framework isolates interactions with the outside world into testable effects to separate business logic from external API calls.
- Logic Validation Frameworks - Validates business logic and state transitions using a specialized store for deterministic assertions.
- State-Driven Flow Control - Determines the active screen and navigation flow based on the current application state to ensure consistent user journeys.
- State Transition Testing - Enables deterministic validation of state transitions and effects by manually stepping through actions in a test store.
- Modular Feature Architectures - Provides architectural patterns to decompose complex features into isolated, reassemblable modules.
- Navigation State Trees - Represents the navigation history and active destinations as a state tree to enable deep linking and coordinated flow.
- Deterministic State Testing - Verifies core functionality and failure paths through a testing suite that simulates state changes and effects.
- Business Logic Isolation - Isolates feature logic into independent modules to improve compilation speed and enable isolated component execution.
- Dependency Mocking - Replaces live service implementations with deterministic mocks to ensure predictable test results.
- End-to-End Testing - Provides automated suites to simulate complete user workflows and resulting side effects.
- Navigation Routing - Provides a state-driven system for managing application navigation paths, including alerts, sheets, and drill-downs.
- Architecture Patterns - Comprehensive library for building consistent, testable applications.
- Composable Architecture - Library for building consistent, testable, and composable applications.
