Como implementar CQRS e APIs de Alta Performance sem escrever Controllers

Do Banco à API em 1 Linha: Zero Complexidade, Performance Máxima.

Por Cesar Romero

Se você desenvolve backends corporativos hoje, provavelmente sofre da “Fadiga do Boilerplate”. Para criar um simples CRUD de uma tabela de Clientes, a arquitetura moderna nos obriga a criar uma procissão de arquivos: um Controller, um DTO, um Service, um Repository, um Validator e, finalmente, a Entidade.

Multiplique isso por 50 tabelas e você tem semanas de trabalho repetitivo que não agrega valor real ao negócio.

E se eu te dissesse que é possível ter uma arquitetura limpa, segura e com performance superior à manual, escrevendo apenas uma linha de código?

Bem-vindo ao Database as API do Dext.

Zero Complexidade

O Dext remove a burocracia do desenvolvimento de APIs. Ele entende que, na maioria das vezes, você só quer expor seus dados de forma segura e padronizada, sem ter que “pedir permissão” para cinco camadas de arquitetura.

Veja como definimos uma entidade no Dext. É puro código Delphi, limpo e tipado:

type
  [Table('customers')]
  TCustomer = class(TEntity)
  private
    FId: Integer;
    FName: string;
    FEmail: string;
    FActive: Boolean;
  public
    [PK, AutoInc]
    property Id: Integer read FId write FId;

    [Column('name'), Required, MaxLength(100)]
    property Name: string read FName write FName;

    [Column('email'), MaxLength(255)]
    property Email: string read FEmail write FEmail;

    [Column('active')]
    property Active: Boolean read FActive write FActive;
  end;

Tradicionalmente, agora você começaria a escrever o CustomerController. No Dext, você vai direto ao Startup e faz isso:

// Mapeia a entidade TCustomer para uma API REST completa
TDataApiHandler<TCustomer>.Map(ABuilder, '/api/customers', FDbContext);

Pronto. O Dext levanta endpoints para GET, POST, PUT e DELETE, com tratamento de status HTTP, serialização JSON e binding de parâmetros. Sem cerimônias, sem arquivos extras.

Performance Máxima com CQRS Implícito

Aqui é onde separamos os “geradores de código simples” das ferramentas de engenharia de software.

Muitos frameworks tentam facilitar o CRUD usando Reflection pesada que instancia objetos, copia propriedades e depois serializa. Isso mata a performance. Outros fazem um dump direto do banco, expondo nomes de colunas feios ou dados sensíveis.

O Dext adota uma abordagem de CQRS (Command Query Responsibility Segregation) Implícito com respeito total ao seu Mapping:

1. Read Pipeline (GET): Direct-to-JSON Streaming Quando você chama GET /api/customers, o Dext cria um pipeline otimizado entre o IDbReader (banco) e o Response.Body (Network). O consumo de memória é próximo de zero.
2. O Mapping é Soberano Mesmo no modo de alta performance, o Dext respeita seus atributos de mapeamento.

• Tem um atributo [JsonIgnore]? O campo não vai para o JSON.
• Tem uma estratégia de Naming configurada (ex: camelCase)? O Dext aplica as transformações de chave/valor em tempo de streaming, garantindo que o contrato da sua API seja respeitado sem sacrificar a velocidade.

3. Write Pipeline (POST/PUT): Domain Safety Já na escrita, a segurança é primordial. O Dext recebe o JSON, hidrata a entidade TCustomer, roda as validações de domínio e persiste via DbContext.

Você ganha a performance de um Micro-ORM na leitura e a segurança de um Enterprise ORM na escrita.

Uma API que Fala a Língua do Front-end

Outro problema comum é o “Backend for Frontend” (BFF). O Front-end pede um endpoint para filtrar por nome. Depois outro para filtrar por status. Depois outro com paginação.

O Database as API entrega uma Queryable API nativa. Sem escrever nenhuma linha extra de código, seu endpoint /api/customers já suporta filtros dinâmicos via query string:

• Filtros: /api/customers?active=true&name=John
• Paginação: /api/customers?_limit=10&_offset=20
• Seleção: O Dext traduz os parâmetros da URL em queries SQL otimizadas automaticamente.

Mas e a Segurança?

“Expor o banco é perigoso!”, diriam os céticos. E estariam certos, se o Dext não tivesse sido desenhado com Security-First.

Embora o exemplo básico seja aberto para facilitar o aprendizado, em produção você blinda sua API com RBAC (Role-Based Access Control) em uma linha fluente:

TDataApiHandler<TCustomer>.Map(App, '/api/customers', FDbContext,
  TDataApiOptions<TCustomer>.Create
    .RequireReadRole('User,Admin')   // Leitura ampla: Viewer, User ou Admin
    .RequireWriteRole('Editor,Admin') // Escrita restrita: Editor ou Admin
);

Conclusão

O Dext não está apenas facilitando a criação de APIs; ele está devolvendo ao desenvolvedor a capacidade de focar no que importa.

Ele elimina a complexidade acidental (controllers repetitivos, DTOs de espelho) e mantém o que é essencial: suas Regras de Negócio, seu Mapping e sua Segurança.

Se você quer a performance de uma arquitetura otimizada sem a complexidade de frameworks verbosos, o Dext é a sua nova ferramenta de trabalho.

---

Gostou? Baixe o exemplo completo DatabaseAsApi.dpr no repositório oficial e veja a mágica acontecer. https://github.com/cesarliws/dext