Protocol Translation Services

service: soap-to-rest-translator
endpoints:
  - id: customer-service
    source:
      protocol: soap
      wsdl: https://legacy.acme.com/CustomerService.wsdl
      namespace: http://acme.com/customer/v1
      binding: CustomerServiceSoapBinding
      authentication:
        type: wsse-username-token
        username: ${SOAP_USERNAME}
        password: ${SOAP_PASSWORD}
    target:
      protocol: rest
      baseUrl: /api/v1/customers
      authentication:
        type: bearer
        token: ${API_KEY}
    operations:
      - soap:
          operation: GetCustomer
          input:
            customerId: string
          output:
            customer: Customer
        rest:
          method: GET
          path: /:customerId
          request:
            params:
              customerId: $.customerId
          response:
            status: 200
            body: $.customer
            transform:
              id: $.customer.CustomerID
              firstName: $.customer.FirstName
              lastName: $.customer.LastName
              email: $.customer.EmailAddress
              phone: $.customer.PhoneNumber
              address:
                street: $.customer.Address.Street
                city: $.customer.Address.City
                state: $.customer.Address.State
                zip: $.customer.Address.ZipCode
      - soap:
          operation: CreateCustomer
          input:
            customer: Customer
          output:
            customerId: string
        rest:
          method: POST
          path: /
          request:
            body:
              FirstName: $.firstName
              LastName: $.lastName
              EmailAddress: $.email
              PhoneNumber: $.phone
              Address:
                Street: $.address.street
                City: $.address.city
                State: $.address.state
                ZipCode: $.address.zip
          response:
            status: 201
            body:
              id: $.customerId
            headers:
              Location: '/api/v1/customers/${customerId}'
      - soap:
          operation: UpdateCustomer
          input:
            customerId: string
            customer: Customer
        rest:
          method: PUT
          path: /:customerId
          request:
            params:
              customerId: $.customerId
            body:
              FirstName: $.firstName
              LastName: $.lastName
              EmailAddress: $.email
          response:
            status: 200
            body:
              success: true
    errorHandling:
      soapFault:
        faultcode:
          'Client': 400
          'Server': 500
          'VersionMismatch': 400
      httpError:
        400: 'Client Error'
        404: 'Customer Not Found'
        500: 'Server Error'
    caching:
      enabled: true
      ttl: 300
      key: 'customer:${customerId}'
      methods: [GET]

// Modern REST client makes request
const response = await fetch('https://api.acme.com/api/v1/customers/12345', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer abc123',
  },
})

// Service automatically:
// 1. Receives REST request
// 2. Constructs SOAP envelope:
//    <soap:Envelope>
//      <soap:Header>
//        <wsse:Security>
//          <wsse:UsernameToken>...</wsse:UsernameToken>
//        </wsse:Security>
//      </soap:Header>
//      <soap:Body>
//        <GetCustomer>
//          <customerId>12345</customerId>
//        </GetCustomer>
//      </soap:Body>
//    </soap:Envelope>
// 3. Sends to legacy SOAP service
// 4. Receives SOAP response
// 5. Parses SOAP envelope
// 6. Transforms to REST format
// 7. Returns JSON response
// 8. Caches for 5 minutes

const customer = await response.json()
console.log(customer)
// {
//   "id": "12345",
//   "firstName": "John",
//   "lastName": "Doe",
//   "email": "[email protected]",
//   "phone": "+14155551234",
//   "address": {
//     "street": "123 Main St",
//     "city": "San Francisco",
//     "state": "CA",
//     "zip": "94105"
//   }
// }

// Create customer via REST
const newCustomer = await fetch('https://api.acme.com/api/v1/customers', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer abc123',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    firstName: 'Jane',
    lastName: 'Smith',
    email: '[email protected]',
    phone: '+14155559999',
    address: {
      street: '456 Oak Ave',
      city: 'San Francisco',
      state: 'CA',
      zip: '94102',
    },
  }),
})

// Service transforms to SOAP and returns:
// {
//   "id": "67890"
// }

// Monitor translation metrics
const metrics = await services.translator.getMetrics({
  serviceId: 'customer-service',
  timeRange: 'last-24h',
})
console.log(metrics)
// {
//   totalRequests: 15234,
//   successful: 15189,
//   failed: 45,
//   cached: 8934,
//   avgLatency: 234, // ms
//   soapLatency: 198, // ms to SOAP service
//   transformLatency: 36, // ms for transformation
//   byOperation: {
//     'GetCustomer': { requests: 12000, cached: 8934 },
//     'CreateCustomer': { requests: 2134, cached: 0 },
//     'UpdateCustomer': { requests: 1100, cached: 0 }
//   }
// }

