Code Generation

- route:
    id: customer-credit-lookup
    from:
      uri: seda:orders.enrichment
      steps:
        - to:
            uri: sql:SELECT credit_status, warehouse_location FROM customers WHERE id = :#${body.customerId}
            parameters:
              dataSource: "#bean:dataSource"
        - setHeader:
            name: creditStatus
            simple: "${body[0]['credit_status']}"
        - setHeader:
            name: warehouseLocation
            simple: "${body[0]['warehouse_location']}"
        - log:
            message: "Customer ${body.customerId}: creditStatus=${header.creditStatus}"
        - to: "micrometer:timer:database.lookup.time"
        - onException:
            - exception: java.sql.SQLException
              redeliveryPolicy:
                maximumRedeliveries: 3
                redeliveryDelay: 2000
                backOffMultiplier: 2
                maximumRedeliveryDelay: 8000
              handled:
                constant: true
              steps:
                - log:
                    message: "Database error after retries: ${exception.message}"
                    loggingLevel: ERROR
                - to: seda:orders.error
                - to: "micrometer:counter:errors.database.total"

# REST Endpoint
rest.port=8080

# Database Configuration
spring.datasource.url=jdbc:postgresql://localhost:5432/orders
spring.datasource.username=orderuser
spring.datasource.password=change-me-in-production

# Kafka Configuration
kafka.brokers=localhost:9092
kafka.topic.warehouse=warehouse.orders
kafka.topic.pending=orders.pending
kafka.topic.invalid=orders.invalid

# SMTP Configuration (Error Alerts)
smtp.host=smtp.company.com
smtp.port=587
smtp.username=alerts@company.com
smtp.password=change-me-in-production
ops.email=ops@company.com

# Camel Configuration
camel.component.kafka.brokers=${kafka.brokers}
camel.component.sql.data-source=#bean:dataSource

# Observability
management.endpoints.web.exposure.include=health,metrics,prometheus
management.metrics.export.prometheus.enabled=true

version: '3.8'

services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: orders
      POSTGRES_USER: orderuser
      POSTGRES_PASSWORD: change-me-in-production
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init-db.sql:/docker-entrypoint-initdb.d/init-db.sql

  kafka:
    image: confluentinc/cp-kafka:7.5.0
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    ports:
      - "9092:9092"
    depends_on:
      - zookeeper

  zookeeper:
    image: confluentinc/cp-zookeeper:7.5.0
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    ports:
      - "2181:2181"

volumes:
  postgres-data:

@Test
public void testValidOrderProcessing() {
    // Given: Valid order JSON
    String validOrder = """
        {
          "orderId": "ORD-12345",
          "customerId": "CUST-67890",
          "items": [{"sku": "WIDGET-A", "quantity": 2, "price": 19.99}],
          "totalAmount": 39.98
        }
        """;
    
    // When: POST to /api/orders
    http()
        .client("restClient")
        .send()
        .post("/api/orders")
        .contentType("application/json")
        .payload(validOrder);
    
    // Then: Receive HTTP 202 Accepted
    http()
        .client("restClient")
        .receive()
        .response(HttpStatus.ACCEPTED);
    
    // And: Message appears on Kafka topic warehouse.orders
    kafka()
        .endpoint("kafkaEndpoint")
        .receive()
        .topic("warehouse.orders")
        .messageKey("ORD-12345")
        .payload(containsString("\"creditStatus\":\"ACTIVE\""));
}

@Test
public void testInvalidOrderHandling() {
    // Given: Invalid order (totalAmount = 0)
    String invalidOrder = """
        {
          "orderId": "ORD-99999",
          "customerId": "CUST-11111",
          "items": [],
          "totalAmount": 0
        }
        """;
    
    // When: POST to /api/orders
    http()
        .client("restClient")
        .send()
        .post("/api/orders")
        .contentType("application/json")
        .payload(invalidOrder);
    
    // Then: Receive HTTP 202 Accepted (fire-and-forget)
    http()
        .client("restClient")
        .receive()
        .response(HttpStatus.ACCEPTED);
    
    // And: Message appears on Kafka topic orders.invalid
    kafka()
        .endpoint("kafkaEndpoint")
        .receive()
        .topic("orders.invalid")
        .messageKey("ORD-99999")
        .payload(containsString("\"error\":\"totalAmount must be > 0\""));
}

# Validation Report: Order Processing Integration

## Component Verification

| Component | Status | Version |
|-----------|--------|---------|
| camel-rest | ✓ Supported | 4.14.0 |
| camel-jackson | ✓ Supported | 4.14.0 |
| camel-seda | ✓ Supported | 4.14.0 |
| camel-kafka | ✓ Supported | 4.14.0 |
| camel-sql | ✓ Supported | 4.14.0 |
| camel-mail | ✓ Supported | 4.14.0 |

## YAML Syntax Check

All 8 route files: ✓ Valid YAML

## Route Structure Check

All 8 routes follow Constitution Rule 1 (from → process → to)

## Summary

- Total routes: 8
- Components verified: 6
- Constitution compliance: 100%
- MCP verification: 100%

No issues found.

## Task 2: Order Transformation (DataMapper)

**Description:**
Transform incoming order JSON to canonical format using XSLT DataMapper.

**Acceptance Criteria:**
- Input: Mule-style order JSON
- Output: Camel canonical order JSON
- Transformation: XSLT via DataMapper
- Field mappings: orderId → id, customer.email → customerEmail, etc.

- route:
    id: order-transformation
    from:
      uri: seda:orders.raw
      steps:
        - to: xslt:xslt/order-transform.xslt?saxon=true
        - to: seda:orders.canonical