DATAWEAVE on DecipherMiddleware

Logging within DataWeave Script

Wed, 08 Oct 2025 00:00:00 +0000

With the release of Mule runtime 4.10 edge version, a new version of DataWeave, i.e. 2.10, is also released. One of the new features introduced in this release is DataWeave Logging Configuration. The feature facilitates the developer to have granular control over logging. This leads to faster development and debugging.

There might be a question: loggers are there; Why can’t we just put a log connector and log the variable or payload? What benefits do we get by logging within DataWeave? Where can I use this feature?

🔭 Let’s explore DataWeave examples of varying complexities.

👴🏼 Old way of debugging 🔗

Let’s consider simple Mule flow which outputs a hello world!, using a transform message.

--- config: theme: 'neutral' --- flowchart LR A["HTTP(s)"] --> B["Transform"]

DataWeave 🔗

Difficulty level | ⭐️⚝⚝⚝⚝

Print “hello world!”

%dw 2.0
output text/plain
---
"hello world!"

Output 🔗

"hello world!"

To analyze the value of payload in logs; the best way would be to add a logger after the transform message.

--- config: theme: 'neutral' --- flowchart LR A["HTTP(s)"] --> B["Transform"] --> C["Logger"]

Console Output 🔗

INFO 2025-10-07 23:50:57,309 [[MuleRuntime].uber.01: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @6198f22a] [processor: dataweave-logsFlow/processors/1; event: 5e704830-a3aa-11f0-bf2a-beeb1f9526e2] org.mule.runtime.core.internal.processor.LoggerMessageProcessor: hello world!

Pretty simple and easy 🫠… ❌ Not anymore, let’s increase the difficulty of the DataWeave script.

DataWeave 🔗

Difficulty level | ⭐️⭐️⚝⚝⚝

Factorial of a number

%dw 2.0
output application/json
---
(1 to payload.inp) reduce $ * $$

Input 🔗

{
 "inp": 5
}

Output 🔗

Considering the same flow, logger output will be as follows:

Console Output 🔗

INFO 2025-10-08 10:38:31,654 [[MuleRuntime].uber.07: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @1d9d48be] [processor: dataweave-logsFlow/processors/1; event: d569a3a0-a404-11f0-bf2a-beeb1f9526e2] org.mule.runtime.core.internal.processor.LoggerMessageProcessor: 120

Yuhhuuu!!! We did it, we got the factorial of the number printed in the logs, and the same has been sent to the calling API.

Now, if we need to know the value on each iteration of the reduce function, how are the values updated at every iteration? 🤔🤔🤔

If it were any other programming language, such as Java, Python, Go, etc. The print command would suffice for the needs. But in DataWeave, how do we do so?

We are still in the old way of debugging 😞. Let’s modify the code to get the desired outcome.

%dw 2.0
output application/json
---
(1 to payload.inp) reduce(it,acc=[1]) -> acc + acc[it-1]*it

Output 🔗

[
 1,
 1,
 2,
 6,
 24,
 120
]

Console Output 🔗

INFO 2025-10-08 11:12:32,863 [[MuleRuntime].uber.06: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @1bbba791] [processor: dataweave-logsFlow/processors/1; event: 961820f0-a409-11f0-bf2a-beeb1f9526e2] org.mule.runtime.core.internal.processor.LoggerMessageProcessor: [
 1,
 1,
 2,
 6,
 24,
 120
]

payload[-1] will be desired output sent to the client.

By doing this, we have significantly altered the dwl script and made it heavier, catering to the use case.

Simple task and complicated solution 😢😢😢

😎 New way of debugging 🔗

Starting with DataWeave 2.10, logging can be configured to control the verbosity of log messages using standard log levels: Debug, Info, Warn, and Error.

Let’s start with an example and remove the logger connector to make the flow simpler.

--- config: theme: 'neutral' --- flowchart LR A["HTTP(s)"] --> B["Transform"]

DataWeave 🔗

Difficulty level | ⭐️⚝⚝⚝⚝

Print “hello world!”

%dw 2.0
output text/plain
---
logInfo("hello world!")

Console Output 🔗

INFO 2025-10-08 19:27:55,625 [[MuleRuntime].uber.06: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @ae03158] [processor: ; event: ca3bdad0-a44e-11f0-bf2a-beeb1f9526e2] org.mule.weave.v2.model.service.DefaultLoggingService$: "hello world!"

