Pular para o conteúdo
Voltar para o blog
  • MongoDB
  • Express
  • React
  • NodeJS
  • Docker

Odisseia do OliBase

A Saga da Criação de um Backend as a Service (BaaS) em MERN, Onde o Código se Torna Arquitetura

A jornada começou não com um *bug*, mas com uma crise existencial de desenvolvedor. Por meses a fio, a imersão no MERN Stack (MongoDB, Express, React, Node) havia sido metódica e bem-sucedida. Cursos, documentação e pequenos projetos de portfólio eram concluídos com a precisão de um relógio suíço. No entanto, uma verdade fria e cortante pairava no ar: "Eu ainda não tinha construído algo grande o suficiente para me obrigar a tomar decisões difíceis."

O problema não era a falta de conhecimento, mas a ausência de um desafio que forçasse a transição do "saber fazer" para o "saber arquitetar". A ambição era clara: ir além do tutorial, abraçar o caos da refatoração, errar, corrigir e, finalmente, entender a alma das decisões de *backend*. Foi nesse cenário de busca por um propósito técnico maior que a ideia do OliBase ascendeu, como uma fênix digital.

O Chamado da Arquitetura: A Inspiração BaaS (Fase 1)

A inspiração veio dos gigantes que simplificam o universo do desenvolvimento: os BaaS (Backend as a Service), como o onipresente Firebase e o elegante Supabase. Essas plataformas resolvem problemas complexos — autenticação, gestão de dados, segurança — com uma facilidade quase mágica. Então eu, fascinado por essa abstração, lancei o desafio definitivo:

"E se eu tentasse construir algo que replicasse essa complexidade, do zero, usando MERN? Não para competir no mercado, mas para forçar um aprendizado profundo, onde cada linha de código fosse uma lição de arquitetura?"

O OliBase nasceu, então, como um manifesto técnico. Um BaaS mínimo, elegante e, acima de tudo, honesto, onde o Backend seria o protagonista absoluto, exigindo o domínio de cada camada da *stack*.

O Primeiro Labirinto: A Separação das Identidades (Fases 2 e 3)

O primeiro obstáculo não foi técnico, mas conceitual: a autenticação. Em um sistema BaaS, existem, na verdade, duas classes de usuários, e misturá-las seria um erro fatal de design. A percepção crítica foi que:

  • A autenticação do dashboard (o "usuário humano" que gerencia o BaaS) é uma coisa.

  • A autenticação dos usuários finais (os clientes das aplicações que usam o BaaS) é outra completamente diferente.

Essa distinção impôs a necessidade de dois sistemas de autenticação isolados. A primeira etapa foi a implementação da Auth Humana, o alicerce administrativo. Foi aqui que o JWT (JSON Web Token) foi empregado para proteger as rotas, garantindo que apenas administradores legítimos pudessem criar projetos e gerar as chaves de acesso. Uma fundação sólida, sem a qual o castelo de cartas desmoronaria.

O Grande Teste: A Criação do Universo Multi-Tenant (Fase 4)

O OliBase não poderia ser apenas um repositório de dados; ele precisava ser um universo de dados isolados. A regra de ouro era o multi-tenant de verdade. Isso significa que, se o Projeto Alfa e o Projeto Beta usam o OliBase, os dados do Alfa devem ser absolutamente invisíveis para o Beta, e vice-versa. A dúvida técnica era a mais crucial:

"Como garantir a separação rígida dos dados de aplicações diferentes, mesmo que elas compartilhem o mesmo banco de dados físico?"

A resposta foi a criação do modelo Project e a vinculação de API Keys a cada um. O isolamento foi transformado em um requisito de protocolo, exigindo que cada requisição de dados carregasse dois *headers* obrigatórios, como um passaporte e um visto:

  1. x-api-key: A chave secreta que identifica a aplicação.

  2. x-project-id: O identificador único do projeto.

A validação de pertencimento se tornou o *middleware* mais rigoroso do sistema. O teste mental que guiou essa fase foi o mantra da segurança: "Se alguém, por engano ou má-fé, tentar usar a chave de um projeto para acessar dados de outro, o sistema TEM que falhar de forma categórica e imediata." Foi nesse ponto que o isolamento de verdade se consolidou, elevando o OliBase a um patamar de sistema de produção.

A Voz da Consciência: Logging e Observabilidade (Fases 5 e 6)

Com a segurança estabelecida, era hora de dar ao OliBase uma voz. Um sistema complexo precisa de observabilidade, a capacidade de saber o que está acontecendo em tempo real. Antes de construir o banco de dados completo, um sistema KV (Key-Value) simples foi implementado para validar o fluxo de dados e, mais importante, o Logging.

O Middleware de Logging foi a solução. Ele não era um luxo, mas uma necessidade de auditoria. Projetado para ser assíncrono e não bloqueante, ele registrava a duração, o status code e a rota de cada requisição, mas com uma regra de ouro: nunca registrar *payloads* sensíveis. A partir desse momento, o OliBase ganhou uma memória, permitindo que o desenvolvedor visse, em tempo real, a vida pulsante de sua criação. O projeto deixava de ser um mero código e se tornava um "produto" com capacidade de auto-auditoria.