{
  "service": "edi-to-json-translator",
  "standards": {
    "x12": {
      "version": "4010",
      "transactions": [
        {
          "code": "850",
          "name": "Purchase Order",
          "schema": "schemas/x12-850.json"
        },
        {
          "code": "810",
          "name": "Invoice",
          "schema": "schemas/x12-810.json"
        },
        {
          "code": "856",
          "name": "Advance Ship Notice",
          "schema": "schemas/x12-856.json"
        }
      ]
    },
    "edifact": {
      "version": "D96A",
      "transactions": [
        {
          "code": "ORDERS",
          "name": "Purchase Order",
          "schema": "schemas/edifact-orders.json"
        },
        {
          "code": "INVOIC",
          "name": "Invoice",
          "schema": "schemas/edifact-invoic.json"
        }
      ]
    }
  },
  "endpoints": [
    {
      "id": "receive-purchase-orders",
      "source": {
        "protocol": "as2",
        "endpoint": "https://edi.acme.com/as2/receive",
        "certificate": "${AS2_CERTIFICATE}",
        "privateKey": "${AS2_PRIVATE_KEY}",
        "mdnRequired": true
      },
      "target": {
        "protocol": "rest",
        "url": "https://api.acme.com/orders/create",
        "method": "POST",
        "authentication": {
          "type": "api-key",
          "header": "X-API-Key",
          "value": "${API_KEY}"
        }
      },
      "translation": {
        "ediType": "x12-850",
        "direction": "inbound",
        "mapping": {
          "orderNumber": "$.BEG.BEG03",
          "orderDate": "$.BEG.BEG05 | parseDate('yyyyMMdd')",
          "poNumber": "$.BEG.BEG03",
          "customer": {
            "name": "$.N1Loop[?(@.N1.N101=='BY')].N1.N102",
            "address": {
              "street": "$.N1Loop[?(@.N1.N101=='BY')].N3.N301",
              "city": "$.N1Loop[?(@.N1.N101=='BY')].N4.N401",
              "state": "$.N1Loop[?(@.N1.N101=='BY')].N4.N402",
              "zip": "$.N1Loop[?(@.N1.N101=='BY')].N4.N403"
            }
          },
          "shipTo": {
            "name": "$.N1Loop[?(@.N1.N101=='ST')].N1.N102",
            "address": {
              "street": "$.N1Loop[?(@.N1.N101=='ST')].N3.N301",
              "city": "$.N1Loop[?(@.N1.N101=='ST')].N4.N401",
              "state": "$.N1Loop[?(@.N1.N101=='ST')].N4.N402",
              "zip": "$.N1Loop[?(@.N1.N101=='ST')].N4.N403"
            }
          },
          "items": "$.PO1Loop[*].{sku: PO1.PO107, quantity: PO1.PO102 | toNumber, price: PO1.PO104 | toNumber, description: PID.PID05}"
        },
        "validation": {
          "required": ["orderNumber", "customer", "items"],
          "custom": {
            "itemsNotEmpty": "$.items.length > 0"
          }
        }
      }
    },
    {
      "id": "send-invoices",
      "source": {
        "protocol": "rest",
        "endpoint": "https://api.acme.com/invoices/send",
        "method": "POST"
      },
      "target": {
        "protocol": "as2",
        "partnerUrl": "${PARTNER_AS2_URL}",
        "certificate": "${PARTNER_AS2_CERTIFICATE}",
        "mdnRequired": true
      },
      "translation": {
        "ediType": "x12-810",
        "direction": "outbound",
        "mapping": {
          "ISA": {
            "ISA01": "00",
            "ISA02": "          ",
            "ISA03": "00",
            "ISA04": "          ",
            "ISA05": "ZZ",
            "ISA06": "${SENDER_ID} | padEnd(15)",
            "ISA07": "ZZ",
            "ISA08": "${RECEIVER_ID} | padEnd(15)",
            "ISA09": "$.invoiceDate | formatDate('yyMMdd')",
            "ISA10": "$.invoiceDate | formatDate('HHmm')",
            "ISA11": "U",
            "ISA12": "00401",
            "ISA13": "${CONTROL_NUMBER}",
            "ISA14": "0",
            "ISA15": "P",
            "ISA16": ">"
          },
          "BIG": {
            "BIG01": "$.invoiceDate | formatDate('yyyyMMdd')",
            "BIG02": "$.invoiceNumber",
            "BIG03": "$.orderDate | formatDate('yyyyMMdd')",
            "BIG04": "$.orderNumber"
          },
          "IT1Loop": "$.items[*].{IT1: {IT101: @index + 1, IT102: @.quantity, IT103: 'EA', IT104: @.price, IT106: 'UP', IT107: @.sku}}"
        }
      }
    }
  ],
  "archiving": {
    "enabled": true,
    "destination": "s3://edi-archive/",
    "retention": 2555, // 7 years
    "format": "original"
  },
  "monitoring": {
    "alerts": {
      "translationFailure": {
        "threshold": 3,
        "action": "email",
        "recipients": ["[email protected]"]
      },
      "mdnNotReceived": {
        "timeout": 300,
        "action": "slack",
        "channel": "#edi-alerts"
      }
    }
  }
}

