> For the complete documentation index, see [llms.txt](https://docs-firehose.blip.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs-firehose.blip.ai/configuracoes/transformacao.md).

# Transformação

É possível aplicar transformações nas mensagens trafegadas no fluxo. Pode ser aplicada em qualquer tipo de configuração, inclusive com uma configuração de [Processamento em Streaming](/configuracoes/processamento-em-streaming.md).

{% hint style="warning" %}
No momento, as transformações **funcionam apenas com payloads com Content-Type `application/json`**.
{% endhint %}

## Tipos

As seguintes transformações são aceitas:

### HTTP

Permite que um endpoint HTTP externo seja consumido durante o processamento e atribui o resultado à mensagem.

### Bloblang

Permite um mapeamento usando a sintaxe [bloblang](https://www.benthos.dev/docs/guides/bloblang/about) e atribui o resultado à mensagem.

Para realizar testes da sintaxe a ferramenta [Bloblang Walkthrough](https://www.benthos.dev/docs/guides/bloblang/walkthrough) pode ser utilizada.

### Delete

Permite uma a sintaxe [bloblang](https://www.benthos.dev/docs/guides/bloblang/about) que retorne um valor booleano indicando se a mensagem deve ser excluída.

## Parâmetros

Parâmetros aceitos na configuração de transformação:

| Campo                                                | Descrição                                                                                                                                                                                                                                                                                                    | Valor                                                                                |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ |
| transformer.description                              | Descrição do estágio de transformação                                                                                                                                                                                                                                                                        | Tipo: string                                                                         |
| transformer.workflow                                 | Configuração de prioridade de execução do fluxo                                                                                                                                                                                                                                                              | <p>Tipo: \[]\[]string<br>Valor padrão: <code>\[\[id1,id2,...]]</code></p>            |
| transformer.steps                                    | Lista com as etapas de transformação                                                                                                                                                                                                                                                                         | <p>Tipo: list<br>Obrigatório</p>                                                     |
| transformer.steps.type                               | Tipo de transformação                                                                                                                                                                                                                                                                                        | <p>Tipo: enum\[BLOBLANG HTTP DELETE]<br>Obrigatório</p>                              |
| transformer.steps.id                                 | Id da transformação. Campo que recebe o resultado da transformação se o campo `override` é falso.                                                                                                                                                                                                            | <p>Tipo: string \[alphanum\_-]<br>Obrigatório - Único entre as etapas</p>            |
| transformer.steps.ignore\_error                      | Ignorar erro durante a transformação                                                                                                                                                                                                                                                                         | <p>Tipo: boolean<br>Valor padrão: <code>false</code></p>                             |
| transformer.steps.override                           | Substituir conteúdo da mensagem com o resultado da transformação                                                                                                                                                                                                                                             | <p>Tipo: boolean<br>Valor padrão: <code>false</code></p>                             |
| transformer.steps.http                               | Transformação do tipo Http                                                                                                                                                                                                                                                                                   | <p>Tipo: object<br>Obrigatório se o campo <code>type</code> for igual a HTTP</p>     |
| transformer.steps.http.url                           | Url do endpoint http a ser chamado                                                                                                                                                                                                                                                                           | <p>Tipo: string<br>Obrigatório se <code>dynamic\_url</code> não for informado</p>    |
| transformer.steps.http.dynamic\_url.mapping          | <p>Url do endpoint http a ser chamado na sintaxe <a href="https://www.benthos.dev/docs/guides/bloblang/about">bloblang</a> permitindo que sejam adicionados parâmetros dinâmicos a partir do payload da mensagem.<br>Ex: "<https://example.com?param1=%s&#x26;param2=%s\\".format(field1,parent.field2)></p> | <p>Tipo: string<br>Obrigatório se <code>url</code> não for informado</p>             |
| transformer.steps.http.verb                          | Tipo da requisição                                                                                                                                                                                                                                                                                           | <p>Tipo: enum\[GET POST]<br>Obrigatório</p>                                          |
| transformer.steps.http.headers                       | Cabeçalhos da requisição                                                                                                                                                                                                                                                                                     | <p>Tipo: object<br>Valor padrão: <code>-</code></p>                                  |
| transformer.steps.http.timeout\_seconds              | Tempo máximo da resposta em segundos                                                                                                                                                                                                                                                                         | <p>Tipo: int \[1-60]<br>Valor padrão: <code>5</code></p>                             |
| transformer.steps.http.ignore\_error\_codes          | Códigos de erro da reposta que devem ser ignorados                                                                                                                                                                                                                                                           | <p>Tipo: \[]int<br>Valor padrão: <code>\[]</code></p>                                |
| transformer.steps.http.body.mapping                  | Body da requisição na sintaxe [bloblang](https://www.benthos.dev/docs/guides/bloblang/about)                                                                                                                                                                                                                 | <p>Tipo: string<br>Valor padrão: <code>"root = this"</code></p>                      |
| transformer.steps.http.rate\_limit                   | Configuração de limites da requisição                                                                                                                                                                                                                                                                        | <p>Tipo: object<br>Valor padrão: <code>{}</code></p>                                 |
| transformer.steps.http.rate\_limit.count             | Quantidade máxima de requisições                                                                                                                                                                                                                                                                             | <p>Tipo: int<br>Valor padrão: <code>-</code></p>                                     |
| transformer.steps.http.rate\_limit.interval\_seconds | Intervalo em segundos                                                                                                                                                                                                                                                                                        | <p>Tipo: int<br>Valor padrão: <code>-</code></p>                                     |
| transformer.steps.http.basic\_auth                   | Autenticação básica da requisição                                                                                                                                                                                                                                                                            | <p>Tipo: object<br>Valor padrão: <code>{}</code></p>                                 |
| transformer.steps.http.basic\_auth.user\_id          | Identificador de acesso                                                                                                                                                                                                                                                                                      | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.basic\_auth.password          | Senha de acesso                                                                                                                                                                                                                                                                                              | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth                         | Autenticação oauth da requisição                                                                                                                                                                                                                                                                             | <p>Tipo: object<br>Valor padrão: <code>{}</code></p>                                 |
| transformer.steps.http.oauth.consumer\_key           | Chave de consumo da API                                                                                                                                                                                                                                                                                      | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth.consumer\_secret        | Segredo de consumo da API                                                                                                                                                                                                                                                                                    | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth.access\_token           | Token de acesso da API                                                                                                                                                                                                                                                                                       | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth.access\_token\_secret   | Segredo do token de acesso da API                                                                                                                                                                                                                                                                            | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth2                        | Autenticação oauth 2 da requisição                                                                                                                                                                                                                                                                           | <p>Tipo: object<br>Valor padrão: <code>{}</code></p>                                 |
| transformer.steps.http.oauth2.client\_key            | Chave do cliente da API                                                                                                                                                                                                                                                                                      | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth2.client\_secret         | Segredo do cliente da API                                                                                                                                                                                                                                                                                    | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth2.token\_url             | Url do serviço de autenticação                                                                                                                                                                                                                                                                               | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.http.oauth2.scopes                 | Escopos de autenticação                                                                                                                                                                                                                                                                                      | <p>Tipo: \[]string<br>Valor padrão: <code>\[]</code></p>                             |
| transformer.steps.http.oauth2.auth\_style            | Localização dos parâmetros com a autenticação                                                                                                                                                                                                                                                                | <p>Tipo: enum\[param header body]<br>Valor padrão: <code>param</code></p>            |
| transformer.steps.http.oauth2.endpoint\_params       | Parâmetros adicionais do serviço de autenticação                                                                                                                                                                                                                                                             | <p>Tipo: map\[string]\[]string<br>Valor padrão: <code>{}</code></p>                  |
| transformer.steps.bloblang                           | Transformação do tipo Bloblang                                                                                                                                                                                                                                                                               | <p>Tipo: object<br>Obrigatório se o campo <code>type</code> for igual a BLOBLANG</p> |
| transformer.steps.bloblang.mapping                   | Sintaxe [bloblang](https://www.benthos.dev/docs/guides/bloblang/about) com a transformação a ser aplicada na mensagem                                                                                                                                                                                        | <p>Tipo: string<br>Obrigatório</p>                                                   |
| transformer.steps.delete                             | Transformação do tipo Delete                                                                                                                                                                                                                                                                                 | <p>Tipo: object<br>Obrigatório se o campo <code>type</code> for igual a DELETE</p>   |
| transformer.steps.delete.mapping                     | Sintaxe [bloblang](https://www.benthos.dev/docs/guides/bloblang/about) que resulte em um valor booleano indicando que a mensagem deve ser removida                                                                                                                                                           | <p>Tipo: string<br>Obrigatório</p>                                                   |

## Requisição

Para habilitar a transformação a seguinte requisição pode ser realizada:

```bash
curl --location '<HOST>/v1/configs' \
--header 'Content-Type: application/json' \
--header 'Authorization: <ACCESS-TOKEN>' \
--data '{
{
  "transformer": {
    "description": "TRANSFORMER-DESCRIPTION",
    "workflow": [
      [
        "http"
      ],
      [
        "bloblang"
      ],
      [
        "delete"
      ]
    ],
    "steps": [
      {
        "id": "http",
        "type": "HTTP",
        "ignore_error": false,
        "override": false,
        "http": {
          "url": "https://example.com",
          "dynamic_url": {
            "mapping": "\"https://example.com?param1=%s&param2=%s\".format(field1,parent.field2)"
          },
          "verb": "GET",
          "headers": {
            "key": "value"
          },
          "timeout_seconds": 10,
          "ignore_error_codes": [
            1,
            2,
            3
          ],
          "body": {
            "mapping": "root = this"
          },
          "rate_limit": {
            "count": 100,
            "interval_seconds": 10
          },
          "basic_auth": {
            "user_id": "USERNAME",
            "password": "PASSWORD"
          },
          "oauth": {
            "consumer_key": "CONSUMER_KEY",
            "consumer_secret": "CONSUMER_SECRET",
            "access_token": "ACCESS_TOKEN",
            "access_token_secret": "ACCESS_TOKEN_SECRET"
          },
          "oauth2": {
            "client_key": "CLIENT_KEY",
            "client_secret": "CLIENT_SECRET",
            "token_url": "TOKEN_URL",
            "auth_style": "body",
            "scopes": [
              "SCOPE"
            ],
            "endpoint_params": {
              "key": [
                "value"
              ]
            }
          }
        }
      },
      {
        "id": "bloblang",
        "type": "BLOBLANG",
        "ignore_error": false,
        "override": false,
        "bloblang": {
          "mapping": "root = this.http"
        }
      },
      {
        "id": "delete",
        "type": "DELETE",
        "ignore_error": false,
        "override": false,
        "delete": {
          "mapping": "root = this.bloblang == \"OK\""
        }
      }
    ]
  }
}
}'
```

No exemplo acima foi gerada uma configuração do Firehose que aplica 3 etapas de transformação de forma sequencial na mensagem.

A primeira etapa realiza uma requisição http e armazena o resultado no campo `http`. A segunda etapa recupera o resultado do campo adicionado pela etapa anterior e armazena o resultado no campo `bloblang`.\
A última etapa verifica se o valor do campo adicionado na etapa anterior é igual à `OK`, em caso positivo a mensagem será apagada.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs-firehose.blip.ai/configuracoes/transformacao.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