Yeah!!! We did it…

Let’s look a little closer 🔎

Difference in packages used for logging 🔗

Logger Connector: org.mule.runtime.core.internal.processor.LoggerMessageProcessor

DataWeave: org.mule.weave.v2.model.service.DefaultLoggingService$

In above example, info level is used, for different log levels, different DataWeave logging functions are available.

DataWeave Logging Functions 🔗

logWith<T>(level: LogLevel, prefix: String, value: T): T
logDebug<T>(prefix: String = "", value: T): T
logInfo<T>(prefix: String = "", value: T): T
logWarn<T>(prefix: String = "", value: T): T
logError<T>(prefix: String = "", value: T): T
log<T>(prefix: String = "", value: T): T

More info on each function at official docs

Now let’s increase DataWeave complexity…

DataWeave 🔗

Difficulty level | ⭐️⭐️⚝⚝⚝

Factorial of a number

%dw 2.0
output application/json
---
(1 to payload.inp) reduce logInfo($ * $$)

Input 🔗

{
 "inp": 5
}

Output 🔗

Console Output 🔗

INFO 2025-10-08 20:16:32,412 [[MuleRuntime].uber.06: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @46ac5059] [processor: ; event: 94c8ac00-a455-11f0-bf2a-beeb1f9526e2] org.mule.weave.v2.model.service.DefaultLoggingService$: 2
INFO 2025-10-08 20:16:32,413 [[MuleRuntime].uber.06: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @46ac5059] [processor: ; event: 94c8ac00-a455-11f0-bf2a-beeb1f9526e2] org.mule.weave.v2.model.service.DefaultLoggingService$: 6
INFO 2025-10-08 20:16:32,413 [[MuleRuntime].uber.06: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @46ac5059] [processor: ; event: 94c8ac00-a455-11f0-bf2a-beeb1f9526e2] org.mule.weave.v2.model.service.DefaultLoggingService$: 24
INFO 2025-10-08 20:16:32,413 [[MuleRuntime].uber.06: [dataweave-logs].dataweave-logsFlow.CPU_INTENSIVE @46ac5059] [processor: ; event: 94c8ac00-a455-11f0-bf2a-beeb1f9526e2] org.mule.weave.v2.model.service.DefaultLoggingService$: 120

With the above log, we can infer that 4 times computation was performed, and the values were printed by the DataWeave logger. It helps in debugging script a lot.

The story doesn’t end here… Let’s make the script a little more complex… But Scope for this blog ends here… 😔😔😔

Part 2 🔗

Part 2 coming soon….

Please share your valuable feedback 😊😊😊…

Experimenting Recursion in DataWeave - Fibonacci Series

Tue, 13 Jun 2023 17:20:00 +0000

In various programming languages, recursion is a process in which a method or function calls itself to simplify a complicated problem. Understanding recursive solution sometimes become difficult. Let’s try to solve a mathematical problem through recursion with a twist by using DataWeave. The Fibonacci series is a generic use case that recursion can solve. This is a very generic question in programming interviews.

Photo by Natalya Letunova on Unsplash

What is Fibonacci Series? 🔗

A Fibonacci series is a set of integers starting with 0 followed by 1, and a series continuing with the sum of the preceding two integers in the sequence. For example,

$$ F_n = 0,1,1,2,3,5,8,13,21,34… $$

Mathematically, 🔗

$$ \begin{align*} & F_0 = 0 \\ & F_1 = 1 \\ & F_n = F_{(n-1)} + F_{(n-2)} \end{align*} $$

Now transforming the above logic in the form of a recursive function to find the nth digit in the Fibonacci series.

DataWeave Recursive Function: 🔗

%dw 2.0
output application/json
fun fib_r(n)=
if (n<=0) 0
else if (n==1) 1
else
fib_r(n-1) + fib_r(n-2)
---
{
recursive:fib_r(9)
}

Output

{
 "recursive": 34
}

Testing on dataweave playground and increasing the value of n. The moment we increase the value beyond 27 , we get an ERROR.

ERROR? 🔗

The error shows the execution time taken by dataweave is more than 2.5 seconds. But how do we know how much time is taken by the recursive function? Is there a way to capture the execution time within DataWeave without any custom code/java modules? It’s a yes, The DataWeave has a utility module Timer, which can be used to capture execution time as well as the result of the functions.