// Partner sends EDI 850 Purchase Order via AS2
// ISA*00*          *00*          *ZZ*PARTNER123     *ZZ*ACME           *241027*1200*U*00401*000000001*0*P*>~
// GS*PO*PARTNER123*ACME*20241027*1200*1*X*004010~
// ST*850*0001~
// BEG*00*SA*PO123456**20241027~
// REF*DP*DEPT001~
// N1*BY*Acme Corporation~
// N3*123 Main Street~
// N4*San Francisco*CA*94105~
// N1*ST*Acme Warehouse~
// N3*456 Oak Avenue~
// N4*Oakland*CA*94607~
// PO1*1*100*EA*25.00**UP*WIDGET-001~
// PID*F****Premium Widget~
// PO1*2*50*EA*45.00**UP*GADGET-002~
// PID*F****Deluxe Gadget~
// CTT*2~
// SE*15*0001~
// GE*1*1~
// IEA*1*000000001~

// Service automatically:
// 1. Receives AS2 transmission
// 2. Verifies digital signature
// 3. Decrypts payload
// 4. Parses EDI document
// 5. Validates against X12 850 schema
// 6. Transforms to JSON
// 7. POSTs to order API
// 8. Sends AS2 MDN (acknowledgment)
// 9. Archives original EDI

// Resulting JSON sent to API:
const order = {
  orderNumber: 'PO123456',
  orderDate: '2024-10-27',
  poNumber: 'PO123456',
  customer: {
    name: 'Acme Corporation',
    address: {
      street: '123 Main Street',
      city: 'San Francisco',
      state: 'CA',
      zip: '94105',
    },
  },
  shipTo: {
    name: 'Acme Warehouse',
    address: {
      street: '456 Oak Avenue',
      city: 'Oakland',
      state: 'CA',
      zip: '94607',
    },
  },
  items: [
    {
      sku: 'WIDGET-001',
      quantity: 100,
      price: 25.0,
      description: 'Premium Widget',
    },
    {
      sku: 'GADGET-002',
      quantity: 50,
      price: 45.0,
      description: 'Deluxe Gadget',
    },
  ],
}

// Send invoice back as EDI 810
await fetch('https://api.acme.com/invoices/send', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    invoiceNumber: 'INV-2024-001',
    invoiceDate: '2024-10-28',
    orderNumber: 'PO123456',
    orderDate: '2024-10-27',
    items: [
      { sku: 'WIDGET-001', quantity: 100, price: 25.0 },
      { sku: 'GADGET-002', quantity: 50, price: 45.0 },
    ],
    total: 4750.0,
  }),
})

// Service automatically:
// 1. Receives JSON invoice
// 2. Transforms to EDI 810 format
// 3. Generates control numbers
// 4. Encrypts for partner
// 5. Signs with digital certificate
// 6. Transmits via AS2
// 7. Waits for MDN
// 8. Archives sent EDI

// Monitor EDI transactions
const stats = await services.translator.getEDIStats({
  timeRange: 'last-30-days',
  transactionTypes: ['850', '810', '856'],
})
console.log(stats)
// {
//   received: {
//     '850': { total: 1234, successful: 1229, failed: 5 },
//     '856': { total: 1187, successful: 1187, failed: 0 }
//   },
//   sent: {
//     '810': { total: 1229, successful: 1225, failed: 4 },
//     'mdn-received': 1225,
//     'mdn-timeout': 4
//   },
//   avgProcessingTime: 2345, // ms
//   totalDataVolume: 125 // MB
// }

