Hosted extractor mapping language
The hosted extractor mapping language translates JSON structures to other JSON structures. The language is similar to JavaScript and is purely functional. A mapping is a single expression that describes how to build one JSON structure from another.
Variables
Use these input objects to define a mapping:
-
input
- This is the content of the received message, parsed into an object. -
context
- This contains information about the message. The content of this object varies between the different hosted extractors.For MQTT, the
context
object containstopic
: which topic the message arrived at
For examples of using these variables, see Handling more data in a single message.
When variables are objects or arrays they can be selected from. For example, given the object
{
"someField": 123,
"someArray": [1, 2, 3, { "nested": [1, 2, 3] }]
}
you can select from an object with
input.someField -> 123
or
input["someField"] -> 123
You select from arrays with
input.someArray[0] -> 1
Selectors can be nested as
input.someArray[3].nested[2] -> 3
Selectors can contain expressions
input.someArray[1 + 1] -> 3
Functions
The hosted extractor mapping language contains a set of predefined functions, which can be used to transform the input in other ways.
For example,
float("1.4") -> 1.4
will try to transform the input from a string to a number, which may fail.
Any function can also be called postfix, as a method on a value, so you could instead write
"1.4".float() -> 1.4
This is especially useful when dealing with chained operations.
See also Functions.
Lambda expressions
Some functions can take user defined functions as arguments, such as map
, reduce
, or filter
. To create the functions for these, use Lambda notation: argument => return
.
If the function takes no arguments, use ()
as the input to the function. If a function takes multiple values, denote them as a tuple: (arg1, arg2)
.
Examples
If we want to turn the list [1, 2, 3, 4]
into [2, 4, 6, 8]
we can use map
to apply a function to each member of the list, and write a lambda function that doubles each value:
[1, 2, 3, 4].map(number => number * 2) -> [2, 4, 6, 8]
If you want to remove all null
s from a list, use the filter
function, and write a lambda function that returns true if the value is the null
type using the is
operator:
[0, 1, 2, 3, 4, null, 5].filter(item => !(item is "null")) -> [0, 1, 2, 3, 4, 5]
To sum all the numbers from 1 through 10, use the reduce
function to iteratively add the next member of the list to an aggregate:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].reduce((sum, next) => sum + next, 0) -> 110
Operators
The operators take one or two inputs and output some value. The operators are:
Plus
1 + 2 + 3 -> 6
Adds two numbers together.
Minus
1 - 2 - 3 -> -4
Subtracts a number from another.
Multiply
2 * 3 -> 6
Multiplies two numbers.
Divide
3 / 2 -> 1.5
Divides one number by another.
And
true && false -> false
Boolean AND, returns true
if the inputs are both not null
or false
.
Or
true || false -> true
Boolean OR, returns true
if either input is not null
or false
.
Equals
1 == 2 -> false
Checks for exact equality. The inputs must be the same type, or this will be false
.
Not equals
1 != 2 -> true
Checks for inequality.
Greater than
2 > 3 -> false
Checks if the first number is greater than the second number.
Greater than or equal
2 >= 3 -> false
Checks if the first number is greater than or equal to the second number.
Less than
2 < 3 -> true
Checks if the first number is less than the second number.
Less than
2 <= 3 -> true
Checks if the first number is less than or equal to the second number.
Modulo
5 % 2 -> 1
Computes the modulus, or remainder, of the first argument divided by the second argument.