%dw 2.0
import * from dw::util::Timer
output application/json
fun fib_r(n)=
if (n<=0) 0
else if (n==1) 1
else
fib_r(n-1) \+ fib_r(n-2)
---
{
recursive:time(()->fib_r(27)),
recursive_d:duration(()->fib_r(27))
}

Output

{
 "recursive": {
 "start": "2023-06-13T16:33:29.053017Z",
 "result": 610,
 "end": "2023-06-13T16:33:29.059367Z"
 },
 "recursive_d": {
 "time": 6,
 "result": 610
 }
}

Duration gives us the time taken by function execution in milliseconds and the time function output the start and end timestamp of the execution. With this, the execution time can be measured easily.

Now, the real issue is if we need to find the nth digit(greater than 27) in the Fibonacci series by optimizing space and time. How can that be done?

Going back to programming days, there is a way of using Tail Recursion. Now what exactly is tail recursion?

Tail recursion is using the recursive function as the last statement of the function. The benefit of this approach is it optimises the space as the function doesn’t need to keep the track of last 2 execution results. Since the result is populated as part of the last execution statement of the function. Putting the coding hats again for the DataWeave.

With the new function let’s find out the 500 th digit in the Fibonacci series.

%dw 2.0
import * from dw::util::Timer
output application/json
fun fib_r(n)=
if (n<=0) 0
else if (n==1) 1
else
fib_r(n-1) \+ fib_r(n-2)
//tail recursion
fun fib_tr(n, x=0, y=1)=
if(n<=0)
x
else if (n==1)
y
else
fib_tr(n-1,y,x+y)
---
{
recursive:time(()->fib_r(5)),
tailRecursive:time(()->fib_tr(500))
}

Output

{
 "recursive": {
 "start": "2023-06-13T16:48:46.007784Z",
 "result": 5,
 "end": "2023-06-13T16:48:46.007897Z"
 },
 "tailRecursive": {
 "start": "2023-06-13T16:48:46.007902Z",
 "result": 139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125,
 "end": "2023-06-13T16:48:46.010339Z"
 }
}

In nearly 4 milliseconds, the new tail recursive function can give results for the **500 th digit **in the series.

Can we improve the timings further? 🔗

In dataweave, we have a “reduce” function, which can be used to get output for the Fibonacci series even faster. Re-writing the logic with the “reduce” function is kind of challenging. After multiple trials and errors, one way is as below.

%dw 2.0
import * from dw::util::Timer
output application/json
fun fib_r(n)=
if (n<=0) 0
else if (n==1) 1
else
fib_r(n-1) \+ fib_r(n-2)
//tail recursion
fun fib_tr(n, x=0, y=1)=
if(n<=0)
x
else if (n==1)
y
else
fib_tr(n-1,y,x+y)
//with reduce
fun fib_rr(n)=
if(n<=0)
0
else
if(n==1)
1
else
([2 to n][0] reduce ((i,acc=[0, 1]) -> acc + (acc[i-1] + acc[i-2])))[n]
---
{
recursive:time(()->fib_r(5)),
tailRecursive:time(()->fib_tr(500)),
reduce:time(()->fib_rr(500))
}

Output

{
 "recursive": {
 "start": "2023-06-13T17:04:41.724469Z",
 "result": 5,
 "end": "2023-06-13T17:04:41.72455Z"
 },
 "tailRecursive": {
 "start": "2023-06-13T17:04:41.724555Z",
 "result": 139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125,
 "end": "2023-06-13T17:04:41.726913Z"
 },
 "reduce": {
 "start": "2023-06-13T17:04:41.726923Z",
 "result": 139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125,
 "end": "2023-06-13T17:04:41.729307Z"
 }
}

The above DataWeave script is one of the many ways to solve the problem. On comparing all three approaches, the solution using reduce function performs best of all.

Please share your valuable feedback 😊😊😊

[Mule 4]Catch numeric exceptions inside DataWeave

Sat, 16 Jul 2022 04:32:00 +0000

Numbers are a simple data type, but become complex in real-time integration transformation scenarios. Number data type, we consider number system in base 10 and perform all kinds of arithmetic operations e.g. +, -, *, / etc. We do this starting in childhood: multiply two numbers, divide one number by another, or add two numbers. Now, where is the tricky part 🤔? Let’s start with, various tricky aspects and possible remedies to these.