service: database-graphql-translator
databases:
  - id: legacy-orders-db
    type: postgresql
    connection:
      host: orders-db.internal
      port: 5432
      database: orders
      username: ${DB_USERNAME}
      password: ${DB_PASSWORD}
      ssl: true
    tables:
      - name: orders
        schema: public
        primaryKey: order_id
      - name: order_items
        schema: public
        primaryKey: item_id
      - name: customers
        schema: public
        primaryKey: customer_id
graphql:
  endpoint: /graphql
  schema:
    types:
      Customer:
        fields:
          id:
            type: ID!
            source: customers.customer_id
          name:
            type: String!
            source: customers.customer_name
          email:
            type: String
            source: customers.email
          phone:
            type: String
            source: customers.phone
          orders:
            type: '[Order!]!'
            source:
              query: |
                SELECT * FROM orders
                WHERE customer_id = :customerId
              params:
                customerId: $.id
      Order:
        fields:
          id:
            type: ID!
            source: orders.order_id
          orderNumber:
            type: String!
            source: orders.order_number
          orderDate:
            type: String!
            source: orders.order_date | formatDate('yyyy-MM-dd')
          status:
            type: OrderStatus!
            source: orders.status
          total:
            type: Float!
            source: orders.total_amount
          customer:
            type: Customer!
            source:
              query: |
                SELECT * FROM customers
                WHERE customer_id = :customerId
              params:
                customerId: $.customer_id
          items:
            type: '[OrderItem!]!'
            source:
              query: |
                SELECT * FROM order_items
                WHERE order_id = :orderId
              params:
                orderId: $.id
      OrderItem:
        fields:
          id:
            type: ID!
            source: order_items.item_id
          sku:
            type: String!
            source: order_items.sku
          quantity:
            type: Int!
            source: order_items.quantity
          price:
            type: Float!
            source: order_items.unit_price
      OrderStatus:
        type: enum
        values: [PENDING, PROCESSING, SHIPPED, DELIVERED, CANCELLED]
    queries:
      customer:
        type: Customer
        args:
          id:
            type: ID!
        resolve:
          query: 'SELECT * FROM customers WHERE customer_id = :id'
          params:
            id: $.args.id
      customers:
        type: '[Customer!]!'
        args:
          limit:
            type: Int
            default: 10
          offset:
            type: Int
            default: 0
        resolve:
          query: 'SELECT * FROM customers ORDER BY customer_id LIMIT :limit OFFSET :offset'
          params:
            limit: $.args.limit
            offset: $.args.offset
      order:
        type: Order
        args:
          id:
            type: ID!
        resolve:
          query: 'SELECT * FROM orders WHERE order_id = :id'
          params:
            id: $.args.id
      orders:
        type: '[Order!]!'
        args:
          customerId:
            type: ID
          status:
            type: OrderStatus
          limit:
            type: Int
            default: 10
        resolve:
          query: |
            SELECT * FROM orders
            WHERE (:customerId IS NULL OR customer_id = :customerId)
            AND (:status IS NULL OR status = :status)
            ORDER BY order_date DESC
            LIMIT :limit
          params:
            customerId: $.args.customerId
            status: $.args.status
            limit: $.args.limit
    mutations:
      createOrder:
        type: Order!
        args:
          customerId:
            type: ID!
          items:
            type: '[OrderItemInput!]!'
        resolve:
          transaction: true
          steps:
            - query: |
                INSERT INTO orders (customer_id, order_number, order_date, status, total_amount)
                VALUES (:customerId, :orderNumber, CURRENT_DATE, 'PENDING', :total)
                RETURNING order_id
              params:
                customerId: $.args.customerId
                orderNumber: 'generateOrderNumber()'
                total: '$.args.items | sum(@.quantity * @.price)'
              output: orderId
            - query: |
                INSERT INTO order_items (order_id, sku, quantity, unit_price)
                VALUES (:orderId, :sku, :quantity, :price)
              params:
                orderId: $.orderId
                sku: $.item.sku
                quantity: $.item.quantity
                price: $.item.price
              forEach: $.args.items
              as: item
            - query: 'SELECT * FROM orders WHERE order_id = :orderId'
              params:
                orderId: $.orderId
      updateOrderStatus:
        type: Order!
        args:
          id:
            type: ID!
          status:
            type: OrderStatus!
        resolve:
          query: |
            UPDATE orders
            SET status = :status, updated_at = CURRENT_TIMESTAMP
            WHERE order_id = :id
            RETURNING *
          params:
            id: $.args.id
            status: $.args.status
  performance:
    caching:
      enabled: true
      ttl: 60
      keys:
        - 'customer:${id}'
        - 'order:${id}'
    dataloader:
      enabled: true
      batchSize: 100
    queryComplexity:
      maxDepth: 5
      maxCost: 1000

