Arquitectura Cebolla

Importante: el modelo de dominio solo depende de sí mismo, en ningún momento tiene dependencia hacia las capas.

• Servicios de dominio: una capa más arriba. Aquí encontramos las interfaces de esos repositorios (base de datos) para acceder a los datos. Están definidas pero no implementadas.

• Servicios de aplicación: una capa más arriba, donde se encuentran las operaciones específicas. Aquí no hay interfaces.

• La capa externa: incluye las diferentes pruebas que queremos usar en nuestra aplicación, así como la interfaz gráfica y la infraestructura.

Se utiliza principalmente en el ecosistema .NET.

Onion Architecture 🧅 Fuente: dev.to

Arquitectura Cebolla

Se compone de:

1. Modelo de dominio: Es la capa que se encuentra más al interior de la cebolla. Se tienen las entidades que modela el problema y éstas no están relacionadas con la persistencia. Sólo tiene dependencia de sí mismo, nunca de las capas que lo están rodeando. Se denomina “modelo de objetos”, “capa de dominio” o “entidades de dominio”.
2. Servicios de dominio: Contiene reglas del negocio, pero un elemento fundamental es que habrán interfaces que van a representar repositorios para acceder a los datos. Se van a definir las interfaces pero no se van a implementar. Se denomina “servicio de objetos” o “capa de repositorio”.
3. Servicios de aplicación: Lógica de la aplicación puede estar repartida entre los servicios de aplicación y servicios de dominio. Se denomina “capa de servicios”.

Esto se denomina el núcleo del sistema.

1. Capa externa: Rodea al núcleo del sistema y esa pueden estar:
2. Pruebas: Unitarias, de integración y ayudar a testear que todo esté funcionando correctamente.
3. Interfaz gráfica: Es algo que puede cambiar con el tiempo.
4. Infraestructura: Se tienen elementos como acceder a un sistema de archivos, aplicaciones de terceros e integraciones varias.

Esta capa externa rodea al dominio.

Datos adicionales:

• Propuesta por Jeffrey Palermo en 2008.
• Arquitectura conocida principalmente en el ecosistema .NET.

En Python, la arquitectura de software cebolla se puede implementar siguiendo estos elementos clave:

1. Núcleo (Core): Es el centro de la aplicación y contiene las reglas de negocio y la lógica principal. En el núcleo, se definen las entidades, modelos de datos y la lógica que representa el comportamiento central de la aplicación. Esta capa no debe depender de ninguna otra capa y, por lo tanto, puede ser reutilizable e independiente.

2. Capa de Aplicación (Application Layer): Esta capa actúa como intermediaria entre el núcleo y las capas externas, como la interfaz de usuario o servicios externos. Contiene los casos de uso de la aplicación y coordina las interacciones entre el núcleo y las capas externas. Aquí se implementan los servicios que serán expuestos a través de API o interfaz de línea de comandos.

3. Capa de Infraestructura (Infrastructure Layer): Es la capa más externa y se encarga de interactuar con elementos externos, como bases de datos, servicios web, sistemas de archivos, etc. La capa de infraestructura proporciona implementaciones concretas de las interfaces definidas en las capas internas. Además, maneja detalles técnicos como el almacenamiento de datos y la comunicación con recursos externos.

En una implementación típica de Onion Architecture en Python, la estructura del proyecto se organizaría en directorios, donde cada capa tiene su propio espacio y las dependencias fluyen hacia adentro, siguiendo la lógica de la cebolla:

- app/
  - core/
    - entities/
    - use_cases/
  - application/
    - services/
  - infrastructure/
    - repositories/
    - external_services/
  - interfaces/
    - web/
    - cli/

Aquí, una breve descripción de cada directorio:

• core: Contiene las entidades y los casos de uso principales de la aplicación.
• application: Implementa los servicios de aplicación que orquestan la lógica de negocio.
• infrastructure: Proporciona implementaciones concretas para interactuar con bases de datos, servicios externos, etc.
• interfaces: Aquí se encuentran las interfaces de usuario o cualquier otra interfaz para interactuar con la aplicación. Puede haber subdirectorios específicos para las interfaces web o de línea de comandos, entre otros.

Es importante destacar que la estructura exacta puede variar según los requisitos y el tamaño del proyecto. La clave está en mantener una separación clara de responsabilidades y dependencias, permitiendo así una mayor flexibilidad y mantenibilidad del software.

Termino de ver este vídeo y estoy en shock.

Me estoy dando cuenta que luego de haber combinado varias patrones de arquitectura, creyendo que aplicaba una arquitectura principalmente hexagonal, puede que haya terminado implementado la arquitectura de Cebolla sin saber que esta existía.

✅