spring-modulith-verifier
Verifies whether code follows Spring Modulith code structure or not. Show list of violations along with recommendations on how to fix them. Use this skill: * When reviewing Spring Boot applications which uses Spring Modulith * When verifying whether Spring Boot application code follows Spring Modulith package structure
How do I install this agent skill?
npx skills add https://github.com/sivaprasadreddy/sivalabs-agent-skills --skill spring-modulith-verifierIs this agent skill safe to install?
- Gen Agent Trust Hubpass
This skill provides architectural guidelines for Spring Modulith applications. It contains only instructional text and no executable code, remote dependencies, or suspicious commands.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
What does this agent skill do?
Spring Modulith Verifier Skill
Use a domain-driven, modular layout: organize packages by business modules, not by technical layers.
Recommended Example Package Structure
dev.sivalabs.projectname/
├── Application # Main Spring Boot entrypoint class
├── shared/ # Cross-cutting concerns
│ ├── package-info.java
├── users/ # Users module (bounded context)
│ ├── config/ # Users module-specific config
│ ├── domain/ # Domain logic
│ │ ├── models/ # Domain models
│ │ │ ├── package-info.java
│ │ ├── exceptions/ # Domain custom Exception classes
│ │ │ ├── package-info.java
│ │ ├── {entities, repositories, mappers, services}
│ ├── api/ # REST API layer
│ │ ├── {controllers, DTOs} # REST controllers, Request, Response payload DTOs
│ └── UsersAPI.java # Module's public API (facade)
│
├── catalog/ # Catalog module
├── orders/ # Orders module
└── config/ # Global Configuration
└── WebMvcConfig.java
└── SecurityConfig.java
└── WebSecurityConfig.java
└── GlobalExceptionHandler.java
Explanation of the above package structure:
-
Application.java: The main Spring Boot entry point class annotated with
@SpringBootApplication. Contains themain()method that bootstraps the application. -
shared/: Contains cross-cutting concerns and utilities shared across multiple modules (e.g., common utilities, shared DTOs, base classes, custom annotations).
-
{module}/ (e.g., users/, catalog/, orders/): Each business module represents a bounded context and contains:
-
config/: Module-specific configuration classes annotated with
@Configurationfor beans, properties, or third-party integrations relevant only to this module. -
domain/: Core business logic layer containing:
- models/: Domain model classes (Command, Query objects, Enums, Value Objects, Result objects, etc) representing business concepts (not JPA entities). These are pure Java objects that encapsulate business rules.
- exceptions/: Domain specific custom Exception classes.
- entities: JPA entity classes annotated with
@Entitythat map to database tables. These should not bepublicto prevent direct instantiation and ensure encapsulation. - repositories: Spring Data JPA repository interfaces extending
JpaRepositoryorCrudRepositoryfor data access. These should not bepublic. - mappers: Mapper classes/interfaces (e.g., MapStruct mappers) for converting between entities, domain models, and DTOs. These should not be
public. - services: Service classes annotated with
@Servicecontaining business logic, converting beans using mappers, transaction management, and orchestration of repository calls.
-
api/: REST API layer containing:
- controllers: REST controller classes annotated with
@RestControllerthat handle HTTP requests, validate input, and delegate to services. - DTOs: Data Transfer Objects including request payloads (data coming from clients) and response payloads (data sent to clients).
- controllers: REST controller classes annotated with
-
{Module}API.java: A facade class that serves as the module's public API, delegating calls to services, exposing only what other modules should access while hiding internal implementation details.
-
-
config/: Global application-wide configuration classes including:
- WebMvcConfig.java: MVC configuration (CORS, interceptors, formatters).
- SecurityConfig.java: Spring Security configuration for authentication and authorization.
- GlobalExceptionHandler.java: Centralized exception handling using
@RestControllerAdvicefor consistent error responses.
Visibility Modifiers
Default to minimum necessary visibility. Only expose what other modules or layers genuinely need.
| Component | Class | Constructor | Methods |
|---|---|---|---|
| Controller | package-private | package-private | package-private |
| Service | public | package-private | public |
| Repository | package-private (interface) | — | — |
| Entity | package-private | protected | public |
| DTO / record | public or package-private | — | — |
| Module API facade | public | package-private | public |
| Request/Response records | package-private | — | — |
| Config/Exception handler | package-private | — | — |
Naming Conventions
| Type | Convention | Example |
|---|---|---|
| Entities | *Entity | UserEntity, AddressEntity |
| Value Objects | Domain name (record) | Email, UserCode, UserId |
| Commands | *Cmd | CreateUserCmd, UpdateAddressCmd |
| Command Response | *Result | LoginResult, RegistrationResult |
| DTOs | *Dto | UserDto, AddressDto |
| HTTP Request | *Request | CreateUserRequest, CreateAddressRequest |
| HTTP Response | *Response | CreateUserResponse, CreateAddressResponse |
| Repositories | *Repository | UserRepository, AddressBookRepository |
| Services | *Service | UserService, AddressBookService |
| Domain Exceptions | *Exception | InvalidUserCreationException, UserCancellationException |
| Module API | *API | UsersAPI |
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/sivaprasadreddy/sivalabs-agent-skills/spring-modulith-verifier">View spring-modulith-verifier on skillZs</a>