From 7ee62e5bf4a025ae0aa4aa57528d66e25a96124f Mon Sep 17 00:00:00 2001 From: Joseph Gonzales Date: Sun, 6 Jul 2025 11:49:53 +1200 Subject: [PATCH] java and kotlin prompts for springboot --- prompts/java-docs.prompt.md | 24 ++++++++++ prompts/java-junit.prompt.md | 64 ++++++++++++++++++++++++++ prompts/java-springboot.prompt.md | 66 +++++++++++++++++++++++++++ prompts/kotlin-springboot.prompt.md | 71 +++++++++++++++++++++++++++++ 4 files changed, 225 insertions(+) create mode 100644 prompts/java-docs.prompt.md create mode 100644 prompts/java-junit.prompt.md create mode 100644 prompts/java-springboot.prompt.md create mode 100644 prompts/kotlin-springboot.prompt.md diff --git a/prompts/java-docs.prompt.md b/prompts/java-docs.prompt.md new file mode 100644 index 0000000..eaca432 --- /dev/null +++ b/prompts/java-docs.prompt.md @@ -0,0 +1,24 @@ +--- +mode: 'agent' +tools: ['changes', 'codebase', 'editFiles', 'problems'] +description: 'Ensure that Java types are documented with Javadoc comments and follow best practices for documentation.' +--- + +# Java Documentation (Javadoc) Best Practices + +- Public and protected members should be documented with Javadoc comments. +- It is encouraged to document package-private and private members as well, especially if they are complex or not self-explanatory. +- The first sentence of the Javadoc comment is the summary description. It should be a concise overview of what the method does and end with a period. +- Use `@param` for method parameters. The description starts with a lowercase letter and does not end with a period. +- Use `@return` for method return values. +- Use `@throws` or `@exception` to document exceptions thrown by methods. +- Use `@see` for references to other types or members. +- Use `{@inheritDoc}` to inherit documentation from base classes or interfaces. + - Unless there is major behavior change, in which case you should document the differences. +- Use `@param ` for type parameters in generic types or methods. +- Use `{@code}` for inline code snippets. +- Use `
{@code ... }
` for code blocks. +- Use `@since` to indicate when the feature was introduced (e.g., version number). +- Use `@version` to specify the version of the member. +- Use `@author` to specify the author of the code. +- Use `@deprecated` to mark a member as deprecated and provide an alternative. diff --git a/prompts/java-junit.prompt.md b/prompts/java-junit.prompt.md new file mode 100644 index 0000000..5fd1a4b --- /dev/null +++ b/prompts/java-junit.prompt.md @@ -0,0 +1,64 @@ +--- +mode: 'agent' +tools: ['changes', 'codebase', 'editFiles', 'problems', 'search'] +description: 'Get best practices for JUnit 5 unit testing, including data-driven tests' +--- + +# JUnit 5+ Best Practices + +Your goal is to help me write effective unit tests with JUnit 5, covering both standard and data-driven testing approaches. + +## Project Setup + +- Use a standard Maven or Gradle project structure. +- Place test source code in `src/test/java`. +- Include dependencies for `junit-jupiter-api`, `junit-jupiter-engine`, and `junit-jupiter-params` for parameterized tests. +- Use build tool commands to run tests: `mvn test` or `gradle test`. + +## Test Structure + +- Test classes should have a `Test` suffix, e.g., `CalculatorTests` for a `Calculator` class. +- Use `@Test` for test methods. +- Follow the Arrange-Act-Assert (AAA) pattern. +- Name tests using a descriptive convention, like `methodName_should_expectedBehavior_when_scenario`. +- Use `@BeforeEach` and `@AfterEach` for per-test setup and teardown. +- Use `@BeforeAll` and `@AfterAll` for per-class setup and teardown (must be static methods). +- Use `@DisplayName` to provide a human-readable name for test classes and methods. + +## Standard Tests + +- Keep tests focused on a single behavior. +- Avoid testing multiple conditions in one test method. +- Make tests independent and idempotent (can run in any order). +- Avoid test interdependencies. + +## Data-Driven (Parameterized) Tests + +- Use `@ParameterizedTest` to mark a method as a parameterized test. +- Use `@ValueSource` for simple literal values (strings, ints, etc.). +- Use `@MethodSource` to refer to a factory method that provides test arguments as a `Stream`, `Collection`, etc. +- Use `@CsvSource` for inline comma-separated values. +- Use `@CsvFileSource` to use a CSV file from the classpath. +- Use `@EnumSource` to use enum constants. + +## Assertions + +- Use the static methods from `org.junit.jupiter.api.Assertions` (e.g., `assertEquals`, `assertTrue`, `assertNotNull`). +- For more fluent and readable assertions, consider using a library like AssertJ (`assertThat(...).is...`). +- Use `assertThrows` or `assertDoesNotThrow` to test for exceptions. +- Group related assertions with `assertAll` to ensure all assertions are checked before the test fails. +- Use descriptive messages in assertions to provide clarity on failure. + +## Mocking and Isolation + +- Use a mocking framework like Mockito to create mock objects for dependencies. +- Use `@Mock` and `@InjectMocks` annotations from Mockito to simplify mock creation and injection. +- Use interfaces to facilitate mocking. + +## Test Organization + +- Group tests by feature or component using packages. +- Use `@Tag` to categorize tests (e.g., `@Tag("fast")`, `@Tag("integration")`). +- Use `@TestMethodOrder(MethodOrderer.OrderAnnotation.class)` and `@Order` to control test execution order when strictly necessary. +- Use `@Disabled` to temporarily skip a test method or class, providing a reason. +- Use `@Nested` to group tests in a nested inner class for better organization and structure. diff --git a/prompts/java-springboot.prompt.md b/prompts/java-springboot.prompt.md new file mode 100644 index 0000000..ff48899 --- /dev/null +++ b/prompts/java-springboot.prompt.md @@ -0,0 +1,66 @@ +--- +mode: 'agent' +tools: ['changes', 'codebase', 'editFiles', 'problems', 'search'] +description: 'Get best practices for developing applications with Spring Boot.' +--- + +# Spring Boot Best Practices + +Your goal is to help me write high-quality Spring Boot applications by following established best practices. + +## Project Setup & Structure + +- **Build Tool:** Use Maven (`pom.xml`) or Gradle (`build.gradle`) for dependency management. +- **Starters:** Use Spring Boot starters (e.g., `spring-boot-starter-web`, `spring-boot-starter-data-jpa`) to simplify dependency management. +- **Package Structure:** Organize code by feature/domain (e.g., `com.example.app.order`, `com.example.app.user`) rather than by layer (e.g., `com.example.app.controller`, `com.example.app.service`). + +## Dependency Injection & Components + +- **Constructor Injection:** Always use constructor-based injection for required dependencies. This makes components easier to test and dependencies explicit. +- **Immutability:** Declare dependency fields as `private final`. +- **Component Stereotypes:** Use `@Component`, `@Service`, `@Repository`, and `@Controller`/`@RestController` annotations appropriately to define beans. + +## Configuration + +- **Externalized Configuration:** Use `application.yml` (or `application.properties`) for configuration. YAML is often preferred for its readability and hierarchical structure. +- **Type-Safe Properties:** Use `@ConfigurationProperties` to bind configuration to strongly-typed Java objects. +- **Profiles:** Use Spring Profiles (`application-dev.yml`, `application-prod.yml`) to manage environment-specific configurations. +- **Secrets Management:** Do not hardcode secrets. Use environment variables, or a dedicated secret management tool like HashiCorp Vault or AWS Secrets Manager. + +## Web Layer (Controllers) + +- **RESTful APIs:** Design clear and consistent RESTful endpoints. +- **DTOs (Data Transfer Objects):** Use DTOs to expose and consume data in the API layer. Do not expose JPA entities directly to the client. +- **Validation:** Use Java Bean Validation (JSR 380) with annotations (`@Valid`, `@NotNull`, `@Size`) on DTOs to validate request payloads. +- **Error Handling:** Implement a global exception handler using `@ControllerAdvice` and `@ExceptionHandler` to provide consistent error responses. + +## Service Layer + +- **Business Logic:** Encapsulate all business logic within `@Service` classes. +- **Statelessness:** Services should be stateless. +- **Transaction Management:** Use `@Transactional` on service methods to manage database transactions declaratively. Apply it at the most granular level necessary. + +## Data Layer (Repositories) + +- **Spring Data JPA:** Use Spring Data JPA repositories by extending `JpaRepository` or `CrudRepository` for standard database operations. +- **Custom Queries:** For complex queries, use `@Query` or the JPA Criteria API. +- **Projections:** Use DTO projections to fetch only the necessary data from the database. + +## Logging + +- **SLF4J:** Use the SLF4J API for logging. +- **Logger Declaration:** `private static final Logger logger = LoggerFactory.getLogger(MyClass.class);` +- **Parameterized Logging:** Use parameterized messages (`logger.info("Processing user {}...", userId);`) instead of string concatenation to improve performance. + +## Testing + +- **Unit Tests:** Write unit tests for services and components using JUnit 5 and a mocking framework like Mockito. +- **Integration Tests:** Use `@SpringBootTest` for integration tests that load the Spring application context. +- **Test Slices:** Use test slice annotations like `@WebMvcTest` (for controllers) or `@DataJpaTest` (for repositories) to test specific parts of the application in isolation. +- **Testcontainers:** Consider using Testcontainers for reliable integration tests with real databases, message brokers, etc. + +## Security + +- **Spring Security:** Use Spring Security for authentication and authorization. +- **Password Encoding:** Always encode passwords using a strong hashing algorithm like BCrypt. +- **Input Sanitization:** Prevent SQL injection by using Spring Data JPA or parameterized queries. Prevent Cross-Site Scripting (XSS) by properly encoding output. diff --git a/prompts/kotlin-springboot.prompt.md b/prompts/kotlin-springboot.prompt.md new file mode 100644 index 0000000..e489e78 --- /dev/null +++ b/prompts/kotlin-springboot.prompt.md @@ -0,0 +1,71 @@ +--- +mode: 'agent' +tools: ['changes', 'codebase', 'editFiles', 'problems', 'search'] +description: 'Get best practices for developing applications with Spring Boot and Kotlin.' +--- + +# Spring Boot with Kotlin Best Practices + +Your goal is to help me write high-quality, idiomatic Spring Boot applications using Kotlin. + +## Project Setup & Structure + +- **Build Tool:** Use Maven (`pom.xml`) or Gradle (`build.gradle`) with the Kotlin plugins (`kotlin-maven-plugin` or `org.jetbrains.kotlin.jvm`). +- **Kotlin Plugins:** For JPA, enable the `kotlin-jpa` plugin to automatically make entity classes `open` without boilerplate. +- **Starters:** Use Spring Boot starters (e.g., `spring-boot-starter-web`, `spring-boot-starter-data-jpa`) as usual. +- **Package Structure:** Organize code by feature/domain (e.g., `com.example.app.order`, `com.example.app.user`) rather than by layer. + +## Dependency Injection & Components + +- **Primary Constructors:** Always use the primary constructor for required dependency injection. It's the most idiomatic and concise approach in Kotlin. +- **Immutability:** Declare dependencies as `private val` in the primary constructor. Prefer `val` over `var` everywhere to promote immutability. +- **Component Stereotypes:** Use `@Service`, `@Repository`, and `@RestController` annotations just as you would in Java. + +## Configuration + +- **Externalized Configuration:** Use `application.yml` for its readability and hierarchical structure. +- **Type-Safe Properties:** Use `@ConfigurationProperties` with `data class` to create immutable, type-safe configuration objects. +- **Profiles:** Use Spring Profiles (`application-dev.yml`, `application-prod.yml`) to manage environment-specific configurations. +- **Secrets Management:** Never hardcode secrets. Use environment variables or a dedicated secret management tool like HashiCorp Vault or AWS Secrets Manager. + +## Web Layer (Controllers) + +- **RESTful APIs:** Design clear and consistent RESTful endpoints. +- **Data Classes for DTOs:** Use Kotlin `data class` for all DTOs. This provides `equals()`, `hashCode()`, `toString()`, and `copy()` for free and promotes immutability. +- **Validation:** Use Java Bean Validation (JSR 380) with annotations (`@Valid`, `@NotNull`, `@Size`) on your DTO data classes. +- **Error Handling:** Implement a global exception handler using `@ControllerAdvice` and `@ExceptionHandler` for consistent error responses. + +## Service Layer + +- **Business Logic:** Encapsulate business logic within `@Service` classes. +- **Statelessness:** Services should be stateless. +- **Transaction Management:** Use `@Transactional` on service methods. In Kotlin, this can be applied to class or function level. + +## Data Layer (Repositories) + +- **JPA Entities:** Define entities as classes. Remember they must be `open`. It's highly recommended to use the `kotlin-jpa` compiler plugin to handle this automatically. +- **Null Safety:** Leverage Kotlin's null-safety (`?`) to clearly define which entity fields are optional or required at the type level. +- **Spring Data JPA:** Use Spring Data JPA repositories by extending `JpaRepository` or `CrudRepository`. +- **Coroutines:** For reactive applications, leverage Spring Boot's support for Kotlin Coroutines in the data layer. + +## Logging + +- **Companion Object Logger:** The idiomatic way to declare a logger is in a companion object. + ```kotlin + companion object { + private val logger = LoggerFactory.getLogger(MyClass::class.java) + } + ``` +- **Parameterized Logging:** Use parameterized messages (`logger.info("Processing user {}...", userId)`) for performance and clarity. + +## Testing + +- **JUnit 5:** JUnit 5 is the default and works seamlessly with Kotlin. +- **Idiomatic Testing Libraries:** For more fluent and idiomatic tests, consider using **Kotest** for assertions and **MockK** for mocking. They are designed for Kotlin and offer a more expressive syntax. +- **Test Slices:** Use test slice annotations like `@WebMvcTest` or `@DataJpaTest` to test specific parts of the application. +- **Testcontainers:** Use Testcontainers for reliable integration tests with real databases, message brokers, etc. + +## Coroutines & Asynchronous Programming + +- **`suspend` functions:** For non-blocking asynchronous code, use `suspend` functions in your controllers and services. Spring Boot has excellent support for coroutines. +- **Structured Concurrency:** Use `coroutineScope` or `supervisorScope` to manage the lifecycle of coroutines.