Saltar al contenido
devjose↗FRONTEND ENGINEER · LIMA, PE
TrabajoSobre míExperienciaBlogHablemos
Inicio/Blog

DESARROLLO FRONTEND

NestJS en un producto fintech multi-tenant: arquitectura hexagonal, CQRS y CASL

Cómo uso arquitectura hexagonal, CQRS y permisos con CASL en NestJS para resolver un backend fintech multi-tenant real, sin duplicar lógica en cada controlador.

Por José Manrique · 11 de agosto de 2026

TL;DR
En el ecosistema CED (cuantoestaeldolar.pe) trabajo un backend NestJS con arquitectura hexagonal, CQRS para separar comandos de consultas y CASL para permisos multi-tenant. La combinación resuelve un problema puntual: varias marcas comparten el mismo backend, pero cada una necesita reglas de acceso distintas sin duplicar controladores.

Por qué hexagonal y no el NestJS "por defecto"

NestJS ya trae una estructura por módulos razonable, pero cuando el dominio crece y hay que soportar MySQL para unas entidades y MongoDB para otras, mezclar el TypeORM de un módulo con la lógica de negocio hace que cambiar de proveedor de datos implique tocar reglas que no deberían depender de la base. Separar puertos (interfaces) de adaptadores (TypeORM, Mongoose) resolvió eso: el dominio no sabe qué motor de base hay detrás.

src/
  modules/
    exchange-rate/
      domain/
        exchange-rate.entity.ts
        exchange-rate.repository.ts   // puerto (interface)
      application/
        commands/
          update-rate.handler.ts
        queries/
          get-latest-rate.handler.ts
      infrastructure/
        typeorm-exchange-rate.repository.ts  // adaptador
        exchange-rate.controller.ts

CQRS: separar quién escribe de quién lee

Uso el módulo @nestjs/cqrs para comandos que cambian estado (actualizar un tipo de cambio) y queries que solo leen (obtener el último tipo de cambio publicado). No es sobre-ingeniería si ya tienes varios tenants leyendo el mismo dato con reglas de caché distintas: separar el camino de lectura permite optimizarlo sin arriesgar la lógica de escritura.

@CommandHandler(UpdateRateCommand)
export class UpdateRateHandler implements ICommandHandler<UpdateRateCommand> {
  constructor(
    private readonly repository: ExchangeRateRepository,
    private readonly eventBus: EventBus,
  ) {}

  async execute(command: UpdateRateCommand) {
    const rate = await this.repository.save(command.payload)
    this.eventBus.publish(new RateUpdatedEvent(rate))
    return rate
  }
}

CASL: permisos que cambian por tenant

El problema concreto: un editor de la marca A puede publicar tasas para su propio país, pero no para el de la marca B, aunque comparten el mismo endpoint. En vez de llenar los controladores de if por rol, construyo las habilidades (Ability) una vez por request según el usuario y su tenant:

export class CaslAbilityFactory {
  createForUser(user: AuthUser) {
    const { can, cannot, build } = new AbilityBuilder<AppAbility>(Ability)

    if (user.role === 'editor') {
      can('update', 'ExchangeRate', { tenantId: user.tenantId })
    }

    if (user.role === 'viewer') {
      can('read', 'ExchangeRate')
    }

    cannot('delete', 'ExchangeRate') // nadie borra tasas históricas

    return build()
  }
}

El controlador solo pregunta ability.can('update', rate); no necesita saber qué combinación de rol y tenant lo permitió. Cuando un producto nuevo pidió un rol "supervisor" que aprueba antes de publicar, el cambio fue agregar una regla en la factory, no tocar cada controlador que usa tasas de cambio.

Lo que no volvería a hacer

Al inicio metí CASL también dentro del dominio, como si fuera una regla de negocio pura. Terminé con lógica de autorización mezclada con validaciones de dominio, y probar una sin la otra se volvió incómodo. Moví la construcción de habilidades a un guard en la capa de infraestructura: el dominio valida reglas de negocio, la capa HTTP valida permisos.

Cuándo no vale la pena esta combinación

Si tienes un solo tenant y pocos roles, hexagonal más CQRS más CASL es más ceremonia de la que necesitas. Esto tiene sentido cuando el mismo backend sirve a varias marcas con reglas de negocio y de acceso distintas, que es justo el caso en CED.

¿Separas permisos del dominio en tus proyectos con NestJS, o los mezclas con las reglas de negocio? Me interesa saber cómo lo resolviste.


Recursos que usé:

  • CQRS en la documentación de NestJS
  • Documentación oficial de CASL

Sigue leyendo

Construir un asistente educativo con AWS Bedrock Agents: lo que aprendí con Unibot ↗Arquitectura por eventos en AWS: lo que aprendí armando un sistema de agendamiento ↗Todos los artículos
devjose↗

© 2026 José Manrique

BlogGitHub LinkedIn PrivacidadTérminosArriba ↑