Conheça o framework que une Injeção de Dependência, Minimal APIs e um ORM Code-First sem sair da linguagem que você domina.

Introdução

Há anos, uma parte significativa da comunidade Delphi olha para o ecossistema .NET — especificamente para o ASP.NET Core — com um certo nível de admiração técnica. A facilidade de escrever APIs RESTful, a injeção de dependência nativa e a limpeza do código assíncrono são padrões que todos desejamos em nossos backends.

Muitos desenvolvedores acabam migrando seus backends para C# apenas para acessar essa arquitetura, mantendo o Delphi apenas no legado ou no front-end desktop. Mas e se fosse possível ter essa mesma experiência de desenvolvimento — Fluent APIs, Middlewares, Async/Await real — dentro do Delphi, compilando para código nativo e performático?

É exatamente essa a proposta do Dext, um novo framework open-source criado por Cesar Romero, MVP Embarcadero, que promete modernizar a stack de desenvolvimento Delphi. Neste artigo, vamos explorar o que é o Dext, como ele funciona e por que ele merece sua atenção.

Vamos neste artigo conhecer melhor esse projeto de código aberto, suas vantagens e facilidades.

O que é o Dext?

O Dext define-se como um ecossistema completo para desenvolvimento moderno. Ele não é apenas um componente para subir um servidor HTTP; é uma suíte inspirada fortemente na filosofia do .NET Core, mas adaptada para a realidade do Object Pascal.

O projeto se baseia em três pilares fundamentais:

1. Dext.Web: Um framework HTTP leve para APIs REST (suporte a Minimal APIs e Controllers).
2. Dext.Entity: Um ORM focado em produtividade (Code-First e Fluent Queries).
3. Dext.Core: A infraestrutura base, provendo Injeção de Dependência (DI), Logging e Primitivos Assíncronos.

Minimal APIs no Delphi: Adeus ao Boilerplate

Uma das maiores tendências atuais é a criação de “Minimal APIs” — rotas declaradas de forma concisa, sem a necessidade de criar classes de Controller verborrágicas para endpoints simples.

Veja como se escreve um “Hello World” com parâmetro no Dext. Note a ausência de DataModules ou componentes visuais arrastados:

uses
  Dext.Core.WebApplication,
  Dext.Http.Results;

begin
  var App := TDextApplication.Create;
  var Builder := App.GetApplicationBuilder;

  // Rota GET simples com captura de parâmetro na URL
  Builder.MapGetR<Integer, IResult>('/users/{id}',
    function(Id: Integer): IResult
    begin
      // Retorno JSON automático
      Result := Results.Json(Format('{"userId": %d, "status": "active"}', [Id]));
    end);

  App.Run(8080);
end.

O framework faz o Smart Binding: ele entende que {id} na rota é um Inteiro e passa para a função anônima automaticamente. Se você declarar um record ou class como parâmetro, ele tentará deserializar o corpo do JSON automaticamente.

Injeção de Dependência (DI) como Cidadã de Primeira Classe

No desenvolvimento moderno, o acoplamento forte é o inimigo. O Dext traz um container de Injeção de Dependência (IoC) robusto. Você registra suas interfaces e implementações na inicialização, e o framework resolve a árvore de dependências para você.

// 1. Registro dos serviços (Singleton, Scoped ou Transient)
App.Services.AddSingleton<IEmailService, TEmailService>;
App.Services.AddScoped<IUserRepository, TUserRepository>;

// 2. Uso na rota: O Dext injeta o 'EmailService' automaticamente
App.MapPostR<TUserDto, IEmailService, IResult>('/register',
  function(Dto: TUserDto; EmailService: IEmailService): IResult
  begin
    EmailService.SendWelcome(Dto.Email);
    Result := Results.Created('/login', 'Usuário registrado');
  end);

Isso elimina a necessidade de criar instâncias manualmente (TClasse.Create) espalhadas pelo código, facilitando drasticamente os testes unitários.

ORM Code-First e Fluent API

Para quem está cansado de SQL strings mágicas ou de componentes TDataset pesados, o Dext.Entity oferece uma abordagem limpa. Ele suporta bancos como SQL Server, PostgreSQL, Firebird, MySQL e Oracle.

A sintaxe é fluente e fortemente tipada:

// Exemplo de consulta complexa sem escrever SQL manual
var Orders := DbContext.Orders
  .Where((O.Status = TOrderStatus.Paid) and (O.Total > 1000)) // Filtro tipado
  .Include('Customer')       // Eager Loading (JOIN automático)
  .Include('Items')
  .OrderByDescending('Date')
  .Take(50)
  .ToList;

Além disso, ele suporta Migrations. Você define suas tabelas como classes Delphi, e o framework gera/atualiza o banco de dados para você via CLI, mantendo o versionamento do schema.

Async/Await e Tasks

O Delphi possui a TTask, mas o gerenciamento de threads ainda pode ser complexo. O Dext introduz uma sintaxe de Promises encadeadas, permitindo código assíncrono que não trava a thread principal (ou a thread do servidor web) e trata exceções de forma centralizada.

TAsyncTask.Run<TRelatorio>(
  function: TRelatorio
  begin
    // Executa em thread separada
    Result := ServicoRelatorio.GerarPesado();
  end)
  .OnComplete(
    procedure(Relatorio: TRelatorio)
    begin
      // Volta contexto automaticamente (ex: logar sucesso)
    end)
  .Start;

Considerações Técnicas e Roadmap

É importante ressaltar que o projeto está em desenvolvimento ativo (v1.0). O autor, Cesar Romero, deixa claro que a API pública pode sofrer alterações (breaking changes) até a estabilização da versão final.

Atualmente, ele utiliza Indy como camada de transporte (o que garante compatibilidade), mas com abstrações que permitirão a troca futura por sockets mais performáticos sem quebrar a aplicação do usuário. Recomenda-se o uso do FastMM5 para gerenciamento de memória em projetos que utilizem o framework.

Conclusão

O Dext é uma lufada de ar fresco para o desenvolvedor Delphi. Ele prova que é possível escrever código limpo, testável e moderno sem abandonar a linguagem. Para empresas que possuem grande know-how em Object Pascal, mas precisam modernizar suas APIs e arquitetura, o Dext é um projeto que merece ser acompanhado de perto (e testado).

Onde encontrar: O projeto é Open Source (Licença Apache 2.0) e está disponível no GitHub: https://github.com/cesarliws/dext