JSLT

Saiba mais sobre o conector JSLT e como usá-lo na Digibee Integration Platform.

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.

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 estão marcados com (DB).

Aba General

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

O conector não suporta importação de declarações JSLT.

Aba Documentation

Parâmetro	Descrição	Valor padrão	Tipo de dado
Documentation	Campo opcional para descrever a configuração do conector e quaisquer regras de negócio relevantes.	N/A	String

Exemplos de expressões JSLT

Transposição de dados simples

Payload

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

JSLT

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

Saída

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

Funções nativas JSLT

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.

Payload

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

JSLT

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

Saída

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

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

JSLT

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

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

Operadores If e For

Payload

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

JSLT

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

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

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

Saída

{
  "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 ({{ }}).

Expressão dinâmica completa

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

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

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

Chave de objeto dinâmica

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

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

Saída

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

Valor de objeto dinâmico

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

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

Saída

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

Chave e valor de objeto dinâmicos

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

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

Saída

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