Prompt Recipes
Copy-paste prompts that build production-ready microservices. No IDE required.

I need to transform this generated microservice into a Product Catalog
MCP server with audit logging. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with Product catalog domain
- Product has: id, name, description, category, price, currency,
  inStock (boolean), imageUrl
- Products API supports pagination: page, pageSize, totalPages,
  totalItems
- Add a ProductSearchCriteria: query (text search), category filter,
  minPrice, maxPrice, inStock filter

AUDIT LOGGING:
- Create an AuditLog entity for JPA: id (auto-generated),
  userId (string), toolName (string), parameters (JSON string),
  timestamp (Instant), responseStatus (SUCCESS/FAILURE)
- Every MCP tool call should be audit-logged to PostgreSQL
  before returning the response
- The userId comes from the MCP call metadata

MCP TOOLS TO EXPOSE:
- listProducts: paginated product listing (page, pageSize params)
- searchProducts: filtered search (query, category, minPrice,
  maxPrice, inStock, page, pageSize)
- getProduct: single product by ID

REST BACKEND:
- GET /products?page={page}&pageSize={pageSize}
- GET /products/search?query={q}&category={cat}&minPrice={min}&maxPrice={max}&inStock={bool}&page={page}&pageSize={pageSize}
- GET /products/{id}

FLOW FOR EACH OPERATION:
1. MCP consumer receives tool call
2. Central route orchestrates:
   a. Call REST backend to get product data
   b. Call JPA backend to write audit log
3. Return product data to the AI agent

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Update the OpenAPI spec if needed
- Add new model classes to ReflectionConfig.java for native build
- Update application.yml with any new configuration
- Update Docker Compose files if needed

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a Currency
Exchange Rate service. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with Exchange Rate domain
- ExchangeRate has: from (String, ISO 4217), to (String, ISO 4217),
  rate (BigDecimal, 6 decimal places), provider (String),
  fetchedAt (Instant), cachedUntil (Instant, fetchedAt + 60s),
  source (RateSource enum: CACHE, PROVIDER)
- ExchangeRateRequest (REST backend query params): from, to
- ExchangeRateResponse (REST backend response body):
  from, to, rate, provider, timestamp (Instant)

REST INTERFACE (replace order-api.yaml):
- GET /exchange-rates?from=USD&to=EUR
- 200: ExchangeRate (full model including source field)
- 400: { error: "Invalid or missing currency code" }
        (when from or to is blank / not 3 uppercase letters)
- 502: { error: "Exchange rate provider unavailable" }
        (when REST backend returns non-200)

POSTGRESQL / JPA PERSISTENCE BACKEND:
- Entity: RateRecord — id (Long, auto), fromCurrency, toCurrency,
  rate (BigDecimal), provider (String), fetchedAt (Instant)
- Flyway migration V1__Create_rate_records.sql
- Write on every PROVIDER call (cache miss): persist the freshly fetched rate
- Read via separate ListOrders route: GET /exchange-rates/history?from=USD&to=EUR&page=0&size=20
  returns List newest first, paginated
- Response headers: X-Total-Count, X-Page, X-Page-Size

REST BACKEND — Exchange Rate Provider API (WireMock):
- GET http://exchange-rate-provider/rates?from={from}&to={to}
- WireMock stubs:
  1. USD to EUR: { rate: 0.921450, provider: "open-exchange-rates" }
  2. USD to GBP: { rate: 0.788320, provider: "open-exchange-rates" }
  3. EUR to GBP: { rate: 0.855700, provider: "open-exchange-rates" }
  4. Error scenario: HTTP 503

REDIS CACHE BACKEND:
- Cache key: {from}:{to} (e.g. "USD:EUR")
- Cache value: full ExchangeRate JSON, TTL: 60 seconds

FLOW FOR GET-RATE OPERATION:
1. REST consumer receives GET /exchange-rates?from=USD&to=EUR
2. Central route checks Redis for key {from}:{to}:
   a. CACHE HIT:  set source = CACHE, return cached ExchangeRate
      (skip REST backend call entirely)
   b. CACHE MISS: call REST backend GET /rates?from={from}&to={to},
      map response, set source = PROVIDER,
      fetchedAt = now(), cachedUntil = now() + 60s,
      write to Redis with TTL 60s,
      persist RateRecord to PostgreSQL via JPA producer route,
      return ExchangeRate
3. Both branches must be distinct Camel choice/when paths so they
   are visible as separate routes in the CamelBee route topology

FLOW FOR HISTORY OPERATION:
1. REST consumer receives GET /exchange-rates/history?from=USD&to=EUR
2. Central route calls JPA producer — query RateRecord by
   fromCurrency + toCurrency ORDER BY fetchedAt DESC, paginated
3. Return JSON array with X-Total-Count, X-Page, X-Page-Size headers

After making all changes:
- Replace the entire Order/Purchase domain — models, mappers,
  routes, tests, OpenAPI spec, WireMock stubs
- Implement cache-aside using Camel choice/when with two distinct
  visible branches (CACHE path and PROVIDER path)
- Add Flyway migration V1__Create_rate_records.sql
- Input validation: reject from/to that is not exactly 3 uppercase
  letters with HTTP 400
- Update application.yml with Redis config, JPA/datasource config,
  and provider base URL pointing to WireMock
- Make sure all unit tests, integration and black-box tests pass
- Update Docker Compose if needed (PostgreSQL + Redis services)

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a Loan Application
Processing Service. Replace the entire Order/Purchase domain with the
Loan Application domain below. Do not deviate from field names, topic
names, endpoint paths, table names, or routing logic specified here.

DOMAIN MODELS

LoanApplication  (API + domain model)
  applicationId       String           UUID, generated on submit
  applicantId         String           provided by caller
  applicantName       String
  applicantEmail      String
  requestedAmount     BigDecimal
  purpose             LoanPurpose      enum: HOME_PURCHASE, CAR_LOAN,
                                             PERSONAL, BUSINESS,
                                             EDUCATION, DEBT_CONSOLIDATION
  termMonths          Integer          one of: 12, 24, 36, 48, 60
  monthlyIncome       BigDecimal
  creditScore         Integer          range 300-850
  employmentStatus    EmploymentStatus enum: EMPLOYED, SELF_EMPLOYED,
                                             UNEMPLOYED, RETIRED
  status              ApplicationStatus enum: RECEIVED, APPROVED,
                                              REJECTED, PENDING_REVIEW
  riskScore           Integer          nullable, set after processing
  decisionReason      String           nullable, set after processing
  submittedAt         Instant          set on submit
  processedAt         Instant          nullable, set on processing

LoanApplicationSubmittedEvent  (Kafka AVRO — loan-applications.submitted)
  applicationId, applicantId, applicantName, applicantEmail,
  requestedAmount, purpose, termMonths, monthlyIncome,
  creditScore, employmentStatus, submittedAt

LoanApplicationProcessedEvent  (Kafka AVRO — loan-applications.processed)
  applicationId, applicantId, decision (ApplicationStatus),
  riskScore, reason, processedAt

