4. Construindo a interface

No momento, os objetos só podem ser acessados através de Configurações. Vamos dar ao aplicativo uma presença real na UI: listar exibições, entradas da barra lateral, um clique Gerar documento comando, um componente frontal de record-page para visualizar um documento e uma guia de editor nativa para templates.

Visualizações e navegação

A view é uma lista salva de um determinado objeto. Um item de menu de navegação coloca essa visualização na barra lateral.

import { defineView, ViewKey } from 'twenty-sdk/define';

export default defineView({
  universalIdentifier: DOCUMENTS_VIEW_UNIVERSAL_IDENTIFIER,
  name: 'All documents',
  objectUniversalIdentifier: DOCUMENT_OBJECT_UNIVERSAL_IDENTIFIER,
  icon: 'IconFile',
  key: ViewKey.INDEX,
  position: 0,
  fields: [
    { universalIdentifier: DOCUMENTS_VIEW_NAME_FIELD_UNIVERSAL_IDENTIFIER,
      fieldMetadataUniversalIdentifier: DOCUMENT_NAME_FIELD_UNIVERSAL_IDENTIFIER,
      position: 0, isVisible: true, size: 280 },
    { universalIdentifier: DOCUMENTS_VIEW_STATUS_FIELD_UNIVERSAL_IDENTIFIER,
      fieldMetadataUniversalIdentifier: DOCUMENT_STATUS_FIELD_UNIVERSAL_IDENTIFIER,
      position: 1, isVisible: true, size: 120 },
    { universalIdentifier: DOCUMENTS_VIEW_TEMPLATE_FIELD_UNIVERSAL_IDENTIFIER,
      fieldMetadataUniversalIdentifier: DOCUMENT_TEMPLATE_FIELD_UNIVERSAL_IDENTIFIER,
      position: 2, isVisible: true, size: 200 },
  ],
});

import { defineNavigationMenuItem, NavigationMenuItemType } from 'twenty-sdk/define';

export default defineNavigationMenuItem({
  universalIdentifier: DOCUMENTS_NAVIGATION_MENU_ITEM_UNIVERSAL_IDENTIFIER,
  name: 'Documents',
  icon: 'IconFile',
  color: 'green',
  position: 1,
  type: NavigationMenuItemType.VIEW,
  viewUniversalIdentifier: DOCUMENTS_VIEW_UNIVERSAL_IDENTIFIER,
});

Adicionar o mesmo par para modelos. Ambos agora aparecem na barra lateral:

Visualização de documentos com um documento gerado — Documentos e Modelos na barra lateral, com o documento gerado listado.

Um componente frontal

A front component é um componente React sandboxed dentro de Twenty. Ours lê o registro selecionado, carrega o modelo de pessoa via CoreApiClient, e POSTs até a rota do último capítulo .

import { useEffect, useState } from 'react';
import { CoreApiClient } from 'twenty-client-sdk/core';
import { RestApiClient } from 'twenty-client-sdk/rest';
import { defineFrontComponent } from 'twenty-sdk/define';
import { enqueueSnackbar, useSelectedRecordIds } from 'twenty-sdk/front-component';

const GenerateDocumentForm = () => {
  const selectedRecordIds = useSelectedRecordIds();
  const recordId = selectedRecordIds.length === 1 ? selectedRecordIds[0] : null;
  const [templates, setTemplates] = useState<{ id: string; name: string }[]>([]);
  const [templateId, setTemplateId] = useState('');

  useEffect(() => {
    new CoreApiClient()
      .query({ documentTemplates: {
        __args: { filter: { target: { eq: 'PERSON' } }, first: 100 },
        edges: { node: { id: true, name: true } } } })
      .then(({ documentTemplates }) => {
        const list = documentTemplates?.edges?.map((e) => e.node) ?? [];
        setTemplates(list);
        if (list[0]) setTemplateId(list[0].id);
      });
  }, []);

  const generate = async () => {
    const res = await new RestApiClient().post<{ success: boolean }>(
      '/s/documents/generate',
      { templateId, recordId },
    );
    await enqueueSnackbar({
      message: res.success ? 'Document generated.' : 'Generation failed.',
      variant: res.success ? 'success' : 'error',
    });
  };

  // ...render a <select> of templates and a Generate button
};