# Query customer with orders
query GetCustomerWithOrders($customerId: ID!) {
  customer(id: $customerId) {
    id
    name
    email
    orders {
      id
      orderNumber
      orderDate
      status
      total
      items {
        sku
        quantity
        price
      }
    }
  }
}

# Variables:
# { "customerId": "12345" }

# Service automatically:
# 1. Parses GraphQL query
# 2. Generates optimized SQL:
#    SELECT * FROM customers WHERE customer_id = $1
#    SELECT * FROM orders WHERE customer_id = $1
#    SELECT * FROM order_items WHERE order_id IN ($1, $2, ...)
# 3. Uses DataLoader to batch item queries
# 4. Transforms database rows to GraphQL schema
# 5. Caches customer and order data
# 6. Returns nested JSON response

# Create order mutation
mutation CreateOrder($customerId: ID!, $items: [OrderItemInput!]!) {
  createOrder(customerId: $customerId, items: $items) {
    id
    orderNumber
    total
    status
  }
}

# Variables:
# {
#   "customerId": "12345",
#   "items": [
#     { "sku": "WIDGET-001", "quantity": 5, "price": 25.00 },
#     { "sku": "GADGET-002", "quantity": 2, "price": 45.00 }
#   ]
# }

# Service automatically:
# 1. Starts database transaction
# 2. Inserts order record
# 3. Generates order number
# 4. Calculates total
# 5. Inserts order items
# 6. Commits transaction
# 7. Returns created order

// Query customer with orders
const query = `
  query GetCustomerWithOrders($customerId: ID!) {
    customer(id: $customerId) {
      id
      name
      email
      orders {
        id
        orderNumber
        orderDate
        status
        total
        items {
          sku
          quantity
          price
        }
      }
    }
  }
`

const response = await fetch('https://api.acme.com/graphql', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: 'Bearer abc123',
  },
  body: JSON.stringify({
    query,
    variables: { customerId: '12345' },
  }),
})

const { data } = await response.json()
console.log(data.customer)
// {
//   id: '12345',
//   name: 'Acme Corporation',
//   email: '[email protected]',
//   orders: [
//     {
//       id: 'ORD-001',
//       orderNumber: 'PO-2024-001',
//       orderDate: '2024-10-27',
//       status: 'SHIPPED',
//       total: 215.00,
//       items: [
//         { sku: 'WIDGET-001', quantity: 5, price: 25.00 },
//         { sku: 'GADGET-002', quantity: 2, price: 45.00 }
//       ]
//     }
//   ]
// }

// Monitor GraphQL performance
const metrics = await services.translator.getGraphQLMetrics({
  timeRange: 'last-hour',
})
console.log(metrics)
// {
//   totalQueries: 15234,
//   totalMutations: 892,
//   avgQueryTime: 45, // ms
//   avgMutationTime: 123,
//   cacheHitRate: 0.67,
//   topQueries: [
//     { name: 'GetCustomerWithOrders', count: 5234, avgTime: 67 },
//     { name: 'GetOrder', count: 4123, avgTime: 23 }
//   ],
//   dataloaderStats: {
//     batches: 892,
//     itemsPerBatch: 12.3,
//     cacheHits: 5643
//   }
// }

