by cesarliws
Dext - Modern Full Stack Framework for Delphi
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
# Add to your Claude Code skills
git clone https://github.com/cesarliws/dextGuides for using mcp servers skills like dext.
No comments yet. Be the first to share your thoughts!
Modern Full-Stack Development for Delphi
[!IMPORTANT] Dext Framework is currently in Version 1 Release Candidate (RC1).
Dext Framework is a native and integrated ecosystem for Delphi development.
It brings together Dependency Injection, ORM, Web Pipeline, and Testing into a single, high-performance architecture. Designed to eliminate the need for connecting isolated libraries and to drastically reduce boilerplate code, Dext handles the infrastructure complexity so your team can focus strictly on business logic.
Dext was specifically designed to solve the real-world pain points faced by Delphi developers:
[DataApi] attribute.TThread class.See how Dext's structure simplifies complex flows into clean, typed, and object-oriented code. Exploring the framework's pillars:
Creating a high-performance endpoint integrated with Dependency Injection requires minimal effort:
program MyAPI;
uses Dext.Web;
begin
var App := WebApplication;
// Simple endpoint
App.MapGet('/hello', function: string
begin
Result := 'Hello from Dext! Modern full-stack for Delphi.';
end);
// Endpoint with native Automatic Dependency Injection (DI) and Model Binding
App.MapPost<TUserDto, IEmailService, IResult>('/register',
function(Dto: TUserDto; EmailService: IEmailService): IResult
begin
EmailService.SendWelcome(Dto.Email);
Result := Results.Created('/login', 'User successfully registered');
end);
App.Run(8080);
end.
Automatic mapping via Convention over Configuration and structured properties for advanced relational mapping:
[Table]
[DataApi('/api/orders')] // Automatically exposed as a REST API (Zero-Code API)!
TOrder = class
private
FId: IntType;
FStatus: Prop<TOrderStatus>;
FNotes: StringType;
FTotal: Nullable<CurrencyType>;
FItems: Lazy<IList<TOrderItem>>;
public
[PK, AutoInc]
property Id: IntType read FId write FId;
property Status: Prop<TOrderStatus> read FStatus write FStatus;
property Notes: StringType read FNotes write FNotes;
// Smart Types to natively handle nulls, validation, and Lazy Loading
property Total: Nullable<CurrencyType> read FTotal write FTotal;
property Items: Lazy<IList<TOrderItem>> read FItems write FItems;
end;
No more magic strings or broken queries at runtime. Dext generates the Abstract Syntax Tree (AST) of your code:
// Complex query with Joins and Filters interpreted as clean code
var O := Prototype.Entity<TOrder>;
var Orders := DbContext.Orders
.Where((O.Status = TOrderStatus.Paid) and (O.Total > 1000))
.Include('Customer') // Eager Loading
.Include('Items')
.OrderBy(O.Date.Desc)
.Take(50)
.ToList;
// High-performance Bulk Update directly in the DBMS without loading records into memory
DbContext.Products
.Where(Prototype.Entity<TProduct>.Category = 'Outdated')
.Update
.Execute;
The complexity of TThread transformed into modern asynchronous chained pipelines. The Fluent Async Tasks abstraction delivers superpowers over the PPL (Parallel Programming Library) and Future<T>, allowing pipelines based on the Thread Pool:
var CTS := TCancellationTokenSource.Create;
TAsyncTask.Run<TStream>(
function: TStream
begin
// Requests a free Task from the Thread Pool for network download
Result := AsyncClient.DownloadStream('https://api.company.com/data', CTS.Token);
end)
.Then<TReport>(
function(Stream: TStream): TReport
begin
// Chains a new processing Task as soon as the previous one finishes
Result := JsonSerializer.Deserialize<TReport>(Stream);
Stream.Free;
end)
.OnComplete(
procedure(Report: TReport)
begin
// Automatically and safely synchronizes the return with the Original Thread (UI)
ShowReport(Report);
end)
.OnException(
procedure(Ex: Exception)
begin
ShowError('Process failed: ' + Ex.Message);
end)
.Start;
Structured environment for registering services and external configurations using JSON, YAML, or Environment Variables:
var Builder := WebApplication.CreateBuilder;
// Load hierarchical configuration sources
Builder.Configuration
.AddJsonFile('appsettings.json')
.AddYamlFile('config.yaml')
.AddEnvironmentVariables;
Builder.Services
// Natively binds configuration to a strongly-typed class
.Configure<TDatabaseSettings>(Builder.Configuration.GetSection('Database'))
// Complete Dependency Injection for repositories and services
.AddSingleton<IEmailService, TSmtpEmailService>
.AddScoped<IOrderRepository, TDbOrderRepository>;
var App := Builder.Build;
The TEntityDataSet converts the ORM's object orientation (POCOs) into DataSet-compatible structures consumable by your VCL grids, data-aware components, and Design Time reports, without losing performance!
Design-Time Support: Native TFields creation from entity code and record visualization directly in the IDE.
Dext is composed of flexible and minimalist modules. You retain full control over the architecture and include only the vital components for your solution:
IList, IDictionary). Dext solves the classic Generic Bloat with Binary Code Folding, significantly reducing huge binaries.TAutoMocker), test coverage, and reporting.See the full features list and Dext modules
Dext distribution prioritizes minimalism, without opaque installers that inject clutter into your system directory:
git clone https://github.com/cesarliws/dext.gitLibrary Paths in Delphi referencing Dext's main modules.Sources\DextFramework.groupproj group.Read Detailed Setup and Installation Instructions
Delphi has historically been chosen for domains that did not tolerate overheads; however, recent frameworks have adopted unrestrained allocation patterns based on developer convenience. Dext returns the performance while maintaining modern ease of use:
strings, causing deadly spikes in the Memory Manager and forced pauses. Dext bypasses classic conversion through Direct-to-JSON streaming, reading entire blocks via immutable memory structures (TSpan).Dext is developed and maintained publicly and provided under the Apache License 2.0. It is fully and unconditionally free (for open-source scenarios or strict enterprise/commercial development). Create billion-dollar software, distribute, or encapsulate at wil