dwl , MuleSoft’s powerful data transformation language, provides elegant solutions for manipulating complex data structures. One common challenge is flattening deeply nested JSON objects into a simple array. This article delves into a DataWeave script. It effectively flattens a JSON structure with nested “children” arrays. The script extracts objects containing “field” and “name” properties.
The Problem: Deeply Nested Data
Imagine a JSON structure where data is organized hierarchically using “children” arrays. This nesting can be arbitrarily deep, making it difficult to extract the desired information. For example, consider the following JSON:
{ "children": [ { "children": [ { "children": [ { "children": [ { "children": [ { "children": [ { "field": 1, "name": "Sandy" }, { "field": 2, "name": "Alex" } ] }, { "field": 3, "name": "Bob" } ] }, { "field": 4, "name": "Charlie" } ] }, { "field": 5, "name": "David" } ] }, { "field": 6, "name": "Eve" } ] }, { "field": 7, "name": "Frank" } ]}The goal is to transform this nested structure into a flat array of objects. Each object will contain the “field” and “name” properties.
The Solution: Recursive DataWeave Function
The following DataWeave script provides a concise and efficient solution:
%dw 2.0output application/jsonfun flattenChildren(data) = if (data is Array) data flatMap (item) -> flattenChildren(item) else if (data.children?) flattenChildren(data.children) else if (data.field?) [data] else []---flattenChildren(payload.children)Explanation:
flattenChildren(data)Function: This recursive function is the core of the solution. It takes adataobject as input and returns a flattened array.- Array Handling: The
if (data is Array)condition checks if the input is an array. If it is,flatMapis used to iterate through each element and recursively callflattenChildren.flatMapensures that the resulting arrays are flattened into a single array. - Nested “children” Traversal: The
else if (data.children?)condition checks if the input has a “children” property. If it does, the function recursively calls itself with the “children” array, effectively traversing deeper into the nested structure. - Leaf Node Extraction: The
else if (data.field?)condition identifies the leaf nodes, which contain the “field” and “name” properties. These nodes are wrapped in an array and returned. - Base Case: The
else []condition serves as the base case for the recursion. If the input is neither an array nor an object with “children” or “field” properties, an empty array is returned. - Main Expression: The
flattenChildren(payload.children)expression initiates the recursive process by calling the function with the “children” array from the input payload.
How it Works:
The script recursively traverses the JSON structure.
- It checks if the current data is an array, and if so, it processes each element.
- If the current data has a “children” property, it recursively calls itself with the “children” array.
- When it encounters an object with a “field” property, it extracts that object and adds it to the result.
- The
flatMapfunction ensures that all extracted objects are combined into a single flat array.
Benefits:
- Conciseness: The DataWeave script is remarkably concise and easy to understand.
- Recursion: Recursion allows for efficient traversal of arbitrarily deep nested structures.
- Flexibility: The script can be easily adapted to handle different JSON structures by modifying the conditions and extraction logic.
- Readability: Dataweave is a very readable language.
Conclusion:
This DataWeave script demonstrates a powerful and elegant approach to flattening nested JSON structures. By leveraging recursion and flatMap, you can efficiently extract the desired information from complex data. This technique is valuable for various data integration and transformation scenarios, particularly when dealing with hierarchical data.