DataWeave Quickstart Guide

Design an example DataWeave transformation between two web services, one that handles SOAP requests and responses, and the other, an HTTP service whose resources are modeled in RAML. By the end of this guide you should understand how to:

The objective of this example is to send an HTTP request to a web service that places t-shirt orders based on information derived from a sales service (which outputs data in an XML structure). The service that accepts order requests requires a JSON input structure with values for the following set of keys:

The order processing service is defined in this example using RAML, a lightweight API-modeling language whose format is supported by the HTTP connector as a way of providing metadata into Studio.

The raw data from the sales service follows this structure:

It is always recommended you set up the other components of your flow before you configure the Transform Message component.

Use the About Transform Message Component to create the actual mapping between the input and output fields. Simply click and drag a field in the input side to a field in the output side. The most obvious task is to match similarly named fields together, thus helping to validate the output data:

Note: The address2 and size fields in the output side should remain unassigned.

Each of these actions draws a connection in the UI and generates DataWeave code in the text editor. At this point your DataWeave code should look like this:

The transform that we mapped in the previous section does not account for the fields size or address2 — you can provide these fields with an expression to populate them with the desired value.

The transformation possibilities are endless. Let’s make the transform we just completed more interesting by modifying the expression that populates the size field, into a conditional expression.

See how the expression that evaluates size has changed—​it uses the Unless and Otherwise operators to set the value to M unless the buyer’s name is Homer Simpson, in which case the shirt size, expressed as size becomes XXL.

The Transform Message component provides realtime feedback in the editor; a preview of what your output data would look like at run time, which is responsive to changes in the metadata structure in design time.

NOte: The Preview can only show an output preview when given valid input sample data.

You should get a response with an JSON body that has a single value, this is the order ID for the shirt order you just placed.

As with the other Transform Message component used in the first example of this Quickstart guide, in the input section you can see a tree that describes the data structure. As there’s no metadata about the desired output, there isn’t anything specified in the output section though. In this example we will write the DataWeave code manually to access more advanced features than are offered through the UI.

Click your Transform Message component. In the text editor pane, replace the curly brackets '{}' for 'payload'.

This is the simplest transformation you can carry out, it replicates the input structure but changes the format from JSON to Java. Whatever exists in the payload – including any child elements at any depth – is transformed directly into Java without changing any of its structure.

Open the Preview tab and see a tree describing the structure of the data, this is what a Java preview always looks like:

You can easily change the output directive from the default application/java to text/csv or to any other of the supported formats and see the results of that transformation.

Change the output directive to application/json so that the final result is identical to the sample data in the input. Later on you can transform this in more interesting ways.

A simple "payload" can be passed on without modifications if you want to preserve the data structure, however if you need to change any of the specific data fields in the payload, then you need to interact with the payload’s items individually.

As the input is a collection of elements, each describing a product in inventory, this code uses the map operator to treat each of these instances separately. What’s enclosed in curly brackets right after the map operator is executed once for each element in the collection. Within this operation, the code refers to the currently selected instance via the $ selector. The code in this example merely takes each item of the input and maps it to an identical field, with the exception of the size field, on which it applies the upper operator to change it to upper case.

If you open the Preview pane, you can see what this transform would output, given the sample as an input. The output is an object that contains a single array, each element in that array is one of the elements in the input, kept identical except that the size field appears in upper case.

The result from the previous step includes a products for which there is zero stock. We can easily filter those cases out using the Filter operator. Modify your DataWeave code to include filter $.count > 0 in the end. Your code should look like this:

The filter operator takes an array as an input validates each element in it against a condition. In this case, the array it takes is the resulting array created by the map operation, since the filter operation is only executed once the map operation is already compiled. Note that the condition uses the $ selector to signal the element of the array that is currently being revised.

If you open the Preview pane, you can see what this transform would output, given the sample as an input. The output’s array now contains one element less, which was the product that had 0 stock.

The elements in the output can be grouped conveniently. The groupBy operator can arrange a collection into a collection of collections where each has the elements that share a common value in one of their fields. Modify your DataWeave code to include groupBy $.size in the end. Your code should look like this:

The Group By operator takes an array as an input and focuses on one of its fields to group the elements according to the values in this field. In this case, the array it takes is the resulting array created by the map operation, since the groupBy operation is only executed once the map operation is already compiled. Note that the condition uses the $ selector to signal the element of the array that is currently being revised.

If you open the Preview section, you can see what this transform would output, given the sample as an input. The output now contains an object with a single "shirts" object in it, which contains an array. Each different available value for "size" will have a corresponding element inside the "shirts" object, each holding an array of objects with every product that matches that value for size.