1. dw::core::URL
The encodeURI() function encodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two "surrogate" characters).
Assumes that the URI is a complete URI, so does not encode reserved characters that have special meaning in the URI.
encodeURI replaces all characters except the following with the appropriate UTF-8 escape sequences:
Type | Includes ---------------------+---------------------------------------------- Reserved characters | ; , / ? : @ & = $ Unescaped characters | alphabetic, decimal digits, - _ . ! ~ * ' ( ) Number sign | #
1.1. Functions
1.1.1. Compose
compose(Array<String>, Array<String>): String
Compose is a custom interpolator used to replace URL components by the encodeURIComponent result of it. Example:
compose `http://asd/$(' texto a encodear ')/texto a encodear`
==
'http://asd/%20texto%20a%20encodear%20/texto a encodear'
1.1.2. DecodeURI
decodeURI(String): String
The decodeURI() function decodes a Uniform Resource Identifier (URI) previously created by encodeURI or by a similar routine.
Replaces each escape sequence in the encoded URI with the character that it represents,
but does not decode escape sequences that could not have been introduced by encodeURI.
The character #
is not decoded from escape sequences.
1.1.3. DecodeURIComponent
decodeURIComponent(String): String
The decodeURIComponent() function decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent or by a similar routine.
1.1.4. EncodeURI
encodeURI(String): String
1.1.5. EncodeURIComponent
encodeURIComponent(String): String
The encodeURIComponent() function encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two "surrogate" characters).
encodeURIComponent escapes all characters except the following: alphabetic, decimal digits, - _ . ! ~ * ' ( ) encodeURIComponent differs from encodeURI in that it encodes reserved characters and the Number sign # of encodeURI:
Type | Includes ---------------------+---------------------------------------------- Reserved characters | Unescaped characters | alphabetic, decimal digits, - _ . ! ~ * ' ( ) Number sign |
1.1.6. ParseURI
parseURI(String): URI
Parses an URL and returns an URI object.
The isValid: Boolean
property dennotes if the parse was succeed.
Every field in the URI object is optional, and it will be present only if it was present in the original URL
1.2. Types
1.2.1. URI
-
Definition
{ isValid: Boolean, host?: String, authority?: String, fragment?: String, path?: String, port?: Number, query?: String, scheme?: String, user?: String, isAbsolute?: Boolean, isOpaque?: Boolean }
2. dw::core::Strings
The functions described here are packaged in the Strings module. The module is included with the Mule runtime, but you must import it to your DataWeave code by adding the line import dw::core::Strings
to your header.
Example
%dw 2.0
import dw::core::Strings
---
Strings::pluralize("box")
2.1. Functions
2.1.1. Camelize
camelize(String): String
Returns the provided string in camel case.
1
2
3
4
5
6
7
8
9
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: camelize("customer"),
b: camelize("customer_first_name"),
c: camelize("customer name")
}
1
2
3
4
5
{
"a": "customer",
"b": "customerFirstName",
"c": "customer name"
}
2.1.2. Capitalize
capitalize(String): String
Returns the provided string with every word starting with a capital letter and no underscores. It also replaces underscores with spaces and puts a space before each capitalized word.
1
2
3
4
5
6
7
8
9
10
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: capitalize("customer"),
b: capitalize("customer_first_name"),
c: capitalize("customer NAME"),
d: capitalize("customerName")
}
1
2
3
4
5
6
{
"a": "Customer",
"b": "Customer First Name",
"c": "Customer Name",
"d": "Customer Name"
}
2.1.3. CharCode
charCode(String): Number
Returns a Number, representing the unicode of the first character of the specified String. This functions fails if the String is empty
1
2
3
4
5
6
7
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: charCode("b")
}
1
2
3
{
"a": 98
}
2.1.4. CharCodeAt
charCodeAt(String, Number): Number
Returns a Number, representing the unicode of the character at the specified index. This functions if the index is invalid
1
2
3
4
5
6
7
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: charCodeAt("baby", 2)
}
1
2
3
{
"a": 98
}
2.1.5. Dasherize
dasherize(String): String
Returns the provided string with every word separated by a dash.
1
2
3
4
5
6
7
8
9
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: dasherize("customer"),
b: dasherize("customer_first_name"),
c: dasherize("customer NAME")
}
1
2
3
4
5
{
"a": "customer",
"b": "customer-first-name",
"c": "customer-name"
}
2.1.6. FromCharCode
fromCharCode(Number): String
Returns the String of the specified Number code.
2.1.7. Ordinalize
ordinalize(String): String
Returns the provided numbers set as ordinals.
1
2
3
4
5
6
7
8
9
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: ordinalize(1),
b: ordinalize(8),
c: ordinalize(103)
}
1
2
3
4
5
{
"a": "1st",
"b": "8th",
"c": "103rd"
}
2.1.8. Pluralize
pluralize(String): String
Returns the provided string transformed into its plural form.
1
2
3
4
5
6
7
8
9
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: pluralize("box"),
b: pluralize("wife"),
c: pluralize("foot")
}
1
2
3
4
5
{
"a": "boxes",
"b": "wives",
"c": "feet"
}
2.1.9. Singularize
singularize(String): String
Returns the provided string transformed into its singular form.
1
2
3
4
5
6
7
8
9
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: singularize("boxes"),
b: singularize("wives"),
c: singularize("feet")
}
1
2
3
4
5
{
"a": "box",
"b": "wife",
"c": "foot"
}
2.1.10. Underscore
underscore(String): String
Returns the provided string with every word separated by an underscore.
1
2
3
4
5
6
7
8
9
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
a: underscore("customer"),
b: underscore("customer-first-name"),
c: underscore("customer NAME")
}
1
2
3
4
5
{
"a": "customer",
"b": "customer_first_name",
"c": "customer_NAME"
}
3. dw::core::Objects
Returns a list of key value pair object describing the object entries
%dw 2.0
import dw::core::Objects
---
Objects::entrySet({a: true, b: 1})
[{key: "a", value: true}, {key: "b", value: 1}]
3.1. Functions
3.1.1. EntryAt
entryAt({ (K): V }, Number): { (K)?: V } | Null
Returns selecting only the entry at the specified index. If the index is not valid it return null. If index es less than 0 then it will start from the last element e.g {a: true, b: 1} entryAt -1 returns the last entry
%dw 2.0
import dw::core::Objects
---
Objects::entryAt({a: true, b: 1}, 0)
{a: true}
3.1.2. EntrySet
entrySet(T)
3.1.3. KeySet
keySet(T): ?
Returns the list of key names of an object
%dw 2.0
import dw::core::Objects
---
Objects::nameSet({a: true, b: 1})
["a","b"]
3.1.4. MergeWith
mergeWith(T, V): ?
Overrides the source with the target object so that the result with contain all the properties from the target plus the properties on the source that are not declared on the target
%dw 2.0
import mergeWith from dw::core::Objects
---
{a: true, b: 1} mergeWith {a: false, c: "Test"}
{a: false, b: 1 , c: "Test"}
mergeWith(Null, T): T
Helper method to make mergetWith
null friendly
mergeWith(T, Null): T
Helper method to make mergetWith
null friendly
3.1.5. NameSet
nameSet(Object): Array<String>
Returns the list of key names of an object
%dw 2.0
import dw::core::Objects
---
Objects::nameSet({a: true, b: 1})
["a","b"]
3.1.6. ValueSet
valueSet({ K?: V }): Array<V>
Returns the list of key values of an object
%dw 2.0
import dw::core::Objects
---
Objects::nameSet({a: true, b: 1})
[true,1]
4. dw::core::Binaries
4.1. Functions
4.1.1. FromBase64
fromBase64(String): Binary
Converts a base64 string representation into a binary
4.1.2. FromHex
fromHex(String): Binary
Converts an hexadecimal string representation into a binary
4.1.3. ToBase64
toBase64(Binary): String
Transforms the specified binary into the base64 string representation
4.1.4. ToHex
toHex(Binary): String
Transforms the specified binary into the hexadecimal String representation
5. dw::core::Assertions
5.1. Functions
5.1.1. Assert
assert(Boolean, String): Boolean
Raises an execution error when the first argument is false. The second argument is the error message.
5.1.2. MustEqual
mustEqual(a, b): Boolean
Raises an execution error if the arguments arent exactly the same.
5.1.3. MustMatch
mustMatch(String, Regex): Boolean
Raises an execution error when the first argument (String) doesn’t match the second argument (Regex)
6. dw::core::Arrays
Returns true if some element of the list matches the condition. It stops the iterations after the first match.
6.1. Functions
6.1.1. CountBy
countBy(Array<T>, (T) → Boolean): Number
Counts the matching elements using a matchingFunction(T)
1
2
3
4
%dw 2.0
output application/json
---
[1, 2, 3] countBy (($ mod 2) == 0)
1
1
6.1.2. Every
every(Array<T>, (T) → Boolean): Boolean
Returns true if every element of the list matches the condition. It stops the iterations after the first negative evaluation.
6.1.3. Private_every
private_every(Array<T>, (T) → Boolean): Boolean
6.1.4. Some
some(Array<T>, (T) → Boolean): Boolean
6.1.5. SumBy
sumBy(Array<T>, (T) → Number): Number
Adds the values returned by the right hand side function
1
2
3
4
5
%dw 2.0
output application/json
---
sumBy([ { a: 1 }, { a: 2 }, { a: 3 } ], (item) -> item.a)
// same as [ { a: 1 }, { a: 2 }, { a: 3 } ] sumBy $.a
1
6
7. dw::System
The functions described here are packaged in the System module. The module is included with the Mule runtime, but you must import it to your DataWeave code by adding the line import dw::System
to your header.
%dw 2.0
import dw::System
---
System::envVar("SYS_PSWD")
This module contains functions that allow you to interact with the underlying system.
7.1. Functions
7.1.1. EnvVar
envVar(String): String | Null
Returns an environment variable with the specified name, or null
if it’s not defined.
%dw 2.0 import dw::System output application/json --- System::envVar("SYS_PSWD")
7.1.2. EnvVars
envVars(): Dictionary<String>
Returns all of the environment variables defined in the hosted System.
%dw 2.0 import dw::System output application/json --- System::envVars().SYS_PSWD
8. dw::Runtime
The functions described here are packaged in the Runtime module. The module is included with Mule runtime, but you must import it to your DataWeave code by adding the line import dw::Runtime
to your header.
%dw 2.0
import dw::Runtime
---
Runtime::fail("Error")
This module contains functions that allow you to interact with the DataWeave engine.
8.1. Functions
8.1.1. Fail
fail(String): Nothing
Throws an exception with the specified message.
8.1.2. FailIf
failIf(T, (value: T) → Boolean, String): T
Throws an exception with the specified message if the expression in the evaluator returns true
.
If not return the value
8.1.3. Try
try(() → T): TryResult<T>
8.1.4. Wait
wait(T, Number): T
Stops the execution for the specified timeout (in milliseconds).
8.2. Types
8.2.1. TryResult
Evaluates the delegate and returns an object with the result or an error message.
-
Definition
{ success: Boolean, result?: T, error?: { kind: String, message: String, stack?: Array<String>, location?: String } }
9. dw::Crypto
The functions described here are packaged in the Crypto module. The module is included with Mule runtime, but you must import it to your DataWeave code by adding the line import dw::Crypto
to your header.
Example
%dw 2.0
import dw::Crypto
---
Crypto::MD5("asd" as Binary)
This module contains encrypting functions that follow common algorithms such as MD5, SHA1, etc.
9.1. Functions
9.1.1. HMACBinary
HMACBinary(Binary, Binary): Binary
Computes a Hash-based Message Authentication Code (HMAC) using the SHA1 hash function.
9.1.2. HMACWith
HMACWith(Binary, Binary): String
Computes the HMAC hash and transforms and transforms the binary result into a hexadecimal lower case string.
9.1.3. MD5
MD5(Binary): String
Computes the MD5 hash and transforms the binary result into a hexadecimal lower case string.
%dw 2.0 import dw::Crypto output application/json --- Crypto::MD5("asd" as Binary)
"7815696ecbf1c96e6894b779456d330e"
9.1.4. SHA1
SHA1(Binary): String
Computes the SHA1 hash and transforms and transforms the binary result into a hexadecimal lower case string.
%dw 2.0 import dw::Crypto output application/json --- Crypto::SHA1("dsasd" as Binary),
"2fa183839c954e6366c206367c9be5864e4f4a65",
9.1.5. HashWith
hashWith(Binary, String): Binary
Computes the hash of the specified content with the given algorithm name and returns the binary content.
Algorithm name can be
|======= |Name |Description
|MD2 |The MD2 message digest algorithm as defined in [RFC 1319| http://www.ietf.org/rfc/rfc1319.txt]. |MD5 |The MD5 message digest algorithm as defined in [RFC 1321 | http://www.ietf.org/rfc/rfc1321.txt]. |SHA-1 SHA-256 SHA-384 SHA-512 | Hash algorithms defined in the [FIPS PUB 180-2 | http://csrc.nist.gov/publications/fips/index.html].
SHA-256 is a 256-bit hash function intended to provide 128 bits of security against collision attacks, while SHA-512 is a 512-bit hash function intended to provide 256 bits of security. A 384-bit hash may be obtained by truncating the SHA-512 output. |=======
10. dw::Core
This module contains all the core data weave functionality. It is automatically imported into any data weave script.
10.1. Functions
10.1.1. ++
++(Array<S>, Array<T>): Array<S | T>
It returns the resulting array of concatenating two existing arrays.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
a: [0, 1, 2] ++ [3, 4, 5]
}
1
2
3
{
"a": [0, 1, 2, 3, 4, 5]
}
Note that the arrays can contain any supported data type, for example:
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
a: [0, 1, true, "my string"] ++ [2, [3,4,5], {"a": 6}]
}
1
2
3
{
"a": [0, 1, true, "my string", 2, [3, 4, 5], { "a": 6}]
}
++(String, String): String
Strings are treated as arrays of characters, so the operation works just the same with strings.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
name: "Mule" ++ "Soft"
}
1
2
3
{
"name": MuleSoft
}
++(Object, Object): Object
Returns the resulting object of concatenating two existing objects.
1
2
3
4
%dw 2.0
output application/xml
---
concat: {aa: "a"} ++ {cc: "c"}
1
2
3
4
5
<?xml version="1.0" encoding="UTF-8"?>
<concat>
<aa>a</aa>
<cc>c</cc>
</concat>
The example above concatenates object {aa: a} and {cc: c} in a single one → {aa: a , cc: c}
++(Date, LocalTime): LocalDateTime
You can append a date to a time (or localtime) object so as to provide a more precise value.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: |2003-10-01| ++ |23:57:59|,
b: |2003-10-01| ++ |23:57:59Z|
}
1
2
3
4
{
"a": "2003-10-01T23:57:59",
"b": "2003-10-01T23:57:59Z"
}
Note that the order in which the two objects are appended is irrelevant, so logically a 'Date' + 'Time' will result in the same as a '#Time' + 'Date'.
++(LocalTime, Date): LocalDateTime
You can append a date to a time (or localtime) object so as to provide a more precise value.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: |23:57:59| ++ |2003-10-01|,
b: |23:57:59Z| ++ |2003-10-01|
}
1
2
3
4
{
"a": "2003-10-01T23:57:59",
"b": "2003-10-01T23:57:59Z"
}
Note that the order in which the two objects are appended is irrelevant, so logically a 'Date' + 'Time' will result in the same as a '#Time' + 'Date'.
++(Date, Time): DateTime
You can append a date to a time (or localtime) object so as to provide a more precise value.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: |2003-10-01| ++ |23:57:59|,
b: |2003-10-01| ++ |23:57:59Z|
}
1
2
3
4
{
"a": "2003-10-01T23:57:59",
"b": "2003-10-01T23:57:59Z"
}
Note that the order in which the two objects are appended is irrelevant, so logically a 'Date' + 'Time' will result in the same as a '#Time' + 'Date'.
++(Time, Date): DateTime
You can append a date to a time (or localtime) object so as to provide a more precise value.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: |23:57:59| ++ |2003-10-01|,
b: |23:57:59Z| ++ |2003-10-01|
}
1
2
3
4
{
"a": "2003-10-01T23:57:59",
"b": "2003-10-01T23:57:59Z"
}
Note that the order in which the two objects are appended is irrelevant, so logically a 'Date' + 'Time' will result in the same as a '#Time' + 'Date'.
++(Date, TimeZone): DateTime
Appends a time zone to a date type value.
1
2
3
4
%dw 2.0
output application/json
---
a: |2003-10-01T23:57:59| ++ |-03:00|
1
2
3
{
"a": "2003-10-01T23:57:59-03:00"
}
++(TimeZone, Date): DateTime
Appends a time zone to a date type value.
1
2
3
4
%dw 2.0
output application/json
---
a: |-03:00| ++ |2003-10-01T23:57:59|
1
2
3
{
"a": "2003-10-01T23:57:59-03:00"
}
++(LocalDateTime, TimeZone): DateTime
Appends a time zone to a date type value.
1
2
3
4
%dw 2.0
output application/json
---
a: |2003-10-01T23:57:59| ++ |-03:00|
1
2
3
{
"a": "2003-10-01T23:57:59-03:00"
}
++(TimeZone, LocalDateTime): DateTime
Appends a time zone to a date type value.
1
2
3
4
%dw 2.0
output application/json
---
a: |-03:00| ++ |2003-10-01T23:57:59|
1
2
3
{
"a": "2003-10-01T23:57:59-03:00"
}
++(LocalTime, TimeZone): Time
Appends a time zone to a date type value.
1
2
3
4
%dw 2.0
output application/json
---
a: |2003-10-01T23:57:59| ++ |-03:00|
1
2
3
{
"a": "2003-10-01T23:57:59-03:00"
}
++(TimeZone, LocalTime): Time
Appends a time zone to a date type value.
1
2
3
4
%dw 2.0
output application/json
---
a: |-03:00| ++ |2003-10-01T23:57:59|
1
2
3
{
"a": "2003-10-01T23:57:59-03:00"
}
10.1.2. —
--(Array<S>, Array<Any>): Array<S>
Removes a set of elements from an array when an element in the base array matches one of the values in the substracted array. If multiple elements in the array match a value, they will all be removed.
1
2
3
4
%dw 2.0
output application/json
---
a: [0, 1, 1, 2] -- [1,2]
1
2
3
{
"a": [0],
}
--({ (K)?: V }, Object): { (K)?: V }
Removes all the entries from the source that are present on the toRemove parameter .Transform
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
hello: 'world',
name: "DW"
} -- {hello: 'world'}
1
2
3
{
"name": "DW"
}
--(Object, Array<String>)
Removes the properties from the source that are present the given list of keys. .Transform
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
hello: 'world',
name: "DW"
} -- ['hello']
1
2
3
{
"name": "DW"
}
--(Object, Array<Key>)
Removes the properties from the source that are present the given list of keys. .Transform
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
hello: 'world',
name: "DW"
} -- ['hello' as Key]
1
2
3
{
"name": "DW"
}
10.1.3. Abs
abs(Number): Number
Returns the absolute value of a number.
1
2
3
4
5
6
7
8
9
%dw 2.0
output application/json
---
{
a: abs(-2),
b: abs(2.5),
c: abs(-3.4),
d: abs(3)
}
1
2
3
4
5
6
{
"a": 2,
"b": 2.5,
"c": 3.4,
"d": 3
}
10.1.4. Avg
avg(Array<Number>): Number
Creates an average of all the values in an array and outputs a single number. The array must of course contain only numerical value in it.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: avg([1, 1000]),
b: avg([1, 2, 3])
}
1
2
3
4
{
"a": 500.5,
"b": 2.0
}
10.1.5. Ceil
ceil(Number): Number
Rounds a number upwards, returning the first full number above than the one provided.
1
2
3
4
5
6
7
8
9
%dw 2.0
output application/json
---
{
a: ceil(1.5),
b: ceil(2.2),
c: ceil(3)
}
1
2
3
4
5
{
"a": 2,
"b": 3,
"c": 3
}
10.1.6. Contains
contains(Array<T>, Any): Boolean
You can evaluate if any value in an array matches a given condition:
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
2
3
{
"ContainsRequestedItem": true
}
contains(String, String): Boolean
You can also use contains to evaluate a substring from a larger string:
1
2
3
4
%dw 2.0
output application/json
---
ContainsString: payload.root.mystring contains "me"
1
2
3
4
<?xml version="1.0" encoding="UTF-8"?>
<root>
<mystring>some string</mystring>
</root>
1
2
3
{
"ContainsString": true
}
contains(String, Regex): Boolean
Instead of searching for a literal substring, you can also match it against a regular expression:
1
2
3
4
%dw 2.0
output application/json
---
ContainsString: payload.root.mystring contains /s[t|p]ring/
1
2
3
4
<?xml version="1.0" encoding="UTF-8"?>
<root>
<mystring>A very long string</mystring>
</root>
1
2
3
{
"ContainsString": true
}
10.1.7. DistinctBy
distinctBy(Array<T>, (T, Number) → Any): Array<T>
Returns only unique values from an array that may have duplicates. The lambda is invoked with two parameters: value and index. If these parameters are not defined, the index is defined by default as $$ and the value as $.
1
2
3
4
5
6
7
8
9
10
11
%dw 2.0
output application/json
---
{
book : {
title : payload.title,
year: payload.year,
authors: payload.author distinctBy $
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
"title": "XQuery Kick Start",
"author": [
"James McGovern",
"Per Bothner",
"Kurt Cagle",
"James Linn",
"Kurt Cagle",
"Kurt Cagle",
"Kurt Cagle",
"Vaidyanathan Nagarajan"
],
"year":"2000"
}
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"
]
}
}
distinctBy({ (K)?: V }, (V, K) → Any): Object
Returns an object with unike key value pairs . The lambda is invoked with two parameters: value and key. If these parameters are not defined, the index is defined by default as $$ and the value as $.
1
2
3
4
5
6
7
8
9
10
%dw 2.0
output application/xml
---
{
book : {
title : payload.book.title,
authors: payload.book.&author distinctBy $
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<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
9
10
11
12
13
14
<book>
<title> "XQuery Kick Start"</title>
<authors>
<author>
James Linn
</author>
<author>
Per Bothner
</author>
<author>
James McGovern
</author>
</authors>
</book>
10.1.8. EndsWith
endsWith(String, String): String
Returns true or false depending on if a string ends with a provided substring.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: "Mariano" endsWith "no",
b: "Mariano" endsWith "to"
}
1
2
3
4
{
"a": true,
"b": false
}
10.1.9. Filter
filter(Array<T>, (T, Number) → Boolean): Array<T>
Returns an array that only contains those elements that pass the criteria specified in the lambda. The lambda is invoked with two parameters: value and the index. If these parameters are not named, the index is defined by default as $$ and the value as $.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
biggerThanTwo: [0, 1, 2, 3, 4, 5] filter $ > 2
}
1
2
3
{
"biggerThanTwo": [3,4,5]
}
The next example passes named key and value parameters. .Transform
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
example2: [0, 1, 2, 3, 4, 5] filter ((key1, value1) -> key1 > 3 and value1 < 5 )
}
1
2
3
{
"example2": [4]
}
filter(Null, (Nothing, Nothing) → Boolean): Null
Helper function that allows filter to work with null values
10.1.10. FilterObject
filterObject({ (K)?: V }, (V, K, Number) → Boolean): { (K)?: V }
Returns an object that filters an input object based on a matching condition. The lambda is invoked with three parameters: value, key and index. If these parameters are not named, the value is defined by default as $, the key * and the index *$.
This example filters an object by its value.
1
2
3
4
%dw 2.0
output application/json
---
{"letter1": "a", "letter2": "b"} filterObject ((value1) -> value1 == "a")
1
2
3
{
"letter1": "a"
}
You can produce the same results with this input:
1
2
3
4
%dw 2.0
output application/json
---
{"letter1": "a", "letter2": "b"} filter ($ == "a")
filterObject(Null, (Nothing, Nothing, Nothing) → Boolean): Null
Helper function that allows filterObject to work with null values
10.1.11. Find
find(Array<T>, Any): Array<Number>
Returns the array of index where the element to be found where present
1
2
3
4
%dw 2.0
output application/json
---
["name", "lastName"] find "name"
1
2
3
[
0
]
find(String, Regex): Array<Array<Number>>
Returns the array of index where the regex matched in the text
1
2
3
4
%dw 2.0
output application/json
---
"DataWeave" find /a/
1
2
3
[
[1], [3], [6]
]
find(String, String): Array<Number>
Given a string, it returns the index position within the string at which a match was matched. If found in multiple parts of the string, it returns an array with the various idex positions at which it was found. You can either look for a simple string or a regular expression.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: "aabccde" find /(a).(b)(c.)d/,
b: "aabccdbce" find "a",
c: "aabccdbce" find "bc"
}
1
2
3
4
5
{
"a": [[0,0,2,3]],
"b": [0,1],
"c": [2,6]
}
10.1.12. Flatten
flatten(Array<Array<T> | Q>): Array<T | Q>
If you have an array of arrays, this operator can flatten it into a single simple array.
1
2
3
4
%dw 2.0
output application/json
---
flatten(payload)
1
2
3
4
5
[
[3,5],
[9,5],
[154,0.3]
]
1
2
3
4
5
6
7
8
[
3,
5,
9,
5,
154,
0.3
]
10.1.13. Floor
floor(Number): Number
Rounds a number downwards, returning the first full number below than the one provided.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: floor(1.5),
b: floor(2.2),
c: floor(3)
}
1
2
3
4
5
{
"a": 1,
"b": 2,
"c": 3
}
10.1.14. GroupBy
groupBy(Array<T>, (T, Number) → R): { ®: Array<T> }
Partitions an Array into a Object that contains Arrays, according to the discriminator lambda you define. The lambda is invoked with three parameters: value, key and index. If these parameters are not named, the value is defined by default as $, the key * and the index *$.
1
2
3
4
%dw 2.0
output application/json
---
"language": payload.langs groupBy $.language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
"langs": [
{
"name": "Foo",
"language": "Java"
},
{
"name": "Bar",
"language": "Scala"
},
{
"name": "FooBar",
"language": "Java"
}
]
}
1
2
3
4
5
6
7
8
9
10
11
{
"language": {
"Scala": [
{"name":"Bar", "language":"Scala"}
],
"Java": [
{"name":"Foo", "language":"Java"},
{"name":"FooBar", "language":"Java"}
]
}
}
groupBy({ (K)?: V }, (V, K) → R): { ®: Array<T> }
Partitions an Object
into a Object
that contains Arrays
, according to the discriminator lambda you define.
The lambda is invoked with two parameters: value and the key.
groupBy(Null, (Nothing, Nothing) → Any): Null
Helper function that allows groupBy to work with null values
10.1.15. IsBlank
isBlank(String): Boolean
Returns true
if it receives a string composed of only whitespace characters.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
empty: isBlank(""),
withSpaces: isBlank(" "),
withText: isBlank(" 1223")
}
1
2
3
4
5
{
"empty": true,
"withSpaces": true,
"withText": false
}
10.1.16. IsDecimal
isDecimal(Number): Boolean
Returns true
if if receives a number that has any decimals in it.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
decimal: isDecimal(1.1),
integer: isDecimal(1)
}
1
2
3
4
{
"decimal": true,
"integer": false
}
10.1.17. IsEmpty
isEmpty(Array): Boolean
Returns wether an Array is empty or not.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
empty: isEmpty([]),
nonEmpty: isEmpty([1])
}
1
2
3
4
{
"empty": true,
"nonEmpty": false
}
isEmpty(String): Boolean
Returns wether a String is empty or not.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
empty: isEmpty(""),
nonEmpty: isEmpty("DataWeave")
}
1
2
3
4
{
"empty": true,
"nonEmpty": false
}
isEmpty(Object): Boolean
Returns whether an Object is empty or not.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
empty: isEmpty({}),
nonEmpty: isEmpty({name: "DataWeave"})
}
1
2
3
4
{
"empty": true,
"nonEmpty": false
}
10.1.18. IsEven
isEven(Number): Boolean
Returns true if the specified number is Even.
10.1.19. IsInteger
isInteger(Number): Boolean
Returns true is the number doesn’t have any decimals.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
decimal: isInteger(1.1),
integer: isInteger(1)
}
1
2
3
4
{
"decimal": false,
"integer": true
}
10.1.20. IsLeapYear
isLeapYear(DateTime): Boolean
Returns true if it receives a DateTime
for a leap year.
isLeapYear(Date): Boolean
Returns true if it receives a Date
for a leap year.
isLeapYear(LocalDateTime): Boolean
Returns true if it receives a LocalDateTime
for a leap year.
10.1.21. IsOdd
isOdd(Number): Boolean
Returns true if the specified number is Odd.
10.1.22. JoinBy
joinBy(Array, String): String
Merges an array into a single string value, using the provided string as a separator between elements.
1
2
3
4
%dw 2.0
output application/json
---
aa: ["a","b","c"] joinBy "-"
1
2
3
{
"aa": "a-b-c"
}
10.1.23. Log
log(String, T): T
Logs the specified value with the specified prefix
, it then returns the value unchanged.
1
2
3
4
5
%dw 2.0
in payload application/json
output application/xml
---
{ age: log("My Age", payload.age) }
1
{ "age" : 33 }
This will print output: My Age - 33
.Output:
1
<age>33</age>
Note that besides producing the expected output, it also logs it.
10.1.24. Lower
lower(String): String
Returns the provided string in lowercase characters.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
name: lower("MULESOFT")
}
1
2
3
{
"name": "mulesoft"
}
10.1.25. Map
map(Array<T>, (T, Number) → R): Array<R>
Returns an array that is the result of applying a transformation function (lambda) to each of the elements. The lambda is invoked with two parameters: value and the index. If these parameters are not named, the index is defined by default as $$ and the value as $.
1
2
3
4
%dw 2.0
output application/json
---
users: ["john", "peter", "matt"] map upper($)
1
2
3
4
5
6
7
{
"users": [
"JOHN",
"PETER",
"MATT"
]
}
In the following example, custom names are defined for the index and value parameters of the map operation, and then both are used to construct the returned value. In this case, value is defined as firstName and its index in the array is defined as position.
1
2
3
4
%dw 2.0
output application/json
---
users: ["john", "peter", "matt"] map ((firstName, position) -> position ++ ":" ++ upper(firstName))
1
2
3
4
5
6
7
{
"users": [
"0:JOHN",
"1:PETER",
"2:MATT"
]
}
map(Null, (Nothing, Nothing) → Boolean): Null
Helper function that allows map to work with null values
10.1.26. MapObject
mapObject({ (K)?: V }, (V, K, Number) → Object): Object
Similar to Map, but instead of processing only the values of an object, it processes both keys and values as a tuple. Also instead of returning an array with the results of processing these values through the lambda, it returns an object, which consists of a list of the key:value pairs that result from processing both key and value of the object through the lambda.
The lambda is invoked with three parameters: value, key and index. If these parameters are not named, the value is defined by default as $, the key * and the index *$.
1
2
3
4
5
6
7
8
9
10
%dw 2.0
output application/json
var conversionRate=13.45
---
priceList: payload.prices mapObject (
'$$':{
dollars: $,
localCurrency: $ * conversionRate
}
)
1
2
3
4
5
<prices>
<basic>9.99</basic>
<premium>53</premium>
<vip>398.99</vip>
</prices>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
"priceList": {
"basic": {
"dollars": "9.99",
"localCurrency": 134.3655
},
"premium": {
"dollars": "53",
"localCurrency": 712.85
},
"vip": {
"dollars": "398.99",
"localCurrency": 5366.4155
}
}
}
Note that when you use a parameter to populate one of the keys of your output, as with the case of in this example, you must either enclose it in quote marks or brackets. '' or ($$) are both equally valid. |
In the example above, as key and value are not defined, they’re identified by the placeholders $$ and $. For each key:value pair in the input, the key is preserved and the value becomes an object with two properties: one of these is the original value, the other is the result of multiplying this value by a constant that is defined as a directive in the header.
The mapping below performs exactly the same transform, but it defines custom names for the properties of the operation, instead of using $ and $$. Here, 'category' is defined as referring to the original key in the object, and 'money' to the value in that key.
1
2
3
4
5
6
7
8
9
10
%dw 2.0
output application/json
var conversionRate=13.45
---
priceList: payload.prices mapObject ((money, category, index) ->
'$category':{
dollars: money,
localCurrency: money * conversionRate
}
)
Note that when you use a parameter to populate one of the keys of your output, as with the case of category in this example, you must either enclose it in brackets or enclose it in quote marks adding a $ to it, otherwise the name of the property is taken as a literal string. '$category' or (category) are both equally valid. |
mapObject(Null, (Any, Any, Number) → Any): Null
Helper function that allows mapObject to work with null values
10.1.27. Match
match(String, Regex): Array<String>
Matches a string against a regular expression. It returns an array that contains the entire matching expression, followed by all of the capture groups that match the provided regex.
It can be applied to the result of any evaluated expression, and can return any evaluated expression. See the Match operator in the DataWeave Language Introduction.
1
2
3
4
%dw 2.0
output application/json
---
hello: "anniepoint@mulesoft.com" match /([a-z]*)@([a-z]*).com/
1
2
3
4
5
6
7
{
"hello": [
"anniepoint@mulesoft.com",
"anniepoint",
"mulesoft"
]
}
In the example above, we see that the search regular expression describes an email address. It contains two capture groups, what’s before and what’s after the @. The result is an array of three elements: the first is the whole email address, the second matches one of the capture groups, the third matches the other one.
10.1.28. Matches
matches(String, Regex): Boolean
Matches a string against a regular expression, and returns true or false.
1
2
3
4
%dw 2.0
output application/json
---
b: "admin123" matches /(\d+)/
1
2
3
{
"b": false
}
For more advanced use cases where you need to output or conditionally process the matched value, see Pattern Matching. |
10.1.29. Max
max(Array<T>): T
Returns the highest element in an array.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: max([1, 1000]),
b: max([1, 2, 3]),
d: max([1.5, 2.5, 3.5])
}
1
2
3
4
5
{
"a": 1000,
"b": 3,
"d": 3.5
}
10.1.30. MaxBy
maxBy(Array<T>, (item: T) → Comparable): T
Returns the element used to get the maximum result using a function.
1
2
3
4
%dw 2.0
output application/json
---
[ { a: "1" }, { a: "2" }, { a: "3" } ] maxBy ((item) -> item.a as Number)
1
{ "a": "3" }
10.1.31. Min
min(Array<T>): T
Returns the lowest element in an array.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: min([1, 1000]),
b: min([1, 2, 3]),
d: min([1.5, 2.5, 3.5])
}
1
2
3
4
5
{
"a": 1,
"b": 1,
"d": 1.5
}
10.1.32. MinBy
minBy(Array<T>, (item: T) → Comparable): T
Returns the element used to get the minimum result using a function.
1
2
3
4
%dw 2.0
output application/json
---
[ { a: 1 }, { a: 2 }, { a: 3 } ] minBy (item) -> item.a
1
{ "a": 1 }
10.1.33. Mod
mod(Number, Number): Number
Returns the remainder after performing a division of the first number by the second one.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: 3 mod 2,
b: 4 mod 2,
c: 2.2 mod 2
}
1
2
3
4
5
{
"a": 1,
"b": 0,
"c": 0.2
}
10.1.34. Native
native(String): Nothing
Loads a native function using the specified identifier.
10.1.35. Now
now(): DateTime
Returns a (Datetime) object with the current date and time.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: now(),
b: now().day,
c: now().minutes
}
1
2
3
4
5
{
"a": "2015-12-04T18:15:04.091Z",
"b": 4,
"c": 15
}
See DataWeave Selectors for a list of possible selectors to use here. |
10.1.36. OrderBy
orderBy(O, (V, K) → R): O
Returns the provided array (or object) ordered according to the value returned by the lambda. The lambda is invoked with two parameters: value and the index. If these parameters are not named, the index is defined by default as $$ and the value as $.
1
2
3
4
%dw 2.0
output application/json
---
orderByLetter: [{ letter: "d" }, { letter: "e" }, { letter: "c" }, { letter: "a" }, { letter: "b" }] orderBy $.letter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"orderByLetter": [
{
"letter": "a"
},
{
"letter": "b"
},
{
"letter": "c"
},
{
"letter": "d"
},
{
"letter": "e"
}
]
}
The orderBy function doesn’t have an option to order in descending order instead of ascending. What you can do in these cases is simply invert the order of the resulting array. Transform
Output
|
orderBy(Array<T>, (T, Number) → R): Array<T>
Sorts the array using the specified criteria
1
2
3
4
5
%dw 2.0
in payload application/json
output application/json
---
[3,2,3] orderBy $
1
2
3
4
5
[
2,
3,
3
]
10.1.37. Pluck
pluck({ (K)?: V }, (V, K, Number) → R): Array<R>
Pluck is useful for mapping an object into an array. Pluck is an alternate mapping mechanism to mapObject. Like mapObject, pluck executes a lambda over every key:value pair in its processed object as a tuple, but instead of returning an object, it returns an array, which may be built from either the values or the keys in the object.
The lambda is invoked with three parameters: value, key and index. If these parameters are not named, the value is defined by default as $, the key * and the index *$.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
result: {
keys: payload.prices pluck $$,
values: payload.prices pluck $
}
1
2
3
4
5
<prices>
<basic>9.99</basic>
<premium>53</premium>
<vip>398.99</vip>
</prices>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
"result": {
"keys": [
"basic",
"premium",
"vip"
],
"values": [
"9.99",
"53",
"398.99"
]
}
}
pluck(Null, (Nothing, Nothing, Nothing) → Any): Null
Helper function that allows pluck to work with null values
10.1.38. Pow
pow(Number, Number): Number
Returns the result of the first number a
to the power of the number following the pow
operator.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: 2 pow 3,
b: 3 pow 2,
c: 7 pow 3
}
1
2
3
4
5
{
"a": 8,
"b": 9,
"c": 343
}
10.1.39. Random
random(): Number
Returns a pseudo-random number between 0 and 1.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
price: random() * 1000
}
10.1.40. RandomInt
randomInt(Number): Number
Returns a pseudo-random integer number between 0 and the specified number (inclusive).
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
price: randomInt(1000) //Returns an integer from 0 to 1000
}
10.1.41. Read
read(String, String, Object)
The read function returns the result of parsing the content parameter with the specified mimeType reader.
The first argument points the content that must be read, the second is the format in which to write it. A third optional argument lists reader configuration properties.
[source,DataWeave,linenums] ---- %dw 2.0 output application/xml --- read('{"name":"DataWeave"}', "application/json") ---- .Output: [source,xml,linenums] ---- <name>DataWeave</name> ----
10.1.42. ReadUrl
readUrl(String, String, Object)
Same as the read
operator, but using a URL as the content provider.
10.1.43. Reduce
reduce(Array<T>, (T, T) → T): T
Apply a reduction to the array using just two parameters: the accumulator ($$), and the value ($). By default, the accumulator starts at the first value of the array.
1
2
3
4
%dw 2.0
output application/json
---
sum: [0, 1, 2, 3, 4, 5] reduce ($$ + $)
1
2
3
{
"sum": 15
}
1
2
3
4
%dw 2.0
output application/json
---
concat: ["a", "b", "c", "d"] reduce ($$ ++ $)
1
2
3
{
"concat": "abcd"
}
In some cases, you may not want to use the first element of the array as an accumulator. To set the accumulator to something else, you must define this in a lambda.
1
2
3
4
%dw 2.0
output application/json
---
concat: ["a", "b", "c", "d"] reduce ((val, acc = "z") -> acc ++ val)
1
2
3
{
"concat": "zabcd"
}
In other cases, you may want to turn an array into a string keeping the commas in between. The example below defines a lambda that also adds commas when concatenating.
1
2
3
4
%dw 2.0
output application/json
---
concat: ["a", "b", "c", "d"] reduce ((val, acc) -> acc ++ "," ++ val)
1
2
3
{
"concat": "a,b,c,d"
}
reduce(Array<T>, (T, A) → A): A
10.1.44. Replace
replace(String, Regex): ((Array<String>, Number) → String) → String
Replaces a section of a string for another, in accordance to a regular expression, and returns a modified string.
1
2
3
4
%dw 2.0
output application/json
---
b: "admin123" replace /(\d+)/ with "ID"
1
2
3
{
"b": "adminID"
}
replace(String, String): ((Array<String>, Number) → String) → String
Replaces the occurance of a given string inside other string with the specified value
1
2
3
4
%dw 2.0
output application/json
---
b: "admin123" replace "123" with "ID"
1
2
3
{
"b": "adminID"
}
10.1.45. Round
round(Number): Number
Rounds the value of a number to the nearest integer.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: round(1.2),
b: round(4.6),
c: round(3.5)
}
1
2
3
4
5
{
"a": 1,
"b": 5,
"c": 4
}
10.1.46. Scan
scan(String, Regex): Array<Array<String>>
Returns an array with all of the matches in the given string. Each match is returned as an array that contains the complete match, as well as any capture groups there may be in your regular expression.
1
2
3
4
%dw 2.0
output application/json
---
hello: "anniepoint@mulesoft.com,max@mulesoft.com" scan /([a-z]*)@([a-z]*).com/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
"hello": [
[
"anniepoint@mulesoft.com",
"anniepoint",
"mulesoft"
],
[
"max@mulesoft.com",
"max",
"mulesoft"
]
]
}
In the example above, we see that the search regular expression describes an email address. It contains two capture groups, what’s before and what’s after the @. The result is an array with two matches, as there are two email addresses in the input string. Each of these matches is an array of three elements, the first is the whole email address, the second matches one of the capture groups, the third matches the other one.
10.1.47. SizeOf
sizeOf(Array<T>): Number
Returns the number of elements in an array (or anything that can be converted to an array such as a string).
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
arraySize: sizeOf([1,2,3])
}
1
2
3
{
"arraySize": 3
}
sizeOf(Object): Number
Returns the number of elements in an object .
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
objectSize: sizeOf({a:1,b:2})
}
1
2
3
{
"objectSize": 2
}
sizeOf(Binary): Number
Returns the byte length of a binary value.
sizeOf(String): Number
Returns the number of characters in an string
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
textSize: sizeOf("MuleSoft")
}
1
2
3
{
"textSize": 8
}
10.1.48. SplitBy
splitBy(String, Regex): Array<String>
Performs the opposite operation as Join By. It splits a string into an array of separate elements, looking for instances of the provided string and using it as a separator.
1
2
3
4
%dw 2.0
output application/json
---
split: "a-b-c" splitBy /-/
1
2
3
{
"split": ["a","b","c"]
}
splitBy(String, String): Array<String>
Performs the opposite operation as Join By. It splits a string into an array of separate elements, looking for instances of the provided string and using it as a separator.
1
2
3
4
%dw 2.0
output application/json
---
split: "a-b-c" splitBy "-"
1
2
3
{
"split": ["a","b","c"]
}
10.1.49. Sqrt
sqrt(Number): Number
Returns the square root of the provided number.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: sqrt(4),
b: sqrt(25),
c: sqrt(100)
}
1
2
3
4
5
{
"a": 2.0,
"b": 5.0,
"c": 10.0
}
10.1.50. StartsWith
startsWith(String, String): Boolean
Returns true or false depending on if a string starts with a provided substring.
1
2
3
4
5
6
7
%dw 2.0
output application/json
---
{
a: "Mariano" startsWith "Mar",
b: "Mariano" startsWith "Em"
}
1
2
3
4
{
"a": true,
"b": false
}
10.1.51. Sum
sum(Array<Number>): Number
Given an array of numbers, it returns the result of adding of all of them.
1
2
3
4
%dw 2.0
output application/json
---
sum([1, 2, 3])
1
6
10.1.52. To
to(Number, Number): Range
Returns a range within the specified boundries. The upper boundry is inclusive.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
"myRange": 1 to 10
}
1
2
3
{
"myRange": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
10.1.53. Trim
trim(String): String
Removes any excess spaces at the start and end of a string.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
"a": trim(" my long text ")
}
1
2
3
{
"a": "my long text"
}
10.1.54. TypeOf
typeOf(T): Type<T>
Returns the type of a value.
1
2
3
4
%dw 2.0
output application/json
---
typeOf("A Text")
1
"String"
10.1.55. Unzip
unzip(Array<Array<T>>): Array<Array<T>>
Performs the opposite function of [zip arrays], that is: given a single array where each index contains an array with two elements, it outputs two separate arrays, each with one of the elements of the pair. This can also be scaled up, if the indexes in the provided array contain arrays with more than two elements, the output will contain as many arrays as there are elements for each index.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: unzip([[0,"a"],[1,"b"],[2,"c"],[3,"d"]]),
b: unzip([ [0,"a"], [1,"a"], [2,"a"], [3,"a"]]),
c: unzip([ [0,"a"], [1,"a","foo"], [2], [3,"a"]])
}
1
2
3
4
5
6
7
8
9
10
11
12
13
{
"a":[
[0, 1, 2, 3],
["a", "b", "c", "d"]
],
"b": [
[0,1,2,3],
["a","a","a","a"]
],
"c": [
[0,1,2,3]
]
}
Note even though example b can be considered the inverse function to the example b in [zip array], the result is not analogous, since it returns an array of repeated elements instead of a single element. Also note that in example c, since the number of elements in each component of the original array is not consistent, the output only creates as many full arrays as it can, in this case just one.
10.1.56. Upper
upper(String): String
Returns the provided string in uppercase characters.
1
2
3
4
5
6
%dw 2.0
output application/json
---
{
name: upper("mulesoft")
}
1
2
3
{
"name": "MULESOFT"
}
10.1.57. Uuid
uuid(): String
Returns a v4 UUID using random numbers as the source.
10.1.58. With
with(((V, U) → R) → X, (V, U) → R): X
Used with the replace applies the specified function
10.1.59. Write
write(Any, String, Object): Any
The write function returns a string with the serialized representation of the value in the specified mimeType.
The first argument points to the element that must be written, the second is the format in which to write it. A third optional argument lists writer configuration properties. See Output Directive and its sub-sections for a full list of available configuration options for each different format.
1
2
3
4
5
6
%dw 2.0
output application/xml
---
{
output: write(payload, "application/csv", {"separator" : "|"})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
{
"Name": "Mr White",
"Email": "white@mulesoft.com",
"Id": "1234",
"Title": "Chief Java Prophet"
},
{
"Name": "Mr Orange",
"Email": "orange@mulesoft.com",
"Id": "4567",
"Title": "Integration Ninja"
}
]
1
2
3
4
5
<?xml version='1.0' encoding='US-ASCII'?>
<output>Name|Email|Id|Title
Mr White|white@mulesoft.com|1234|Chief Java Prophet
Mr Orange|orange@mulesoft.com|4567|Integration Ninja
</output>
10.1.60. Zip
zip(Array<T>, Array<X>): Array<Array<T | X>>
Given two or more separate lists, the zip function can be used to merge them together into a single list of consecutive n-tuples. Imagine two input lists each being one side of a zipper: similar to the interlocking teeth of a zipper, the zip function interdigitates each element from each input list, one element at a time.
1
2
3
4
5
6
7
8
%dw 2.0
output application/json
---
{
a: [0, 1, 2, 3] zip ["a", "b", "c", "d"],
b: [0, 1, 2, 3] zip ["a"],
c: [0, 1, 2, 3] zip ["a", "b"]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
"a": [
[0,"a"],
[1,"b"],
[2,"c"],
[3,"d"]
],
"b": [
[0,"a"]
],
"c": [
[0,"a"],
[1,"b"]
]
}
Here is another example of the zip function with more than two input lists.
1
2
3
4
%dw 2.0
output application/json
---
payload.list1 zip payload.list2 zip payload.list3
1
2
3
4
5
6
{
"list1": ["a", "b", "c", "d"],
"list2": [1, 2, 3],
"list3": ["aa", "bb", "cc", "dd"],
"list4": [["a", "b", "c"], [1, 2, 3, 4], ["aa", "bb", "cc", "dd"]]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[
[
"a",
1,
"aa"
],
[
"b",
2,
"bb"
],
[
"c",
3,
"cc"
]
]
10.2. Types
10.2.1. String
String
type
-
Definition
String
10.2.2. Boolean
A Boolean
type true
of false
-
Definition
Boolean
10.2.3. Number
A number any number decimals and intigers are represented by Number
type
-
Definition
Number
10.2.4. Range
A Range type represents a sequence of numbers
-
Definition
Range
10.2.5. Namespace
A namespace type represented by an Uri and a Prefix
-
Definition
Namespace
10.2.6. Uri
An Uri
-
Definition
Uri
10.2.7. DateTime
A Date Time with in a TimeZone
-
Definition
DateTime
10.2.8. LocalDateTime
A DateTime in the current TimeZone
-
Definition
LocalDateTime
10.2.9. Date
A Date represented by Year Month Day
-
Definition
Date
10.2.10. LocalTime
A Time in the current TimeZone
-
Definition
LocalTime
10.2.11. Time
A Time in a specific TimeZone
-
Definition
Time
10.2.12. TimeZone
A TimeZone
-
Definition
TimeZone
10.2.13. Period
A Period
-
Definition
Period
10.2.14. Binary
A Blob
-
Definition
Binary
10.2.15. Null
A null type
-
Definition
Null
10.2.16. Regex
Regex Type
-
Definition
Regex
10.2.17. Nothing
Bottom type. This type is can be assigned to all the types
-
Definition
Nothing
10.2.18. Any
Any
type, is the top level type. Any extends all of the system types.
That means anything can be assigned to a Any
typed variable.
-
Definition
Any
10.2.19. Array
Array
type, requires a Type(T) to represent the elements of the list.
Example: Array<Number> represents an array of numbers.
-
Definition
Array
10.2.20. Object
Object
type. Represents any object, collection of Key Value Pairs
-
Definition
Object
10.2.21. Type
Represents a Type in the DataWeave Type System
-
Definition
Type
10.2.22. Key
A Key of an Object
-
Definition
Key
10.2.23. Dictionary
Generic Dictionary interface
-
Definition
{ _?: T }
10.2.24. Comparable
A union type that represents all the types that can be compared to each other.
-
Definition
String | Number | Boolean | DateTime | LocalDateTime | LocalTime | Time | TimeZone
10.2.25. SimpleType
A union type that represents all the simple types.
-
Definition
String | Boolean | Number | DateTime | LocalDateTime | Date | LocalTime | Time | TimeZone | Period
10.2.26. Iterator
This type is based in the iterator Java class. The iterator contains a collection, and includes methods to iterate through and filter it.
Just like the Java class, the iterator is designed to be consumed only once. For example, if you then pass this value to a logger would result in consuming it and it would no longer be readable to further elements in the flow. |
-
Definition
Array {iterator: true}
10.2.27. Enum
This type is based in the Enum java class.
It must always be used with the class
property, specifying the full java class name of the class, as shown in the example below.
1
2
3
4
%dw 2.0
output application/java
---
"Male" as Enum {class: "com.acme.GenderEnum"}
-
Definition
String {enumeration: true}
10.2.28. CData
XML defines a custom type named CData, it extends from string and is used to identify a CDATA XML block.
It can be used to tell the writer to wrap the content inside CDATA or to check if the input string arrives inside a CDATA block. :cdata
inherits from the type :string
.
1
2
3
4
5
6
7
8
9
10
%dw 2.0
output application/xml
---
{
users:
{
user : "Mariano" as CData,
age : 31 as CData
}
}
1
2
3
4
5
<?xml version="1.0" encoding="UTF-8"?>
<users>
<user><![CDATA[Mariano]]></user>
<age><![CDATA[31]]></age>
</users>
-
Definition
String {cdata: true}