export default defineFrontComponent({
  universalIdentifier: GENERATE_DOCUMENT_FORM_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER,
  name: 'generate-document-form',
  component: GenerateDocumentForm,
});

Estilo com variáveis CSS inline (var(--t-color-blue)), não valores importados de 25ui. O SDK simula esse pacote durante a compilação, portanto, as importações em nível de módulo de constantes de tema ficariam undefined. Veja o componente inteiro.

Um comando para abri-lo

Um item de menu de comando com availabilityType: 'RECORD_SELECTION' aparece quando uma pessoa é selecionada, e abre o componente no painel lateral.

import { defineCommandMenuItem, STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS } from 'twenty-sdk/define';

export default defineCommandMenuItem({
  universalIdentifier: GENERATE_DOCUMENT_COMMAND_UNIVERSAL_IDENTIFIER,
  label: 'Generate document',
  availabilityType: 'RECORD_SELECTION',
  availabilityObjectUniversalIdentifier:
    STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person.universalIdentifier,
  frontComponentUniversalIdentifier:
    GENERATE_DOCUMENT_FORM_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER,
});

Experimente todo o fluxo

Abra Pessoas, marque uma pessoa e pressione ⌘K / Ctrl K. “Gerar documento” aparece, marcado com seu aplicativo:

Menu de comando com o documento gerado — O comando aparece quando uma pessoa é selecionada.

Executá-lo — seu componente abre no painel lateral. Escolha um modelo, clique Gerar e uma nova terra em Documentos.

Gerar painel lateral do documento — O componente inicial, carregando templates e gerando no clique.

Cada documento gerado grava o seu aplicativo como seu autor:

Um registro de documento gerado — Criado pelo Gerador do Documento: Status Gerado.

Pré-visualizar um documento em sua página de registro

Um componente frontal não é apenas para menus de comando. Você pode montar um como uma **aba de uma página de registro . Vamos adicionar uma aba Pré-visualização ao registro de documento que renderiza o corpo Markdown como uma página polida e impressa. O componente lê o id de registro atual de seu contexto de execução, carrega o documento e o renderiza. Componentes frontais executados em uma sandbox que só permite uma lista branca de tags HTML — injeção HTML bruta (dangerouslySetInnerHTML) e \<style> estão bloqueados — então renderizamos o Markdown como elementos React com estilos inline através de um pequeno Markdown helper.

import { CoreApiClient } from 'twenty-client-sdk/core';
import { RestApiClient } from 'twenty-client-sdk/rest';
import { defineFrontComponent } from 'twenty-sdk/define';
import { useFrontComponentExecutionContext } from 'twenty-sdk/front-component';
import { Markdown } from 'src/utils/markdown-to-react';

const DocumentViewer = () => {
  const recordId = useFrontComponentExecutionContext((c) => c.recordId ?? null);
  // ...load { content, file } for recordId, then derive the links:
  const pdfUrl = document.file?.[0]?.url;
  const webUrl = new RestApiClient().resolveUrl('/s/documents/view', {
    query: { id: recordId },
  });

  // Render the template body, plus quick links to the web page and the PDF.
  // Links open in a new tab so they don't navigate the embedded component.
  return (
    <div style={styles.scroll}>
      <div style={styles.actions}>
        <a style={styles.actionLink} href={webUrl} target="_blank" rel="noopener noreferrer">
          Open web page
        </a>
        {pdfUrl ? (
          <a style={styles.actionLink} href={pdfUrl} target="_blank" rel="noopener noreferrer">
            Download PDF
          </a>
        ) : null}
      </div>
      <div style={styles.paper}>
        <div style={styles.body}>
          <Markdown content={document.content} />
        </div>
      </div>
    </div>
  );
};

export default defineFrontComponent({
  universalIdentifier: DOCUMENT_VIEWER_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER,
  name: 'document-viewer',
  component: DocumentViewer,
});

Monte-o com um layout da página. Um layout RECORD_PAGE adiciona abas à vista de registro de um objeto; um widget FRONT_COMPONENT em uma aba CANVAS hospeda o componente:

