# 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](/documentation/connectors-and-triggers/pt-br/double-braces/overview.md) 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](/documentation/connectors-and-triggers/pt-br/double-braces/overview.md) (`{{ }}`).

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


---

# 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/pt-br/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.