This article is published on the MuleSoft Community LinkedIn page.

To continue reading please visit the below link.

https://www.linkedin.com/pulse/mule-4catch-numeric-exceptions-inside-dataweave-mulesoftcommunity

Please share your valuable feedback 😊😊😊

Number System Conversion in MuleSoft(Mule 4) using Dataweave

Wed, 23 Mar 2022 05:51:00 +0000

The number 11, we call it eleven in the decimal system. Still, it can be a representation of three in a binary system or it can be seventeen in a hexadecimal system. The actual value of a number depends on the base it is calculated. It is interesting changing the base changes the value of the representation. Let us assume in some integration flow we are getting values in binary number system but target system accepts values in a decimal system or hexadecimal system or vice versa.

Examples depicting values in various number systems:

#	DECIMAL	BINARY	HEXADECIMAL	OCTAL
	BASE 10	BASE 2	BASE 16	BASE 8
I	5	101	5	5
II	14	1110	E	16
III	54	110110	36	66
IV	123	1111011	7B	173
V	240	11110000	F0	360

In our engineering days, we have studied a lot about number systems. Below is the mathematical representation of conversion logic.

Let us assume:

d, represents the nth digit.
b, represents the base.
n, represents the number of digits

Value(V) of number with base b in the decimal system will be:

$$ V_{10} = (Σd*b(n-1))_{10} $$

Let us take example number 7B in hexadecimal(base 16) and use the above formula to convert to decimal.

$V_{10} = (7 * 16^{(2-1)} + 11 * 16^{(1-1)})_{10}$

$V_{10} = (112 + 11)_{10}$

$V_{10} = (123)_{10}$

The above conversion was through pen and paper but how to do this in Mule?

Dataweave has built-in functions under the dw::core::Numbers module, which can help us to perform these conversions without writing complex logic. To convert to decimal values we have below 3 functions. Let’s see usage one by one.

1. fromHex() 🔗

This function helps to convert hexadecimal value to decimal. This function takes a hexadecimal string as input and gives decimal value as output. Example:

%dw 2.0
import fromHex from dw::core::Numbers
output application/json
---
fromHex("7B")

Output:

2. fromBinary() 🔗

This function helps to convert the binary string value to decimal value. This function takes a binary string as input and gives decimal value as output. Example:

%dw 2.0
import fromBinary from dw::core::Numbers
output application/json
---
fromBinary("110110")

Output

3. fromRadixNumber() 🔗

This function helps to convert the numeric value in any base to decimal value. This function takes a number string and base as input and gives decimal value as output. Example:

%dw 2.0
import fromRadixNumber from dw::core::Numbers
output application/json
---
fromRadixNumber("360",8)

Here, 360 is the number in octal (base 8) and 8 represents the base.

Output

The above three ways were to convert numeric values from any base to decimal values. Dataweave also provides functions to do the reverse which is converting a decimal number to any base.

4. toHex() 🔗

This function helps to convert a decimal value to a hexadecimal value. This function takes a decimal number as input and gives a hexadecimal string value as output. Example:

%dw 2.0
import toHex from dw::core::Numbers
output application/json
---
toHex(54)

Output

"36"

5. toBinary() 🔗

This function helps to convert a decimal value to a binary string value. This function takes a decimal number as input and gives a binary string value as output. Example:

%dw 2.0
import toBinary from dw::core::Numbers
output application/json
---
toBinary(54)

Output

"110110"

6. toRadixNumber() 🔗

This function helps to convert a decimal value to a numeric string value as per the specified base. This function takes a decimal number and base as input and gives a string output of decimal value in the specified base. Example:

%dw 2.0
import toRadixNumber from dw::core::Numbers
output application/json
---
toRadixNumber(54,8)

Output

"66"

The above output is in base 8 or in octal.

Direct Conversion 🔗

What if we want to convert numeric value in base 4 directly to numeric value with base 3. In such a case, we can use a combination of fromRadixNumber and toRadixNumber.

$$ (54)_{10} = (312)_{4} = (2000)_{3} $$

Dataweave

%dw 2.0
import * from dw::core::Numbers
output application/json
---
toRadixNumber(fromRadixNumber(312,4),3)