{
  "service": "mq-protocol-bridge",
  "bridges": [
    {
      "id": "kafka-to-rabbitmq",
      "source": {
        "protocol": "kafka",
        "brokers": ["kafka-1:9092", "kafka-2:9092", "kafka-3:9092"],
        "topics": ["orders", "payments", "shipments"],
        "consumerGroup": "mq-bridge",
        "config": {
          "auto.offset.reset": "earliest",
          "enable.auto.commit": false
        }
      },
      "target": {
        "protocol": "rabbitmq",
        "url": "amqp://rabbitmq.acme.com",
        "exchange": "legacy-events",
        "exchangeType": "topic",
        "durable": true
      },
      "transformation": {
        "routingKey": "$.topic | replace('-', '.')",
        "headers": {
          "x-source": "kafka",
          "x-topic": "$.topic",
          "x-partition": "$.partition",
          "x-offset": "$.offset"
        },
        "body": "$.value",
        "deliveryMode": "persistent"
      }
    },
    {
      "id": "sqs-to-kafka",
      "source": {
        "protocol": "sqs",
        "queueUrl": "${SQS_QUEUE_URL}",
        "region": "us-west-2",
        "maxMessages": 10,
        "waitTimeSeconds": 20,
        "visibilityTimeout": 300
      },
      "target": {
        "protocol": "kafka",
        "brokers": ["kafka-1:9092", "kafka-2:9092"],
        "topic": "external-events",
        "config": {
          "acks": "all",
          "compression.type": "gzip"
        }
      },
      "transformation": {
        "key": "$.messageId",
        "value": "$.body | parseJSON",
        "headers": {
          "sqs-message-id": "$.messageId",
          "sqs-receipt-handle": "$.receiptHandle"
        },
        "partition": "$.attributes.EventType | hash % 10"
      }
    },
    {
      "id": "rest-to-kafka",
      "source": {
        "protocol": "rest",
        "endpoint": "/api/events",
        "method": "POST",
        "authentication": {
          "type": "api-key",
          "header": "X-API-Key"
        }
      },
      "target": {
        "protocol": "kafka",
        "brokers": ["kafka-1:9092"],
        "topic": "api-events",
        "config": {
          "acks": "all"
        }
      },
      "transformation": {
        "key": "$.eventId",
        "value": "$",
        "headers": {
          "content-type": "application/json",
          "source": "rest-api"
        }
      },
      "responseMode": "async",
      "response": {
        "status": 202,
        "body": {
          "accepted": true,
          "eventId": "$.eventId"
        }
      }
    }
  ],
  "errorHandling": {
    "retryPolicy": {
      "maxAttempts": 5,
      "initialDelay": 1000,
      "maxDelay": 60000,
      "backoffMultiplier": 2
    },
    "deadLetterQueue": {
      "enabled": true,
      "destination": "kafka://kafka-1:9092/dlq"
    }
  },
  "monitoring": {
    "metrics": {
      "enabled": true,
      "interval": 60,
      "provider": "prometheus"
    },
    "tracing": {
      "enabled": true,
      "provider": "jaeger"
    }
  }
}

// Kafka message consumed
// Topic: orders
// Key: order-12345
// Value: { "orderId": "12345", "status": "created" }

// Service automatically:
// 1. Consumes from Kafka
// 2. Transforms message
// 3. Publishes to RabbitMQ exchange "legacy-events"
// 4. Routing key: "orders"
// 5. Headers: { x-source: "kafka", x-topic: "orders", ... }
// 6. Commits Kafka offset after successful publish

// SQS message received
// {
//   "messageId": "abc-123",
//   "body": "{\"eventType\":\"PaymentReceived\",\"amount\":99.99}",
//   "attributes": { "EventType": "PaymentReceived" }
// }

// Service automatically:
// 1. Polls SQS queue
// 2. Parses JSON body
// 3. Calculates partition based on event type
// 4. Produces to Kafka topic "external-events"
// 5. Deletes message from SQS after successful production

// REST API submission
await fetch('https://api.acme.com/api/events', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'secret-key',
  },
  body: JSON.stringify({
    eventId: 'evt-789',
    eventType: 'UserSignup',
    userId: 'user-456',
    timestamp: new Date().toISOString(),
  }),
})

// Service automatically:
// 1. Receives REST POST
// 2. Validates API key
// 3. Produces to Kafka asynchronously
// 4. Returns 202 Accepted immediately
// 5. Client doesn't wait for Kafka confirmation

// Response:
// {
//   "accepted": true,
//   "eventId": "evt-789"
// }

// Monitor bridge performance
const metrics = await services.translator.getBridgeMetrics({
  bridgeId: 'kafka-to-rabbitmq',
  timeRange: 'last-hour',
})
console.log(metrics)
// {
//   messagesConsumed: 45234,
//   messagesProduced: 45189,
//   messagesFailed: 45,
//   avgLatency: 23, // ms from consume to produce
//   consumerLag: 0, // no lag
//   throughput: 753, // messages/second
//   errors: {
//     connectionErrors: 2,
//     serializationErrors: 3,
//     productionErrors: 40
//   }
// }

