Como converti o GenLatte para Dart full stack
E reduzi a conta de servidor do app
Se você acompanhou a saga da equipe do Flutter para montar barraquinhas de café pop-up, sabe que combinamos Flutter, Firebase e Gemini para servir cafés divertidos. Também sabe que, por não cobrarmos nada, não tivemos lucro.
Além disso, se você olhou o código, talvez também tenha notado que nosso front-end em Flutter era complementado por funções do Firebase escritas em Node.js. Isso é um artefato histórico um tanto surpreendente, considerando que o suporte do Firebase a funções em Dart entrou em prévia pública quase no mesmo momento em que o GenLatte apareceu pela primeira vez no Google Cloud Next.
Mas é exatamente isso: com o suporte do Firebase a Dart chegando no último segundo, simplesmente não conseguimos nos comprometer em usá-lo em um app de produção, com a pressão do “o show precisa continuar”. Se o suporte do Firebase a Dart tivesse atrasado por qualquer motivo, talvez não conseguíssemos fazer o deploy a tempo do Cloud Next. E assim, quando o GenLatte apareceu nos meses de abril, maio ou junho, ele o fez com um backend em Node.js.
E eu levei isso para o lado pessoal.
Apostando de vez no Dart full-stack
Dart e JavaScript são linguagens diferentes, com pontos fortes diferentes. Em certo sentido, isso é só o óbvio, mas também tem implicações mais profundas para uma migração no lado do servidor, então uma reescrita 1 para 1 provavelmente não vale a pena. Afinal, o Dart no servidor pode aproveitar a segurança de tipos de ponta a ponta com o Dart no cliente, e seria uma pena continuar usando Maps sem tipagem.
Com isso em mente, e com os olhos maiores que a barriga, eu me propus a reescrever radicalmente o GenLatte. Entre meus muitos objetivos:
-
Compartilhar modelos em toda a stack (o que foi um esforço pequeno, dada
minha decisão original de colocar todas as classes de dados em um
pacote separado
genlatte_data) - Reduzir as Firebase Functions a uma única função implantável
- Remover todas as escritas do lado do cliente; em vez disso, focar em chamar funções do lado do servidor
- Remover todos os triggers do lado do servidor e, em vez disso, executar explicitamente qualquer mutação de dados em funções do servidor chamadas a partir do cliente
- Persistir todas as verificações de ACL baseadas em papéis
- Finalmente ter testes ponta a ponta!
Esses objetivos eram ambiciosos e não estavam exatamente no meu roadmap de 2026, então, naturalmente, mantive meus planos em segredo e comecei a digitar!
Executando a migração
Diferente do meu trabalho no GenLatte original, que foi desenvolvido em grande parte sem o uso de IA, eu sabia que meu cronograma apertado exigia trazer um assistente de digitação turbinado. Meu modelo escolhido foi o Gemini 3.6 Flash, e sua combinação de baixa latência com conhecimento geral realmente se destacou para mim.
De um ponto de vista geral, eu ainda li cada linha que o Gemini escreveu, em ordem, para manter a posse cognitiva do projeto. Isso ficou bem mais fácil por começar de uma posição de conhecimento profundo, e, sem esse compromisso, não acho que a reescrita teria dado certo nos poucos dias que eu tinha disponíveis. Assistentes de código, por mais incríveis que sejam, ainda se beneficiam muito da orientação humana.
Compartilhando modelos
Type safety fullstack significa código compartilhado entre o cliente e o servidor.
Como mencionei antes, isso quer dizer separar qualquer código que precise rodar
no servidor em um pacote próprio que, criticamente,
não pode depender do SDK do Flutter. Isso é, em grande parte, direto,
mas exigiu adições no meu próprio pacote de gerenciamento de dados,
pkg:data_layer.
Um dos seus pacotes complementares,
pkg:data_layer_firestore,
depende do SDK do Firebase do lado do cliente (que depende do Flutter),
então precisei adicionar
pkg:data_layer_firestore_admin,
que é Dart puro e, portanto, adequado para o servidor.
Usando uma única função do Firebase
Por padrão, cada função do Firebase que você implanta vira o seu próprio serviço do Cloud Run. (Se você é usuário de Firebase Functions e isso é novidade para você, vá até o Cloud Run no console do Google Cloud e confira como a salsicha do Firebase é feita!)
No entanto, depois de depender de mais de 15 serviços separados do Cloud Run na era Node.js do GenLatte, eu sabia que queria uma configuração mais enxuta por vários motivos. Primeiro, os deploys seriam bem mais rápidos, mas o mais importante: isso reduziria drasticamente a conta de servidor do GenLatte.
“Mas, Craig!”, você deve estar pensando, “o Cloud Run desliga até zero quando não está em uso, então isso realmente importa?”
Ótima pergunta. Fico feliz que você esteja prestando atenção.
E sim, é muito importante! Enquanto o GenLatte estava em uso, várias gravações de dados e tarefas assíncronas ativavam todos os 15 serviços, e, embora cada um desligasse quando ocioso, isso ainda tinha efeitos previsíveis na nossa conta de servidor. Mas, para piorar, configuramos o número mínimo de instâncias de cada serviço como 1 enquanto o GenLatte estava em uso, para evitar cold starts, o que, claro, desligava essa funcionalidade de descer até zero. O resultado final foi que o GenLatte era surpreendentemente caro de manter ligado.
Como colocar tudo em um único serviço do Firebase
Para economizar, decidi me inspirar no
Serverpod e introduzir um BackendMessage
DTO
para dizer à minha função única do Firebase qual função interna eu queria
que ela realmente chamasse. Com um truque esperto de pkg:freezed que o Gemini me ajudou a escrever,
consegui até ter respostas tipadas.
A configuração final das classes é um pouco complicada, mas vale a pena entender se você gosta de type safety e de economizar.
BackendMessage
Esta é a classe DTO pai, que eu uso nas assinaturas reais das minhas funções.
abstract interface class BackendMessage<R extends MessageResponse> {
/// Json serializer.
Json toJson();
}
MessageParameters
Ela implementa BackendMessage e usa pkg:freezed para vincular
cada tipo de mensagem individual às classes de resposta esperadas.
O truque de @Implements.fromString gera classes que satisfazem
a exigência do pai de vincular um tipo MessageResponse.
E, embora o uso de strings puras na classe de origem pareça perigoso do ponto de vista de tipos,
qualquer erro de digitação resulta em erros nas classes geradas,
o que significa que, na prática, é type-safe.
@freezed
sealed class MessageParameters with _$MessageParameters {
/// Creates a new latte order.
@Implements.fromString('BackendMessage<SaveOrderResponse>')
const factory MessageParameters.saveOrder({
@LatteOrderConverter() required LatteOrder order,
}) = SaveOrderParameters;
/// Marks a latte order as completed.
@Implements.fromString('BackendMessage<EmptyResponse>')
const factory MessageParameters.completeOrder({
required String orderId,
required String baristaId,
}) = CompleteOrderParameters;
// Many more message types...
}
MessageResponse
Isso fecha o ciclo, declarando as classes de resposta que cada chamada de método espera.
Ele oferece uma mistura de tipos de resposta individuais para métodos que querem
feedback imediato e respostas vazias para representar uma espécie de
202 Accepted ou 204 No Content de resposta HTTP.
@freezed
sealed class MessageResponse with _$MessageResponse {
/// Return data for [SaveOrderParameters].
const factory MessageResponse.saveOrder({required LatteOrder? latteOrder}) =
SaveOrderResponse;
// Many more response types...
/// Placeholder for method calls which require no return value.
///
/// This is typically because the client will pick up any state changes via
/// watched Firestore collections.
const factory MessageResponse.empty() = EmptyResponse;
}
Com meus DTOs em ordem, eu precisava de uma única função do lado do servidor para receber
e rotear cada BackendMessage de entrada de acordo.
firebase.https.onCallWithData<MessageParameters, Object>(
(request) {
final MessageResponse response = switch (request.data) {
SaveOrderParameters msg => saveOrder(msg),
CompleteOrderParameters msg => completeOrder(msg),
...
};
return response.toJson();
},
...
}
Por fim, eu precisava dos métodos saveOrder e completeOrder que
cumprissem o seu contrato.
// Other Dart files
Future<SaveOrderResponse> saveOrder(SaveOrderParameters message) {}
Future<EmptyResponse> completeOrder(CompleteOrderParameters message) {}
// Many more functions...
Com esses sistemas no lugar, consegui colocar um número arbitrário de operações do lado do servidor em uma única função Dart. Oláaaaa, economia!
Refatorando todas as gravações
O sistema BackendMessage acima preparou o terreno para alcançar imediatamente
outros três subobjetivos:
-
Removi todas as gravações do lado do cliente, bloqueando-as no seu arquivo
firestore.rules. Também refatorei minhas camadas de gerenciamento de dados para chamar a função única do backend, em vez de chamar diretamente funções do Firestore comodocRef.set(). - Do mesmo modo, removi todos os triggers do Firestore, mas recriei a funcionalidade que faltava em funções que eu podia chamar explicitamente a partir do cliente.
- Mantive o modelo de permissões rigoroso do GenLatte introduzindo verificações de ACL no código Dart, o que, por ser um sistema testável, me permitiu dormir tranquilo.
Adicionando testes end-to-end
Para o meu truque final, consegui dar ordens ao Gemini para escrever testes do lado do servidor e, com muito entusiasmo, simular o comportamento do backend em testes do lado do cliente, que de repente viraram testes end-to-end. Com os valores de retorno tipados, isso levou a uma estabilidade e confiabilidade do app com as quais fiquei muito satisfeito!
A alegria de uma linguagem full stack
Seja você alguém que gosta de dados relacionais e por isso usa algo como Serverpod, ou uma solução não relacional como o Cloud Firestore, escrever na mesma linguagem em toda a stack é um sonho. E os ganhos não param se essa linguagem for Dart e você se pegar curtindo a segurança total de tipos com null safety. Dá a impressão de que os computadores estão realmente ali para ser seus amigos!
Gostei de converter o GenLatte para usar Dart em tudo e, com isso, reduzi a conta de servidor a uma pequena fração do que era com Node, e aumentei a confiabilidade e a performance. O dinheiro que gastei com tokens do Gemini para executar a mudança foi facilmente recuperado depois de apenas alguns minutos de operação. Agora o GenLatte pode continuar servindo cafés personalizados para participantes de eventos por muito tempo, ou até nos cansarmos de mantê-lo no ar.
