How williamandreu/angular_clean_architecture works
A continuación se detalla una guía lineal, organizada y bien estructurada para crear un diagrama de diseño del sistema acorde con la arquitectura del proyecto:
Tipo y propósito del proyecto
• Se trata de un proyecto de Angular basado en Clean Architecture, siguiendo principios SOLID.
• La arquitectura está dividida en capas: Presentación, Dominio, Data (datos) y Core.
• Además, se incluye un script para la generación automática de dominios, facilitando la creación de nuevas capas de negocio de forma modular.
Componentes principales y carpetas relevantes
A. Presentación (Frontend Angular)
• Ubicación: Carpeta “src/presentation”.
• Subcarpetas relevantes:
• “app”: Contiene módulos de enrutamiento, componentes principales (app.component.ts, etc.) y shared-components.
• “views”: Cada vista (ej. “characters-list-view”) que incluye sus subcarpetas: “view” (HTML/SCSS/TS) y “viewmodel”.
• “assets”: Recursos estáticos.
B. Dominio (Lógica de negocio)
• Ubicación: Carpeta “src/domain”.
• Subcarpetas relevantes:
• “entities”: Entidades del dominio (por ejemplo, “characters-entity.model.ts”).
• “repositories”: Interfaces de repositorios.
• “usecases”: Casos de uso que encapsulan la lógica de negocio.
C. Datos (Capa de acceso a datos)
• Ubicación: Carpeta “src/data”.
• Subcarpetas relevantes:
• “datasource”: Operaciones de obtención de datos, divididas en “local” y “remote” (con sus propias subcarpetas: “dbo”, “dto”, “source”).
• “repositories”: Implementaciones de repositorios y mapeadores (subcarpeta “character” con “mappers”).
• “di”: Configuraciones de inyección de dependencias para datos (ej. “characters.di.ts”).
D. Core (Elementos transversales)
• Ubicación: Carpeta “src/core”.
• Subcarpetas relevantes:
• “core-interface”: Interface de componentes básicos (mappers, solicitudes, casos de uso).
• “directives”, “guards”, “interceptors” y “pipes”: Elementos reutilizables en toda la aplicación.
• “environments”: Configuraciones de entornos.
• “utils”: Utilidades (validación u otras funciones comunes).
• “public-interface”: Exposición de funcionalidades de manera pública.
E. Scripts para generación de dominio
• Ubicación: Carpeta “scripts/generate-domain”.
• Contiene:
• Archivos JavaScript que gestionan la creación de módulos en base a plantillas.
• Plantillas (ubicadas bajo “templates”) organizadas en subdirectorios: “datasource”, “domain/entities”, “domain/repositories” y “domain/usecases”.
• Utilidades adicionales en “utils”.
Relaciones e interacciones entre componentes
• La capa de Presentación se comunica con la capa de Dominio a través de casos de uso expuestos en los servicios/componentes.
• La capa de Dominio contiene la lógica de negocio y se apoya en la capa de Datos para el acceso y manejo de la información, utilizando repositorios y datasources.
• La capa de Data se encarga de conectarse tanto a fuentes locales como remotas (detalladas en datasources), y de mapear datos a entidades de dominio mediante mappers.
• Los elementos transversales del Core (como directivas, pipes, interceptors) se integran en toda la aplicación para mantener la consistencia y reutilización del código.
• El script para la generación de dominio permite crear las carpetas y subcarpetas necesarias (por ejemplo, “datasource”, “domain/entities”, “domain/repositories”, “domain/usecases”) de forma automatizada, facilitando la integración al módulo de datos.
Principios y patrones arquitectónicos
• Clean Architecture: Separación estricta entre las capas de presentación, dominio y datos.
• Principios SOLID: Cada capa y componente tiene responsabilidades bien definidas.
• Inyección de Dependencias: Los “di” (dependency injection) en la carpeta “src/data/di” permiten desacoplar implementaciones y facilitar testeo.
• Uso de plantillas para generación de nuevas funcionalidades/domains, asegurando consistencia en la estructura (en “scripts/generate-domain/templates”).
Recomendaciones para el diagrama de sistema
a. Crear nodos bien etiquetados para cada capa:
• Nodo "Presentación" subdividido en:
• "App y Routing"
• "Views y ViewModels"
• "Shared Components"
• "Assets y Estilos"
• Nodo "Dominio" subdividido en:
• "Entities"
• "Repositories (Interfaces)"
• "Use Cases"
• Nodo "Datos" subdividido en:
• "Datasources" (con subdivisiones “local”, “remote”, “source”, “dto”, “dbo”)
• "Repositories (Implementaciones y Mappers)"
• "DI Configurations"
• Nodo "Core" subdividido en:
• "Core Interfaces"
• "Directives / Guards / Pipes / Interceptors"
• "Utilities" y "Environment"
• Nodo "Scripts" que incluya:
• "Generate Domain" con sus carpetas “templates” (incluyendo subcarpetas para datasource, domain/entities, etc.)
b. Determinar flechas direccionales:
• De “Presentación” a “Dominio” (llamadas a casos de uso).
• De “Dominio” a “Datos” (obtención y almacenamiento de datos mediante repositorios).
• Flechas que indiquen la inyección de dependencias desde “DI” en “Datos”.
c. Emplear codificación por colores o diferentes formas:
• Diferenciar entre interfaces, implementaciones y utilitarios mediante iconografía o formas distintas.
d. Incluir detalles de tecnologías y herramientas:
• Notar que se utiliza Angular y TypeScript en la capa de Presentación.
• Mostrar la integración con Node.js para scripts y configuración automatizada.
• Mencionar el uso de Jest en la realización de tests (carpeta “src/tests”).
Guía para agregar carpetas y subcarpetas en el diagrama
• Cada nodo principal debe expandirse en sus subcarpetas, resaltando relaciones jerárquicas. Por ejemplo:
▸ Datos
├── Datasource
│ ├── Characters
│ │ ├── Local
│ │ │ └── (Archivos DBO, implementación, etc.)
│ │ ├── Remote
│ │ │ └── (Archivos DTO, implementación, etc.)
│ │ └── Source
│ └── (Otros dominios si existen)
├── Repositories
│ └── Characters (con su carpeta de mappers)
└── DI
• Este desglose visual ayudará a identificar tanto la organización física en carpetas como las relaciones lógicas entre ellas.
Resumen e implementación
• El diagrama final debe ser muy detallado, separando cada componente de la aplicación en múltiples nodos y subnodos.
• Incluir flechas indicativas para representar la dirección del flujo de datos entre las capas.
• Documentar cada nodo con etiquetas claras que mencionen su responsabilidad y rol dentro de la arquitectura.
Con esta guía lineal y organizada, el diagrama de sistema representará fielmente la estructura de la aplicación Angular basada en Clean Architecture, incluyendo las carpetas y subcarpetas que definen la separación de responsabilidades y la modularidad del proyecto.