Entrar Inscrever-se
Rowy

Desvendando os Campos Derivados no Rowy: Automatize e Transforme Seus Dados com Scripts

Xavier

• 4 min read

Introdução ao Rowy e aos Campos Derivados

O Rowy é uma plataforma low-code poderosa que se integra ao Firebase e ao Google Cloud, permitindo gerenciar dados de forma semelhante a uma planilha, mas com a flexibilidade de um backend robusto. Uma de suas funcionalidades mais versáteis é o campo derivado (derivative field). Este tipo de campo permite executar lógica customizada, transformar dados e até mesmo interagir com APIs externas, tudo isso disparado por alterações em outros campos da sua tabela.

Fundamentalmente, um campo derivado "escuta" um ou mais campos (chamados campos ouvintes ou listener fields). Quando o valor de um desses campos ouvintes muda, o campo derivado executa um script JavaScript (rodando como uma Google Cloud Function nos bastidores) e então exibe um valor resultante. Isso abre um leque de possibilidades para automação e enriquecimento de dados diretamente na sua interface Rowy.

Como Funcionam os Campos Derivados no Rowy?

Para utilizar campos derivados, é necessário ter o Rowy Run configurado no seu projeto, pois ele é o responsável por executar as Google Cloud Functions associadas a esses campos. O fluxo básico de um campo derivado é:

  1. Campo Ouvinte (Listener Field): Um ou mais campos na sua tabela são definidos para "disparar" a execução do campo derivado quando seus valores mudam.
  2. Script Derivado: Um código JavaScript, geralmente uma função assíncrona, é executado. Este script tem acesso a diversos objetos e informações, como os dados da linha atual (`row`), referências do Firestore (`ref`, `db`), Firebase Storage (`storage`) e autenticação (`auth`).
  3. Valor de Saída: O script retorna um valor, que será exibido no campo derivado. O tipo desse valor deve corresponder ao tipo de campo de saída configurado para o campo derivado.

Configurando um Campo Derivado

Ao adicionar um novo campo e selecionar o tipo "Derivative", você terá acesso a diversas opções de configuração:

  • Default value type: Define um valor padrão para o campo quando uma nova linha é criada.
  • Make this column required: Indica se o campo deve ser preenchido.
  • Listener fields: Aqui você seleciona quais campos da sua tabela irão disparar a execução do script derivado.
  • Output field type: Escolhe o tipo de dado que o campo derivado irá exibir (ex: Short Text, Long Text, Toggle, Number, etc.). É crucial que o valor retornado pelo seu script seja compatível com este tipo. A documentação do Rowy sobre tipos de campos suportados detalha os tipos de dados esperados para cada campo.
  • Derivative script: O editor onde você escreverá seu código JavaScript. Após qualquer alteração no script, é necessário reimplantar (re-deploy) a Google Cloud Function associada.

Exemplos Práticos de Campos Derivados no Rowy

Vamos explorar alguns cenários para ilustrar o poder dos campos derivados.

Exemplo 1: Manipulação Básica de Strings

Imagine que você tem uma coluna de texto chamada "nome" e quer que o campo derivado exiba uma saudação personalizada.

  1. Crie um campo "nome" do tipo Short Text.
  2. Crie um campo derivado chamado "saudacao".
  3. Configure o campo "saudacao":
    • Listener fields: selecione o campo "nome".
    • Output field type: Short Text.
    • Derivative script:
      const derivative = async ({row, ref, db, storage, auth}) => {
  if (row.nome) {
    return `Olá, ${row.nome}!`;
  }
  return 'Por favor, insira um nome.';
};

Agora, sempre que o campo "nome" for preenchido, o campo "saudacao" será atualizado automaticamente.

Exemplo 2: Lógica Condicional para Fluxo de Aprovação

Suponha um sistema de aprovação de produtos onde um item só está pronto para revisão se tiver um preço e um tamanho definidos.

  1. Crie um campo "preco" do tipo Number.
  2. Crie um campo "tamanho" do tipo Single Select (com opções como Pequeno, Médio, Grande).
  3. Crie um campo derivado "prontoParaRevisao" do tipo Toggle.
  4. Configure o campo "prontoParaRevisao":
    • Listener fields: selecione os campos "preco" e "tamanho".
    • Output field type: Toggle (que espera um valor booleano: `true` ou `false`).
    • Derivative script:
      const derivative = async ({row}) => {
  if (row.preco && row.tamanho) {
    return true; // Produto pronto para revisão
  }
  return false; // Produto não está pronto
};

O toggle "prontoParaRevisao" será ativado automaticamente assim que ambos os campos "preco" e "tamanho" forem preenchidos.

Exemplo 3: Chamando uma API Externa – Dicionário

Podemos usar um campo derivado para buscar a definição de uma palavra usando uma API externa, como a Free Dictionary API.

  1. Crie um campo "palavra" do tipo Short Text.
  2. Crie um campo derivado "definicao" do tipo Long Text.
  3. Configure o campo "definicao":
    • Listener fields: selecione o campo "palavra".
    • Output field type: Long Text.
    • Derivative script:
      const derivative = async ({row}) => {
  if (!row.palavra) return 'Digite uma palavra para buscar.';

  try {
    const response = await fetch(`https://api.dictionaryapi.dev/api/v2/entries/en/${row.palavra}`);
    if (!response.ok) {
      return 'Não foi possível encontrar a definição.';
    }
    const data = await response.json();
    // A estrutura da resposta pode variar; este é um exemplo.
    // A API retorna um array, então pegamos o primeiro resultado.
    // E então a primeira definição dentro do primeiro significado.
    if (data && data && data.meanings && data.meanings && data.meanings.definitions && data.meanings.definitions) {
      return data.meanings.definitions.definition.toString();
    }
    return 'Definição não encontrada no formato esperado.';
  } catch (error) {
    console.error('Erro ao buscar definição:', error);
    return 'Erro ao buscar definição.';
  }
};

Ao digitar uma palavra no campo "palavra", o campo "definicao" buscará e exibirá a definição correspondente.

Exemplo 4: Utilizando Pacotes NPM – Lodash para CamelCase

Os scripts derivados no Rowy rodam em um ambiente Node.js, o que permite importar pacotes NPM. Vamos usar o Lodash para converter uma string para o formato camelCase.

  1. Crie um campo "textoOriginal" do tipo Short Text.
  2. Crie um campo derivado "textoCamelCase" do tipo Short Text.
  3. Configure o campo "textoCamelCase":
    • Listener fields: selecione o campo "textoOriginal".
    • Output field type: Short Text.
    • Derivative script:
      const derivative = async ({row}) => {
  if (!row.textoOriginal) return '';

  const _ = require('lodash');
  return _.camelCase(row.textoOriginal.toString());
};

Se você digitar "Exemplo de Texto" em "textoOriginal", o campo derivado mostrará "exemploDeTexto".

Conclusão

Os campos derivados no Rowy são uma ferramenta extremamente flexível e poderosa para desenvolvedores e usuários que buscam automatizar processos, enriquecer dados e adicionar lógica customizada às suas tabelas. Seja para simples transformações de texto, validações complexas, integrações com APIs de terceiros ou aproveitando o vasto ecossistema de pacotes NPM, os campos derivados elevam o potencial do Rowy, permitindo criar soluções sofisticadas com agilidade. Explorar essa funcionalidade pode desbloquear níveis de eficiência e automação antes inimagináveis em uma interface de gerenciamento de dados.

Inscreva-se, Fique Atualizado!

Digite seu e-mail
Inscrever-se