Output

"2000"

References: 🔗

https://docs.mulesoft.com/dataweave/2.4/dw-numbers

Please share your valuable feedback 😊😊😊

Creating and Using Key-Value Lookups in MuleSoft (Mule 4)

Wed, 16 Feb 2022 17:59:00 +0000

Lookups or key-value pairs are really helpful while developing integrations. Suppose, we get a value from the source system but the target system requires a corresponding value for that key(incoming data). One way is to store such cross-reference in a database table and fetch values. What if, these values are not changed frequently, and accessing a database will probably pose an overhead. A better approach would be to have a static lookup file included within the Mule application. This lookup file can be a .csv, JSON, XML, Excel, etc. file. For simplicity, in this blog, we will be using CSV files as an example for creating and using lookups in Mule 4. A CSV file is easy to maintain and use. Let’s start with the below use case.

Let’s take a use case of Country codes. From the source system, the country field contains Country Name e.g. India but our target system requires 2 character Country Code e.g. IN as input in one of the fields. Now such fields will hardly change in a real-time scenario. We can create a csv file(country_codes.csv) as shown below.

CSV File- country_codes.csv 🔗

Country,CountryCode 
India,IN 
Indonesia,ID 
Philippines,PH 
United States,US 
Russia,RU 
Netherlands,NL 
Czech Republic,CZ

From the source system, we are getting an address payload as shown below.

Source Payload 🔗

{
 "address": {
 "streetAdd": "street1",
 "streetAdd2": "address2",
 "city": "City1",
 "state": "State1",
 "country": "Indonesia",
 "zip": "123456"
 }
}

Our target system expects only country code to be sent in the payload. Below are the steps to accomplish this

STEPS: 🔗

1. Place the file country_codes.csv under src/main/resources. In this example, we will place it inside a folder named lookup. If you are using a different folder update classpath accordingly.

2. Now, we can refer to the file inside the dataweave using the readUrl() dataweave function.

3. Let us assume input data is stored in payload, our dataweave transformation will look as below.

%dw 2.0
output application/json
var csvData = readUrl("classpath://lookup/country_codes.csv","application/csv")
fun lookupCC(country: String) : String =
(csvData filter ((item, index) -> item.Country == country))[0].CountryCode as String
---
add:{
addressLine: payload.address.streetAdd ++ " " ++ payload.address.streetAdd2,
city: payload.address.city,
state: payload.address.state,
countryCode: lookupCC(payload.address.country)
}

4. We have created a function called lookupCC() which will take one String input and match the incoming value of Country in the lookup csv file and give the country code as output. The output of the above code will look like this:

Output Payload 🔗

{
 "add": {
 "addressLine": "street1 address2",
 "city": "City1",
 "state": "State1",
 "countryCode": "ID"
 }
}

5. What if the country name is not available in the csv file, the output will come as null. In such cases, we can update the function and provide the default value. For example:

fun lookupCC(country: String) : String =
(csvData filter ((item, index) -> item.Country == country))[0].CountryCode as String default "--"

If we don’t find any matching value in the lookup file it will default country code as “–”.

Similarly, we can extend the function and the csv file to fetch values with multiple inputs and conditions.

References: 🔗

Please share your valuable feedback 😊😊😊

Playing with XML Namespaces in Mule 4 Dataweave

Sat, 22 Jan 2022 15:52:00 +0000

Today, the world is full of REST APIs which use JSON as a major message type. But we have a lot of applications and APIs in the middleware world which rely on XML message structures. XML messages are a bit more complex than JSON messages, as in XML messages namespaces play a vital role. A miss in the namespace can lead to errors that are sometimes unseen to normal eyes. In this blog, we will discuss various ways by which we can handle the transformation of XML messages with or without namespaces in Mule 4 using Dataweave.

Transforming XML messages without namespaces
Transforming XML messages with namespaces

1. Transforming XML messages without namespaces 🔗

This conversion is pretty simple, all we need to consider is XPath and do the mapping accordingly. This is similar to the JSON data transformation Let’s take an example of 2 XMLs, wherein both input and output XMLs don’t have namespaces. The output we need to specify is application/xml.

INPUT:

<InputRoot>
 <contact>
 <firstName>Test</firstName>
 <lastName>Data</lastName>
 <address>
 <street1>Street1</street1>
 <street2>Street2</street2>
 <city>City</city>
 <state>State</state>
 <country>Country</country>
 </address>
 </contact>
</InputRoot>

Suppose we want to extract the value of country from the above XML message. All we need to do is traverse to the node as we do in the case of JSON transformations i.e. (Assuming data is in the payload variable) payload.InputRoot.contact.address.country . Below is the dataweave file for the transformation transforming the data to a different XML format.

DATAWEAVE :

%dw 2.0
output application/xml
---
OutputRoot:{
Contact:{
Name: payload.InputRoot.contact.firstName ++ payload.InputRoot.contact.lastName,
Address :{
Street: payload.InputRoot.contact.address.street1 ++ payload.InputRoot.contact.address.street2 ,
City: payload.InputRoot.contact.address.city,
State:payload.InputRoot.contact.address.state
}
}
}

OUTPUT:

<OutputRoot>
 <Contact>
 <Name>TestData</Name>
 <Address>
 <Street>Street1Street2</Street>
 <City>City</City>
 <State>State</State>
 </Address>
 </Contact>
</OutputRoot>

Above is the output for the dataweave file.

2. Transforming XML messages with namespaces. 🔗

Namespaces are really important for various systems to understand the element and its data. As the same element name with a different namespace corresponds to 2 different meanings. For example element name in an XML message with a namespace corresponding to the account namespace, is different from the element name corresponding to the contact namespace. So the business meaning of an element differs and so does the representation. An element belonging to a particular namespace will have a target namespace denoted by xmlns attribute. In some cases, namespaces are declared as attributes of elements and are referenced as prefixes like:

<acc:name xmlns:acc="http://deciphermiddleware.in/ns/account"/>
<cont:name xmlns:cont="****http://deciphermiddleware.in/ns/contact"/>

Let’s take the below example:

INPUT:

<InputRoot xmlns="http://deciphermiddleware.in/ns/sample/data">
 <cont:contact xmlns:cont="http://deciphermiddleware.in/ns/sample/contact">
 <cont:firstName>Test</cont:firstName>
 <cont:lastName>Data</cont:lastName>
 <cont:address xmlns:add="http://deciphermiddleware.in/ns/sample/address">
 <add:street1>Street1</add:street1>
 <add:street2>Street2</add:street2>
 <add:city>City</add:city>
 <add:state>State</add:state>
 <add:country>Country</add:country>
 </cont:address>
 </cont:contact>
</InputRoot>

Now, in the above case, we have multiple namespaces. To deal with such scenarios we need to declare namespaces in the Dataweave file.

We can declare the namespace in the following way.

%dw 2.0
output application/xml
ns ns0 http://deciphermiddleware.in/ns/sample/data
ns cont http://deciphermiddleware.in/ns/sample/contact
ns add http://deciphermiddleware.in/ns/sample/address

In dataweave, an element with namespace will be denoted by ns# Element (ns denotes namespace prefix as declared, Element is the name of node or element of XML and, # acts as separator)

Suppose we need to extract data of the country, now dataweave expression for the same will be “payload.ns0#InputRoot.cont#contact.cont#address.add#country "

Combining the above parameters, below is a sample dataweave file that will output the XML message generated from the above sample input XML, having different namespaces.

DATAWEAVE:

%dw 2.0
output application/xml
ns ns0 http://deciphermiddleware.in/ns/sample/data
ns cont http://deciphermiddleware.in/ns/sample/contact
ns add http://deciphermiddleware.in/ns/sample/address
ns ns1 http://deciphermiddleware.in/ns/sample/data1
ns cont1 http://deciphermiddleware.in/ns/sample/contact1
ns add1 http://deciphermiddleware.in/ns/sample/address1
---
ns1#OutputRoot:{
cont1#Contact:{
cont1#Name: payload.ns0#InputRoot.cont#contact.cont#firstName ++ payload.ns0#InputRoot.cont#contact.cont#lastName,
add1#Address :{
add1#Street: payload.ns0#InputRoot.cont#contact.cont#address.add#street1 ++ payload.ns0#InputRoot.cont#contact.cont#address.add#street2 ,
add1#City: payload.ns0#InputRoot.cont#contact.cont#address.add#city,
add1#State:payload.ns0#InputRoot.cont#contact.cont#address.add#state,
add1#Country:payload.ns0#InputRoot.cont#contact.cont#address.add#country
}
}
}