CreditAssessmentRequest  (REST backend request body)
  applicantId, requestedAmount, creditScore,
  monthlyIncome, employmentStatus

CreditAssessmentResult  (REST backend response body)
  assessmentId            String
  approved                boolean
  riskScore               Integer    0-100, lower = lower risk
  reason                  String
  recommendedMaxAmount    BigDecimal

REST INTERFACE  (replace order-api.yaml entirely)

POST   /loan-applications
  Body:     LoanApplication (exclude: applicationId, status, riskScore,
                             decisionReason, submittedAt, processedAt)
  Response 202: { applicationId, status: "RECEIVED", submittedAt }

GET    /loan-applications/{applicationId}
  Response 200: full LoanApplication

GET    /loan-applications?status=PENDING_REVIEW&page=0&pageSize=10
  Response 200: { applications: LoanApplication[], totalItems, page, pageSize }

MCP TOOLS  (replace all generated Order MCP tools)

submitLoanApplication
  Description: "Submit a new loan application for async processing.
                Returns immediately with RECEIVED status."
  Params:  applicantId, applicantName, applicantEmail,
           requestedAmount, purpose, termMonths,
           monthlyIncome, creditScore, employmentStatus
  Returns: { applicationId, status, submittedAt }

getLoanApplicationStatus
  Description: "Get the current status and decision of a loan application.
                Served from cache when available."
  Params:  applicationId
  Returns: full LoanApplication including riskScore and decisionReason

listPendingApplications
  Description: "List applications requiring manual review
                (status = PENDING_REVIEW), paginated."
  Params:  page (default 0), pageSize (default 10)
  Returns: { applications: LoanApplication[], totalItems, page, pageSize }

KAFKA TOPICS  (AVRO format — Apicurio Schema Registry)

loan-applications.submitted   Kafka producer publishes LoanApplicationSubmittedEvent (AVRO) — CreateOrder
loan-applications.processed   Kafka producer publishes LoanApplicationProcessedEvent (AVRO) — UpdateOrder
Kafka consumer listens on loan-applications.submitted (AVRO) and triggers UpdateOrder
Schema Registry URL: http://schema-registry:8081 (configure in application.yml)

REST BACKEND — Credit Bureau API  (WireMock)

POST  http://credit-bureau-api/credit-assessments
  Request:  CreditAssessmentRequest
  Response: CreditAssessmentResult

WireMock stubs:
  1. Standard approval (creditScore >= 650, amount <= 50000)
       approved: true, riskScore: 25, reason: "Credit profile acceptable"
  2. High-risk (creditScore 500-649)
       approved: false, riskScore: 72,
       reason: "Credit score below threshold — manual review required"
  3. Error scenario: HTTP 503

REDIS CACHE BACKEND

Cache key:   applicationId
Cache value: full LoanApplication JSON

Write — CreateOrder: after JPA saves RECEIVED, write to Redis with TTL 1 hour
Write — UpdateOrder: after JPA updates final status, overwrite Redis entry
Read  — GetOrder (cache-aside): check Redis first; on miss call JPA then write Redis
These must be visible as distinct route paths in the CamelBee topology.

DATABASE  (table: LOAN_APPLICATIONS)

  id                BIGINT        PK, auto-generated
  application_id    VARCHAR(36)   unique, UUID
  applicant_id      VARCHAR(100)
  applicant_name    VARCHAR(200)
  applicant_email   VARCHAR(200)
  requested_amount  DECIMAL(15,2)
  purpose           VARCHAR(50)
  term_months       INT
  monthly_income    DECIMAL(15,2)
  credit_score      INT
  employment_status VARCHAR(50)
  status            VARCHAR(20)
  risk_score        INT           nullable
  decision_reason   VARCHAR(500)  nullable
  submitted_at      TIMESTAMP
  processed_at      TIMESTAMP     nullable

Flyway migration: V1__create_loan_applications.sql

PROCESSING LOGIC  (central UpdateOrder route — three paths via Camel choice/when)

PATH 1 — AUTO-APPROVE  (no REST call needed)
  Condition: requestedAmount <= 5000 AND creditScore >= 700
  status = APPROVED, riskScore = 10
  decisionReason = "Auto-approved: low-risk application"
  → JPA: save APPROVED
  → Redis: overwrite cache entry
  → Kafka: publish LoanApplicationProcessedEvent to loan-applications.processed

PATH 2 — AUTO-REJECT  (no REST call needed)
  Condition: creditScore < 500
  status = REJECTED, riskScore = 95
  decisionReason = "Auto-rejected: credit score below minimum threshold"
  → JPA: save REJECTED
  → Redis: overwrite cache entry
  → Kafka: publish LoanApplicationProcessedEvent

PATH 3 — CREDIT BUREAU ASSESSMENT  (all other cases)
  → call REST backend POST /credit-assessments
  → if approved == true:
       status = APPROVED, riskScore from response, decisionReason from response
  → if approved == false:
       status = PENDING_REVIEW, riskScore from response,
       decisionReason = response.reason + " — queued for manual review"
  → JPA: save resolved status
  → Redis: overwrite cache entry
  → Kafka: publish LoanApplicationProcessedEvent

SUBMIT FLOW  (central CreateOrder route — triggered by REST POST and MCP submit)
  → generate applicationId (UUID)
  → set status = RECEIVED, submittedAt = now()
  → JPA: save with status RECEIVED
  → Redis: write LoanApplication (RECEIVED) with TTL 1 hour
  → Kafka: publish LoanApplicationSubmittedEvent to loan-applications.submitted
  → return { applicationId, status: RECEIVED, submittedAt }

INSTRUCTIONS

1. Replace the entire Order/Purchase domain — models, mappers, routes,
   tests, OpenAPI spec, Kafka topic names, WireMock stubs,
   test data files, Flyway migration.

2. Implement three-path content-based routing in central UpdateOrder
   exactly as specified using Camel choice/when/otherwise.

3. Implement cache-aside in central GetOrder: Redis check first,
   JPA fallback on miss, Redis write after JPA hit.
   These must be distinct visible paths in the route topology.

