Operadores personalizados

O Fracttal ETL estende os operadores padrão do JSON Logic com operadores próprios disponíveis no bloco transform de qualquer configuração ETL.

Renomeação e cast

`rename`

Mapeia campos de origem para destino, renomeando-os e opcionalmente fazendo cast do tipo.

Assinatura: ["rename", [logic, "novo_nome", "tipo?"], ...]

Cada elemento do array é uma tupla de 2 ou 3 elementos: a lógica para obter o valor, o nome do campo de saída e o tipo de cast opcional.

{
  "rename": [
    [{"var": "firstName"}, "nombre", "string"],
    [{"var": "age"}, "edad", "integer"],
    [{"var": "price"}, "precio", "number"],
    [{"var": "active"}, "activo", "boolean"],
    [{"var": "tags"}, "etiquetas", "array"]
  ]
}

Consulte Tipos de dados para a referência completa dos tipos de cast.

Texto

`trim`

Remove caracteres das extremidades de uma string.

Assinatura: ["trim", logic, "caracteres", "mode"]

Parâmetro	Tipo	Padrão	Descrição
`logic`	JSON Logic	—	Expressão para obter a string
`caracteres`	string	—	Caracteres a remover
`mode`	string	`"all"`	`"all"`, `"left"` ou `"right"`

{"trim": [{"var": "name"}, " ", "all"]}

{"trim": [{"var": "code"}, "0", "left"]}

`split`

Divide uma string por um separador e retorna o elemento no índice indicado.

Assinatura: ["split", logic, "separador", indice]

{"split": [{"var": "full_name"}, " ", 0]}

{"split": [{"var": "email"}, "@", 1]}

`join`

Une os elementos de um array em uma string usando um separador.

Assinatura: ["join", logic, "separador"]

{"join": [{"var": "tags"}, ", "]}

`substring`

Extrai uma parte de uma string por índice de início e fim.

Assinatura: ["substring", logic, inicio, fim]

Índices com base 0. Se fim for 0, extrai até o final.

{"substring": [{"var": "code"}, 0, 4]}

{"substring": [{"var": "description"}, 10, 0]}

`case`

Converte uma string para maiúsculas ou minúsculas.

Assinatura: ["case", logic, "upper"|"lower"]

{"case": [{"var": "country"}, "upper"]}

`replace`

Substitui todas as ocorrências de uma substring na string.

Assinatura: ["replace", logic, "original", "substituto"]

{"replace": [{"var": "phone"}, "-", ""]}

{"replace": [{"var": "text"}, " ", "_"]}

`switch`

Mapeia um valor para outro usando pares valor,resultado separados por vírgula. O último elemento sem par é o valor padrão.

Assinatura: ["switch", logic, "v1,r1,v2,r2,...,default"]

{"switch": [{"var": "status"}, "A,Activo,I,Inactivo,P,Pendiente,Desconocido"]}

Com um único par e sem padrão:

{"switch": [{"var": "type"}, "premium,true,"]}

`replace_if_condition`

Substitui o valor somente se ele coincidir com um valor de comparação; caso contrário, retorna o valor original.

Assinatura: ["replace_if_condition", logic, "valor_comparar", "valor_substituto"]

{"replace_if_condition": [{"var": "status"}, "None", "Pendiente"]}

{"replace_if_condition": [{"var": "category"}, "null", "Sin categoría"]}

`string_to_array`

Divide uma string em um array usando o separador indicado.

Assinatura: ["string_to_array", logic, "separador"]

{"string_to_array": [{"var": "tags"}, ","]}

`startsWith`

Retorna true se a string começa com o prefixo fornecido.

Assinatura: ["startsWith", logic, "prefixo"]

{"startsWith": [{"var": "code"}, "FTL-"]}

`endsWith`

Retorna true se a string termina com o sufixo fornecido.

Assinatura: ["endsWith", logic, "sufixo"]

{"endsWith": [{"var": "filename"}, ".pdf"]}

Números

`round`

Arredonda um número para o número de casas decimais indicado. Sem decimais, arredonda para o inteiro mais próximo.

Assinatura: ["round", logic, decimais?]

{"round": [{"var": "price"}, 2]}

{"round": [{"var": "total"}, 0]}

`format_number`

Formata um número usando templates de formato Python ({:,}, {:.2f}, etc.).

Assinatura: ["format_number", logic, "formato_inteiro", "formato_decimal?"]

{"format_number": [{"var": "amount"}, "{:,}"]}

Com decimais:

{"format_number": [{"var": "amount"}, "{:,}", "{:.2f}"]}

Datas

`format_date`

