Cómo implementar CQRS y APIs de Alto Rendimiento sin escribir Controladores

De la Base de Datos a la API en 1 Línea: Cero Complejidad, Máximo Rendimiento.

Por Cesar Romero

Si desarrollas backends corporativos hoy en día, probablemente sufras de “Fatiga del Boilerplate”. Para crear un simple CRUD de una tabla de Clientes, la arquitectura moderna nos obliga a crear una procesión de archivos: un Controller, un DTO, un Service, un Repository, un Validator y, finalmente, la Entidad.

Multiplica esto por 50 tablas y tendrás semanas de trabajo repetitivo que no agrega valor real al negocio.

¿Y si te dijera que es posible tener una arquitectura limpia, segura y con un rendimiento superior al manual, escribiendo solo una línea de código?

Bienvenido a Database as API de Dext.

Cero Complejidad

Dext elimina la burocracia del desarrollo de APIs. Entiende que, la mayoría de las veces, solo quieres exponer tus datos de forma segura y estandarizada, sin tener que “pedir permiso” a cinco capas de arquitectura.

Mira cómo definimos una entidad en Dext. Es código Delphi puro, limpio y 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, ahora comenzarías a escribir el CustomerController. En Dext, vas directo a Startup y haces esto:

// Mapea la entidad TCustomer a una API REST completa
TDataApiHandler<TCustomer>.Map(ABuilder, '/api/customers', FDbContext);

Listo. Dext levanta endpoints para GET, POST, PUT y DELETE, con manejo de estados HTTP, serialización JSON y binding de parámetros. Sin ceremonias, sin archivos extra.

Rendimiento Máximo con CQRS Implícito

Aquí es donde separamos los “generadores de código simple” de las herramientas de ingeniería de software.

Muchos frameworks intentan facilitar el CRUD usando Reflection pesada que instancia objetos, copia propiedades y luego serializa. Esto mata el rendimiento. Otros hacen un volcado directo de la base de datos, exponiendo nombres de columnas feos o datos sensibles.

Dext adopta un enfoque de CQRS (Command Query Responsibility Segregation) Implícito con respeto total a tu Mapping:

1. Read Pipeline (GET): Direct-to-JSON Streaming Cuando llamas a GET /api/customers, Dext crea un pipeline optimizado entre el IDbReader (base de datos) y el Response.Body (Red). El consumo de memoria es cercano a cero.
2. El Mapping es Soberano Incluso en modo de alto rendimiento, Dext respeta tus atributos de mapeo.

• ¿Tienes un atributo [JsonIgnore]? El campo no va al JSON.
• ¿Tienes una estrategia de Naming configurada (ej: camelCase)? Dext aplica las transformaciones de clave/valor en tiempo de streaming, asegurando que el contrato de tu API se respete sin sacrificar la velocidad.

3. Write Pipeline (POST/PUT): Domain Safety Ya en la escritura, la seguridad es primordial. Dext recibe el JSON, hidrata la entidad TCustomer, ejecuta las validaciones de dominio y persiste vía DbContext.

Obtienes el rendimiento de un Micro-ORM en la lectura y la seguridad de un Enterprise ORM en la escritura.

Una API que Habla el Idioma del Front-end

Otro problema común es el “Backend for Frontend” (BFF). El Front-end pide un endpoint para filtrar por nombre. Luego otro para filtrar por estado. Luego otro con paginación.

Database as API entrega una Queryable API nativa. Sin escribir ninguna línea extra de código, tu endpoint /api/customers ya soporta filtros dinámicos vía query string:

• Filtros: /api/customers?active=true&name=John
• Paginación: /api/customers?_limit=10&_offset=20
• Selección: Dext traduce los parámetros de la URL en consultas SQL optimizadas automáticamente.

¿Pero qué hay de la Seguridad?

“¡Exponer la base de datos es peligroso!”, dirían los escépticos. Y tendrían razón, si Dext no hubiera sido diseñado con Security-First (Seguridad Primero).

Aunque el ejemplo básico es abierto para facilitar el aprendizaje, en producción blindas tu API con RBAC (Role-Based Access Control) en una línea fluida:

TDataApiHandler<TCustomer>.Map(App, '/api/customers', FDbContext,
  TDataApiOptions<TCustomer>.Create
    .RequireReadRole('User,Admin')   // Lectura amplia: Viewer, User o Admin
    .RequireWriteRole('Editor,Admin') // Escritura restringida: Editor o Admin
);

Conclusión

Dext no solo está facilitando la creación de APIs; está devolviendo al desarrollador la capacidad de concentrarse en lo que importa.

Elimina la complejidad accidental (controladores repetitivos, DTOs de espejo) y mantiene lo esencial: tus Reglas de Negocio, tu Mapping y tu Seguridad.

Si quieres el rendimiento de una arquitectura optimizada sin la complejidad de frameworks detallados, Dext es tu nueva herramienta de trabajo.

---

¿Te gustó? Descarga el ejemplo completo DatabaseAsApi.dpr en el repositorio oficial y mira cómo ocurre la magia. https://github.com/cesarliws/dext