# Do código ao relatório. Sem construir tudo do zero.

Integre dados e regras do seu produto a um editor rico, personalizável e pronto para gerar relatórios profissionais.

[Abrir a página do produto](https://rhizzalab.com/)

## Começar

* [Criar conta](https://app.rhizzalab.com/signup)

* [Ver documentação](https://rhizzalab.com/docs)

## Contrato mínimo da integração

| Campo      | Papel             |
| ---------- | ----------------- |
| token      | sessão temporária |
| reportType | tipo publicado    |
| data       | dados do host     |

## Seu produto continua no comando.

A RhizzaDocs entra no ponto exato em que o trabalho documental começa. Seu host preserva autenticação, navegação e contexto; o widget recebe somente o necessário para abrir aquela sessão.

```typescript
const token = await seuBackend.editorToken()
const reportType = "acme.relatorio-mensal"
const data = await carregarDadosDoRelatorio()
```

| Campo      | Responsabilidade                                                                     |
| ---------- | ------------------------------------------------------------------------------------ |
| token      | Um JWT temporário emitido pelo backend do host. O clientSecret não vai ao navegador. |
| reportType | A chave estável da definição publicada que aquela tela tem permissão para abrir.     |
| data       | O contexto estruturado do negócio, validado contra o schema do relatório.            |

## Um novo relatório nasce por cadastro, não por um fork do SDK.

Tipos de relatório, blocos, DataViews, temas e modelos são definidos por contratos declarativos versionados. O núcleo continua genérico: o JSON descreve estrutura e layout, mas nunca executa código.

* **Produto** — Define o que aquela experiência precisa mostrar.

* **Engenharia** — Integra uma superfície estável, sem componentes de negócio no SDK.

* **Operação** — Compõe e revisa o documento dentro do sistema que já usa.

### Estrutura do documento

Visão real do editor com a organização dos blocos aberta.

![Editor da RhizzaDocs com a estrutura do documento aberta ao lado de um relatório de planejamento de obra.](https://rhizzalab.com/product/structure.png)

A estrutura continua editável; as regras e os dados calculados continuam sob controle do produto.

## Da composição à entrega, sem trocar de linguagem.

Editor, prévia e PDF partem da mesma árvore de documento e do mesmo motor de renderização. O que muda é o momento do trabalho — não a fonte da verdade.

### Componha no editor

Insira blocos permitidos, edite texto e reorganize a estrutura sem sair da tela do host.

![Editor da RhizzaDocs exibindo blocos disponíveis e um relatório de planejamento de obra.](https://rhizzalab.com/product/editor.png)

### Reutilize modelos

Aplique o padrão da empresa ou salve uma composição própria, mantendo dados concretos fora do modelo.

![Painel de modelos da RhizzaDocs aberto ao lado de um documento em edição.](https://rhizzalab.com/product/templates.png)

### Revise a saída paginada

Escolha o tema e confira como o documento chega às páginas antes de solicitar a exportação.

![Prévia paginada de um documento com o painel de seleção de tema aberto.](https://rhizzalab.com/product/preview.png)

### Exporte com confirmação explícita

Regras sensíveis permanecem no backend e a exportação pode exigir confirmação antes de gerar o PDF.

![Editor mostrando a verificação de conteúdo sensível antes da exportação em PDF.](https://rhizzalab.com/product/export.png)

## O trabalho documental, sem virar outro produto para manter.

A experiência foi dividida na fronteira certa: o host conhece o negócio; a RhizzaDocs cuida da composição, da revisão e da saída.

* **Editor orientado a blocos** — Texto rico, blocos declarativos, imagens e reorganização do documento no mesmo espaço de trabalho.

* **Modelos reutilizáveis** — A empresa define um ponto de partida e o usuário salva variações sem misturar valores concretos dos dados.

* **Temas de documento** — A aparência do relatório muda sem alterar a estrutura editável nem as regras recebidas do host.

* **Prévia paginada** — A revisão mostra a saída em páginas antes da exportação, com o mesmo motor que prepara o documento.

* **Persistência opcional** — Com uma chave de documento, o trabalho pode ser restaurado e salvo automaticamente no fluxo do produto.

* **PDF no backend** — A exportação congela um snapshot explícito e mantém regras sensíveis fora do navegador.

## O segredo fica no seu backend. O contexto fica na sessão.

A integração não duplica o login do seu produto nem leva credenciais permanentes para o cliente. Autorização, isolamento entre empresas, uploads e exportação pertencem ao backend.

| Elemento              | Local ou regra                                 |
| --------------------- | ---------------------------------------------- |
| Credencial permanente | Servidor do host                               |
| Token temporário      | Memória do widget                              |
| Dados correntes       | Não persistidos no documento de trabalho       |
| JSON de cadastro      | Validado, allowlisted e sem execução de código |

[Entender a arquitetura](https://rhizzalab.com/docs)

## A superfície React cabe no fluxo que você já tem.

Crie o client uma vez, entregue-o pelo provider e abra cada documento com o token, o tipo de relatório e os dados daquela sessão.

```tsx filename="report-screen.tsx"
import { useMemo } from "react";
import {
  createReportClient,
  ReportEditor,
  ReportSdkProvider,
  type ReportEditorProps,
} from "@rhizzalab/report-react";

type Props = {
  token: string;
  data: ReportEditorProps["data"];
};

export function ReportScreen({ token, data }: Props) {
  const client = useMemo(() => createReportClient(), []);

  return (
    <ReportSdkProvider client={client}>
      <ReportEditor
        token={token}
        reportType="acme.relatorio-mensal"
        data={data}
      />
    </ReportSdkProvider>
  );
}
```

[Abrir documentação](https://rhizzalab.com/docs)

## Do código ao relatório

Passe o mouse, toque ou use Tab e as setas para trazer uma etapa ao primeiro plano.

* **Integração no host** — Token temporário, reportType e dados estruturados entram no widget.

* **Editor rico** — O usuário compõe o documento dentro do fluxo do seu produto.

* **Relatório final** — A mesma estrutura chega à prévia paginada e à exportação em PDF.

```tsx
import { ReportEditor }
from "@rhizzalab/report-react"

const token = await getEditorToken()
const reportType = "acme.relatorio-mensal"
const data = getReportData()

<ReportEditor
  token={token}
  reportType={reportType}
  data={data}
/>
```

## Seu time entrega a regra do negócio. A RhizzaDocs entrega o documento.

Comece pela documentação ou crie uma conta para configurar a integração do seu produto.

* [Criar conta](https://app.rhizzalab.com/signup)

* [Ver documentação](https://rhizzalab.com/docs)

* [Já tenho conta](https://app.rhizzalab.com/login)

## Links

* [Documentação](https://rhizzalab.com/docs)

* [Quickstart](https://rhizzalab.com/docs/quickstart)

* [Blog](https://rhizzalab.com/blog)

* [Casos simulados](https://rhizzalab.com/casos-simulados)

* [RSS](https://rhizzalab.com/blog/feed.xml)

* [llms.txt](https://rhizzalab.com/llms.txt)

* [Entrar](https://app.rhizzalab.com/login)

* [Criar conta](https://app.rhizzalab.com/signup)

Infraestrutura de relatórios para produtos que precisam entregar.

RhizzaDocs, by RhizzaLab.