How miroslth/flat_cms works
Tipo y propósito del proyecto (según file tree + README)
Proyecto: Flat CMS (sin base de datos) para gestionar noticias y secciones con imágenes.
Arquitectura: Aplicación full‑stack con:
• Frontend React (client/)
• Backend Node.js + Express (server/)
• Persistencia en filesystem mediante JSON (server/content/**) + uploads para imágenes (server/uploads/)
El README confirma explícitamente: “JSON en filesystem (Flat CMS)” y separación client/ (frontend) / server/ (API) / content/ (datos).
Frontend (client/)
Pistas claras de CRA/React:
• client/public/index.html y client/src/index.js → punto de entrada UI
• client/src/App.js → composición principal
• client/src/components/
• SeccionNoticias.js → UI/flujo para noticias
• SeccionesManager.js → UI/flujo para CRUD/gestión de secciones
• client/src/api/content.js → capa de acceso a API (muy importante para el diagrama; aquí se centralizan llamadas HTTP al backend)
Backend (server/)
• server/index.js → Express app (bootstrap, middlewares, mount de rutas)
• server/routes/content.js → endpoints de contenido (noticias/secciones)
• server/routes/upload.js → endpoints para subida de imágenes
• server/utils/fileSystem.js → lógica de lectura/escritura JSON en disco (la “base de datos”)
• server/content/… → “almacenamiento” en JSON (fuente de verdad)
• server/uploads/ → almacenamiento de archivos subidos (imágenes)
Datos / persistencia (filesystem)
• server/content/noticias/*.json
• server/content/secciones/*.json
Esto equivale al rol de una DB, solo que en “flat files”.
Diagrama de Contexto / Contenedores (C4 – Container level)
Qué “sistemas” existen y cómo se comunican (Browser ↔ React ↔ Express ↔ FS/JSON, etc.).
Diagrama de Componentes (C4 – Component level) dentro del Backend y del Frontend
• Frontend: Components + API client
• Backend: Express app + rutas + utils + FS paths (content/uploads)
Esto encaja perfecto con el tree: se ve claramente el “container boundary” de client/ y server/, y adentro aparecen componentes.
Usuario / Cliente
• Admin/User (Browser): interactúa con la UI (login simple por “Admin26” según README; aunque no se ve un módulo auth claro en tree, puedes anotarlo como “credenciales/validación simple” si aplica en código).
Frontend (React SPA)
• React App (client/src/App.js)
• UI Components
• SeccionesManager (gestión secciones)
• SeccionNoticias (gestión noticias)
• API Client Layer
• client/src/api/content.js (requests a Express)
• (Opcional pero útil) Hosting estático si lo despliegas (Vercel/Static hosting), ya que README menciona demo en Vercel.
Backend (Express API)
• Express Server (server/index.js)
• Routes
• routes/content.js (CRUD de noticias/secciones)
• routes/upload.js (subida/serving de imágenes)
• Utils
• utils/fileSystem.js (read/write JSON; validaciones; paths; etc.)
• Storage (Filesystem)
• server/content/secciones/*.json
• server/content/noticias/*.json
• server/uploads/* (imágenes)
Infra / runtime (importante para exactitud)
• Node.js runtime (ejecuta Express)
• NPM scripts (build/run) — no hace falta dibujar scripts, pero sí indicar que son dos procesos: React dev server y Express server en local.
• CORS / HTTP (si aplica; normalmente React llama a API en otro puerto)
Relaciones e interacciones (flechas que no pueden faltar)
Dibuja flujos separados para Noticias, Secciones e Imágenes:
fileSystem utils → Filesystem
• lee/escribe server/content/secciones/*.json y server/content/noticias/*.json
Guarda en server/uploads/
4. Devuelve URL/path de imagen a frontend (y potencialmente se referencia desde el JSON de noticia/sección)
Nota clave para el diagrama: aquí hay dos “stores” distintos:
• Content Store (JSON) = server/content/**
• Binary Store (uploads) = server/uploads/**
Patrones/decisiones arquitectónicas que debes reflejar explícitamente
• SPA + API: React desacoplado del backend vía HTTP.
• Flat-file persistence: en vez de DB, el backend implementa “DAL” en utils/fileSystem.js.
• Routing layer separada: routes/ agrupa endpoints por dominio (content vs upload).
• Dominio explícito: “noticias” y “secciones” como bounded contexts simples (dos carpetas y dos tipos de endpoints).
Etiquetas obligatorias en cajas
• “React SPA (client/)”
• “API Client (client/src/api/content.js)”
• “Express API (server/index.js)”
• “Content Routes (server/routes/content.js)”
• “Upload Routes (server/routes/upload.js)”
• “Filesystem Utils (server/utils/fileSystem.js)”
• “JSON Content Store (server/content/noticias, server/content/secciones)”
• “Uploads Store (server/uploads/)”
Flechas (direccionales) con protocolo/forma de datos
• React → Express: HTTP REST (JSON)
• React → Upload: HTTP multipart/form-data
• Express → FS: read/write JSON files, write image binaries
Qué NO omitir (errores comunes en este proyecto)
• No dibujar “DB” genérica: aquí la DB es el filesystem (content JSON).
• No mezclar “content” con “uploads”: son dos persistencias distintas con rutas distintas.
• Incluir la capa API client del frontend (client/src/api/content.js), porque explica dónde se centraliza la comunicación y facilita rastrear cambios.
• Mostrar que el backend está modularizado por routes + utils, no todo en index.js.
Puedes literalmente dibujar estas cajas:
[Browser (Admin/User)]
→ [React SPA (client/src/App.js)]
→ [UI Components: SeccionesManager, SeccionNoticias]
→ [API Client: client/src/api/content.js]
→ (HTTP JSON / multipart) [Express Server: server/index.js]
→ [Routes: content.js | upload.js]
→ [Utils: fileSystem.js]
→ **[Filesystem: server/content/{noticias,secciones}/*.json]**
→ **[Filesystem: server/uploads/*]**
Con eso capturas “lo esencial” y además separas el proyecto en el máximo de componentes útiles sin inventar partes que no existen.