dw::Core

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "result" : [0, 1, 2] ++ ["a", "b", "c"] }

  
1

  
{ "result": [0, 1, 2, "a", "b", "c"] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "a" : [0, 1, true, "my string"] ++ [2, [3,4,5], {"a": 6}] }

  
1

  
{ "a": [0, 1, true, "my string", 2, [3, 4, 5], { "a": 6}] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "name" : "Mule" ++ "Soft" }

  
1

  
{ "name": "MuleSoft" }

  
1
2
3
4

  
%dw 2.0
output application/xml
---
{ concat : {aa: "a", bb: "b"} ++ {cc: "c"} }

  
1
2
3
4
5
6

  
<?xml version="1.0" encoding="UTF-8"?>
<concat>
  <aa>a</aa>
  <bb>b</bb>
  <cc>c</cc>
</concat>

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "LocalDateTime" : (|2017-10-01| ++ |23:57:59|) }

  
1

  
{ "LocalDateTime": "2017-10-01T23:57:59" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "LocalDateTime" : (|23:57:59| ++ |2003-10-01|) }

  
1

  
{ "LocalDateTime": "2017-10-01T23:57:59" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ |2017-10-01| ++ |23:57:59-03:00|, |2017-10-01| ++ |23:57:59Z| ]

  
1

  
[ "2017-10-01T23:57:59-03:00", "2017-10-01T23:57:59Z" ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
|2018-11-30| ++ |23:57:59+01:00|

  
1

  
"2018-11-30T23:57:59+01:00"

  
1
2
3
4
5
6
7
8

  
%dw 2.0
output application/json
---
{
  "DateTime1" : (|23:57:59| as Time) ++ |2017-10-01|,
  "DateTime2" : |23:57:59Z| ++ |2017-10-01|,
  "DateTime3" : |2017-10-01| ++ |23:57:59+02:00|
}

  
1
2
3
4
5

  
{
  "DateTime1": "2017-10-01T23:57:59Z",
  "DateTime2": "2017-10-01T23:57:59Z",
  "DateTime3": "2017-10-01T23:57:59+02:00"
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "DateTime" : (|2017-10-01| ++ |-03:00|) }

  
1

  
{ "DateTime": "2017-10-01T00:00:00-03:00" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "DateTime" : |-03:00| ++ |2017-10-01| }

  
1

  
{ "DateTime": "2017-10-01T00:00:00-03:00" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "DateTime" : (|2003-10-01T23:57:59| ++ |-03:00|) }

  
1

  
{ "DateTime": "2003-10-01T23:57:59-03:00 }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "TimeZone" : (|-03:00| ++ |2003-10-01T23:57:59|) }

  
1

  
{ "TimeZone": "2003-10-01T23:57:59-03:00" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "Time" : (|23:57| ++ |-03:00|) }

  
1

  
{ "Time": "23:57:00-03:00" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "Time" : (|-03:00| ++ |23:57|) }

  
1
2
3

  
{
  "Time": "23:57:00-03:00"
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "a" : [0, 1, 1, 2] -- [1,2] }

  
1

  
{ "a": [0] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "hello" : "world", "name" : "DW" } -- { "hello" : "world"}

  
1

  
{ "name": "DW" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "yes" : "no", "good" : "bad", "old" : "new" } -- ["yes", "old"]

  
1

  
{ "good": "bad" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "hello" : "world", "name" : "DW" } -- ["hello" as Key]

  
1

  
{ "name": "DW" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ abs(-2), abs(2.5), abs(-3.4), abs(3) ]

  
1

  
[ 2, 2.5, 3.4, 3 ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ a: avg([1, 1000]), b: avg([1, 2, 3]) }

  
1

  
{ "a": 500.5, "b": 2.0 }

  
1
2
3
4
5

  
%dw 2.0
output application/json
---

[ ceil(1.5), ceil(2.1), ceil(3) ]

  
1

  
[ 2, 3, 3 ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ 1, 2, 3, 4 ] contains(2)

  
1

  
true

  
1
2
3
4

  
%dw 2.0
output application/json
---
ContainsRequestedItem: payload.root.*order.*items contains "3"

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  
<?xml version="1.0" encoding="UTF-8"?>
<root>
    <order>
      <items>155</items>
    </order>
    <order>
      <items>30</items>
    </order>
    <order>
      <items>15</items>
    </order>
    <order>
      <items>5</items>
    </order>
    <order>
      <items>4</items>
      <items>7</items>
    </order>
    <order>
      <items>1</items>
      <items>3</items>
    </order>
    <order>
        null
    </order>
</root>

  
1

  
{ "ContainsRequestedItem": true }

  
1
2
3
4

  
%dw 2.0
output application/json
---
"mulesoft" contains("mule")

  
1

  
true

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ ContainsString : payload.root.mystring contains("me") }

  
1
2

  
<?xml version="1.0" encoding="UTF-8"?>
<root><mystring>some string</mystring></root>

  
1

  
{ "ContainsString": true }

  
1
2
3
4

  
%dw 2.0
output application/json
---
contains("mulesoft", /[e-g]/)

  
1

  
true

  
1
2
3
4

  
%dw 2.0
output application/json
---
ContainsString: payload.root.mystring contains /s[t|p]rin/

  
1
2

  
<?xml version="1.0" encoding="UTF-8"?>
<root><mystring>A very long string</mystring></root>

  
1

  
{ "ContainsString": true }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ days : daysBetween('2016-10-01T23:57:59-03:00', '2017-10-01T23:57:59-03:00') }

  
1

  
 { "days" : 365 }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[0, 1, 2, 3, 3, 2, 1, 4] distinctBy (value) -> { "unique" : value }

  