Converte datas entre formatos, aplica fusos horários ou gera a data/hora atual.

Assinatura: ["format_date", logic_ou_"now", "formato_entrada", "formato_saida", "timezone?"]

Formato de saída especial	Descrição
`"timestamp"`	Unix timestamp como string
`"microsoft_json_date"`	Formato `/Date(milissegundos)/`

Conversão de formato:

{"format_date": [{"var": "created_at"}, "%Y-%m-%d", "%d/%m/%Y"]}

Com fuso horário:

{"format_date": [{"var": "date"}, "%Y-%m-%dT%H:%M:%S", "%d/%m/%Y %H:%M", "America/Santiago"]}

Data e hora atual:

{"format_date": ["now", "", "%Y-%m-%dT%H:%M:%S", "Europe/Madrid"]}

Para timestamp:

{"format_date": [{"var": "date"}, "%Y-%m-%d", "timestamp"]}

`add_timedelta`

Soma um intervalo de tempo a uma data no formato ISO 8601 (%Y-%m-%dT%H:%M:%S.%f%z).

Assinatura: ["add_timedelta", "data_iso", numero, "tipo"]

`tipo`	Descrição
`"hour"` (padrão)	Horas
`"day"`	Dias (equivale a 24 horas)
`"second"`	Segundos

{"add_timedelta": ["2024-01-15T00:00:00.000+0000", 24, "hour"]}

{"add_timedelta": ["2024-01-15T00:00:00.000+0000", 7, "day"]}

`substract_timedelta`

Subtrai um intervalo de tempo de uma data no formato ISO 8601.

Assinatura: ["substract_timedelta", "data_iso", numero, "tipo"]

{"substract_timedelta": ["2024-01-15T00:00:00.000+0000", 1, "day"]}

`substract_datetime`

Calcula a diferença entre duas datas e a retorna em segundos.

Assinatura: ["substract_datetime", logic, "data_referencia_ou_now", "formato"]

Usando "now" como referência (data atual em UTC):

{"substract_datetime": [{"var": "start_date"}, "now", "%Y-%m-%dT%H:%M:%S%z"]}

Entre duas datas concretas:

{"substract_datetime": [{"var": "end_date"}, "2024-01-01T00:00:00+0000", "%Y-%m-%dT%H:%M:%S%z"]}

Booleanos

`set_boolean`

Converte um valor para true/false/null comparando-o com valores de referência.

Assinatura: ["set_boolean", logic, "valor_true", "valor_false?"]

Caso	Comportamento
Sem `valor_false`	`true` se coincidir com `valor_true`, `false` em qualquer outro caso
Com `valor_false`	`true`, `false` ou `null` se não coincidir com nenhum

{"set_boolean": [{"var": "status"}, "active"]}

Com valor false explícito:

{"set_boolean": [{"var": "flag"}, "SI", "NO"]}

Arrays

`in`

Retorna true se um valor está contido no resultado da lógica.

Assinatura: ["in", "valor", logic]

{"in": ["admin", {"var": "roles"}]}

`flatmap`

Achata um array de objetos adicionando campos do contexto pai a cada elemento.

Assinatura: ["flatmap", logic_array, context_fields?]

context_fields é uma lista de especificações de campos do objeto pai a injetar em cada item:

{
  "flatmap": [
    {"var": "items"},
    [
      {"field": {"var": "order_id"}, "as": "order_id"},
      {"field": {"var": "customer_name"}, "as": "customer"}
    ]
  ]
}

Sem campos de contexto (apenas achata o array):

{"flatmap": [{"var": "lines"}]}

Exemplo completo

Transformação de um pedido: renomeação, formato de data, cálculo de diferença e cast de tipo.

{
  "merge": [
    {
      "rename": [
        [{"var": "orderId"}, "id_pedido", "string"],
        [{"var": "totalAmount"}, "total", "number"],
        [{"var": "customerName"}, "cliente", "string"]
      ]
    },
    {
      "fecha_creacion": {
        "format_date": [{"var": "createdAt"}, "%Y-%m-%dT%H:%M:%S", "%d/%m/%Y", "America/Bogota"]
      }
    },
    {
      "estado": {
        "switch": [{"var": "status"}, "pending,Pendiente,confirmed,Confirmado,cancelled,Cancelado,Desconocido"]
      }
    },
    {
      "nombre_cliente": {
        "trim": [{"var": "customerName"}, " ", "all"]
      }
    }
  ]
}

Operadores personalizados

Renomeação e cast

rename

Texto

trim

split

join

substring

case

replace

switch

replace_if_condition

string_to_array

startsWith

endsWith