Design UseCase interfaces and CQRS Service implementations for Java/Spring Port-In layers.
npx skills add https://github.com/ryu-qqq/AuthHub --skill usecase-expert
Please help me install this Agent Skill. Skill: usecase-expert Source: https://github.com/ryu-qqq/AuthHub/tree/main/.claude/skills/usecase-expert Command: npx skills add https://github.com/ryu-qqq/AuthHub --skill usecase-expert
This Skill guides the design and implementation of the Application Layer's UseCase interfaces (Port-In) and Service implementations. It ensures a clean separation of concerns, adheres to CQRS principles, and manages transaction boundaries properly, leading to highly maintainable and testable business logic.
UseCase interfaces (e.g., PlaceOrderUseCase, GetOrderUseCase) as inbound ports, defining the application's capabilities.Command, Query, and Response DTOs as immutable records, ensuring data integrity and clear communication between layers.@Transactional annotations are managed by Facade/Manager components, not directly within Services, for better control and testability.Create a 'Place Order' UseCase, including its interface, command DTO, response DTO, and service implementation.
High-intent search queries and answers about installing and using this skill.
UseCase interfaces define your application's Port-In layer as single-method contracts (e.g., execute()). Design them as clean inbound ports for each business capability—command UseCases for state changes, query UseCases for data retrieval—following CQRS principles to separate read and write operations.
Define immutable Command, Query, and Response DTOs as records to ensure data integrity and clear layer boundaries. Keep them focused on their use case; Command DTOs carry input, Query DTOs specify retrieval criteria, and Response DTOs return results, maintaining strict separation between layers.
@Transactional boundaries belong in Facade or Manager components, not directly in Services. This delegation keeps Services testable and transactional control centralized, allowing Facades to orchestrate Services, factories, and assemblers while managing transaction scope.
Each UseCase interface defines one execute() method accepting a single DTO (Command or Query) and returning a Response. This enforces single responsibility and consistency across your application layer, making services predictable and composable.
UseCase interfaces, Service implementations, CommandFactory, Assembler, and Facade/Manager components coordinate in the Port-In layer. Factories create commands, Assemblers map between DTOs and domain objects, Services execute logic, and Facades manage transactions and dependencies.
Yes, this skill targets Java/Spring CQRS architectures specifically. It leverages Spring's @Transactional, component composition, and dependency injection to implement clean UseCase interfaces and Service layers aligned with hexagonal architecture principles.
sylin-orgDefine aggregate-first domain models with lifecycle hooks and value objects in Koan Framework.
ocbunknownEnforce Client + Service boundaries for HTTP API integrations.
signalbeam-ioScaffolds a complete DDD domain entity with value object ID, aggregate root, factory method, and domain event.
wesleyegbertoCompare architectural patterns like Hexagonal, CQRS, Event Sourcing, and MVC for design decisions.