How codingangel27/fullstack-products works
Tipo y propósito del proyecto (qué estás diagramando)
Este repo es un full‑stack CRUD de productos con:
• Frontend: Angular v17 (frontend-products/) con UI Bootstrap y alertas SweetAlert2.
• Backend: Spring Boot 2.x Java 8 (products-app/) expone un REST API.
• Base de datos: Oracle 19c+ con tabla, secuencia y stored procedure (conectionProductos.sql).
• Reglas de negocio importantes a reflejar:
• Borrado lógico: productos pasan de A (activo) a I (inactivo); el frontend solo lista A.
• Fechas automáticas: fecha_creacion y fecha_modificacion gestionadas por el sistema (DB o backend según implementación).
Tu “mejor diagrama” debería mostrar claramente capas, flujos CRUD, contratos API y el acoplamiento backend↔Oracle (incluyendo stored procedures / secuencias).
Backend: products-app/ (arquitectura por capas)
Rutas relevantes:
• controller/ProductoController.java: REST endpoints /api/productos (GET/POST/PUT/DELETE).
• service/IProductoService.java y serviceImpl/ProductoServiceImpl.java: lógica de negocio (estado A/I, validaciones, fechas).
• repository/IProductoRepository.java: persistencia (Spring Data JPA).
• entity/Producto.java: modelo persistente.
• dto/ProductoDTO.java, dto/ApiResponse.java: contratos hacia/desde API.
• exception/* + GlobalExceptionHandler.java: manejo centralizado de errores.
• config/WebConfig.java: típicamente CORS / MVC config (clave para frontend).
• application.properties: datasource Oracle, JPA dialect.
Esto sugiere un diagrama con Controller → Service → Repository → Oracle + “cross‑cutting” para excepciones/config.
Frontend: frontend-products/ (feature-based Angular)
Rutas relevantes:
• core/services/producto.service.ts: cliente HTTP hacia http://localhost:8080/api/productos.
• features/productos/pages/*: UI por páginas: list/detail/form.
• features/productos/models/producto.ts: modelo TypeScript.
• app.routes.ts: rutas; según README, entry principal /productos.
• Presencia de server.ts, main.server.ts, app.config.server.ts: indica SSR (Angular Universal / server-side rendering) o preparación para SSR. En el diagrama, al menos marca que Angular puede correr como SPA dev server y potencialmente como SSR Node server (según cómo se despliegue).
DB y tooling
• conectionProductos.sql: crea tabla PRODUCTO, SEQ_PRODUCTO, SP_CREAR_PRODUCTO, data seed.
• Api-productos.postman_collection.json: evidencia de contrato API y escenarios de prueba.
Qué diagramas conviene producir (mínimo 3 vistas)
Para que sea “best and most accurate”, produce múltiples vistas (C4 recomendado):
Objetivo: quién usa el sistema y qué dependencias externas hay.
• Actor: Usuario (Browser).
• Sistema: Fullstack Products.
• Dependencias: Oracle DB.
Objetivo: separar runtime containers y protocolos.
Incluye:
• Browser (Angular SPA) o “Angular SSR Node” (si aplica).
• Angular App (UI) → llama a → Spring Boot API (HTTP/JSON).
• Spring Boot → conecta a → Oracle DB (JDBC).
• Oracle incluye: Tabla PRODUCTO, Secuencia, Stored Procedure.
Aquí ya dibujas puertos:
• Frontend: :4200
• Backend: :8080
• Oracle: :1521 (típico), service XEPDB1 (según README).
Backend (muy valioso en este repo):
• ProductoController
• ProductoServiceImpl (implements IProductoService)
• IProductoRepository (Spring Data)
• Producto entity
• DTOs (ProductoDTO, ApiResponse)
• GlobalExceptionHandler (cross-cutting)
• WebConfig (CORS)
DB side:
• PRODUCTO table
• SEQ_PRODUCTO
• SP_CREAR_PRODUCTO
Frontend (opcional pero útil):
• Pages: producto-list, producto-detail, producto-form
• ProductoService (HttpClient)
• Producto TS model
• Router (app.routes.ts)
Frontend (Angular)
• UI Pages/Components
• ProductoListComponent (GET list; muestra solo A)
• ProductoDetailComponent (GET by id, si existe)
• ProductoFormComponent (POST create / PUT update)
• Service
• ProductoService (HTTP client)
• Routing
• /productos route
• UI libs
• Bootstrap (layout)
• SweetAlert2 (alerts/confirm delete)
Backend (Spring Boot)
• REST Controller
• ProductoController (CRUD endpoints)
• Service layer
• ProductoServiceImpl + IProductoService
• reglas: estado A/I, set de fechas, validaciones
• Repository layer
• IProductoRepository (JPA)
• Domain + DTO
• Producto entity
• ProductoDTO, ApiResponse
• Cross-cutting
• GlobalExceptionHandler + exceptions (BadRequestException, ResourceNotFoundException)
• WebConfig (CORS)
• Runtime
• Spring Boot app (Main.java)
Database (Oracle)
• PRODUCTO (campos + estado, fechas)
• SEQ_PRODUCTO
• SP_CREAR_PRODUCTO (usado para inserts seed y posiblemente create path si el backend lo invoca; si NO lo invoca, acláralo en la nota del diagrama)
Relaciones e interacciones (qué flechas dibujar)
Dibuja flechas con protocolo + payload:
Browser → Angular
• “User actions: view list / create / edit / delete”
Angular ProductoService → Spring Boot ProductoController
• HTTP GET /api/productos → lista (filtrada por estado A ya sea backend o frontend; README sugiere que el frontend solo muestra A, pero lo ideal es que el backend también filtre; en el diagrama puedes poner: “returns active products”).
• HTTP POST /api/productos → create product (backend asigna fecha_creacion)
• HTTP PUT /api/productos/{id} → update (backend actualiza fecha_modificacion)
• HTTP DELETE /api/productos/{id} → logical delete (set estado='I')
ProductoController → ProductoServiceImpl
• llamadas internas (métodos create/update/delete/list/get)
ProductoServiceImpl → IProductoRepository
• persistencia JPA
IProductoRepository → Oracle DB
• JDBC / JPA / Hibernate
• Operaciones sobre tabla PRODUCTO
• Si se usa SP/sequence desde backend: flecha explícita “calls stored procedure / uses sequence”.
Si solo se usa en script de inicialización, marca SP/sequence como “DB initialization/seed”.
GlobalExceptionHandler
• flechas punteadas desde Controller layer: “translates exceptions → HTTP responses (ApiResponse)”
WebConfig (CORS)
• flecha punteada hacia Controller/API: “enables CORS for Angular origin :4200”
Patrones/diseño a resaltar (porque son “esenciales” aquí)
• Arquitectura por capas: Controller → Service → Repository → DB.
• DTO pattern: separar ProductoDTO de Producto entity (contrato vs persistencia).
• Centralized exception handling: GlobalExceptionHandler.
• Soft delete: estado A/I (esto debe aparecer explícitamente como regla de negocio).
• Audit timestamps: fecha_creacion/fecha_modificacion automáticas.
• (Frontend) Feature-based structure: features/productos/pages + core/services.
Notación y estilo
• Cajas por contenedor: “Angular App”, “Spring Boot API”, “Oracle DB”.
• Dentro de cada caja, subcajas por capa/componente.
• Flechas direccionales con:
• protocolo (HTTP/JSON, JDBC)
• endpoint (GET/POST/PUT/DELETE /api/productos)
• efecto de negocio (“logical delete sets estado=I”)
• Azul: Frontend components/services
• Verde: Backend components
• Naranja: Database objects (table/sequence/SP)
• Gris punteado: cross-cutting (CORS, exception handler)
Etiquetas obligatorias (para máxima precisión)
• Puertos: 4200, 8080, 1521
• URL API base: http://localhost:8080/api/productos
• Estado: A/I
• Campos fecha: fecha_creacion, fecha_modificacion
Plantilla concreta de diagrama (qué dibujar exactamente)
Si tuviera que decirte “dibuja esto”:
Nivel Contenedores
• [User Browser]
→ (HTTP) → [Angular Frontend (ng serve :4200)]
→ (HTTP/JSON) → [Spring Boot Products API (:8080)]
→ (JDBC) → [Oracle DB 19c (:1521/XEPDB1)]
Nivel Componentes dentro de Spring Boot
• ProductoController (REST)
→ ProductoServiceImpl
→ IProductoRepository
→ PRODUCTO table
• A un lado: GlobalExceptionHandler (punteado desde controller)
• A un lado: WebConfig (CORS) (punteado habilitando requests desde :4200)
• DB objects cerca de PRODUCTO: SEQ_PRODUCTO, SP_CREAR_PRODUCTO (anotar “seed/init” o “used by backend” según aplique)
Nivel Componentes dentro de Angular
• Router /productos
• ProductoListComponent ↔ ProductoService
• ProductoFormComponent ↔ ProductoService
• ProductoDetailComponent ↔ ProductoService
• Anota Bootstrap/SweetAlert2 como librerías de UI.
Checklist final (para validar que el diagrama es fiel al repo)
• Aparece el borrado lógico A→I y su efecto en el listado.
• Se distinguen DTO vs Entity.
• Se ven las capas (controller/service/repository) explícitas.
• Se muestra Oracle con tabla + secuencia + SP (al menos como artefactos).
• Se indica CORS y el origen Angular.
• Se anotan endpoints CRUD y protocolo.
• El diagrama separa claramente dev runtime (ng serve) vs backend (Spring Boot) y DB.
Con estas vistas, el diagrama resultante no solo “se entiende”, sino que es trazable a carpetas/archivos concretos del repo (lo que lo hace preciso y defendible en una revisión técnica).