Sairyss/domain-driven-hexagon

Features

• Database Adapters - Provides standardized interfaces for decoupling application logic from specific database engines and external services.
• Project Boilerplates - Enforces clean separation between domain entities, application use cases, and external technology adapters through project templates.
• Command Query Responsibility Segregation Patterns - The framework routes state-changing operations and data-retrieval requests through distinct handlers to simplify logic and enable independent scaling of read and write models.
• Clean Architecture Frameworks - Provides a strictly typed foundation for organizing complex business logic into decoupled modules with standardized command and query patterns.
• Domain-Driven Designs - Implements clean, modular software by separating core business logic from infrastructure concerns using hexagonal architectural patterns.
• Aggregate State Management - Encapsulates business logic and state transitions within a central object to maintain consistency and enforce domain-specific rules.
• Command Execution Engines - The framework processes business logic by invoking handlers that apply state changes and ensure domain rules remain consistent across the application.
• Design Pattern Implementations - Separates state-changing commands from data-retrieval queries to simplify scaling and maintainability in complex systems.
• Dependency Inversion Patterns - Enforces strict boundaries by ensuring high-level business logic depends only on abstractions rather than concrete infrastructure implementations.
• Command Query Separation - Separating state-changing operations from data-retrieval queries to simplify complex business logic and enable independent scaling of models.
• Atomic Transaction Execution - Groups multiple database operations into a single unit of work that succeeds or fails entirely to ensure data consistency.
• Business Invariant Enforcement - Validates entity state against defined rules before persistence to ensure that only valid data is saved to the database.
• Persistence Abstractions - Decouples core business models from specific database technologies by using repository patterns and standardized interfaces.
• Repository Patterns - Centralizes data access logic and decouples the domain model from specific database implementations using repository patterns.
• Transaction Managers - Groups multiple database operations into atomic units to ensure data integrity and reliable persistence across complex business processes.
• Infrastructure Abstraction Layers - The framework provides technology-agnostic interfaces for external services, ensuring business logic remains independent of specific databases, third-party APIs, or infrastructure implementation details.
• Event-Driven Architectures - Triggers asynchronous side effects across system components to maintain data consistency without creating direct dependencies between different modules.
• Dependency Boundary Enforcers - The framework analyzes and enforces dependency rules between layers to prevent unauthorized access to core domain logic from external infrastructure or interface layers.
• Request Dispatchers - The framework dispatches incoming transport requests to specific domain commands through a centralized bus to decouple the communication layer from core business operations.
• Decoupled Logic Encapsulation - Groups data and business rules within objects to ensure state remains consistent and protected from unauthorized external modifications.
• Use Case Orchestrators - The framework coordinates interactions between the outside world and domain entities using application services that do not contain core business logic.
• Workflow Orchestrators - The framework executes use cases by coordinating domain entities and external services through defined ports to keep business logic decoupled from infrastructure.
• Domain Event Emission - Triggers notifications when state changes occur within an entity so that other parts of the system can react to updates asynchronously.
• Domain Event Handlers - The framework executes automated side effects across system aggregates in response to specific events to maintain data consistency and decoupled business logic.
• Data Persistence Layers - Maps domain objects to database records and handles storage operations to ensure data consistency between the application and the persistence layer.
• Data Access Contracts - Standardizes database operations by enforcing a consistent interface for entity persistence and retrieval across different modules.
• Atomic Transactions - Wraps database operations in atomic transactions to ensure that domain events and state changes are persisted reliably.
• Project Scaffolding - Automates the creation of standardized application structures and boilerplate code to ensure consistent architecture across enterprise-grade projects.
• Type Safety - Applies rigorous type safety rules during compilation to catch potential runtime errors and ensure consistent data structures.
• Command Objects - The framework packages business intent and required data into structured objects to trigger state changes within the core application logic.
• Error Handling - The framework converts internal error types into appropriate status codes and messages to ensure consistent and predictable error reporting for all system users.
• Event-Driven Triggers - Decouples system components by using asynchronous domain events to trigger side effects and maintain data consistency.
• Value Objects - Encapsulates domain data with built-in validation logic to ensure that objects remain in a valid state throughout the application lifecycle.
• Request Validation - The framework enforces structural and content constraints on incoming data to ensure integrity and correctness before information reaches the core application logic.
• Database Migration Management - Executes schema changes and versioning scripts to keep database structures synchronized across development, testing, and production environments.
• Entity Mappings - Fetches records from the database by identifier or as a collection and transforms them back into domain objects using mapping logic.
• Code Organization - Groups related business logic into independent, encapsulated modules to minimize coupling and support vertical slicing of features.
• Error Handling Patterns - Returns explicit error types instead of throwing exceptions to make failure states visible and manageable within the application flow.
• Query Objects - Separates read operations from business logic by encapsulating data retrieval within dedicated query objects.
• Mutation Mappers - The framework maps incoming GraphQL mutation requests to internal command objects to trigger domain logic while returning standardized response types to the client.
• Data Validation - Checks if provided values are empty or fall within specified length ranges to ensure data meets business requirements before processing.
• Event Tracking - Records significant state changes within aggregates to facilitate decoupled communication and side effects across the system.
• Pagination - Retrieves filtered data sets from the database using pagination parameters to optimize performance and reduce memory usage.
• Message Brokers - The framework listens for incoming messages from a message queue and dispatches them to the correct command handler to execute business logic asynchronously.
• Logging Abstractions - Standardizes how system events, errors, and warnings are recorded by defining a consistent interface for various logging implementations.
• End-to-End Testing - Runs automated suites that simulate complete user workflows across an entire application stack to verify system-wide functional correctness.
• Response Mappers - The framework maps internal domain entities to documented and serializable formats to ensure consistent data structures for all client communication across the system.

Star history