setup-spring-component

Prompt file imported from karlkyck/humansreadcode-springboot-exemplar (.github/prompts/setup-spring-component.prompt.md). Copyright stays with the author.

Setup Spring Boot Component

You are tasked with creating a new Spring Boot component following the project's established patterns and conventions.

Information Required

Ask for the following if not provided:

1. Component Type: Controller, Service, Repository, Entity, or complete module
2. Domain Name: The business domain (e.g., Order, Customer, Product)
3. Operations: What operations/methods should be included
4. Database Integration: Whether database persistence is needed

Project Conventions

Spring Modulith Structure

src/main/java/com/humansreadcode/springboot_exemplar/
├── {domain}/
│   ├── {Domain}Controller.java
│   ├── {Domain}Service.java
│   ├── {Domain}ServiceImpl.java
│   ├── {Domain}Repository.java
│   ├── {Domain}Entity.java
│   ├── dto/
│   │   ├── {Domain}Request.java
│   │   └── {Domain}Response.java
│   └── internal/
│       └── {Domain}InternalService.java

Component Guidelines

Controllers:

• Thin controllers that delegate to services
• Use request/response DTOs
• Include validation annotations
• Implement proper error handling
• Use meaningful HTTP status codes

Services:

• Implement interfaces for better testability
• Use service DTOs for input/output
• Include proper transaction boundaries
• Implement comprehensive logging
• Handle business logic and validation

Repositories:

• Extend Spring Data JPA interfaces
• Use custom queries when needed
• Follow naming conventions
• Include proper indexing hints

Entities:

• Use JPA annotations appropriately
• Include audit fields (created/updated timestamps)
• Implement proper equals/hashCode
• Use appropriate relationships

Required Files

For a complete module, create:

1. Entity - JPA entity with proper annotations
2. DTOs - Request and Response DTOs in dto package
3. Repository - Spring Data JPA repository interface
4. Service Interface - Service contract
5. Service Implementation - Business logic implementation
6. Controller - REST API endpoints
7. Tests - Unit and integration tests
8. Migration - Flyway database migration if needed

Code Style Requirements

• Use constructor injection for dependencies
• Follow Java naming conventions
• Include comprehensive Javadoc
• Use appropriate validation annotations
• Implement proper exception handling
• Follow project logging standards

Testing Requirements

• Create unit tests for service layer
• Create integration tests with Testcontainers
• Test all public methods and edge cases
• Use meaningful test names and assertions
• Follow AAA (Arrange-Act-Assert) pattern

Database Considerations

If database integration is needed:

• Create appropriate Flyway migration
• Use proper indexing strategy
• Follow database naming conventions
• Include foreign key constraints
• Consider performance implications

Example Output

When creating an Order module, generate:

1. Database migration for orders table
2. Order entity with JPA annotations
3. OrderRequest and OrderResponse DTOs
4. OrderRepository interface
5. OrderService interface and implementation
6. OrderController with REST endpoints
7. Comprehensive unit and integration tests

Ensure all components follow Spring Boot best practices, project conventions, and include proper documentation.