Below is the output for the above dataweave.

OUTPUT:

<ns1:OutputRoot xmlns:ns1="http://deciphermiddleware.in/ns/sample/data1">
 <cont1:Contact xmlns:cont1="http://deciphermiddleware.in/ns/sample/contact1">
 <cont1:Name>TestData</cont1:Name>
 <add1:Address xmlns:add1="http://deciphermiddleware.in/ns/sample/address1">
 <add1:Street>Street1Street2</add1:Street>
 <add1:City>City</add1:City>
 <add1:State>State</add1:State>
 <add1:Country>Country</add1:Country>
 </add1:Address>
 </cont1:Contact>
</ns1:OutputRoot>

References: 🔗

https://docs.mulesoft.com/dataweave/2.3/dataweave-cookbook-include-xml-namespaces

Please share your valuable feedback 😊😊😊

Tips and tricks to handle dateTime formats in Mule 4

Sun, 12 Dec 2021 17:17:00 +0000

We generally come across various scenarios while developing integrations, wherein we have to deal with multiple formats of date, time, or DateTime. Sometimes source systems can send date data in only one format which may or may not be accepted by target systems, which we have to handle using dataweave expressions. In this blog, we will be going through a couple of generic scenarios which we come across frequently. For example, if we use now() in dataweave, we get an output as below.

DataWeave expression:

%dw 2.0
output application/json
---
now()

Output:

"2021-12-12T14:27:48.064709Z"

The above output is in the format of DateTime, and from this, it is easy to convert or extract and date or time values.

Scenario #1 🔗

What if we get date time in some different format, for e.g. “2021/12/12 14.27.48 " and we just need to extract date and time in a different format as “12-12-2021 14:27:48 “. The best way is to cast the input date string to LocalDateTime by providing format and then convert to the string by providing the desired format.

DataWeave expression:

%dw 2.0
output application/json
---
"2021/12/12 14.27.48" as LocalDateTime {format:"yyyy/MM/dd HH.mm.ss"} as String {format:"dd-MM-yyyy HH:mm:ss"}

Output:

"12-12-2021 14:27:48"

Scenario #2 🔗

Sometimes, we have to insert dateTime to databases like SQL Server, Oracle database, etc. The generally accepted format for the database date column through Mule4 is “yyyy-MM-dd HH:mm:ss "

DataWeave expression:

%dw 2.0
output application/json
---
now() as String {format:"yyyy-MM-dd HH:mm:ss"}

Output:

"2021-12-12 14:27:48"

Scenario #3 🔗

What if we want to extract year and append Y in the end to output for example “2021Y”. If we use the format as “yyyyY” or “yY”, the output will come as a year repeated 2 times. The reason is y or Y is formatting character. If we want explicit Y to be displayed, one way could be to extract Year and then concatenate year with Y. Another way is to escape the formatting character by enclosing it in ‘’. For example:

DataWeave expression:

%dw 2.0
output application/json
---
now() as String {format:"yyyy'Y'"}

Output:

"2021Y"

Tabular representation of various formatting characters that can be used.

DateTime: “2021-08-09T15:37:29.519633+05:30”

Character(s)	Description	Example
y	Year of the era (BCE or CE) or calendar year	2021
yy	Calendar Year limit to 2 digits	21
Y	Week based year	2021
YY	Week based year limit to 2 digits	21
u	Calendar Year without era (BCE or CE)	2021
uu	Calendar Year limit to 2 digits	21
M	The month with no leading 0	8
MM	The month with leading 0	08
MMM	Month name with 3 characters	Aug
MMMM	Complete Month name	August
d	Day of the Month	09
D	Day of the Year	221
E	Abbreviated day of the Week	Mon
EEEE	Day of the Week	Monday
h	An hour in 12 hour clock (1-12)	03
H	An hour in 24 hour clock (0-23)	03
m	Minute of the hour	37
s	Second of the Minute	29
S	Fraction of the second	5
a	AM/PM	PM
Z	Timezone Offset	+0530
ZZZZ	Timezone Offset	GMT+05:30

References: 🔗

https://docs.mulesoft.com/dataweave/2.3/dataweave-cookbook-format-dates

Please share your valuable feedback 😊😊😊