4. Update application.yml with Kafka topic names, AVRO Schema Registry URL
   (http://schema-registry:8081), and Redis config.

5. Add Apicurio Schema Registry service to Docker Compose and TestContainers setup.

6. Update WireMock stubs for the Credit Bureau API contract.

7. After all changes run unit tests, integration tests, and
   black-box tests. All must pass.

Follow all patterns in CLAUDE.md and .claude/ exactly.

I need to transform this generated microservice into a full Order
Management API. Here's what I need:

DOMAIN:
- Keep the Order/Purchase domain but flesh it out properly
- Order has: orderId (UUID), customerId, customerEmail,
  status (OrderStatus enum: PENDING, CONFIRMED, SHIPPED, DELIVERED,
  CANCELLED), items (List<OrderItem>), subtotal (BigDecimal),
  tax (BigDecimal), total (BigDecimal), shippingAddress (Address),
  createdAt (Instant), updatedAt (Instant), version (Long)
- OrderItem has: productId, productName, quantity (int),
  unitPrice (BigDecimal), lineTotal (BigDecimal)
- Address has: street, city, state, postalCode, country
- OrderEvent (Kafka): orderId, customerId, status, total,
  eventType (CREATED, UPDATED, DELETED), occurredAt (Instant)
- OrderPage: orders (List<Order>), totalItems, page, pageSize

REST INTERFACE (replace order-api.yaml):
- POST   /orders              — create single order (201 + orderId)
- POST   /orders/batch        — batch create (201 + list of orderIds)
- GET    /orders?page=0&pageSize=20&status=PENDING
- GET    /orders/{orderId}
- PUT    /orders/{orderId}    — replace entire order
- PATCH  /orders/{orderId}    — partial update (status, shippingAddress)
- DELETE /orders/{orderId}    — 204

JPA BACKEND (tables: ORDERS + ORDER_ITEMS):
- orders: order_id VARCHAR(36) PK, customer_id, customer_email,
  status, subtotal, tax, total, shipping_street, shipping_city,
  shipping_state, shipping_postal, shipping_country,
  created_at TIMESTAMP, updated_at TIMESTAMP, version BIGINT
- order_items: id BIGINT PK auto, order_id FK, product_id,
  product_name, quantity INT, unit_price, line_total DECIMAL(12,2)
- Flyway migration: V1__create_orders.sql
- All 7 operations; on update use version column for optimistic locking

KAFKA BACKEND (topic: order-events):
- Key: orderId
- Publish OrderEvent on CreateOrder (CREATED), ReplaceOrder/UpdateOrder (UPDATED), DeleteOrder (DELETED)

CAFFEINE CACHE BACKEND:
- Key: orderId, TTL: 10 minutes
- GetOrder (cache-aside, two distinct Camel choice/when paths):
    CACHE HIT:  return from Caffeine (skip JPA)
    CACHE MISS: JPA fetch → write Caffeine → return
- Invalidate (evict) on ReplaceOrder, UpdateOrder, DeleteOrder

FLOW:
- CreateOrder:       validate → JPA save → Kafka CREATED → return 201
- BatchCreateOrders: validate each → JPA batch save → Kafka CREATED per order
- GetOrder:          Caffeine choice/when → hit: cached / miss: JPA + cache write
- ReplaceOrder/UpdateOrder: JPA update → Caffeine evict → Kafka UPDATED → return 200
- DeleteOrder:       JPA delete → Caffeine evict → Kafka DELETED → return 204
- ListOrders:        JPA paginated query with optional status filter

After making all changes:
- Implement Caffeine cache-aside for GetOrder as two distinct choice/when paths
- Add Flyway migrations for both tables
- Update application.yml with Kafka topic and datasource config
- Update Docker Compose (PostgreSQL + Kafka)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into an IoT Sensor
Data Ingestion service. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with SensorReading domain
- SensorReading has: readingId (UUID, generated on ingestion),
  deviceId (String), sensorType (SensorType enum: TEMPERATURE,
  HUMIDITY, PRESSURE, CO2, MOTION, VIBRATION), value (Double),
  unit (String), quality (ReadingQuality enum: GOOD, UNCERTAIN, BAD),
  location (String, nullable), recordedAt (Instant — from device),
  receivedAt (Instant — set by this service on ingestion)
- SensorReadingPage (REST list response): readings (List<SensorReading>),
  totalItems, page, pageSize, deviceId, from, to

MQTT INTERFACE (topic: sensors/+/readings — wildcard):
- Payload: JSON SensorReading (without readingId, receivedAt)
- On receive: generate readingId (UUID), set receivedAt = now()
- Single CreateOrder operation: ingest reading

REST INTERFACE (replace order-api.yaml):
- GET /sensor-readings?deviceId=device-001
      &from=2025-01-01T00:00:00Z&to=2025-01-02T00:00:00Z
      &page=0&pageSize=50
  Response: SensorReadingPage
- GET /sensor-readings/{readingId}
  Response: SensorReading

KAFKA BACKEND (topic: sensor-readings):
- Key: deviceId
- Publish full SensorReading JSON after every MQTT ingestion

MONGODB BACKEND (collection: sensorReadings):
- Index: { deviceId: 1, recordedAt: -1 }
- TTL index: recordedAt expires after 30 days
- CreateOrder: insert document
- ListOrders: query by deviceId + optional time range (from/to), paginated
- GetOrder: find by readingId

MQTT INGEST FLOW (central CreateOrder route):
1. MQTT consumer receives on sensors/{deviceId}/readings
2. Parse JSON, generate readingId, set receivedAt = now()
3. Call MongoDB CreateOrder backend → insert SensorReading
4. Call Kafka CreateOrder backend → publish to sensor-readings topic
5. Fire-and-forget — no HTTP response

REST QUERY FLOW:
- ListOrders: central → MongoDB ListOrders (paginated, deviceId + time range filter)
- GetOrder: central → MongoDB GetOrder (by readingId)

After making all changes:
- Replace Order/Purchase domain with SensorReading domain
- Configure MQTT consumer to subscribe to sensors/+/readings wildcard
- Add MongoDB TTL index setup on startup
- Update application.yml with MQTT broker URL, Kafka topic, MongoDB config
- Update Docker Compose (Mosquitto MQTT broker, Kafka, MongoDB)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a File-to-Database
ETL Pipeline for employee records. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with Employee domain
- Employee has: employeeId (String — from CSV), firstName, lastName,
  email, department, jobTitle, salary (BigDecimal), hireDate (LocalDate),
  status (EmployeeStatus enum: ACTIVE, INACTIVE, ON_LEAVE)
- CSV columns (header row required):
  employee_id,first_name,last_name,email,department,
  job_title,salary,hire_date,status
- FileProcessingResult (Kafka event): fileName, processedAt (Instant),
  totalRows (int), successRows (int), errorRows (int),
  batchStatus (BatchStatus enum: COMPLETED, PARTIAL, FAILED)

FILE INTERFACE:
- Poll directory: /data/input every 30 seconds
- File pattern: *.csv
- Move successfully processed files to: /data/archive/
- Move failed files (unparseable) to: /data/error/

JPA BACKEND (table: EMPLOYEES):
- employee_id VARCHAR(50) PK
- first_name, last_name, email, department, job_title VARCHAR
- salary DECIMAL(12,2), hire_date DATE, status VARCHAR(20)
- created_at TIMESTAMP, updated_at TIMESTAMP
- Flyway migration: V1__create_employees.sql
- On duplicate employee_id: UPDATE existing record (upsert)

KAFKA BACKEND (topic: etl-file-results):
- Key: fileName
- Publish FileProcessingResult after each file is fully processed

PROCESSING FLOW:
1. File consumer picks up CSV file, reads into memory
2. Validate header row — if missing required columns → move to /data/error/
3. For each data row:
   a. Validate: email format valid, salary > 0, hireDate not in future,
      status is valid enum value
   b. Valid rows: collect into batch list
   c. Invalid rows: append to /data/error/{fileName}.errors.txt
      with row number and reason
4. Batch-upsert all valid rows via JPA BatchCreateOrders backend (single transaction)
5. Publish FileProcessingResult to Kafka
6. Move file to /data/archive/

After making all changes:
- Replace Order/Purchase domain with Employee domain
- Configure file consumer poll.period=30000 in application.yml
- Set up /data/input, /data/archive, /data/error as Docker volume mounts
- Add Flyway migration V1__create_employees.sql
- Update application.yml with file paths, Kafka topic, datasource config
- Update Docker Compose (PostgreSQL + Kafka + volume mounts)
- Include a sample employees.csv fixture in src/test/resources
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a GraphQL Product
API with Redis caching. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with Product domain
- Product has: productId (UUID), name, description, category,
  price (BigDecimal), currency (String, ISO 4217), stock (Integer),
  tags (List<String>), active (boolean),
  createdAt (Instant), updatedAt (Instant)
- ProductFilter: category, minPrice, maxPrice, active, tag
- ProductPage: products (List<Product>), totalItems, page, pageSize

GRAPHQL SCHEMA (replace order-api.yaml with GraphQL schema):
Queries:
  products(filter: ProductFilter, page: Int, pageSize: Int): ProductPage
  product(productId: ID!): Product
Mutations:
  createProduct(input: CreateProductInput!): Product
  updateProduct(productId: ID!, input: UpdateProductInput!): Product
  deleteProduct(productId: ID!): Boolean

REST BACKEND — Product Catalog (WireMock):
- GET  /products?category={cat}&page={p}&pageSize={ps} → ProductPage
- GET  /products/{productId} → Product
- POST /products → Product
- PUT  /products/{productId} → Product
- DELETE /products/{productId} → 204
WireMock stubs:
  1. GET /products → 3 sample products
  2. GET /products/{id} → single product or 404
  3. POST, PUT → created/updated product
  4. DELETE → 204

REDIS CACHE BACKEND:
- Key: product:{productId}
- TTL: 5 minutes (300 seconds)
- GetOrder (cache-aside, two distinct Camel choice/when paths):
    CACHE HIT:  return from Redis (skip REST entirely)
    CACHE MISS: call REST → write Redis → return
- After UpdateOrder: overwrite Redis key product:{productId}
- After DeleteOrder: delete Redis key product:{productId}

FLOW:
- ListOrders: GraphQL → central → REST ListOrders (no caching on list queries)
- GetOrder: central → Redis choice/when → hit: cached / miss: REST + cache write
- CreateOrder: central → REST POST → return Product
- UpdateOrder: central → REST PUT → Redis overwrite → return Product
- DeleteOrder: central → REST DELETE → Redis evict → return true

After making all changes:
- Replace Order/Purchase domain with Product domain
- Implement GetOrder cache-aside as two distinct Camel choice/when paths
- Update application.yml with Redis config and REST backend base URL
- Update Docker Compose (Redis + WireMock)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into an Event-Driven
Inventory Sync service. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with InventoryItem domain
- InventoryItem has: itemId (UUID), sku (String, unique), name,
  description, category, quantity (Integer), reservedQuantity (Integer),
  reorderPoint (Integer), warehouseId (String), location (String),
  unitCost (BigDecimal), lastSyncedAt (Instant, nullable),
  updatedAt (Instant)
- InventoryEvent (Kafka): itemId, sku, warehouseId,
  eventType (CREATED, UPDATED, DELETED), quantity, updatedAt
- SyncResult (SNS payload): itemId, sku, syncStatus (SYNCED, SYNC_FAILED),
  warehouseConfirmation (String, nullable), syncedAt (Instant)

REST INTERFACE (replace order-api.yaml):
- POST   /inventory                               → 201
- GET    /inventory?warehouseId=WH-001&category=Electronics&page=0&pageSize=20
- GET    /inventory/{itemId}
- PATCH  /inventory/{itemId}  — update quantity, location, reorderPoint
- DELETE /inventory/{itemId}  → 204

MONGODB BACKEND (collection: inventoryItems):
- Indexes: { sku: 1 } unique, { warehouseId: 1, category: 1 }
- ListOrders: filter by warehouseId + category (both optional), paginated
- CreateOrder/GetOrder/UpdateOrder/DeleteOrder: standard document operations

KAFKA BACKEND (topic: inventory-events, key: warehouseId:itemId):
- Publish InventoryEvent after CreateOrder (CREATED), UpdateOrder (UPDATED), DeleteOrder (DELETED)

KAFKA CONSUMER INTERFACE (topic: inventory-events):
- Receives InventoryEvent messages
- Drives warehouse sync (UpdateOrder operation in central route)

WAREHOUSE REST BACKEND (WireMock):
POST /warehouse-api/sync
  Body: { itemId, sku, quantity, warehouseId, operation }
  Response: { confirmation, syncedAt }
WireMock stubs:
  1. Successful sync: 200 + confirmation string
  2. Warehouse unavailable: 503

AWS SNS BACKEND (topic ARN: inventory-sync-notifications):
- Publish SyncResult after each sync attempt
- SYNC_FAILED when warehouse returns 503

FLOWS:
REST CreateOrder:  MongoDB save → Kafka CREATED → return 201
REST UpdateOrder:  MongoDB update → Kafka UPDATED → return 200
REST DeleteOrder:  MongoDB delete → Kafka DELETED → return 204
REST ListOrders/GetOrder: MongoDB query → return

KAFKA CONSUMER UpdateOrder (sync flow):
1. Receive InventoryEvent from inventory-events
2. Call warehouse REST CreateOrder backend POST /warehouse-api/sync
3. On 200: SNS publish SYNCED → MongoDB UpdateOrder: set lastSyncedAt
4. On 503: SNS publish SYNC_FAILED (no MongoDB update)

After making all changes:
- Replace Order/Purchase domain with InventoryItem domain
- Update application.yml with Kafka topics, MongoDB URI, SNS topic ARN
- Update Docker Compose (Kafka, MongoDB, LocalStack for SNS, WireMock)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a SOAP-to-REST
Modernization Bridge for a Customer service. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with Customer domain
- Customer has: customerId (UUID), firstName, lastName, email,
  phone, dateOfBirth (LocalDate), status (CustomerStatus enum:
  ACTIVE, INACTIVE, SUSPENDED), tier (CustomerTier enum:
  STANDARD, SILVER, GOLD, PLATINUM), createdAt (Instant), updatedAt (Instant)
- CustomerList: customers (List<Customer>), totalItems, page, pageSize
- AuditLog (JPA entity): id (Long PK auto), operation, customerId,
  soapAction, requestPayload (String), responseStatus (SUCCESS/FAILURE),
  latencyMs (Long), calledAt (Instant)

SOAP INTERFACE (update the generated WSDL for Customer operations):
  ListCustomers(page, pageSize, status filter) → CustomerList
  CreateCustomer(firstName, lastName, email, phone, dateOfBirth, tier) → Customer
  GetCustomer(customerId) → Customer
  UpdateCustomer(customerId, status, tier, phone) → Customer
  DeleteCustomer(customerId) → DeleteResponse { success, message }

REST BACKEND — Customer Service (WireMock):
- GET  /customers?page={p}&pageSize={ps}&status={s} → CustomerList (JSON)
- POST /customers → Customer (JSON)
- GET  /customers/{customerId} → Customer (JSON)
- PATCH /customers/{customerId} → Customer (JSON)
- DELETE /customers/{customerId} → 204
WireMock stubs:
  1. GET /customers → 2 sample customers
  2. GET /customers/{id} → single customer or 404
  3. POST, PATCH → created/updated customer
  4. DELETE → 204

JPA BACKEND (table: SOAP_AUDIT_LOG):
- id BIGINT PK auto, operation VARCHAR(50), customer_id VARCHAR(36),
  soap_action VARCHAR(200), request_payload TEXT,
  response_status VARCHAR(20), latency_ms BIGINT, called_at TIMESTAMP
- Flyway migration: V1__create_soap_audit_log.sql
- CreateOrder: insert audit entry after every SOAP operation

FLOW FOR EACH SOAP OPERATION:
1. SOAP consumer receives XML request → record startTime
2. Central route:
   a. Map XML (JAXB) → domain object
   b. Call REST backend with JSON
   c. Map REST response → domain object
   d. Write AuditLog to JPA (operation, customerId, soapAction,
      requestPayload, responseStatus=SUCCESS/FAILURE,
      latencyMs = System.currentTimeMillis() - startTime)
3. Map domain → XML response → return to SOAP caller

After making all changes:
- Replace Order/Purchase domain with Customer domain
- Update WSDL with Customer operations and types
- Implement XML ↔ JSON mapping (JAXB ↔ domain ↔ REST DTOs)
- Add Flyway migration V1__create_soap_audit_log.sql
- Update application.yml with REST backend base URL and datasource
- Update Docker Compose (PostgreSQL + WireMock)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into an S3 Document
Processing Pipeline. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with DocumentRecord domain
- DocumentRecord has: documentId (UUID, generated on ingestion),
  bucketName, s3Key, fileName, fileSize (Long), contentType,
  status (ProcessingStatus enum: RECEIVED, PROCESSING, COMPLETED, FAILED),
  pageCount (Integer, nullable), language (String, nullable),
  documentType (DocumentType enum: PDF, WORD, EXCEL, IMAGE, UNKNOWN),
  errorMessage (String, nullable),
  receivedAt (Instant), processedAt (Instant, nullable)
- DocumentPage: documents (List<DocumentRecord>), totalItems, page, pageSize
- DocumentAnalysis (REST backend response): pageCount, language,
  documentType, wordCount (Integer)
- ProcessingNotification (SNS payload): documentId, s3Key, fileName,
  status, processedAt, errorMessage

AWS S3 INTERFACE:
- Poll bucket: document-inbox
- On each new object: trigger CreateOrder operation
- After successful processing: copy object to document-processed/ prefix, delete original
- After failed processing: copy object to document-failed/ prefix, delete original

REST INTERFACE (replace order-api.yaml — query API only):
- GET /documents?status=COMPLETED&page=0&pageSize=20 → DocumentPage
- GET /documents/{documentId} → DocumentRecord

REST BACKEND — Document Analysis Service (WireMock):
POST /analyze
  Body: { s3Key, bucketName, contentType }
  Response: DocumentAnalysis
WireMock stubs:
  1. PDF: { pageCount: 12, language: "en", documentType: "PDF", wordCount: 3240 }
  2. Image: { pageCount: 1, language: "n/a", documentType: "IMAGE", wordCount: 0 }
  3. Failure: 422 { error: "Unsupported format" }

JPA BACKEND (table: DOCUMENT_RECORDS):
- document_id VARCHAR(36) PK, bucket_name, s3_key, file_name VARCHAR,
  file_size BIGINT, content_type VARCHAR(100), status VARCHAR(20),
  page_count INT nullable, language VARCHAR(10) nullable,
  document_type VARCHAR(20), error_message VARCHAR(500) nullable,
  received_at TIMESTAMP, processed_at TIMESTAMP nullable
- Flyway migration: V1__create_document_records.sql
- CreateOrder: insert with status=RECEIVED
- UpdateOrder: update with analysis results and final status
- ListOrders: paginated, optional status filter
- GetOrder: find by documentId

AWS SNS BACKEND (topic: document-processing-notifications):
- Publish ProcessingNotification after processing completes or fails

S3 PROCESSING FLOW (central CreateOrder route):
1. S3 consumer picks up new object
2. Generate documentId (UUID), set status=RECEIVED, receivedAt=now()
3. JPA CreateOrder: save initial DocumentRecord
4. Set status=PROCESSING → JPA UpdateOrder
5. Call REST backend POST /analyze
6. On 200 success:
   - Map DocumentAnalysis into DocumentRecord
   - status=COMPLETED, processedAt=now()
   - JPA UpdateOrder: save final record → SNS: publish COMPLETED
7. On failure (non-200):
   - status=FAILED, errorMessage from response
   - JPA UpdateOrder: save failed record → SNS: publish FAILED

After making all changes:
- Replace Order/Purchase domain with DocumentRecord
- Update application.yml with S3 bucket, SNS ARN, REST backend URL,
  datasource, LocalStack endpoint
- Add Flyway migration V1__create_document_records.sql
- Update Docker Compose (PostgreSQL, LocalStack for S3+SNS, WireMock)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a Real-time
WebSocket Notification Hub. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with Notification domain
- Notification has: notificationId (UUID), topic (String),
  title, message, severity (Severity enum: INFO, WARNING, ERROR, CRITICAL),
  source (String — publishing system), publishedAt (Instant),
  expiresAt (Instant, nullable)
- NotificationPage: notifications (List<Notification>), totalItems, page, pageSize
- WebSocketMessage: type ("NOTIFICATION"), payload (Notification)

WEBSOCKET INTERFACE (endpoint: /notifications/ws/{topic}):
- Clients connect to /notifications/ws/{topic} to subscribe to a topic
- On connect: if Caffeine has a cached Notification for that topic,
  push it immediately as the "last known state"
- On new CreateOrder: push WebSocketMessage to all sessions subscribed to that topic
- CreateOrder operation: handle notification push to WebSocket subscribers

REST INTERFACE (replace order-api.yaml):
- POST /notifications
  Body: { topic, title, message, severity, source, expiresAt }
  Response 201: full Notification with notificationId and publishedAt
- GET  /notifications?topic=system&severity=ERROR&page=0&pageSize=50
- GET  /notifications/{notificationId}

KAFKA BACKEND (topic: notifications, key: topic):
- Publish full Notification JSON on every REST CreateOrder

CAFFEINE CACHE BACKEND:
- Key: topic (e.g. "system", "payments", "alerts")
- Value: latest Notification for that topic, TTL: 1 hour
- CreateOrder: write after Kafka publish (cache latest per topic)
- GetOrder (by topic): read latest cached Notification for that topic

REST PUBLISH FLOW (central CreateOrder route):
1. REST consumer receives POST /notifications
2. Generate notificationId (UUID), publishedAt = now()
3. Kafka CreateOrder backend → publish to notifications topic
4. Caffeine CreateOrder backend → cache as latest for topic
5. WebSocket push → broadcast WebSocketMessage to all sessions
   subscribed to that topic
6. Return 201 + full Notification

REST QUERY FLOW:
- ListOrders: central → Caffeine (all cached topics, filter by severity)
- GetOrder: central → Caffeine GetOrder (latest Notification by topic)

WEBSOCKET ON-CONNECT FLOW:
1. Client connects to /notifications/ws/{topic}
2. Caffeine GetOrder backend: fetch latest for topic
3. If found: push immediately as WebSocketMessage
4. Register session in a ConcurrentHashMap keyed by topic
   for future pushes

After making all changes:
- Replace Order/Purchase domain with Notification domain
- Implement WebSocket session registry (in-memory ConcurrentHashMap)
- Update application.yml with Kafka topic and Caffeine TTL config
- Update Docker Compose (Kafka)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a gRPC User
Profile service backed by PostgreSQL and Caffeine. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with UserProfile domain
- UserProfile has: userId (UUID), username (String, unique),
  email (String, unique), displayName, avatarUrl (String, nullable),
  bio (String, max 500 chars, nullable),
  role (UserRole enum: USER, MODERATOR, ADMIN),
  status (UserStatus enum: ACTIVE, SUSPENDED, DELETED),
  preferences (Map<String, String> — stored as JSON in DB),
  createdAt (Instant), updatedAt (Instant)
- UserProfileList: profiles (List<UserProfile>), totalItems, page, pageSize

PROTO DEFINITION (replace src/main/proto/*.proto):
service UserProfileService {
  rpc ListUserProfiles(ListUserProfilesRequest) returns (UserProfileList)
  rpc CreateUserProfile(CreateUserProfileRequest) returns (UserProfile)
  rpc BatchCreateUserProfiles(BatchCreateRequest) returns (BatchCreateResponse)
  rpc GetUserProfile(GetUserProfileRequest) returns (UserProfile)
  rpc ReplaceUserProfile(ReplaceUserProfileRequest) returns (UserProfile)
  rpc UpdateUserProfile(UpdateUserProfileRequest) returns (UserProfile)
  rpc DeleteUserProfile(DeleteUserProfileRequest) returns (DeleteResponse)
}
ListUserProfilesRequest: page, page_size, role (optional), status (optional)
GetUserProfileRequest: user_id
DeleteUserProfileRequest: user_id
DeleteResponse: success (bool), message (string)
BatchCreateRequest: repeated CreateUserProfileRequest profiles
BatchCreateResponse: repeated UserProfile created, count (int32)

JPA BACKEND (table: USER_PROFILES):
- user_id VARCHAR(36) PK, username VARCHAR(50) unique not null,
  email VARCHAR(200) unique not null, display_name VARCHAR(100),
  avatar_url VARCHAR(500), bio VARCHAR(500), role VARCHAR(20),
  status VARCHAR(20), preferences TEXT (JSON),
  created_at TIMESTAMP, updated_at TIMESTAMP
- Flyway migration: V1__create_user_profiles.sql
- All 7 operations

CAFFEINE CACHE BACKEND:
- Key: userId, TTL: 15 minutes
- GetOrder (cache-aside, two distinct Camel choice/when paths):
    CACHE HIT:  return from Caffeine (skip JPA entirely)
    CACHE MISS: JPA GetOrder → write Caffeine → return
- CreateOrder/ReplaceOrder/UpdateOrder: write updated profile to Caffeine after JPA save
- DeleteOrder: evict from Caffeine

FLOW:
- ListOrders:        JPA paginated query, optional role/status filter
- CreateOrder:       JPA save → Caffeine write → return
- BatchCreateOrders: JPA batch save → Caffeine write all
- GetOrder:          Caffeine choice/when (two paths) → hit: cached / miss: JPA + cache
- ReplaceOrder:      JPA replace → Caffeine write → return
- UpdateOrder:       JPA partial update → Caffeine write → return
- DeleteOrder:       JPA delete → Caffeine evict → return DeleteResponse(success=true)

After making all changes:
- Replace Order/Purchase domain with UserProfile domain
- Update .proto file with UserProfileService above
- Run ./mvnw generate-sources to regenerate gRPC stubs
- Implement GetOrder cache-aside as two distinct Camel choice/when paths
- Add UserProfile classes to ReflectionConfig.java for native build
- Add Flyway migration V1__create_user_profiles.sql
- Update application.yml with datasource and Caffeine TTL config
- Update Docker Compose (PostgreSQL)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a RabbitMQ
Work Queue Processor for background task execution. Here's what I need:

DOMAIN:
- Replace Order/Purchase domain with WorkTask domain
- WorkTask has: taskId (UUID), taskType (TaskType enum: EMAIL_SEND,
  REPORT_GENERATE, DATA_EXPORT, IMAGE_RESIZE, NOTIFICATION_PUSH),
  priority (Priority enum: LOW, NORMAL, HIGH, CRITICAL),
  payload (String — JSON string, task-type-specific),
  status (TaskStatus enum: QUEUED, PROCESSING, COMPLETED,
  FAILED, DEAD_LETTERED),
  result (String, nullable), attemptCount (Integer), maxAttempts (Integer, default 3),
  errorMessage (String, nullable), queuedAt (Instant),
  startedAt (Instant, nullable), completedAt (Instant, nullable)
- TaskAttemptLog (JPA): id (Long PK auto), taskId, attemptNumber (int),
  processorResponse (String), attemptStatus (String),
  latencyMs (Long), attemptedAt (Instant)

RABBITMQ INTERFACE:
- Main queue: task-queue (durable)
- Dead-letter exchange: task-dlx
- Dead-letter queue: task-dead-letter (durable, holds for 5 min then re-routes)
- Retry queue: task-retry (x-dead-letter-exchange → task-queue)
- Message acknowledgement: manual (ack on success, nack on retry/dead-letter)
- CreateOrder: process new WorkTask from task-queue
- UpdateOrder: process retry WorkTask (incrementing attemptCount)

REST BACKEND — Task Processor API (WireMock):
POST /process-task
  Body: { taskId, taskType, payload, priority }
  Response: { taskId, result, processingTimeMs }
WireMock stubs:
  1. EMAIL_SEND success: { result: "Email delivered to 142 recipients" }
  2. REPORT_GENERATE success: { result: "Report report-2025-001.pdf generated" }
  3. Transient failure: 503 (triggers retry with backoff)
  4. Permanent failure: 422 { error: "Invalid payload format" }

JPA BACKEND (tables: WORK_TASKS + TASK_ATTEMPT_LOGS):
Work tasks: task_id VARCHAR(36) PK, task_type, priority, status,
  payload TEXT, result TEXT nullable, attempt_count INT, max_attempts INT,
  error_message VARCHAR(500) nullable,
  queued_at, started_at, completed_at TIMESTAMP
Attempt logs: id BIGINT PK auto, task_id VARCHAR(36),
  attempt_number INT, processor_response TEXT, attempt_status VARCHAR(20),
  latency_ms BIGINT, attempted_at TIMESTAMP
Flyway migration: V1__create_work_tasks.sql

PROCESSING FLOW (central CreateOrder / UpdateOrder routes):
1. RabbitMQ consumer receives WorkTask JSON
2. JPA CreateOrder/UpdateOrder: upsert WorkTask (status=PROCESSING, startedAt=now(), increment attemptCount)
3. Call REST backend POST /process-task, measure latencyMs
4. On 200 success:
   - status=COMPLETED, result from response, completedAt=now()
   - JPA UpdateOrder: update WorkTask → JPA CreateOrder: log TaskAttemptLog (COMPLETED)
   - Ack message
5. On 503 (transient):
   - JPA CreateOrder: log attempt (RETRYING)
   - If attemptCount < maxAttempts: nack → route to retry queue (exponential backoff)
   - If attemptCount >= maxAttempts: status=DEAD_LETTERED
     → JPA UpdateOrder + CreateOrder log (DEAD_LETTERED) → ack (do not keep retrying)
6. On 422 (permanent):
   - status=FAILED, errorMessage from response
   - JPA UpdateOrder + CreateOrder log (FAILED) → ack (do not retry permanent failures)

After making all changes:
- Replace Order/Purchase domain with WorkTask domain
- Configure RabbitMQ queues, DLX, and retry exchange in application.yml
- Implement manual ack/nack in the RabbitMQ consumer route
- Add Flyway migration V1__create_work_tasks.sql
- Update application.yml with RabbitMQ connection, queue names, REST backend URL
- Update Docker Compose (RabbitMQ with management UI, WireMock, PostgreSQL)
- Make sure all unit tests, integration and black-box tests pass

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a JMS Trade
Settlement Bridge. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with Trade
- Trade has: tradeId (UUID), instrument (string), side (BUY/SELL),
  quantity (BigDecimal), price (BigDecimal), currency (ISO 4217),
  counterpartyId (string), status (NEW/SETTLED/FAILED),
  settlementRef (string, set after settlement), createdAt, settledAt

JMS CONSUMER:
- Two queues: trade.new (new trades) and trade.update (revisions)
- Each message triggers the central settlement route
- Use a transacted JMS listener with redelivery on transient failures

CENTRAL SETTLEMENT FLOW (per trade):
1. Persist the trade to PostgreSQL with status=NEW
2. Call the REST settlement system
3. On success: update status=SETTLED, settlementRef from response,
   then publish to SNS topic 'trade-settled'
4. On failure: update status=FAILED, then publish to SNS topic
   'trade-failed' with the error reason

REST QUERY API:
- GET /audit/trades?status={status}&page={p}&pageSize={n} (paginated)
- GET /audit/trades/{tradeId}

SNS NOTIFICATIONS:
- topic 'trade-settled' on success: tradeId, settlementRef, settledAt
- topic 'trade-failed' on failure: tradeId, errorCode, errorMessage

ERROR HANDLING:
- Transient REST errors (5xx, timeout) → JMS redelivery up to 3 times
- 4xx from settlement system → status=FAILED, no redelivery
- All errors logged and surfaced in the audit record

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Update OpenAPI spec for the query endpoints
- Update application.yml with JMS connection settings and SNS topics
- Update Docker Compose with an Artemis broker

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into an AWS-Native
Serverless Event Router. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with RoutingEvent
- RoutingEvent has: eventId (UUID, partition key), tenantId,
  eventType (string), payload (JSON map), priority (LOW/NORMAL/HIGH),
  status (RECEIVED/ENRICHED/ROUTED/FAILED), routedTopics (list),
  enrichmentRef (string), createdAt, processedAt

SQS CONSUMER:
- Polls the routing queue with long-polling (20s wait time)
- Each message becomes a RoutingEvent with status=RECEIVED
- Visibility timeout of 90s allows enrichment + routing in one pass

CENTRAL ROUTING FLOW:
1. Read SQS message → create RoutingEvent with status=RECEIVED
2. Persist to DynamoDB
3. Call REST enrichment API (adds tenant context + risk score)
4. Update DynamoDB: status=ENRICHED, store enrichmentRef
5. Determine target SNS topics from routingRules (e.g.,
   priority=HIGH → topic 'critical-events'; eventType='payment'
   → topic 'payment-events')
6. Publish to each target SNS topic; collect topic ARNs into
   routedTopics
7. Update DynamoDB: status=ROUTED, processedAt now

REST QUERY API:
- GET /events?tenantId={t}&status={s}&page={p}&pageSize={n}
  (paginated, DynamoDB Scan with FilterExpression)
- GET /events/{eventId}

DYNAMODB SCHEMA:
- Partition key: eventId
- GSI: tenantId-createdAt-index (for tenant-scoped queries)
- TTL attribute: ttl (auto-delete events older than 30 days)

ERROR HANDLING:
- Enrichment 5xx → exponential backoff, SQS message returns to queue
- Routing failures → status=FAILED, publish to 'dlq-events' SNS topic
- Capture last error message and timestamp in the DynamoDB record

NATIVE BUILD:
- Add RoutingEvent and all DTOs to ReflectionConfig.java
- Verify the project builds with -Pnative and image fits 256 MB

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Update OpenAPI spec for the query endpoints
- Update application.yml with SQS queue URL, SNS topic ARNs, DynamoDB
  table name (env-overridable)
- LocalStack-based integration tests for SQS/SNS/DynamoDB

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a Cassandra
Timeseries Metrics Ingest service. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with MetricEvent
- MetricEvent has: metricName (string), tenantId, timestamp (Instant,
  milliseconds), value (double), unit (string), tags (map of string),
  source (hostname or service name)

AVRO SCHEMA:
- Define MetricEvent.avsc registered with Apicurio Schema Registry
- Use BACKWARD compatibility so consumers can evolve fields safely

KAFKA CONSUMER:
- Topic 'metrics-raw' — schema-registered AVRO
- Manual ack mode; batch up to 100 records per ack to reduce overhead

CENTRAL INGEST FLOW:
1. Deserialize AVRO record → MetricEvent
2. Write to Cassandra (single insert, prepared statement)
3. Append to in-memory 5-minute window buffer keyed by metricName
4. When buffer reaches 5 minutes or 1000 records → flush to S3

CASSANDRA SCHEMA:
- Table: metrics_by_day
- Partition key: (metricName, dayBucket) where dayBucket = yyyy-MM-dd
- Clustering: timestamp DESC
- Columns: tenantId, value, unit, tags, source
- TTL: 30 days at table level

S3 ARCHIVE:
- Bucket: ${METRICS_ARCHIVE_BUCKET}
- Key format: archive/{yyyy/MM/dd}/{HH}/{metricName}-{HHmm}-{uuid}.jsonl
- One JSON object per line — easy Athena/DuckDB querying

REST QUERY API:
- GET /metrics?name={n}&from={iso}&to={iso}&page={p}&pageSize={s}
  — bounded scan, returns at most 10000 points
- GET /metrics/{name}/latest — last data point per source

ERROR HANDLING:
- Cassandra write failure → Kafka redelivery (no ack)
- S3 archive failure → continue serving Cassandra; alert on consecutive
  failures
- Schema-registry unreachable → fail-fast on startup

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Add Testcontainers for Cassandra + Apicurio + LocalStack S3
- Update application.yml with all topic, bucket, and Cassandra
  contact-point settings (env-overridable)

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into an AMQP
Enterprise Messaging Hub. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with HubMessage
- HubMessage has: messageId (UUID), sourceQueue, destinationQueue,
  routingKey, payload (string), enrichmentRef, decision
  (FORWARDED/DROPPED/DLQ), reason (string), createdAt, processedAt

AMQP CONSUMER:
- Single source queue 'hub.inbound' with prefetch=50, manual ack
- Each message carries headers: tenantId, messageType, priority

CENTRAL ROUTING FLOW:
1. Receive AMQP message → build HubMessage with status pending
2. Call REST enrichment API with tenantId + messageType
   (returns tier, allowedDestinations, riskScore)
3. Apply routing rules:
   - riskScore > 80 → destination 'hub.dlq', decision=DLQ
   - messageType='priority' AND tier='gold' → 'hub.gold-fast',
     decision=FORWARDED
   - otherwise → 'hub.default', decision=FORWARDED
4. Persist HubMessage to PostgreSQL
5. Publish to chosen destination AMQP queue with routingKey
6. Ack the inbound message

REST QUERY API:
- GET /audit/messages?decision={d}&from={iso}&to={iso}&page={p}
- GET /audit/messages/{messageId}

ERROR HANDLING:
- Enrichment 5xx → exponential backoff, redeliver from queue
- Enrichment 4xx → decision=DLQ, reason='enrichment-rejected'
- Destination publish failure → audit with decision=DLQ, route to
  'hub.dlq' as fallback

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Update Docker Compose with an Artemis/ActiveMQ broker
- Update application.yml with AMQP connection + per-destination queue
  names (env-overridable)

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into an Outbox-Polling
API Gateway. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with OutboxRecord
- OutboxRecord has: messageId (UUID, unique), aggregateId, eventType,
  payload (JSON text), status (NEW/SENT/FAILED), attempts (int),
  createdAt, sentAt, lastError

POSTGRESQL OUTBOX TABLE:
- Flyway migration creates table 'outbox_records'
- Indexes: (status, createdAt) for efficient polling
- Polling query: SELECT * FROM outbox_records WHERE status='NEW'
  ORDER BY createdAt LIMIT 50 FOR UPDATE SKIP LOCKED

SQL POLLING CONSUMER:
- Camel SQL component, poll interval configurable
  (camelbee.outbox.poll-interval, default 5000ms)
- Use 'FOR UPDATE SKIP LOCKED' to allow horizontal scale-out
- One Camel exchange per row

CENTRAL FORWARD FLOW:
1. Read OutboxRecord
2. Check Caffeine dedupe cache by messageId — if hit, mark SENT
   and skip downstream
3. Call downstream REST API with payload + idempotency-key header
4. On success: UPDATE row SET status='SENT', sentAt=NOW; cache hit
5. On failure: UPDATE row SET attempts=attempts+1, lastError=...
   - attempts < 5 → leave status=NEW for retry on next poll
   - attempts >= 5 → status=FAILED, surface in health endpoint

CAFFEINE CACHE:
- Key: messageId, value: sentAt
- Max size 50000, TTL 10 minutes
- Purpose: protect downstream from duplicate sends within the
  retry window even if the DB UPDATE is delayed

OBSERVABILITY:
- Micrometer counters: outbox_polled_total, outbox_forwarded_total,
  outbox_dedup_skipped_total, outbox_failed_total
- /health/outbox endpoint reports FAILED row count + last poll time

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Provide a seeder SQL script that inserts a few sample NEW rows
- Use WireMock for the downstream REST API in black-box tests
- Update application.yml with poll interval and downstream URL

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.

I need to transform this generated microservice into a MongoDB Change
Watcher with a relational mirror. Here's what I need:

DOMAIN:
- Replace the Order/Purchase domain with CustomerProfile
- The MongoDB source collection 'customer_profiles' has nested
  documents (address: {street, city, country}, preferences: {...})
- The PostgreSQL mirror flattens to columns: id, tenantId, email,
  fullName, street, city, country, preferenceLanguage, status,
  createdAt, updatedAt

MONGODB POLLING CONSUMER:
- Poll 'customer_profiles' every N seconds
  (camelbee.mongo.poll-interval, default 3000ms)
- High-water-mark cursor: WHERE updatedAt > lastSeenUpdatedAt
- Persist lastSeenUpdatedAt to a checkpoint collection so restarts
  resume cleanly
- Batch limit 200 docs per poll

CENTRAL SYNC FLOW (per Mongo document):
1. Map nested Mongo document → flat CustomerProfile
2. UPSERT into PostgreSQL via JPA (insert if new id, update otherwise)
3. Publish AVRO change event to Kafka topic 'customer-profiles-cdc'
   with operation=CREATE or UPDATE
4. Advance lastSeenUpdatedAt on the checkpoint

REST QUERY API:
- GET /customers?status={s}&tenantId={t}&from={iso}&to={iso}
  &page={p}&pageSize={n}
- GET /customers/{id}

KAFKA CHANGE EVENTS:
- Topic: 'customer-profiles-cdc'
- Headers: operation (CREATE/UPDATE), source ('mongo-mirror'),
  tenantId
- Body (AVRO): id, operation, before (null for create), after, ts

ERROR HANDLING:
- Mongo unreachable → log + retry on next poll (no checkpoint advance)
- PostgreSQL constraint violation → log + skip the doc, do not block
  the poll
- Kafka publish failure → JPA write rolls back, doc gets re-processed
  on next poll

After making all changes:
- Make sure all unit tests, integration and black-box tests pass
- Testcontainers: Mongo + PostgreSQL + Kafka
- Add Flyway migrations for the PostgreSQL mirror table + indexes
- Add new model classes to ReflectionConfig.java for native build
- Update application.yml with Mongo URI, Postgres URL, Kafka brokers
  (env-overridable)

Please follow all patterns in CLAUDE.md and .claude/ exactly.
Run the tests after changes to verify everything works.