O Ponto de Inflexão: A Autenticação do Usuário Final (Fases 7 e 8)

A verdadeira prova de fogo veio com a implementação da Auth de Usuários Finais. A complexidade era exponencial: o sistema precisava gerenciar a identidade de usuários que, embora pudessem ter o mesmo e-mail, pertenciam a universos de dados completamente diferentes (projetos). A decisão arquitetural foi de uma elegância brutal:

  • O usuário final é sempre um cidadão de um projeto.

  • Um JWT e um Secret completamente separados da autenticação do dashboard foram criados.

  • O JWT do usuário final carrega, de forma inseparável, o projectId, garantindo que ele só possa interagir com o seu próprio universo.

Endpoints como POST /api/auth/signup e POST /api/auth/login eram apenas a ponta do *iceberg*. A verdadeira engenharia estava nas Validações Críticas: a API Key tinha que ser válida, pertencer ao projeto e, o mais importante, o e-mail tinha que ser único dentro daquele projeto específico. Após uma bateria de testes que simulavam o caos do mundo real, o resultado foi um Auth multi-tenant real funcionando, um triunfo que validou toda a arquitetura de isolamento.

A Coroa da Segurança: Row Level Security (RLS) (Fases 9 e 10)

Um BaaS sem um sistema de dados robusto é apenas um sistema de autenticação. A implementação do Data Layer, com Collections e Documents dinâmicos, exigiu a aplicação de um conceito avançado: a Row Level Security (RLS). Inspirada nos sistemas de banco de dados mais sofisticados, a RLS é a camada de segurança que garante que o usuário só veja o que lhe é permitido ver.

As regras de acesso eram como leis universais do OliBase:

  1. O Usuário Comum (o cliente final da aplicação) só pode ver e manipular os documentos que ele mesmo criou (identificados pelo ownerId).

  2. O Admin do projeto (o usuário do dashboard) tem uma visão panorâmica, podendo ver tudo dentro do seu projeto.

  3. Projetos continuam em isolamento absoluto, sem chance de cruzamento de dados.

A fase de testes se concentrou nos casos negativos: a tentativa de um Usuário A de espiar os dados do Usuário B, ou a audácia de um Projeto A de acessar o banco de dados do Projeto B. O sucesso foi medido pelo fracasso correto dessas tentativas. O OliBase provou ser não apenas um repositório de dados, mas um guardião da privacidade e do isolamento multi-tenant.

O Batismo de Fogo: A Realidade da Correção (Fase 11)

A parte mais rica em aprendizado de qualquer projeto é o momento em que a teoria encontra a falha. O crisol do aprendizado veio com a descoberta de um bug sutil: a *Role* do administrador não estava sendo salva corretamente no *signup*. Esse não era um erro de sintaxe, mas um erro de lógica de fluxo.

A correção exigiu uma intervenção cirúrgica: um ajuste no signup, uma validação explícita no fluxo de criação de usuário e uma refatoração completa do *middleware* de autorização. "Isso é backend real," foi a conclusão. A falha provou que o sistema não era mágico, mas sim o resultado de um trabalho meticuloso de engenharia, onde cada erro se transformava em uma fundação mais forte.

O Fechamento do Círculo: O Dashboard e o Eventum (Fases 12, 13 e 14)

Para gerenciar essa complexidade arquitetural, o Dashboard foi construído em React, em um ato de auto-referência: ele consumia a própria API do OliBase. Com um design cyberpunk minimalista e *mobile first*, ele era o centro de comando para gerenciar Projetos, Usuários Finais, Collections, RLS e, o mais vital, visualizar os Logs em tempo real.

O ciclo de desenvolvimento se completou com o Eventum, uma aplicação cliente real. O Eventum não era um projeto de portfólio; era a prova viva de que o OliBase funcionava. Ele realizava:

  • Autenticação de usuários via OliBase.

  • Operações CRUD protegidas pela RLS.

  • Geração de logs visíveis no dashboard.

A validação final foi um coro de sucesso: OliBase funcional, Eventum funcional, RLS funcionando, Isolamento funcionando. O projeto deixou o campo da teoria e se estabeleceu como uma realidade funcional e robusta.

O Legado: A Prova de que Você Constrói Sistemas (Fase 15)

O que começou como uma busca por um projeto de estudos se transformou em um sistema complexo que toca em todos os pilares da engenharia de software moderna.

O código, essa obra de engenharia, será disponibilizado sob licença open source, e a jornada foi documentada em vídeo, servindo como um farol para outros desenvolvedores que buscam a transição do tutorial para a arquitetura.

Se você é apaixonado por backend, arquitetura de sistemas ou pelo poder do MERN Stack, este projeto é um convite para uma conversa técnica profunda.

Recursos da Odisseia:

Vídeo Demonstrativo (A Prova de Conceito): OliBase - Demonstração Completa da Arquitetura

Repositório Open Source (O Código Aberto): Código Fonte do OliBase