quarkus-patterns

What it does

Implements Quarkus 3.x architecture patterns for cloud-native, event-driven services. It covers REST APIs, service and repository layering, event-driven Camel patterns, Panache data access, and async processing. It includes logging, event tracking, Camel publishing, file processing, REST resources, Panache repository usage, DTOs/validation, exception mapping, CompletableFuture async operations, caching, and YAML configuration. The skill provides concrete code examples for common patterns like service layer with multiple dependencies, custom logging context, event service, Camel routes, file processing, REST endpoints, repositories, transactional service methods, DTO validation, and async storage operations.

Key concrete actions include:

• Use of Lombok @RequiredArgsConstructor and @Slf4j; @Transactional on write operations.
• EventService methods to create SUCCESS and ERROR events with payload serialization.
• Camel publishers and routes to send messages to RabbitMQ and route in-memory Direct routes with error handling.
• REST API structure with JAX-RS annotations for listing, creating, and fetching documents.
• Panache repository methods for paging, finding by reference, and counting by status/date.
• DTOs for CreateDocumentRequest and DocumentResponse with from() mapping.
• Exception mappers for validation and generic errors.
• CompletableFuture-based async method in FileStorageService for S3 uploads with logging scope.
• Caching via @CacheResult and cache invalidation.
• Configuration examples in YAML for dev/test environments.

The skill is designed to be used by Java Quarkus backends in event-driven architectures and demonstrates a wide range of patterns and integration points.

How it works

• Activates for REST API development, layered architecture, event-driven patterns with Camel and RabbitMQ, and async processing.
• Defines a service layer (OrderProcessingService, DocumentService) with injected dependencies and transactional boundaries.
• Provides an EventService to persist success/error events with timestamps and serialized payloads.
• Uses Camel components: BusinessRulesPublisher to publish messages, and Route classes to configure in-memory direct routes and RabbitMQ publishing.
• Demonstrates REST endpoints in DocumentResource with list, create, and getById operations using a DocumentService.
• Shows a Panache-based repository (DocumentRepository) with paging, reference lookup, and date-based counts.
• Includes DTOs/validation for CreateDocumentRequest and DocumentResponse, ensuring input constraints and proper response shaping.
• Implements exception mappers to translate validation and unexpected errors into HTTP responses.
• Provides a CompletableFuture-based file upload flow in FileStorageService with scoped logging context.
• Adds a caching service for document retrieval to improve read performance.
• Contains YAML-based configuration blocks for dev/test deployments (datasource, Hibernate, RabbitMQ).

When to use it

• When you need a structured Quarkus 3.x pattern set for REST APIs, event-driven messaging, and data access via Panache.
• When building services with asynchronous processing, transactional service methods, and robust error/event handling.
• When you want documented examples of Camel integration with RabbitMQ and in-memory routes, plus logging context patterns.

What it can touch

• Java codebase with Quarkus, Lombok, Jackson, and Logback/Logstash encoder.
• Camel components (ProducerTemplate, RouteBuilder, direct routes) and RabbitMQ integration.
• Panache repositories, JAX-RS resources, DTOs, and validation annotations.
• S3 storage via S3Client, an ExecutorService, and CompletableFuture for async operations.
• Caching via CacheResult, CacheInvalidate, and CacheInvalidateAll annotations.
• YAML configuration files for application settings.

Caveats

• License: MIT.
• The skill provides example patterns and code; actual integration and behavior depend on project setup and environment.
• Some sections require further project wiring (e.g., actual dependencies, route wiring, and runtime configuration) beyond the snippets.