1

  
[ 0, 1, 2, 3, 4]

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  
%dw 2.0
output application/json
var record =  {
  "title": "XQuery Kick Start",
  "author": [
    "James McGovern",
    "Per Bothner",
    "Kurt Cagle",
    "James Linn",
    "Kurt Cagle",
    "Kurt Cagle",
    "Kurt Cagle",
    "Vaidyanathan Nagarajan"
  ],
  "year":"2000"
}
---
{
    "book" : {
      "title" : record.title,
      "year" : record.year,
      "authors" : record.author distinctBy $
    }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13

  
{
  "book": {
    "title": "XQuery Kick Start",
    "year": "2000",
    "authors": [
      "James McGovern",
      "Per Bothner",
      "Kurt Cagle",
      "James Linn",
      "Vaidyanathan Nagarajan"
    ]
  }
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
{a : "b", a : "b", A : "b", a : "B"} distinctBy (value) -> { "unique" : value }

  
1

  
{ "a": "b", "a": "B" }

  
1
2
3
4
5
6
7
8
9

  
%dw 2.0
output application/xml
---
{
   book : {
     title : payload.book.title,
     authors: payload.book.&author distinctBy $
   }
}

  
1
2
3
4
5
6
7
8

  
<book>
  <title> "XQuery Kick Start"</title>
  <author>James Linn</author>
  <author>Per Bothner</author>
  <author>James McGovern</author>
  <author>James McGovern</author>
  <author>James McGovern</author>
</book>

  
1
2
3
4
5
6
7
8

  
<book>
  <title> "XQuery Kick Start"</title>
  <authors>
      <author>James Linn</author>
      <author>Per Bothner</author>
      <author>James McGovern</author>
  </authors>
</book>

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ "Mariano" endsWith "no", "Mariano" endsWith "to" ]

  
1

  
[ true, false ]

  
1

  
[9,2,3,4,5] filter (value, index) -> (value > 2)

  
1

  
[9,3,4,5]

  
1

  
[9,2,3,4,5] filter ((value, index) -> (index > 2))

  
1

  
[4,5]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[9, 2, 3, 4, 5] filter (($$ > 1) and ($ < 5))

  
1

  
[3,4]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{"a" : "apple", "b" : "banana"} filterObject ((value) -> value == "apple")

  
1

  
{ "a": "apple" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{"letter1": "a", "letter2": "b", "id": 1} filterObject ((value, key) -> key startsWith "letter")

  
1

  
{ "letter1": "a", "letter2": "b" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "1": "a", "2": "b", "3": "c"} filterObject ((value, key, index) -> index < 1)

  
1

  
{ "1": "a" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
["Bond", "James", "Bond"] find "Bond"

  
1

  
[0,2]

  
1
2
3
4

  
%dw 2.0
output application/json
---
"I heart DataWeave" find /\w*ea\w*(\b)/

  
1

  
[ [2,7], [8,17] ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
"aabccdbce" find "a"

  
1

  
[0,1]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ [3,5], [0.9,5.5] ] flatMap (value, index) -> value

  
1

  
[ 3, 5, 0.9, 5.5]

  
1
2
3
4

  
%dw 2.0
output application/json
---
flatten([ [0.0, 0], [1,1], [2,3], [5,8] ])

  
1

  
[ 0.0, 0 1, 1, 2, 3, 5, 8 ]

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  
%dw 2.0
var myData =
{ user : [
   {
     group : "dev",
     myarray : [
       { name : "Shoki", id : 5678 },
       { name : "Mariano", id : 9123 }
     ]
   }
 ]
}
output application/json
---
flatten(myData.user.myarray)

  
1
2
3
4
5
6
7
8
9
10

  
[
  {
    "name": "Shoki",
    "id": 5678
  },
  {
    "name": "Mariano",
    "id": 9123
  }
]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ floor(1.5), floor(2.2), floor(3) ]

  
1

  
[ 1, 2, 3]

  
1
2
3
4

  
%dw 2.0
output application/json
---
["a","b","c"] groupBy (item, index) -> index

  
1

  
{ "2": [ "c" ], "1": [ "b" ], "0": [ "a" ] }

  
1
2
3
4
5
6
7
8
9

  
%dw 2.0
var myArray = [
   { "name": "Foo", "language": "Java" },
   { "name": "Bar", "language": "Scala" },
   { "name": "FooBar", "language": "Java" }
]
output application/json
---
myArray groupBy (item) -> item.language

  
1
2
3
4
5
6
7
8
9

  
{
  "Scala": [
    { "name": "Bar", "language": "Scala" }
  ],
  "Java": [
    { "name": "Foo", "language": "Java" },
    { "name": "FooBar", "language": "Java" }
  ]
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  
%dw 2.0
var myVar = { menu: {
    header: "Move Items",
    items: [
        {"id": "internal"},
        {"id": "left", "label": "Move Left"},
        {"id": "right", "label": "Move Right"},
        {"id": "up", "label": "Move Up"},
        {"id": "down", "label": "Move Down"}
    ]
}}
output application/json
---
(myVar.menu.items.*label groupBy "myLabels")

  
1

  
{ "myLabels": [ "Move Left", "Move Right", "Move Up", "Move Down" ] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "a" : "b", "c" : "d"} groupBy upper($)

  
1

  
{ "D": { "c": "d" }, "B": { "a": "b" } }

  
1
2
3
4
5
6

  
%dw 2.0
var myRead =
read("<prices><price>9.99</price><price>10.99</price></prices>","application/xml")
output application/json
---
myRead.prices groupBy "costs"

  
1

  
{ "costs" : { "price": "9.99", "price": "10.99" } }

  
1
2
3
4
5
6
7
8
9
10
11
12

  
%dw 2.0
output  application/json
---
{
  "empty" : isBlank(""),
  "withSpaces" : isBlank("      "),
  "withText" : isBlank(" 1223"),
  // not blank
  "checkNotEmpty" : not isBlank(" 1234"),
  // ! for not in DataWeave 2.2.0 for Mule 4.2 and later
  "checkNotEmptyTwo" : ! isBlank(" 1234")
}

  
1
2
3
4
5
6
7

  
{
  "empty": true,
  "withSpaces": true,
  "withText": false,
  "checkNotEmpty": true,
  "checkNotEmptyTwo": true
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isDecimal(1.1), isDecimal(1), isDecimal("1.1") ]

  
1

  
[ true, false, true ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isEmpty([]), isEmpty([1]) ]

  
1

  
[ true, false ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isEmpty(""), isEmpty("DataWeave") ]

  
1

  
[ true, false ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "nullValue" : isEmpty(null) }

  
1

  
{ "nullValue": true }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isEmpty({}), isEmpty({name: "DataWeave"}) ]

  
1

  
[ true, false ]

  
1
2
3
4

  
%dw 2.0
output  application/json
---
{ "isEven" : [ isEven(0), isEven(1), isEven(1+1) ] }

  
1

  
{ "isEven" : [ true, false, true ] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isLeapYear(locDT1), isLeapYear(locDT2), isInteger("1") ]

  
1

  
[ false, true, true ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isLeapYear(|2016-10-01T23:57:59|), isLeapYear(|2017-10-01T23:57:59|) ]

  
1

  
[ true, false ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ isLeapYear(|2016-10-01|), isLeapYear(|2017-10-01|) ]

  
1

  
[ true, false ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ |2016-10-01T23:57:59-03:00|, |2016-10-01T23:57:59Z| ] map isLeapYear($)

  
1

  
[ true, true ]

  
1
2
3
4

  
%dw 2.0
output  application/json
---
{ "isOdd" : [ isOdd(0), isOdd(1), isOdd(2+2) ] }

  
1

  
{ "isOdd": [ false, true, false ] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "hyphenate" : ["a","b","c"] joinBy "-" }

  
1

  
{ "hyphenate": "a-b-c" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
"WARNING" log("Houston, we have a problem.")

  
1

  
WARNING - "Houston, we have a problem."

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "name" : lower("MULESOFT") }

  
1

  
{ "name": "mulesoft" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
["jose", "pedro", "mateo"] map (value, index) -> { (index) : value}

  
1

  
[ { "0": "jose" }, { "1": "pedro" }, { "2": "mateo" } ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
['a', 'b', 'c'] map ((value, index) -> (index + 1) ++ '_' ++ value)

  
1

  
[ "1_a", "2_b", "3_c" ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
['joe', 'pete', 'matt'] map ( "$$" : $)

  
1
2
3
4
5

  
[
  { "0": "joe" },
  { "1": "pete" },
  { "2": "matt" }
]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{"a":"b","c":"d"} mapObject (value,key,index) -> { (index) : { (value):key} }

  
1

  
{ "0": { "b": "a" }, "1": { "d": "c" } }

  
1
2
3
4
5
6
7
8

  
%dw 2.0
output application/xml
---
{
    prices: payload.prices mapObject (value, key) -> {
        (key): (value + 5) as Number {format: "##.00"}
    }
}

  
1
2
3
4
5
6

  
<?xml version='1.0' encoding='UTF-8'?>
<prices>
    <basic>9.99</basic>
    <premium>53</premium>
    <vip>398.99</vip>
</prices>

  
1
2
3
4
5
6

  
<?xml version='1.0' encoding='UTF-8'?>
<prices>
  <basic>14.99</basic>
  <premium>58.00</premium>
  <vip>403.99</vip>
</prices>

  
1
2
3
4

  
%dw 2.0
output application/json
---
"me@mulesoft.com" match(/([a-z]*)@([a-z]*).com/)

  
1
2
3
4
5

  
[
  "me@mulesoft.com",
  "me",
  "mulesoft"
]

  
1
2
3
4
5
6
7

  
%dw 2.0
var a = '192.88.99.0/24'
var b = '192.168.0.0/16'
var c = '192.175.48.0/24'
output application/json
---
[ a, b, c ] flatMap ( $ match(/.*[$4]/) )

  
1

  
[  "192.88.99.0/24", "192.175.48.0/24" ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ ("admin123" matches /a.*\d+/), ("admin123" matches /^b.+/) ]

  
1

  
[ true, false ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ a: max([1, 1000]), b: max([1, 2, 3]), c: max([1.5, 2.5, 3.5]) }

  
1

  
{ "a": 1000, "b": 3, "c": 3.5 }

  
1
2
3
4

  
%dw 2.0
output  application/json
---
[ { "a" : 1 }, { "a" : 3 }, { "a" : 2 } ] maxBy ((item) -> item.a)

  
1

  
{ "a" : 3 }

  
1
2
3
4
5
6
7
8
9
10
11
12
13

  
%dw 2.0
var myDateTime1 = "2017-10-01T22:57:59-03:00"
var myDateTime2 = "2018-10-01T23:57:59-03:00"
output application/json
---
{
  myMaxBy: {
    byDateTime: [ myDateTime1, myDateTime2 ] maxBy ((item) -> item),
    byDate: [ myDateTime1 as Date, myDateTime2 as Date ] maxBy ((item) -> item),
    byTime: [ myDateTime1 as Time, myDateTime2 as Time ] maxBy ((item) -> item),
    emptyArray: [] maxBy ((item) -> item)
  }
}

  
1
2
3
4
5
6
7
8

  
{
  "myMaxBy": {
    "byDateTime": "2018-10-01T23:57:59-03:00",
    "byDate": "2018-10-01",
    "byTime": "23:57:59-03:00",
    "emptyArray": null
  }
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ a: min([1, 1000]), b: min([1, 2, 3]), c: min([1.5, 2.5, 3.5]) }

  
1

  
{ "a": 1, "b": 1, "c": 1.5 }

  
1
2
3
4

  
%dw 2.0
output  application/json
---
[ { "a" : 1 }, { "a" : 2 }, { "a" : 3 } ] minBy (item) -> item.a

  
1

  
{ "a" : 1 }

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  
%dw 2.0
var myDateTime1 = "2017-10-01T22:57:59-03:00"
var myDateTime2 = "2018-10-01T23:57:59-03:00"
output application/json
---
{
  myMinBy: {
    byDateTime: [ myDateTime1, myDateTime2 ] minBy ((item) -> item),
    byDate: [ myDateTime1 as Date, myDateTime2 as Date ] minBy ((item) -> item),
    byTime: [ myDateTime1 as Time, myDateTime2 as Time ] minBy ((item) -> item),
    aBoolean: [ true, false, (0 > 1), (1 > 0) ] minBy $,
    emptyArray: [] minBy ((item) -> item)
  }
}

  
1
2
3
4
5
6
7
8
9

  
{
  "myMinBy": {
    "byDateTime": "2017-10-01T22:57:59-03:00",
    "byDate": "2017-10-01",
    "byTime": "22:57:59-03:00",
    "aBoolean": false,
    "emptyArray": null
  }
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ (3 mod 2), (4 mod 2), (2.2 mod 2) ]

  
1

  
[ 1, 0, 0.2]

  
1
2
3
4
5
6
7

  
%dw 2.0
output application/json
---
{
   nowCalled: now(),
   nowCalledSpecificTimeZone: now() >> "America/New_York"
}

  
1
2
3
4

  
{
  "nowCalled": "2019-08-26T13:32:10.64-07:00",
  "nowCalledSpecificTimeZone": "2019-08-26T16:32:10.643-04:00"
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  
%dw 2.0
output application/json
---
{
  now: now(),
  epochTime : now() as Number,
  nanoseconds: now().nanoseconds,
  milliseconds: now().milliseconds,
  seconds: now().seconds,
  minutes: now().minutes,
  hour: now().hour,
  day: now().day,
  month: now().month,
  year: now().year,
  quarter: now().quarter,
  dayOfWeek: now().dayOfWeek,
  dayOfYear: now().dayOfYear,
  offsetSeconds: now().offsetSeconds,
  formattedDate: now() as String {format: "y-MM-dd"},
  formattedTime: now() as String {format: "hh:m:s"}
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

  
{
  "now": "2019-06-18T16:55:46.678-07:00",
  "epochTime": 1560902146,
  "nanoseconds": 678000000,
  "milliseconds": 678,
  "seconds": 46,
  "minutes": 55,
  "hour": 16,
  "day": 18,
  "month": 6,
  "year": 2019,
  "quarter": 2,
  "dayOfWeek": 2,
  "dayOfYear": 169,
  "offsetSeconds": -25200,
  "formattedDate": "2019-06-18",
  "formattedTime": "04:55:46"
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ orderByLetter: [{ letter: "e" }, { letter: "d" }] } orderBy($.letter)

  
1

  
{ "orderByLetter": [ { "letter": "d" }, { "letter": "e" } ] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
orderDescending: ([3,8,1] orderBy -$)

  
1

  
{ "orderDescending": [8,3,1] }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[3,2,3] orderBy $

  
1

  
[ 2, 3, 3 ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[{name: "Santiago", age: 42},{name: "Leandro", age: 29}, {name: "Mariano", age: 35}] orderBy (person) -> person.age

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  
[
  {
    name: "Leandro",
    age: 29
  },
  {
    name: "Mariano",
    age: 35
  },
  {
    name: "Santiago",
    age: 42
  }
]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{"a":"b","c":"d"} pluck (value,key,index) -> { (index) : { (value):key} }

  
1

  
[ { "0": { "b": "a" },  "1": { "d": "c" } } ]

  
1
2
3
4
5
6
7
8
9
10
11
12
13

  
%dw 2.0
output application/json
var readXml = read("<prices>
    <basic>9.99</basic>
    <premium>53.00</premium>
    <vip>398.99</vip>
    </prices>", "application/xml")
---
"result" : {
  "keys" : readXml.prices pluck($$),
  "values" : readXml.prices pluck($) as Number,
  "indices" : readXml.prices pluck($$$)
}

  
1
2
3
4
5
6
7

  
{
   "result": {
     "keys": [ "basic", "premium", "vip" ],
     "values": [ 9.99, 53, 398.99 ],
     "indices": [ 0, 1, 2 ]
   }
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ (2 pow 3), (3 pow 2), (7 pow 3) ]

  
1

  
[ 8, 9, 343 ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ price: random() * 1000 }

  
1

  
{ "price": 65.02770292248383 }

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ price: randomInt(1000) }

  
1

  
{ "price": 442.0 }

  
1
2
3
4

  
%dw 2.0
output application/xml
---
read('{ "hello" : "world" }','application/json')

  
1

  
<?xml version='1.0' encoding='UTF-8'?><hello>world</hello>

%dw 2.0
var myVar = "Some, Body"
output application/json
---
read(myVar,"application/csv",{header:false})[0]

  
1

  
{ "column_0": "Some", "column_1": " Body" }

  
1
2
3
4
5
6
7
8

  
%dw 2.0
output application/xml
---
{
   "XML" : read("<prices><basic>9.99</basic></prices>",
                "application/xml",
                { indexedReader: "false" })."prices"
}

  
1
2
3
4

  
<?xml version='1.0' encoding='UTF-8'?>
<XML>
  <basic>9.99</basic>
</XML>

  
1
2
3
4

  
%dw 2.0
output application/json
---
readUrl("https://jsonplaceholder.typicode.com/posts/1", "application/json")

  
1

  
{ "userId": 1, "id": 1, "title": "sunt aut ...", "body": "quia et ..." }

  
1
2
3
4
5

  
%dw 2.0
var myJsonSnippet = readUrl("classpath://myJsonSnippet.json", "application/json")
output application/csv
---
(myJsonSnippet.results map(item) -> item.profile)

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

  
{
  "results": [
    {
      "profile": {
        "firstName": "john",
        "lastName": "doe",
        "email": "johndoe@demo.com"
      },
      "data": {
        "interests": [
          {
            "language": "English",
            "tags": [
              "digital-strategy:Digital Strategy",
              "innovation:Innovation"
            ],
            "contenttypes": []
          }
        ]
      }
    },
    {
      "profile": {
      "firstName": "jane",
        "lastName": "doe",
        "email": "janedoe@demo.com"
      },
      "data": {
        "interests": [
          {
            "language": "English",
            "tags": [
              "tax-reform:Tax Reform",
              "retail-health:Retail Health"
            ],
            "contenttypes": [
              "News",
              "Analysis",
              "Case studies",
              "Press releases"
            ]
          }
        ]
      }
    }
  ]
}

  
1
2
3

  
firstName,lastName,email
john,doe,johndoe@demo.com
jane,doe,janedoe@demo.com

  
1
2
3
4

  
%dw 2.0
output application/json
---
(readUrl("classpath://name.dwl", "application/dw")).firstName

  
1
2
3
4

  
{
  "firstName" : "Somebody",
  "lastName" : "Special"
}

  
1

  
"Somebody"

  
1
2
3
4

  
%dw 2.0
output application/json
---
[2, 3] reduce ($ + $$)

  
1

  
5

  
1
2
3
4
5
6
7
8
9
10

  
%dw 2.0
var myNums = [1,2,3,4]
var myEmptyList = []
output application/json
---
{
   "sum" : myNums reduce ($$ + $),
   "concat" : myNums reduce ($$ ++ $),
   "emptyList" : myEmptyList reduce ($$ ++ $)
}

  
1

  
{ "sum": 10, "concat": "1234", "emptyList": null }

  
1
2
3
4
5
6
7
8
9

  
%dw 2.0
output application/json
---
{
   "concat" : ["a", "b", "c", "d"] reduce ((item, acc = "z") -> acc ++ item),
   "sum": [0, 1, 2, 3, 4, 5] reduce ((item, acc = 3) -> acc + item),
   "multiply" : [2,3,3] reduce ((item, acc) -> acc * item),
   "multiplyAcc" : [2,2,3] reduce ((item, acc = 3) -> acc * item)
}

  
1

  
{ "concat": "zabcd", "sum": 18, "multiply": 18, "multiplyAcc": 36 }

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

  
%dw 2.0
output application/json
var myVar =
{
  "a": [0, 1, 2, 3, 4, 5],
  "b": ["a", "b", "c", "d", "e"],
  "c": [{ "letter": "a" }, { "letter": "b" }, { "letter": "c" }],
  "d": [true, false, false, true, true]
}
---
{
  "a" : [0, 1, 2, 3, 4, 5] reduce $$,
  "b": ["a", "b", "c", "d", "e"] reduce $$,
  "c": [{ "letter": "a" }, { "letter": "b" }, { "letter": "c" }] reduce ((item, acc = "z") -> acc ++ item.letter),
  "d": [{ letter: "a" }, { letter: "b" }, { letter: "c" }] reduce $$,
  "e": [true, false, false, true, true] reduce ($$ and $),
  "f": [true, false, false, true, true] reduce ((item, acc) -> acc and item),
  "g": [true, false, false, true, true] reduce ((item, acc = false) -> acc and item),
  "h": [true, false, false, true, true] reduce $$,
  "i": myVar.a reduce ($$ + $),
  "j": myVar.a reduce ((item, acc) -> acc + item),
  "k": myVar.a reduce ((item, acc = 3) -> acc + item),
  "l": myVar.a reduce $$,
  "m": myVar.b reduce ($$ ++ $),
  "n": myVar.b reduce ((item, acc) -> acc ++ item),
  "o": myVar.b reduce ((item, acc = "z") -> acc ++ item),
  "p": myVar.b reduce $$,
  "q": myVar.c reduce ((item, acc = "z") -> acc ++ item.letter),
  "r": myVar.c reduce $$,
  "s": myVar.d reduce ($$ and $),
  "t": myVar.d reduce ((item, acc) -> acc and item),
  "u": myVar.d reduce ((item, acc = false) -> acc and item),
  "v": myVar.d reduce $$,
  "w": ([0, 1, 2, 3, 4] reduce ((item, acc = {}) -> acc ++ { a: item })) pluck $,
  "x": [] reduce $$,
  "y": [] reduce ((item,acc = 0) -> acc + item)
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  
"a": 0,
"b": "a",
"c": "zabc",
"d": { "letter": "a" },
"e": false,
"f": false,
"g": false,
"h": true,
"i": 15,
"j": 15,
"k": 18,
"l": 0,
"m": "abcde",
"n": "abcde",
"o": "zabcde",
"p": "a",
"q": "zabc",
"r": { "letter": "a" },
"s": false,
"t": false,
"u": false,
"v": true,
"w": [ 0,1,2,3,4 ],
"x": null,
"y": 0
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
["123-456-7890" replace /.*-/ with(""), "abc123def" replace /[b13e]/ with("-")]

  
1

  
[ 7890, "a-c-2-d-f" ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ "my123" replace /(\d+)/ with("ID"), replace("myOther123", /(\d+)/) with("ID") ]

  
1

  
[ "myID", "myOtherID" ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
{ "replace": "admin123" replace "123" with("ID") }

  
1

  
{ "replace": "adminID" }

  
1
2
3
4

  
%dw 2.0
output application/json
---
[ round(1.2), round(4.6), round(3.5) ]

  
1

  
[ 1, 5, 4 ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
flatten("www.mulesoft.com" scan(/([w]*).([a-z]*).([a-z]*)/))

  
1

  
[ "www.mulesoft.com", "www", "mulesoft", "com" ]

  
1
2
3
4

  
%dw 2.0
output application/json
---
"anypt@mulesoft.com,max@mulesoft.com" scan(/([a-z]*)@([a-z]*).com/)

  
1
2
3
4

  
[
  [ "anypt@mulesoft.com", "anypt", "mulesoft" ],
  [ "max@mulesoft.com", "max", "mulesoft" ]
]

  
1
2
3
4

  
%dw 2.0
output application/json
---
sizeOf([ "a", "b", "c"])

  
1

  
3

  
1
2
3
4
5
6
7
8
9
10

  
%dw 2.0
output application/json
---
{
  "arraySizes": {
     size3: sizeOf([1,2,3]),
     size2: sizeOf([[1,2,3],[4]]),
     size0: sizeOf([])
   }
}

  
1
2
3
4
5
6
7

  
{
   "arraySizes": {
     "size3": 3,
     "size2": 2,
     "size0": 0
   }
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
sizeOf({a: 1, b: 2})

  
1

  
2

  
1
2
3
4
5
6
7
8
9

  
%dw 2.0
output application/json
---
{
   objectSizes : {
     sizeIs2: sizeOf({a:1,b:2}),
     sizeIs0: sizeOf({})
   }
}

  
1
2
3
4
5
6

  
{
  "objectSize": {
    "sizeIs2": 2,
    "sizeIs0": 0
  }
}

  
1
2
3
4

  
%dw 2.0
output application/json
---
sizeOf(["\u0000" as Binary, "\u0001" as Binary, "\u0002" as Binary])

  
1

  
3

  
1
2
3
4

  
%dw 2.0
output application/json
---
sizeOf("abc")