---
title: Transformação com Go Template
slug: transformacao-com-go-template
icon: {"faIcon":"fa-solid fa-graduation-cap"}
docTags: 
createdAt: 2024-03-13T12:39:15.559Z
---

## Introdução

Nesta documentação, mostramos como usar **Go Template** para transformar dados diretamente nos conectores da Fluid, com foco na **sintaxe v3**. Use o template para montar corpos de requisição, headers, partes de arquivos e quaisquer strings dinâmicas do seu fluxo.

Para fundamentos de v3 (de onde vêm os dados no template), consulte o guia oficial de migração. [Migração de sintaxe v2 para v3](docId:7DfxtAAavUfSiSw228YqD)&#x20;

## Como a v3 organiza os dados no template

Na v3, os dados ficam disponíveis nas seguintes raízes:

- **Entrada do fluxo (webhook/evento/teste):**&#x20;
  - `{{ .input.body }}` – JSON do payload de entrada&#x20;
  - `{{ .input.headers }}` – headers do disparo&#x20;
  - `{{ .input.query_params }}` – query params do disparo&#x20;
- **Resultado de passos do fluxo:**&#x20;
  - `{{ .steps.<nome_do_passo>.body }}` – body retornado pelo passo&#x20;
  - `{{ .steps.<nome_do_passo>.headers }}` – headers retornados&#x20;
  - `{{ .steps.<nome_do_passo>.query_params }}` – query params usados/derivados&#x20;
  - `{{ .steps.<nome_do_passo>.code }}` – status code resultante do passo

```json
Antes (v2) usava-se {{ .state ... }}. Agora (v3), use {{ .input... }} e {{ .steps... }}. Exemplos oficiais no guia de migração.
```

## Funcionalidades

O Playground do Go Template oferece uma gama de funcionalidades para facilitar o desenvolvimento e teste de templates, incluindo:

1. **Edição de Templates**: Permite aos usuários escrever e editar templates Go de maneira intuitiva e fácil.
2. **Visualização de Resultados**: Após a execução do template, o Playground exibe o resultado gerado com base nos dados de entrada fornecidos.
3. **Depuração Interativa**: Facilita a identificação e correção de erros no template, fornecendo mensagens de erro detalhadas e sugestões de correção.
4. **Suporte a Bibliotecas Externas**: Permite a utilização de bibliotecas externas, como a biblioteca Spring Functions (sprig), expandindo as funcionalidades disponíveis nos templates.

## Utilização

Para utilizar o Playground do Go Template, siga estas etapas:

1. Acesse o Playground do Go Template através do seguinte link: [https://repeatit.io/](https://repeatit.io/).
2. Na interface do Playground, você encontrará um editor de texto onde poderá escrever seu template Go.
3. Caso deseje utilizar funções da biblioteca Spring Functions (sprig), consulte a documentação oficial da biblioteca para conhecer as funções disponíveis e sua sintaxe correta: [Documentação do Spring Functions (sprig)](https://masterminds.github.io/sprig/).
4. Após escrever o template, clique no botão "Run" para executá-lo.
5. O Playground exibirá o resultado gerado com base nos dados de entrada fornecidos.
6. Se houver erros durante a execução do template, o Playground fornecerá mensagens de erro detalhadas para auxiliá-lo na depuração.
7. Faça os ajustes necessários no template e repita o processo até alcançar o resultado desejado.

## Exemplo de Uso

:::hint{type="info"}
Uma dica para ver tudo que está disponível no `input` ou `steps` durante determinada execução do fluxo é logar a raiz com:

```go
{{ . | toJson}}}
```
:::

## Exemplos rápidos

### 1) Lendo campos do payload de entrada

```json
{{ .input.body.payload_campo_1 }}
```

Headers e query params do disparo:

```json
{{ .input.headers | toJson }}
{{ .input.query_params.cod_cliente }}
```

### 2) Usando o resultado de um passo anterior

Suponha um passo chamado busca\_cliente que retornou:

```json
{ "id": 10, "nome": "Ana", "status": "ativo" }
```

Template (v3):

```json
{{ $c := .steps.busca_cliente.body }}
{
  "clienteId": {{ $c.id }},
  "nome": "{{ $c.nome }}",
  "ativo": "{{ eq $c.status "ativo" }}"
}
```

### 3) Acessando chaves com hífen ou maiúsculas

Use index quando houver hífen, espaços ou capitalização específica:

```json
{{ index .input.headers "Content-Type" }}
{{ index .steps.busca_produtos.body "itens-vendidos" }}
```

Mais exemplos na [FAQ - Perguntas frequentes](docId\:QywCSbSRcT6Tak5QXIvP6) .

### 4) Compondo dados de múltiplos passos

```json
{{ $cli := .steps.busca_cliente.body }}
{{ $ped := .steps.lista_pedidos.body }}

{
  "cliente": {
    "id": {{ $cli.id }},
    "nome": "{{ $cli.nome }}"
  },
  "primeiroPedido": {{ index $ped.pedidos 0 | toJson }}
}
```

### 5) Montando combinações com pipes e funções

```json
{{ $email := .input.body.contato.email | tolower }}
{{ $slug  := (.input.body.nome) | toslug }}
{
  "email": "{{ $email }}",
  "slug": "{{ $slug }}"
}
```

## Exemplo completo: do input ao template

**Entrada (payload do disparo):**

```json
{
  "payload_campo_1": "valor do payload de entrada",
  "payload_campo_2": { "msg": "valor do payload de entrada" }
}
```

**Resposta de um passo passo\_1:**

```json
{ "campo_1": "resultado do campo 1", "campo_2": "resultado do campo 2" }
```

**Template:**

```json
{{ $in  := .input.body }}
{{ $p1  := .steps.passo_1.body }}

{
  "fromInput": "{{ $in.payload_campo_1 }} - {{ $in.payload_campo_2.msg }}",
  "fromStep":  "{{ $p1.campo_1 }} - {{ $p1.campo_2 }}"
}
```

**Resultado:**

```json
{
  "fromInput": "valor do payload de entrada - valor do payload de entrada",
  "fromStep": "resultado do campo 1 - resultado do campo 2"
}
```

## Boas práticas

- Defina variáveis`{{$x := ...}}` para reuso e legibilidade.&#x20;
- Use index para chaves com hífen/espacos e para acessar arrays por índice.&#x20;
- Serialize trechos com toJson quando a API esperar objetos/arrays inline.&#x20;
- Em erros por campo ausente, valide a origem dos dados e a sintaxe v3 (guia de migração).

## Conclusão

O [Playground do Go Template](https://repeatit.io/) é uma ferramenta valiosa para simplificar o desenvolvimento e teste de templates em nossos conectores Fluid. Ao utilizar este recurso, os desenvolvedores podem iterar rapidamente na criação e depuração de templates, garantindo uma configuração precisa e eficiente dos dados nos fluxos de trabalho da Fluid. Não hesite em explorar todas as funcionalidades oferecidas pelo Playground do Go Template para melhorar sua produtividade e eficácia na criação de templates.
