# JSLT

The **JSLT** connector allows manipulation of a JSON using JSLT, a language for JSON processing and querying. For more information, [see the official documentation on Github](https://github.com/schibsted/jslt).

The connector is useful to perform several actions, such as:

* Modify the structure of a JSON and keep its values.
* Add, extract, and remove data from a JSON.
* Sort the structure of a JSON.
* Modify the values contained in a JSON through functions, such as text manipulation, mathematical calculations, conversions between data types, among others.
* Access and manipulate data from arrays.

## **Parameters**

Take a look at the configuration parameters for the connector. Parameters supported by [Double Braces expressions](https://docs.digibee.com/documentation/connectors-and-triggers/double-braces/overview) are marked with `(DB)`.

### **General tab**

<table data-full-width="true"><thead><tr><th>Parameter</th><th>Description</th><th>Default value</th><th>Data type</th></tr></thead><tbody><tr><td><strong>Payload</strong> <code>(DB)</code></td><td>The JSON content to be manipulated.</td><td><code>{{ message.payload }}</code></td><td>JSON</td></tr><tr><td><strong>JSLT</strong></td><td>The JSLT declaration to be executed.</td><td><code>{ *: . }</code></td><td>JSON</td></tr><tr><td><strong>Fail On Error</strong></td><td>If enabled, interrupts the pipeline execution when an error occurs. If disabled, execution continues, but the <code>"success"</code> property will be set to <code>false</code>.</td><td>False</td><td>Boolean</td></tr><tr><td><strong>Raw Mode</strong></td><td><p>If this option is active, the JSLT expression can dynamically incorporate values using Double Braces (<code>{{ }}</code>) for entire expressions, object keys, or object values. This enables more flexible and dynamic transformations.</p><p></p><p><strong>Important:</strong> When using Double Braces for a JSON key within the <code>jsltExpr</code> and <strong>Raw Mode</strong> is <strong>enabled</strong>, you must escape the key. For example, to dynamically use <code>myKey</code> as a key, you would write <code>"{ \"{{message.myKey}}\": .value }"</code>.</p></td><td>False</td><td>Boolean</td></tr></tbody></table>

{% hint style="info" %}
The connector doesn’t support JSLT import statements.
{% endhint %}

### **Documentation tab**

<table data-full-width="true"><thead><tr><th>Parameter</th><th>Description</th><th>Default value</th><th>Data type</th></tr></thead><tbody><tr><td><strong>Documentation</strong></td><td>Optional field to describe the connector configuration and any relevant business rules.</td><td>N/A</td><td>String</td></tr></tbody></table>

## **JSLT expression examples**

### **Simple data transpose**

#### **Payload**

```json
{
  "id" : "w23q7ca1-8729-24923-922b-1c0517ddffjf1",
  "type" : "component",
  "prefix": "jslt",
  "myString": "test",
  "myArray": [ 1, 2, 3, 4],
  "boolean": true
}
```

#### **JSLT**

```json
{
  "uuid": .id,
  "obj": {
   "key-1": .type,
   "key-2": .prefix
  },
  * - myString, myArray, id: .
}
```

#### **Output**

```json
{
  "uuid" : "w23q7ca1-8729-24923-922b-1c0517ddffjf1",
  "obj" : {
    "key-1" : "component",
    "key-2" : "jslt"
  },
  "type" : "component",
  "prefix" : "jslt",
  "boolean" : true
}
```

### **JSLT Native functions**

{% hint style="info" %}
The example below represents some of the available JSLT native functions. For more information about it and the complete list of functions, [visit the Github documentation](https://github.com/schibsted/jslt/blob/master/functions.md).
{% endhint %}

#### **Payload**

```json
{
  "id" : "w23q7ca1-8729-24923-922b-1c0517ddffjf1",
  "type" : "component",
  "prefix": "jslt",
  "myString": "TEST",
  "myArray": [ 1, 2, 3, 4],
  "boolean": true
}

```

#### **JSLT**

```json
{
  "uuid": split(.id, "-"),
  "obj": {
   "key-1": uppercase(.type),
   "key-2": join(.myArray, lowercase(.myString))
  },
  * : .
}
```

#### **Output**

```json
{
  "uuid" : [ "w23q7ca1", "8729", "24923", "922b", "1c0517ddffjf1" ],
  "obj" : {
    "key-1" : "COMPONENT",
    "key-2" : "1test2test3test4"
  },
  "id" : "w23q7ca1-8729-24923-922b-1c0517ddffjf1",
  "type" : "component",
  "prefix" : "jslt",
  "myString" : "TEST",
  "myArray" : [ 1, 2, 3, 4 ],
  "boolean" : true
}
```

### **Variables and custom functions**

#### **Payload**

```json
{
  "id" : "w23q7ca1-8729-24923-922b-1c0517ddffjf1",
  "s1": "jslt",
  "s2": "component"
}
```

#### **JSLT**

```json
let splitted = split(.id, "-")
let size = size($splitted)

def concat(s1, s2)
  if ($s1 != null)
    $s1 + "___" + $s2
  else
    ""

{
  "variables": $splitted,
  "size": $size,
  "customFunction": concat(.s1, .s2)
}
```

#### **Output**

```json
{
  "variables": [
    "w23q7ca1",
    "8729",
    "24923",
    "922b",
    "1c0517ddffjf1"
  ],
  "size": 5,
  "customFunction": "jslt___component"
}
```

### **If and For Operators**

#### **Payload**

```json
{
  "id" : "w23q7ca1-8729-24923-922b-1c0517ddffjf1",
  "status": true
}
```

#### **JSLT**

```json
let aux = split(.id, "-")

def concat(string1, string2)
   $string1 + "-" + $string2

{
  "forResult": [for ($aux) concat("test", .)],
  "ifResult": if (.status)
                 size(.id)
              else
                 0
}

```

#### **Output**

```javascript
{
  "forResult" : [ "test-w23q7ca1", "test-8729", "test-24923", "test-922b", "test-1c0517ddffjf1" ],
  "ifResult" : 38
}

```

### **Dynamic expressions with Raw Mode**

When **Raw Mode** is enabled, you can dynamically construct parts of your JSLT expression using [Double Braces](https://docs.digibee.com/documentation/connectors-and-triggers/double-braces/overview) (`{{ }}`).

<details>

<summary><strong>Complete dynamic expression</strong></summary>

This example shows how to use a complete JSLT expression passed dynamically through the payload.

**Parameters**

* **Payload**: `{{ message.payload }}`
* **JSLT**: `{{ message.expression }}`
* **Raw Mode**: `true`

**Input Payload**

```json
{
  "payload": {
    "id" : "123456",
    "type": "String",
    "object": {
      "nested": "true"
    },
    "array": [
      99, 88, 77, 66, 55
    ]
  },
  "expression": "{  \\"code\\" : .id,  \\"boolean\\": .object.nested,  \\"element\\": .array[3],  \\"range\\": . array[0 : 2],   *: .}"
}
```

**Output**

```json
{
  "code": "123456",
  "boolean": "true",
  "element": 66,
  "range": [ 99, 88 ],
  "id": "123456",
  "type": "String",
  "object": {
    "nested": "true"
  },
  "array": [ 99, 88, 77, 66, 55 ]
}
```

</details>

<details>

<summary><strong>Dynamic object key</strong></summary>

This example demonstrates how to dynamically set an object key within the JSLT expression. Note the escaped double quotes for the dynamic key.

**Parameters**

* **Payload**: `{{ message.payload }}`
* **JSLT**: `{ "code" : .id, {{ message.key }}: .object.nested, "element": .array[3], "range": . array[0 : 2], *: .}`
* **Raw Mode**: `true`

**Input payload**

```json
{
  "payload": {
    "id" : "123456",
    "type": "String",
    "object": {
      "nested": "true"
    },
    "array": [
      99, 88, 77, 66, 55
    ]
  },
  "key": "\"boolean\""
}
```

**Output**

```json
{
  "code": "123456",
  "boolean": "true",
  "element": 66,
  "range": [ 99, 88 ],
  "id": "123456",
  "type": "String",
  "object": {
    "nested": "true"
  },
  "array": [ 99, 88, 77, 66, 55 ]
}
```

</details>

<details>

<summary><strong>Dynamic object value</strong></summary>

This example shows how to dynamically set an object value within the JSLT expression.

**Parameters**

* **Payload**: `{{ message.payload }}`
* **JSLT**: `{ "code" : .id, "boolean": {{ message.value }}, "element": .array[3], "range": . array[0 : 2], *: .}`
* **Raw Mode**: `true`

**Input payload**

```json
{
  "payload": {
    "id" : "123456",
    "type": "String",
    "object": {
      "nested": "true"
    },
    "array": [
      99, 88, 77, 66, 55
    ]
  },
  "value": ".object.nested"
}
```

**Output**

```json
{
  "code": "123456",
  "boolean": "true",
  "element": 66,
  "range": [ 99, 88 ],
  "id": "123456",
  "type": "String",
  "object": {
    "nested": "true"
  },
  "array": [ 99, 88, 77, 66, 55 ]
}
```

</details>

<details>

<summary><strong>Dynamic object key and value</strong></summary>

This example demonstrates using Double Braces for both a dynamic key-value pair (`*: .`) within the JSLT expression.

**Parameters**

* **Payload**: `{{ message.payload }}`
* **JSLT**: `{ "code" : .id, "boolean": {{ message.value }}, "element": .array[3], "range": . array[0 : 2], {{ message.keyAndValue }}}`
* **Raw Mode**: `true`

**Input payload**

```json
{
  "payload": {
    "id" : "123456",
    "type": "String",
    "object": {
      "nested": "true"
    },
    "array": [
      99, 88, 77, 66, 55
    ]
  },
  "value": ".object.nested",
  "keyAndValue": "*:."
}
```

**Output**

```json
{
  "code": "123456",
  "boolean": "true",
  "element": 66,
  "range": [ 99, 88 ],
  "id": "123456",
  "type": "String",
  "object": {
    "nested": "true"
  },
  "array": [ 99, 88, 77, 66, 55 ]
}
```

</details>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.digibee.com/documentation/connectors-and-triggers/connectors/tools/jslt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.