service: grpc-rest-gateway
services:
  - id: user-service
    grpc:
      address: user-service:50051
      protoFile: protos/user.proto
      package: user.v1
      service: UserService
      tls:
        enabled: true
        cert: ${GRPC_CLIENT_CERT}
        key: ${GRPC_CLIENT_KEY}
        ca: ${GRPC_CA_CERT}
    rest:
      basePath: /api/v1/users
      endpoints:
        - grpc:
            method: GetUser
            request:
              userId: string
            response: User
          rest:
            method: GET
            path: /:userId
            params:
              userId: $.userId
            response:
              status: 200
              body: $
        - grpc:
            method: ListUsers
            request:
              pageSize: int32
              pageToken: string
            response: ListUsersResponse
            streaming: server
          rest:
            method: GET
            path: /
            query:
              limit: $.pageSize
              cursor: $.pageToken
            response:
              status: 200
              body: $.users
              headers:
                X-Next-Cursor: $.nextPageToken
        - grpc:
            method: CreateUser
            request: CreateUserRequest
            response: User
          rest:
            method: POST
            path: /
            body:
              name: $.name
              email: $.email
              phone: $.phone
            response:
              status: 201
              body: $
              headers:
                Location: '/api/v1/users/${id}'
        - grpc:
            method: UpdateUser
            request: UpdateUserRequest
            response: User
          rest:
            method: PUT
            path: /:userId
            params:
              userId: $.userId
            body:
              name: $.name
              email: $.email
            response:
              status: 200
              body: $
        - grpc:
            method: DeleteUser
            request:
              userId: string
            response: google.protobuf.Empty
          rest:
            method: DELETE
            path: /:userId
            params:
              userId: $.userId
            response:
              status: 204
        - grpc:
            method: StreamUserEvents
            request:
              userId: string
            response: UserEvent
            streaming: server
          rest:
            method: GET
            path: /:userId/events/stream
            params:
              userId: $.userId
            response:
              status: 200
              contentType: text/event-stream
              streaming: true
              format: sse
    errorMapping:
      NOT_FOUND: 404
      INVALID_ARGUMENT: 400
      ALREADY_EXISTS: 409
      PERMISSION_DENIED: 403
      UNAUTHENTICATED: 401
      INTERNAL: 500
      UNAVAILABLE: 503
    performance:
      connectionPoolSize: 10
      keepAlive: 30s
      timeout: 30s
      maxRetries: 3

// REST client makes request
const response = await fetch('https://api.acme.com/api/v1/users/12345', {
  method: 'GET',
  headers: {
    Authorization: 'Bearer abc123',
  },
})

// Service automatically:
// 1. Receives REST request
// 2. Extracts userId from path
// 3. Creates gRPC request:
//    message GetUserRequest {
//      string user_id = 1;
//    }
// 4. Calls gRPC method: GetUser(GetUserRequest)
// 5. Receives gRPC response (protobuf)
// 6. Converts protobuf to JSON
// 7. Returns REST response

const user = await response.json()
console.log(user)
// {
//   "id": "12345",
//   "name": "John Doe",
//   "email": "[email protected]",
//   "phone": "+14155551234",
//   "createdAt": "2024-01-15T10:30:00Z"
// }

// Server-side streaming example
const eventsResponse = await fetch('https://api.acme.com/api/v1/users/12345/events/stream', {
  headers: { Authorization: 'Bearer abc123' },
})

// Service automatically:
// 1. Receives REST request
// 2. Calls gRPC streaming method
// 3. Converts gRPC stream to Server-Sent Events
// 4. Streams events to client

const reader = eventsResponse.body.getReader()
const decoder = new TextDecoder()

while (true) {
  const { value, done } = await reader.read()
  if (done) break

  const chunk = decoder.decode(value)
  const events = chunk.split('\n\n')

  for (const event of events) {
    if (event.startsWith('data: ')) {
      const data = JSON.parse(event.slice(6))
      console.log('Event:', data)
      // {
      //   "eventType": "USER_UPDATED",
      //   "userId": "12345",
      //   "timestamp": "2024-10-27T14:30:00Z",
      //   "changes": { "email": "[email protected]" }
      // }
    }
  }
}

// Create user via REST
const newUser = await fetch('https://api.acme.com/api/v1/users', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer abc123',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Jane Smith',
    email: '[email protected]',
    phone: '+14155559999',
  }),
})

// Service automatically:
// 1. Receives REST POST
// 2. Transforms JSON to protobuf
// 3. Calls gRPC CreateUser method
// 4. Converts protobuf response to JSON
// 5. Returns 201 with Location header

