# JSLT

O conector **JSLT** permite a manipulação de um JSON utilizando JSLT, uma linguagem para processamento e consulta de dados em JSON. Para mais informações, [consulte a documentação oficial no GitHub](https://github.com/schibsted/jslt).

Esse conector é útil para realizar diversas ações, como:

* Modificar a estrutura de um JSON mantendo seus valores.
* Adicionar, extrair e remover dados de um JSON.
* Ordenar a estrutura de um JSON.
* Modificar os valores contidos em um JSON por meio de funções, como manipulação de texto, cálculos matemáticos, conversões entre tipos de dados, entre outras.
* Acessar e manipular dados de arrays.

## **Parâmetros**

Dê uma olhada nos parâmetros de configuração do conector. Parâmetros suportados por [expressões Double Braces](https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/double-braces/overview) estão marcados com `(DB)`.

### **Aba General**

<table data-full-width="true"><thead><tr><th>Parâmetro</th><th>Descrição</th><th>Valor padrão</th><th>Tipo de dado</th></tr></thead><tbody><tr><td><strong>Payload</strong> <code>(DB)</code></td><td>O conteúdo JSON a ser manipulado.</td><td><code>{{ message.payload }}</code></td><td>JSON</td></tr><tr><td><strong>JSLT</strong></td><td>A declaração JSLT a ser executada.</td><td><code>{ *: . }</code></td><td>JSON</td></tr><tr><td><strong>Fail On Error</strong></td><td>Se ativado, interrompe a execução do pipeline ao ocorrer um erro. Se desativado, a execução continua, mas a propriedade <code>"success"</code> será definida como <code>false</code>.</td><td>False</td><td>Booleano</td></tr><tr><td><strong>Raw Mode</strong></td><td><p>Se esta opção estiver ativa, a expressão JSLT pode incorporar dinamicamente valores usando Double Braces (<code>{{ }}</code>) em expressões inteiras, chaves de objetos ou valores. Isso permite transformações mais flexíveis e dinâmicas. </p><p></p><p><strong>Importante:</strong> Ao usar Double Braces para uma chave JSON dentro de <code>jsltExpr</code> com o <strong>Raw Mode</strong> ativado, é necessário escapar a chave. Por exemplo, para usar dinamicamente <code>myKey</code> como chave, deve-se escrever <code>"{ \"{{message.myKey}}\": .value }"</code>.</p></td><td>False</td><td>Booleano</td></tr></tbody></table>

{% hint style="info" %}
O conector não suporta importação de declarações JSLT.
{% endhint %}

### **Aba Documentation**

<table data-full-width="true"><thead><tr><th>Parâmetro</th><th>Descrição</th><th>Valor padrão</th><th>Tipo de dado</th></tr></thead><tbody><tr><td><strong>Documentation</strong></td><td>Campo opcional para descrever a configuração do conector e quaisquer regras de negócio relevantes.</td><td>N/A</td><td>String</td></tr></tbody></table>

## **Exemplos de expressões JSLT**

### **Transposição de dados simples**

#### **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: .
}
```

#### **Saída**

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

### **Funções nativas JSLT**

{% hint style="info" %}
O exemplo abaixo representa algumas das funções nativas JSLT disponíveis. Para mais informações e a lista completa de funções, [visite a documentação do Github](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))
  },
  * : .
}
```

#### **Saída**

```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
}
```

### **Variáveis e funções personalizadas**

#### **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)
}
```

#### **Saída**

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

### **Operadores If e For**

#### **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
}
```

#### **Saída**

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

### **Expressões dinâmicas com o Raw Mode**

Quando o **Raw Mode** está ativado, você pode construir partes da sua expressão JSLT dinamicamente usando [Double Braces](https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/double-braces/overview) (`{{ }}`).

<details>

<summary><strong>Expressão dinâmica completa</strong></summary>

Este exemplo mostra como usar uma expressão JSLT completa passada dinamicamente através do payload.

**Parâmetros**

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

**Payload de entrada**

```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],   *: .}"
}
```

**Saída**

```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>Chave de objeto dinâmica</strong></summary>

Este exemplo demonstra como definir dinamicamente uma chave de objeto dentro da expressão JSLT. Note as aspas duplas escapadas para a chave dinâmica.

**Parâmetros**

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

**Payload de entrada**

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

**Saída**

```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>Valor de objeto dinâmico</strong></summary>

Este exemplo mostra como definir dinamicamente um valor de objeto dentro da expressão JSLT.

**Parâmetros**

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

**Payload de entrada**

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

**Saída**

```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>Chave e valor de objeto dinâmicos</strong></summary>

Este exemplo demonstra o uso de Double Braces para um par chave-valor dinâmico (`*: .`) dentro da expressão JSLT.

**Parâmetros**

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

**Payload de entrada**

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

**Saída**

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

</details>