spring-boot4-skill 1.0.0

package/skills/java-spring-framework/references/spring-framework-7.md

@@ -0,0 +1,314 @@
+# Spring Framework 7.0.x — Feature Reference
+
+**Version**: 7.0.5 (Stable) | **Java baseline**: 17 (25 recommended) | **Jakarta EE**: 11
+
+---
+
+## Table of Contents
+1. [API Versioning](#1-api-versioning)
+2. [Null Safety — JSpecify](#2-null-safety--jspecify)
+3. [Resilience Annotations](#3-resilience-annotations)
+4. [Programmatic Bean Registration](#4-programmatic-bean-registration)
+5. [RestClient (Synchronous)](#5-restclient-synchronous)
+6. [HTTP Service Proxy (Declarative)](#6-http-service-proxy-declarative)
+7. [JdbcClient](#7-jdbcclient)
+8. [JmsClient](#8-jmsclient)
+9. [Streaming Support](#9-streaming-support)
+10. [SpEL — Optional Support](#10-spel--optional-support)
+11. [Enhanced PathPattern](#11-enhanced-pathpattern)
+12. [RestTestClient (Testing)](#12-resttestclient-testing)
+13. [Removed APIs Migration](#13-removed-apis-migration)
+
+---
+
+## 1. API Versioning
+
+Spring 7 introduces **native HTTP API versioning** via `@RequestMapping(version = "...")`.
+Routing uses the `Version` HTTP request header by default.
+
+```java
+@RestController
+@RequestMapping("/api/products")
+public class ProductController {
+
+    @GetMapping(value = "/search", version = "1")
+    public List<ProductV1> searchV1(@RequestParam String query) { ... }
+
+    @GetMapping(value = "/search", version = "2")
+    public ProductPageV2 searchV2(@RequestParam String query,
+                                  @RequestParam(defaultValue = "10") int limit) { ... }
+}
+```
+
+**No library required** — built into Spring MVC and WebFlux.
+
+---
+
+## 2. Null Safety — JSpecify
+
+Spring 7 adopts **JSpecify** (`org.jspecify`) for null safety annotations.
+
+```java
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+import org.jspecify.annotations.NullMarked;
+
+@NullMarked          // entire package is non-null by default
+@Service
+public class UserService {
+
+    public @NonNull User findRequired(@NonNull String userId) { ... }
+
+    public @Nullable User findOptional(@Nullable String userId) { ... }
+}
+```
+
+**Gradle dependency**:
+```kotlin
+implementation("org.jspecify:jspecify:1.0.0")
+```
+
+---
+
+## 3. Resilience Annotations
+
+Spring 7 ships **built-in resilience** — no Resilience4j required for basic cases.
+
+```java
+@Service
+@EnableResilientMethods
+public class PaymentService {
+
+    @Retryable(maxAttempts = 3, delay = 500)
+    public Receipt processPayment(PaymentRequest req) { ... }
+
+    @ConcurrencyLimit(maxConcurrentCalls = 10)
+    public Balance fetchBalance(String accountId) { ... }
+
+    @CircuitBreaker(failureRateThreshold = 0.5)
+    public ExchangeRate getExchangeRate(String currency) { ... }
+}
+```
+
+---
+
+## 4. Programmatic Bean Registration
+
+Prefer `BeanRegistrar` over `@Bean`-heavy classes. Avoids proxy overhead and is GraalVM-friendly.
+
+```java
+@Configuration(proxyBeanMethods = false)
+public class InfrastructureConfig implements BeanRegistrar {
+
+    @Override
+    public void registerBeans(BeanRegistry registry) {
+        registry.registerBean("userRepository",
+            UserRepository.class,
+            spec -> spec.supplier(UserRepositoryImpl::new)
+                        .scope(BeanDefinition.SCOPE_SINGLETON));
+    }
+}
+```
+
+---
+
+## 5. RestClient (Synchronous)
+
+`RestClient` replaces `RestTemplate`. Fluent, immutable, interceptor-aware.
+
+```java
+@Configuration(proxyBeanMethods = false)
+public class HttpConfig {
+
+    @Bean
+    RestClient restClient(RestClient.Builder builder) {
+        return builder
+            .baseUrl("https://api.example.com")
+            .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
+            .build();
+    }
+}
+
+// Usage
+record Product(Long id, String name) {}
+
+List<Product> products = restClient.get()
+    .uri("/products")
+    .retrieve()
+    .body(new ParameterizedTypeReference<List<Product>>() {});
+```
+
+---
+
+## 6. HTTP Service Proxy (Declarative)
+
+Use `@HttpExchange` interfaces with `HttpServiceProxyFactory` for zero-boilerplate clients.
+
+```java
+// Declare the interface
+@HttpExchange("/products")
+public interface ProductClient {
+
+    @GetExchange("/{id}")
+    Product findById(@PathVariable Long id);
+
+    @PostExchange
+    Product create(@RequestBody Product product);
+}
+
+// Register as a bean
+@Configuration(proxyBeanMethods = false)
+@ImportHttpServices(group = "product", types = {ProductClient.class})
+public class ClientConfig {}
+```
+
+Auto-configuration wires the `RestClient` adapter. For custom setup:
+
+```java
+@Bean
+ProductClient productClient(RestClient restClient) {
+    return HttpServiceProxyFactory
+        .builderFor(RestClientAdapter.create(restClient))
+        .build()
+        .createClient(ProductClient.class);
+}
+```
+
+---
+
+## 7. JdbcClient
+
+Fluent JDBC wrapper — replaces direct `JdbcTemplate` usage.
+
+```java
+@Repository
+public class UserRepository {
+
+    private final JdbcClient jdbc;
+
+    public UserRepository(JdbcClient jdbc) {
+        this.jdbc = jdbc;
+    }
+
+    public List<User> findAll() {
+        return jdbc.sql("SELECT id, name, email FROM users")
+                   .query(User.class)       // uses RowMapper by convention
+                   .list();
+    }
+
+    public Optional<User> findById(Long id) {
+        return jdbc.sql("SELECT id, name, email FROM users WHERE id = :id")
+                   .param("id", id)
+                   .query(User.class)
+                   .optional();
+    }
+
+    public int save(User user) {
+        return jdbc.sql("INSERT INTO users (name, email) VALUES (:name, :email)")
+                   .param("name", user.name())
+                   .param("email", user.email())
+                   .update();
+    }
+}
+```
+
+---
+
+## 8. JmsClient
+
+Fluent JMS API replacing `JmsTemplate`.
+
+```java
+@Service
+public class OrderEventPublisher {
+
+    private final JmsClient jms;
+
+    public OrderEventPublisher(JmsClient jms) {
+        this.jms = jms;
+    }
+
+    public void publishOrder(OrderCreatedEvent event) {
+        jms.send("orders.created", event);
+    }
+
+    public OrderCreatedEvent consumeNext() {
+        return jms.receive("orders.created", OrderCreatedEvent.class);
+    }
+}
+```
+
+---
+
+## 9. Streaming Support
+
+Spring MVC now accepts `InputStream` directly in controller parameters for large uploads.
+
+```java
+@PostMapping("/upload")
+public ResponseEntity<Void> upload(InputStream body) throws IOException {
+    storageService.store(body);
+    return ResponseEntity.accepted().build();
+}
+```
+
+---
+
+## 10. SpEL — Optional Support
+
+Spring Expression Language now understands `Optional` chaining natively.
+
+```java
+@Value("#{userService.findUser(#userId)?.orElse('Guest')}")
+private String currentUser;
+```
+
+---
+
+## 11. Enhanced PathPattern
+
+Double-wildcard `**` now works in the middle of patterns (previously end-only).
+
+```java
+@GetMapping("/**/docs/{name}")
+public String getDoc(@PathVariable String name) { ... }
+```
+
+---
+
+## 12. RestTestClient (Testing)
+
+`RestTestClient` replaces `TestRestTemplate` and `WebTestClient` for servlet-layer tests.
+
+```java
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+class ProductControllerTest {
+
+    @Autowired
+    private RestTestClient client;
+
+    @Test
+    void shouldReturnProducts() {
+        client.get().uri("/api/products")
+              .exchange()
+              .expectStatus().isOk()
+              .expectBodyList(Product.class).hasSize(3);
+    }
+}
+```
+
+---
+
+## 13. Removed APIs Migration
+
+| Removed | Replacement |
+|---|---|
+| `RestTemplate` | `RestClient` |
+| `JdbcTemplate` (direct) | `JdbcClient` |
+| `javax.*` namespaces | `jakarta.*` |
+| `spring-jcl` | Apache Commons Logging |
+| JUnit 4 | JUnit 5 |
+| Jackson 2.x | Jackson 3.x |
+| XML Spring MVC config | `WebMvcConfigurer` (Java) |
+| `suffixPatternMatch` | Explicit media types |
+| `trailingSlashMatch` | Explicit URI templates |

package/skills/java-spring-framework/references/spring-modulith.md

@@ -0,0 +1,220 @@
+# Spring Modulith 2.0.x — Reference
+
+**Version**: 2.0.3 | **Spring Boot**: 4.0.x | **Purpose**: Domain-driven modular monolith
+
+---
+
+## Table of Contents
+1. [Module Package Structure](#1-module-package-structure)
+2. [Gradle Dependency](#2-gradle-dependency)
+3. [Module Verification Test](#3-module-verification-test)
+4. [@ApplicationModule Annotation](#4-applicationmodule-annotation)
+5. [Event-Driven Inter-Module Communication](#5-event-driven-inter-module-communication)
+6. [Transactional Event Listeners](#6-transactional-event-listeners)
+7. [Module Integration Testing](#7-module-integration-testing)
+8. [Generating Documentation](#8-generating-documentation)
+
+---
+
+## 1. Module Package Structure
+
+Each direct sub-package of the application's root package is a **module**.
+Internal types live in sub-packages; only the top-level package is public API.
+
+```
+com.example.shop/
+├── ShopApplication.java          ← root
+├── orders/                       ← "orders" module
+│   ├── OrderService.java         ← public API
+│   ├── OrderController.java      ← public API
+│   └── internal/
+│       ├── OrderRepository.java  ← internal
+│       └── OrderMapper.java      ← internal
+├── inventory/                    ← "inventory" module
+│   ├── InventoryService.java     ← public API
+│   └── internal/
+│       └── StockRepository.java  ← internal
+└── shared/                       ← shared utilities (no module boundary)
+    └── Money.java
+```
+
+Modules **cannot** directly import each other's `internal` sub-packages.
+Cross-module communication happens through **events** or **public service interfaces**.
+
+---
+
+## 2. Gradle Dependency
+
+```kotlin
+// build.gradle.kts
+dependencyManagement {
+    imports {
+        mavenBom("org.springframework.modulith:spring-modulith-bom:2.0.3")
+    }
+}
+
+dependencies {
+    implementation("org.springframework.modulith:spring-modulith-starter-core")
+    implementation("org.springframework.modulith:spring-modulith-starter-jpa")      // if using JPA
+    testImplementation("org.springframework.modulith:spring-modulith-starter-test")
+}
+```
+
+---
+
+## 3. Module Verification Test
+
+Run once per CI pipeline — validates that no module violates boundaries.
+
+```java
+@Test
+void applicationModulesShouldBeCompliant() {
+    ApplicationModules.of(ShopApplication.class).verify();
+}
+```
+
+`verify()` throws if:
+- A module imports another module's `internal` package.
+- Circular module dependencies exist.
+
+---
+
+## 4. @ApplicationModule Annotation
+
+Fine-tune module visibility and allowed dependencies:
+
+```java
+// orders/package-info.java
+@ApplicationModule(
+    displayName = "Orders",
+    allowedDependencies = {"inventory", "shared"}   // only these modules may be imported
+)
+package com.example.shop.orders;
+
+import org.springframework.modulith.ApplicationModule;
+```
+
+Named interfaces (explicit public API within a module):
+
+```java
+@NamedInterface("api")
+package com.example.shop.orders.api;
+```
+
+---
+
+## 5. Event-Driven Inter-Module Communication
+
+Modules communicate via Spring's `ApplicationEventPublisher`. No direct service calls between modules.
+
+**Publisher** (orders module):
+
+```java
+record OrderPlacedEvent(Long orderId, String productSku, int quantity) {}
+
+@Service
+public class OrderService {
+
+    private final ApplicationEventPublisher events;
+    private final JdbcClient jdbc;
+
+    public Order placeOrder(OrderRequest req) {
+        Order order = persistOrder(req);
+        events.publishEvent(new OrderPlacedEvent(order.id(), req.sku(), req.quantity()));
+        return order;
+    }
+}
+```
+
+**Listener** (inventory module):
+
+```java
+@Service
+public class InventoryService {
+
+    @ApplicationModuleListener   // replaces @EventListener for cross-module events
+    public void on(OrderPlacedEvent event) {
+        reserveStock(event.productSku(), event.quantity());
+    }
+}
+```
+
+`@ApplicationModuleListener` is async and transactional by default in Modulith.
+
+---
+
+## 6. Transactional Event Listeners
+
+For guaranteed "at-least-once" delivery with persistent event logs:
+
+```kotlin
+// build.gradle.kts
+implementation("org.springframework.modulith:spring-modulith-events-api")
+implementation("org.springframework.modulith:spring-modulith-events-jpa")  // or jdbc, mongodb
+```
+
+```java
+@Service
+public class OrderService {
+
+    @Transactional
+    public Order placeOrder(OrderRequest req) {
+        Order order = persistOrder(req);
+        // Event is stored in the event publication log within the same transaction.
+        // Published to listeners after commit — even survives a crash.
+        events.publishEvent(new OrderPlacedEvent(order.id(), req.sku(), req.quantity()));
+        return order;
+    }
+}
+```
+
+Incomplete publications are retried automatically on next application start.
+
+---
+
+## 7. Module Integration Testing
+
+Test a single module in isolation with only its direct dependencies.
+
+```java
+@ApplicationModuleTest          // boots only the "orders" module + stubs
+class OrderServiceTest {
+
+    @Autowired OrderService orderService;
+    @MockitoBean InventoryService inventoryService;  // stub cross-module dependency
+
+    @Test
+    void shouldPlaceOrderAndPublishEvent() {
+        var result = orderService.placeOrder(new OrderRequest("SKU-001", 2));
+        assertThat(result.id()).isNotNull();
+    }
+}
+```
+
+Bootstrap modes:
+- `STANDALONE` — only the annotated module (default)
+- `DIRECT_DEPENDENCIES` — module + direct dependencies
+- `ALL_DEPENDENCIES` — full transitive graph
+
+```java
+@ApplicationModuleTest(mode = BootstrapMode.DIRECT_DEPENDENCIES)
+class OrderServiceTest { ... }
+```
+
+---
+
+## 8. Generating Documentation
+
+Produces AsciiDoc / PlantUML diagrams of module dependencies:
+
+```java
+@Test
+void generateModuleDocumentation() throws Exception {
+    var modules = ApplicationModules.of(ShopApplication.class);
+    new Documenter(modules)
+        .writeDocumentation()
+        .writeIndividualModulesAsPlantUml();
+}
+```
+
+Output lands in `target/spring-modulith-docs/` (Maven) or `build/spring-modulith-docs/` (Gradle).

package/skills-lock.json

@@ -0,0 +1,20 @@
+{
+  "version": 1,
+  "skills": {
+    "agent-browser": {
+      "source": "vercel-labs/agent-browser",
+      "sourceType": "github",
+      "computedHash": "69e805b9bba58a76e3f9ac835d506a4f06f18a7867d2ba5e23e40638f6f351eb"
+    },
+    "find-skills": {
+      "source": "vercel-labs/skills",
+      "sourceType": "github",
+      "computedHash": "6412eb4eb3b91595ebab937f0c69501240e7ba761b3d82510b5cf506ec5c7adc"
+    },
+    "skill-creator": {
+      "source": "anthropics/skills",
+      "sourceType": "github",
+      "computedHash": "a096b9af85c9d954374ebe3f7a23b5b7737ed3f35fe2a8f5893742c4e00dba1c"
+    }
+  }
+}

package/templates/gradle-kotlin/build.gradle.kts.template

@@ -0,0 +1,113 @@
+import org.springframework.boot.gradle.tasks.bundling.BootJar
+
+plugins {
+    java
+    id("org.springframework.boot")          version "{{bootVersion}}"
+    id("io.spring.dependency-management")   version "1.1.7"
+{{#if hasNative}}    id("org.graalvm.buildtools.native")     version "0.10.4"
+{{/if}}}
+
+group   = "{{packageName}}"
+version = "0.0.1-SNAPSHOT"
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of({{javaVersion}})
+    }
+}
+
+{{#if enablePreview}}
+tasks.withType<JavaCompile> {
+    options.compilerArgs.addAll(listOf("--enable-preview"))
+}
+
+tasks.withType<Test> {
+    jvmArgs("--enable-preview")
+    useJUnitPlatform()
+}
+
+tasks.named<BootJar>("bootJar") {
+    jvmArguments.addAll(listOf("--enable-preview"))
+}
+{{/if}}
+{{#if !enablePreview}}
+tasks.withType<Test> {
+    useJUnitPlatform()
+}
+{{/if}}
+
+repositories {
+    mavenCentral()
+}
+
+{{#if hasModulith}}
+dependencyManagement {
+    imports {
+        mavenBom("org.springframework.modulith:spring-modulith-bom:2.0.3")
+    }
+}
+{{/if}}
+
+dependencies {
+    // --- Web ---
+{{#if hasWebFlux}}    implementation("org.springframework.boot:spring-boot-starter-webflux")
+{{/if}}
+{{#if !hasWebFlux}}    implementation("org.springframework.boot:spring-boot-starter-web")
+{{/if}}
+
+    // --- Data ---
+{{#if hasJpa}}    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    implementation("org.springframework.boot:spring-boot-starter-jdbc")
+{{/if}}
+{{#if hasMongo}}    implementation("org.springframework.boot:spring-boot-starter-data-mongodb")
+{{/if}}
+    {{dbDependency}}
+
+    // --- Validation ---
+{{#if hasValidation}}    implementation("org.springframework.boot:spring-boot-starter-validation")
+{{/if}}
+
+    // --- Security ---
+{{#if hasSecurity}}    implementation("org.springframework.boot:spring-boot-starter-security")
+    implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server")
+{{/if}}
+
+    // --- Observability ---
+{{#if hasActuator}}    implementation("org.springframework.boot:spring-boot-starter-actuator")
+    implementation("io.micrometer:micrometer-tracing-bridge-otel")
+    implementation("io.opentelemetry:opentelemetry-exporter-otlp")
+    runtimeOnly("io.micrometer:micrometer-registry-prometheus")
+{{/if}}
+
+    // --- Null Safety (JSpecify) ---
+    implementation("org.jspecify:jspecify:1.0.0")
+
+{{#if hasModulith}}    // --- Spring Modulith ---
+    implementation("org.springframework.modulith:spring-modulith-starter-core")
+    {{modulithDataDep}}
+{{/if}}
+
+    // --- Dev Tools ---
+    developmentOnly("org.springframework.boot:spring-boot-devtools")
+    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
+
+    // --- Testing ---
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
+{{#if hasSecurity}}    testImplementation("org.springframework.security:spring-security-test")
+{{/if}}
+{{#if hasModulith}}    testImplementation("org.springframework.modulith:spring-modulith-starter-test")
+{{/if}}
+{{#if hasJpa}}    testImplementation("org.testcontainers:postgresql")
+    testImplementation("org.testcontainers:junit-jupiter")
+{{/if}}
+}
+{{#if hasNative}}
+graalvmNative {
+    binaries {
+        named("main") {
+            imageName.set("{{projectName}}")
+            buildArgs.add("--enable-preview")
+        }
+    }
+}
+{{/if}}

package/templates/gradle-kotlin/compose.yaml.template

@@ -0,0 +1,40 @@
+services:
+{{#if hasJpa}}  postgres:
+    image: postgres:17
+    environment:
+      POSTGRES_DB: {{projectName}}
+      POSTGRES_USER: app
+      POSTGRES_PASSWORD: secret
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U app"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+{{/if}}
+
+{{#if hasMongo}}  mongodb:
+    image: mongo:7.0
+    ports:
+      - "27017:27017"
+    environment:
+      MONGO_INITDB_DATABASE: {{projectName}}
+    volumes:
+      - mongodata:/data/db
+{{/if}}
+
+{{#if hasActuator}}  otel-collector:
+    image: otel/opentelemetry-collector-contrib:latest
+    ports:
+      - "4317:4317"   # gRPC
+      - "4318:4318"   # HTTP
+{{/if}}
+
+volumes:
+{{#if hasJpa}}  pgdata:
+{{/if}}
+{{#if hasMongo}}  mongodata:
+{{/if}}

package/templates/gradle-kotlin/settings.gradle.kts.template

@@ -0,0 +1 @@
+rootProject.name = "{{projectName}}"