MuleSoft Migration — Camel-Kit

Overview

MuleSoft to Apache Camel 4.x is one of the most common migration paths. Camel-Kit understands Mule XML flows, DataWeave 1.x/2.x, connectors, error handling, choice routers, scatter-gather, sub-flows, and flow references.

Key features:

Automatic DataWeave to XSLT conversion via DataMapper
Component mapping from Mule connectors to Camel components
Preservation of error handling semantics
Flow-ref to direct: route conversion

What Gets Parsed

Camel-Kit analyzes the following MuleSoft artifacts:

Artifact	Location
Flow XML	`src/main/mule/`
DataWeave scripts	`.dwl` files
Connector configurations	XML configs
POM dependencies	`pom.xml`

Connector Mapping

Camel-Kit maps MuleSoft connectors to their Apache Camel equivalents:

Mule Connector	Camel Component
HTTP Listener	`camel-rest`, `camel-jetty`
Database	`camel-sql`, `camel-jdbc`
File	`camel-file`
JMS	`camel-jms`
Kafka	`camel-kafka`
Salesforce	`camel-salesforce`
FTP	`camel-ftp`
Email	`camel-mail`
VM	`camel-seda`

Note: If there is no direct equivalent, Camel-Kit flags the connector and suggests alternatives.

Common Migration Scenarios

HTTP-to-Database

A typical HTTP endpoint that queries a database based on URI parameters.

Mule XML

<flow name="get-customer">
  <http:listener path="/customer/{id}"/>
  <db:select config-ref="dbConfig">
    <db:sql>SELECT * FROM customers WHERE id = :id</db:sql>
    <db:input-parameters>
      #[{'id': attributes.uriParams.id}]
    </db:input-parameters>
  </db:select>
</flow>

Camel YAML

- route:
    id: get-customer
    from:
      uri: "platform-http:/customer/{id}"
      parameters:
        httpMethodRestrict: GET
      steps:
        - to: "sql:SELECT * FROM customers WHERE id = :#${header.id}"

Scatter-Gather

Parallel processing pattern that calls multiple services concurrently and aggregates results.

Mule XML

<scatter-gather>
  <route>
    <http:request url="http://inventory-service/check"/>
  </route>
  <route>
    <http:request url="http://pricing-service/price"/>
  </route>
</scatter-gather>

Camel YAML

- multicast:
    parallelProcessing: true
    steps:
      - to: http://inventory-service/check
      - to: http://pricing-service/price
- aggregate:
    strategy: GroupedBodyAggregationStrategy

DataWeave to XSLT

DataWeave transformations are automatically converted to XSLT for Apache Camel.

DataWeave

%dw 2.0
output application/xml
---
{
  Order: {
    ID: payload.orderId,
    Customer: payload.customer.name,
    Items: payload.items map {
      Item: {
        SKU: $.sku,
        Qty: $.quantity
      }
    }
  }
}

XSLT

<xsl:stylesheet version="2.0">
  <xsl:template match="/">
    <Order>
      <ID><xsl:value-of select="/order/orderId"/></ID>
      <Customer><xsl:value-of select="/order/customer/name"/></Customer>
      <Items>
        <xsl:for-each select="/order/items/item">
          <Item>
            <SKU><xsl:value-of select="sku"/></SKU>
            <Qty><xsl:value-of select="quantity"/></Qty>
          </Item>
        </xsl:for-each>
      </Items>
    </Order>
  </xsl:template>
</xsl:stylesheet>

Sub-Flow Conversion

Mule sub-flows and flow references are converted to Camel direct routes.

Mule XML

<flow name="main-flow">
  <http:listener path="/api"/>
  <flow-ref name="validate-order"/>
</flow>
<sub-flow name="validate-order">
  <validation:is-not-null value="#[payload.orderId]"/>
</sub-flow>

Camel YAML

- route:
    id: main-flow
    from:
      uri: "platform-http:/api"
      parameters:
        httpMethodRestrict: POST
      steps:
        - to: "direct:validate-order"
- route:
    id: validate-order
    from:
      uri: "direct:validate-order"
      steps:
        - validate:
            simple: "${body.orderId} != null"

Choice Router

Conditional routing based on message content.

Mule XML

<choice>
  <when expression="#[payload.amount > 1000]">
    <flow-ref name="high-value-processing"/>
  </when>
  <otherwise>
    <flow-ref name="standard-processing"/>
  </otherwise>
</choice>

Camel YAML

- choice:
    when:
      - simple: ${body.amount} > 1000
        steps:
          - to: direct:high-value-processing
    otherwise:
      steps:
        - to: direct:standard-processing