// Monitor gateway performance
const metrics = await services.translator.getGatewayMetrics({
  serviceId: 'user-service',
  timeRange: 'last-hour',
})
console.log(metrics)
// {
//   totalRequests: 12345,
//   successful: 12289,
//   failed: 56,
//   avgLatency: 45, // ms
//   grpcLatency: 23, // ms to gRPC service
//   transformLatency: 22, // ms for transformation
//   byEndpoint: {
//     'GET /api/v1/users/:userId': { requests: 8234, avgLatency: 34 },
//     'POST /api/v1/users': { requests: 2345, avgLatency: 67 },
//     'GET /api/v1/users': { requests: 1766, avgLatency: 89 }
//   },
//   errors: {
//     'NOT_FOUND': 45,
//     'INVALID_ARGUMENT': 8,
//     'INTERNAL': 3
//   }
// }

Simple Translation (JSON ↔ XML):
- Tier 1 (0 - 1M messages/month):      $0.0005 per message = $500
- Tier 2 (1M - 10M messages/month):    $0.0003 per message = $3,000
- Tier 3 (10M+ messages/month):        $0.0001 per message

Complex Translation (EDI, SOAP):
- Tier 1 (0 - 100K messages/month):    $0.005 per message = $500
- Tier 2 (100K - 1M messages/month):   $0.003 per message = $3,000
- Tier 3 (1M+ messages/month):         $0.001 per message

Legacy Protocol (Mainframe, AS2):
- Tier 1 (0 - 50K messages/month):     $0.01 per message = $500
- Tier 2 (50K+ messages/month):        $0.005 per message

Standard Translation:
- $299/month per translation
- Includes 500K messages/month
- Overage: $0.0003 per message
- Protocols: REST, JSON, XML, GraphQL

Premium Translation:
- $999/month per translation
- Includes 1M messages/month
- Overage: $0.001 per message
- Protocols: SOAP, gRPC, EDI, HL7

Legacy Translation:
- $2,999/month per translation
- Includes 500K messages/month
- Overage: $0.003 per message
- Protocols: Mainframe, AS2, FTP

Starter:
- $500/month base
- 5 translations included
- 1M messages/month included
- Standard protocols only
- 99.9% SLA
- Overage: $0.0005 per message

Professional:
- $2,000/month base
- 20 translations included
- 10M messages/month included
- All protocols supported
- Schema management
- 99.95% SLA
- Overage: $0.0002 per message

Enterprise:
- $10,000/month base
- Unlimited translations
- 100M messages/month included
- Custom protocol support
- Dedicated infrastructure
- 99.99% SLA
- Premium support
- Overage: $0.0001 per message

Schema Management:               +$500/month
Custom Transformations:          +$0.0002 per message
Data Enrichment:                 +$0.0005 per message
Message Archiving:               +$0.10 per GB/month
Custom Protocol Support:         +$5,000 one-time setup
Dedicated Support:               +$2,000/month
Priority Processing:             +$1,000/month
99.99% SLA:                      +$1,500/month
HIPAA Compliance:                +$3,000/month

Translation:                 As above
Data Transfer In:            $0.01 per GB
Data Transfer Out:           $0.05 per GB
Message Storage:             $0.10 per GB/month (first 30 days)
Long-term Archive:           $0.01 per GB/month (>30 days)

// Maintain multiple schema versions
const schemaRegistry = {
  'order-v1': orderSchemaV1,
  'order-v2': orderSchemaV2,
  'order-v3': orderSchemaV3,
}

// Automatic version detection
const version = detectVersion(message)
const schema = schemaRegistry[`order-v${version}`]

// Forward compatibility
const translated = translate(message, {
  sourceSchema: schema,
  targetSchema: schemaRegistry['order-v3'],
  strategy: 'forward-compatible',
})

try {
  const translated = await services.translator.translate({
    source: 'soap',
    target: 'rest',
    message: soapMessage,
  })
} catch (error) {
  if (error.type === 'SchemaValidationError') {
    // Invalid source message
    logger.error('Invalid SOAP message', error.details)
  } else if (error.type === 'TransformationError') {
    // Translation failed
    logger.error('Translation failed', error.details)
  } else if (error.type === 'TargetSystemError') {
    // Target system unavailable
    logger.error('Target system error', error.details)
    // Retry later
  }
}

// Key metrics
const metrics = {
  translationsAttempted: 'counter',
  translationsSucceeded: 'counter',
  translationsFailed: 'counter',
  translationLatency: 'histogram',
  messageSize: 'histogram',
  schemaValidationErrors: 'counter',
}

// Alerting
const alerts = [
  {
    name: 'high-failure-rate',
    condition: 'translationsFailed / translationsAttempted > 0.05',
    severity: 'high',
  },
  {
    name: 'slow-translation',
    condition: 'p95(translationLatency) > 1000', // 1 second
    severity: 'warning',
  },
]