import { definePageLayout, PageLayoutTabLayoutMode } from 'twenty-sdk/define';

export default definePageLayout({
  universalIdentifier: DOCUMENT_PAGE_LAYOUT_UNIVERSAL_IDENTIFIER,
  name: 'Document record page',
  type: 'RECORD_PAGE',
  objectUniversalIdentifier: DOCUMENT_OBJECT_UNIVERSAL_IDENTIFIER,
  tabs: [{
    universalIdentifier: DOCUMENT_PAGE_LAYOUT_TAB_UNIVERSAL_IDENTIFIER,
    title: 'Preview',
    icon: 'IconEye',
    position: 50,
    layoutMode: PageLayoutTabLayoutMode.CANVAS,
    widgets: [{
      universalIdentifier: DOCUMENT_PAGE_LAYOUT_WIDGET_UNIVERSAL_IDENTIFIER,
      title: 'Document preview',
      type: 'FRONT_COMPONENT',
      configuration: {
        configurationType: 'FRONT_COMPONENT',
        frontComponentUniversalIdentifier: DOCUMENT_VIEWER_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER,
      },
    }],
  }],
});

Abra qualquer documento — uma guia Pré-visualizar renderiza belíssima, com links para a página web compartilhável de e o PDF:

Visualizador de documentos do componente frontal em uma aba de registros — A aba de Pré-visualização renderiza o documento com estilos embutidos, mais links rápidos.

Edite um modelo com o editor de texto rico

Os templates não precisam de um componente personalizado. Como o body é um campo RICH_TEXT, Twenty já fornece um editor de rich text completo para ele — o mesmo que os objetos padrão Note e Task usam. Nós apenas a apresentamos na página de registro de template. Adicione uma aba com um widget FIELD no modo de exibição EDITOR, apontando para o campo body através de fieldMetadataId:

{
  universalIdentifier: TEMPLATE_PAGE_LAYOUT_TAB_UNIVERSAL_IDENTIFIER,
  title: 'Template',
  position: 1,
  layoutMode: PageLayoutTabLayoutMode.GRID,
  widgets: [{
    universalIdentifier: TEMPLATE_PAGE_LAYOUT_WIDGET_UNIVERSAL_IDENTIFIER,
    title: 'Template',
    type: 'FIELD',
    gridPosition: { row: 0, column: 0, rowSpan: 6, columnSpan: 12 },
    configuration: {
      configurationType: 'FIELD',
      fieldMetadataId: TEMPLATE_BODY_FIELD_UNIVERSAL_IDENTIFIER,
      fieldDisplayMode: 'EDITOR',
    },
  }],
}

Um campo RICH_TEXT armazena tanto o JSON de blocos do editor quanto uma projeção em Markdown. O pipeline de geração lê essa projeção Markdown, então espaços reservados, o PDF, e a página da web compartilhável continuam funcionando inalterado — veja o template-record. leiaute-idade.ts. Agora editores escrevem modelos em um editor de texto rico:

Registro de modelo com a aba de editor de texto rico nativo — A aba Modelo: editor de texto rico nativo de 20 vinculado ao campo de corpo.

Após este passo: os documentos pré-visualizar lindo e os templates são editáveis dentro do aplicativo. Em seguida, deixe um atendente da IA gerá-los a partir de um chat.

Próximo: um atendente de IA →

Adicione um agente e uma habilidade que chama sua ferramenta.

Visão Geral

Aplicativos

API

Auto-Anfitrião

Contribuir

Visualizações e navegação

Um componente frontal

Um comando para abri-lo

Experimente todo o fluxo

Pré-visualizar um documento em sua página de registro

Edite um modelo com o editor de texto rico

Próximo: um atendente de IA →

​Visualizações e navegação

​Um componente frontal

​Um comando para abri-lo

​Experimente todo o fluxo

​Pré-visualizar um documento em sua página de registro

​Edite um modelo com o editor de texto rico

Próximo: um atendente de IA →

Visualizações e navegação

Um componente frontal

Um comando para abri-lo

Experimente todo o fluxo

Pré-visualizar um documento em sua página de registro

Edite um modelo com o editor de texto rico