From f7962f894dd5d8b6e0458ce922c5b31bbb906764 Mon Sep 17 00:00:00 2001 From: msaldain Date: Mon, 25 Aug 2025 16:05:12 +0000 Subject: [PATCH] =?UTF-8?q?Actualizaci=C3=B3n=20de=20funci=C3=B3n=20/plane?= =?UTF-8?q?s=20en=20base=20de=20datos=20+=20primera=20versi=C3=B3n=20del?= =?UTF-8?q?=20README?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 2 +- README.md | 303 +++++++++++++++++++++++++++++++++++++ services/auth/src/index.js | 13 +- 3 files changed, 310 insertions(+), 8 deletions(-) create mode 100644 README.md diff --git a/.gitignore b/.gitignore index 01cf053..ca1399e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,7 @@ # Ignorar los directorios de dependencias node_modules/ -# Ignorar los volumenes respaldados +# Ignorar los volumenes respaldados de docker compose docker-volumes* # Ignorar las carpetas de bases de datos diff --git a/README.md b/README.md new file mode 100644 index 0000000..7ea441f --- /dev/null +++ b/README.md @@ -0,0 +1,303 @@ +# SuiteCoffee — Sistema de gestión para cafeterías (Dockerizado y multi‑servicio) + +SuiteCoffee es un sistema modular pensado para la **gestión de cafeterías** (y negocios afines), con servicios Node.js para **aplicación** y **autenticación**, bases de datos **PostgreSQL** separadas para negocio y multi‑tenencia, y un **stack Docker Compose** que facilita levantar entornos de **desarrollo** y **producción**. Incluye herramientas auxiliares como **Nginx Proxy Manager (NPM)** y **CloudBeaver** para administrar bases de datos desde el navegador. + +> Repositorio: https://gitea.mateosaldain.uy/msaldain/SuiteCoffee.git + +--- + +## Tabla de contenidos + +- [Arquitectura](#arquitectura) +- [Características principales](#características-principales) +- [Requisitos](#requisitos) +- [Inicio rápido](#inicio-rápido) +- [Variables de entorno](#variables-de-entorno) +- [Endpoints](#endpoints) +- [Estructura del proyecto](#estructura-del-proyecto) +- [Herramientas auxiliares (NPM y CloudBeaver)](#herramientas-auxiliares-npm-y-cloudbeaver) +- [Backups y restauración de volúmenes](#backups-y-restauración-de-volúmenes) +- [Comandos útiles](#comandos-útiles) +- [Licencia](#licencia) +- [Sugerencias de mejora](#sugerencias-de-mejora) + +--- + +## Arquitectura + +**Servicios principales** + +- **app** (Node.js / Express): API de negocio y páginas simples para cargar y listar *roles, usuarios, categorías y productos*. +- **auth** (Node.js / Express + bcrypt): endpoints de **registro** e **inicio de sesión**. +- **db** (PostgreSQL 16): base de datos de la aplicación. +- **tenants** (PostgreSQL 16): base de datos separada para **multi-tenencia** (aislar clientes/tiendas). + +**Herramientas** + +- **Nginx Proxy Manager (NPM)**: reverse proxy y certificados (Let’s Encrypt) para exponer servicios. +- **CloudBeaver (DBeaver)**: administración de PostgreSQL vía web. + +**Redes & Volúmenes** + +- Redes independientes por entorno (`suitecoffee_dev_net` / `suitecoffee_prod_net`). +- Volúmenes gestionados por Compose para persistencia: `suitecoffee-db`, `tenants-db`, etc. + +### Diagrama (alto nivel) + +```plantuml +@startuml +skinparam componentStyle rectangle +skinparam rectangle { + BorderColor #555 + RoundCorner 10 +} +actor Usuario + +package "Entorno DEV/PROD" { + [app (Express)] as APP + [auth (Express + bcrypt)] as AUTH + database "db (PostgreSQL)" as DB + database "tenants (PostgreSQL)" as TENANTS + APP -down-> DB : Pool PG + APP -down-> TENANTS : Pool PG + AUTH -down-> DB : Pool PG (usuarios) + Usuario --> APP : UI / API + Usuario --> AUTH : Login/Registro +} + +package "Herramientas" { + [Nginx Proxy Manager] as NPM + [CloudBeaver] as DBVR + NPM ..> APP : proxy + NPM ..> AUTH : proxy + DBVR ..> DB : admin + DBVR ..> TENANTS : admin +} +@enduml +``` + +--- + +## Características principales + +- **API REST** para entidades clave (roles, usuarios, categorías y productos). +- **Autenticación básica** (registro y login) con **hash de contraseñas** (bcrypt). +- **Multi‑tenencia** con base `tenants` separada para aislar clientes/tiendas. +- **Docker Compose v2** con entornos de **desarrollo** y **producción**. +- **Herramientas integradas** (NPM + CloudBeaver) en un `compose.tools.yaml` aparte. +- **Scripts** de **backup/restauración de volúmenes** y **gestión de entornos**. + +--- + +## Requisitos + +- **Docker** y **Docker Compose v2** (recomendado). +- **Python 3.9+** (para scripts `suitecoffee.py`, backups y utilidades). +- **Node.js 20+** (sólo si vas a ejecutar servicios Node fuera de Docker). + +--- + +## Inicio rápido + +### Opción A — Gestor interactivo (recomendado) + +1. Clona el repo y entra al directorio: + ```bash + git clone https://gitea.mateosaldain.uy/msaldain/SuiteCoffee.git + cd SuiteCoffee + ``` +2. (Opcional) Crea/copía tus archivos `.env` para **app** y **auth** en `./services//.env.development` (ver sección de variables). +3. Ejecuta el gestor: + ```bash + python3 suitecoffee.py + ``` + - Verás un **menú** para levantar **DESARROLLO** o **PRODUCCIÓN**. + - Desde ahí también puedes **levantar/apagar** las herramientas **NPM** y **CloudBeaver**. +4. Accede: + - App (dev): suele estar disponible via NPM o directamente dentro de la red, según tu configuración. + - Páginas simples: `/roles`, `/usuarios`, `/categorias`, `/productos` (servidas por `app`). + - Salud: `/health` en `app` y `auth`. + +> Consejo: primero levanta **desarrollo/producción** y luego las **herramientas** para que existan las redes externas `suitecoffee_dev_net`/`suitecoffee_prod_net` que usa `compose.tools.yaml`. + +### Opción B — Comandos Docker Compose (avanzado) + +- **Desarrollo**: + ```bash + docker compose -f compose.yaml -f compose.dev.yaml --env-file ./services/app/.env.development --env-file ./services/auth/.env.development -p suitecoffee_dev up -d + ``` + +- **Producción**: + ```bash + docker compose -f compose.yaml -f compose.prod.yaml --env-file ./services/app/.env.production --env-file ./services/auth/.env.production -p suitecoffee_prod up -d + ``` + +> Los puertos se **exponen** para herramientas (NPM UI `:81`, CloudBeaver `:8978`); los servicios `app` y `auth` se **exponen dentro de la red** y se publican externamente a través de NPM. + +--- + +## Variables de entorno + +Crea un archivo `.env.development` (y uno `.env.production`) en **cada servicio** (`./services/app` y `./services/auth`). Variables comunes: + +```dotenv +# Servidor +PORT=4000 # puerto HTTP del servicio +NODE_ENV=development # development | production + +# Base de datos +DB_HOST=db # nombre del servicio postgres (o host) +DB_LOCAL_PORT=5432 # puerto de PG al que conectarse +DB_USER=postgres +DB_PASS=postgres +DB_NAME=suitecoffee_db # para 'db' (aplicación) +TENANTS_DB_NAME=tenants_db # si el servicio necesita apuntar a 'tenants' +``` + +> Ajusta `DB_HOST` a `db` o `tenants` según corresponda. En desarrollo, los alias útiles son `dev-db` y `dev-tenants`; en producción: `prod-db` y `prod-tenants`. + +--- + +## Endpoints + +### Servicio **app** (negocio) + +- `GET /health` +- `GET /api/roles` — lista roles +- `POST /api/roles` — crea un rol +- `GET /api/usuarios` — lista usuarios +- `POST /api/usuarios` — crea un usuario +- `GET /api/categorias` — lista categorías +- `POST /api/categorias` — crea una categoría +- `GET /api/productos` — lista productos +- `POST /api/productos` — crea un producto +- Páginas estáticas simples para probar: `/roles`, `/usuarios`, `/categorias`, `/productos` + +### Servicio **auth** (autenticación) + +- `GET /health` +- `POST /register` — registro de usuario (password con **bcrypt**) +- `POST /auth/login` — inicio de sesión + +> **Nota**: En esta etapa los endpoints son **básicos** y pensados para desarrollo/PoC. Ver la sección *Sugerencias de mejora* para próximos pasos (JWT, autorización, etc.). + +--- + +## Estructura del proyecto + +``` +SuiteCoffee/ +├─ services/ +│ ├─ app/ +│ │ ├─ src/ +│ │ │ ├─ index.js # API y páginas simples +│ │ │ └─ pages/ # roles.html, usuarios.html, categorias.html, productos.html +│ │ ├─ .env.development # variables (ejemplo) +│ │ └─ .env.production +│ └─ auth/ +│ ├─ src/ +│ │ └─ index.js # /register y /auth/login +│ ├─ .env.development +│ └─ .env.production +├─ compose.yaml # base (db, tenants) +├─ compose.dev.yaml # entorno desarrollo (app, auth, db, tenants) +├─ compose.prod.yaml # entorno producción (app, auth, db, tenants) +├─ compose.tools.yaml # herramientas (NPM, CloudBeaver) con redes externas +├─ suitecoffee.py # gestor interactivo (Docker Compose) +├─ backup_compose_volumes.py # backups de volúmenes Compose +└─ restore_compose_volumes.py# restauración de volúmenes Compose +``` + +--- + +## Herramientas auxiliares (NPM y CloudBeaver) + +Los servicios de **herramientas** están separados para poder usarlos con **ambos entornos** (dev y prod) a la vez. Se levantan con `compose.tools.yaml` y se conectan a las **redes externas** `suitecoffee_dev_net` y `suitecoffee_prod_net`. + +- **Nginx Proxy Manager (NPM)** + Puertos: `80` (HTTP), `81` (UI). Volúmenes: `npm_data`, `npm_letsencrypt`. +- **CloudBeaver** + Puerto: `8978`. Volúmenes: `dbeaver_logs`, `dbeaver_workspace`. + +> Si es la primera vez, arranca un entorno (dev/prod) para que Compose cree las redes; luego levanta las herramientas: +> +> ```bash +> docker compose -f compose.tools.yaml --profile npm -p suitecoffee up -d +> docker compose -f compose.tools.yaml --profile dbeaver -p suitecoffee up -d +> ``` + +--- + +## Backups y restauración de volúmenes + +Este repo incluye dos utilidades: + +- `backup_compose_volumes.py` — detecta volúmenes de un proyecto de Compose (por **labels** y nombres) y los exporta a `tar.gz` usando un contenedor `alpine` temporal. +- `restore_compose_volumes.py` — permite restaurar esos `tar.gz` en volúmenes (útil para migraciones y pruebas). + +**Ejemplos básicos** + +```bash +# Listar ayuda +python3 backup_compose_volumes.py --help + +# Respaldar volúmenes asociados a "suitecoffee_dev" en ./backups +python3 backup_compose_volumes.py --project suitecoffee_dev --output ./backups + +# Restaurar un archivo a un volumen +python3 restore_compose_volumes.py --archive ./backups/suitecoffee_dev_suitecoffee-db-YYYYmmddHHMMSS.tar.gz --volume suitecoffee_dev_suitecoffee-db +``` + +> Consejo: si migraste manualmente y ves advertencias tipo “volume ... already exists but was not created by Docker Compose”, considera marcar el volumen como `external: true` en el YAML o recrearlo para que Compose lo etiquete correctamente. + +--- + +## Comandos útiles + +```bash +# Ver estado (menú interactivo) +python3 suitecoffee.py + +# Levantar DEV/PROD por menú (con o sin --force-recreate) +python3 suitecoffee.py + +# Levantar herramientas (también desde menú) +docker compose -f compose.tools.yaml --profile npm -p suitecoffee up -d +docker compose -f compose.tools.yaml --profile dbeaver -p suitecoffee up -d + +# Inspeccionar servicios/volúmenes que Compose detecta desde los YAML +docker compose -f compose.yaml -f compose.dev.yaml config --services +docker compose -f compose.yaml -f compose.dev.yaml config --format json | jq .volumes +``` + +--- + +## Licencia + +- **ISC** (ver `package.json`). + +--- + +## Sugerencias de mejora + +- **Autenticación y seguridad** + - Emitir **JWT** en el login y proteger rutas (roles/autorización por perfil). + - Configurar **CORS** por orígenes (en dev está abierto; en prod restringir). + - Añadir **rate‑limit** y **helmet** en Express. +- **Esquema de datos y migraciones** + - Añadir migraciones automatizadas (p.ej. **Prisma**, **Knex**, **Sequelize** o SQL versionado) y seeds iniciales. + - Clarificar el **modelo multi‑tenant**: por **BD por tenant** o **schema por tenant**; documentar estrategia. +- **Calidad & DX** + - Tests (unitarios e integración) y **CI** básico. + - Validación de entrada (**zod / joi**), manejo de errores consistente y logs estructurados. +- **Docker/DevOps** + - Documentar variables `.env` completas por servicio. + - Publicar imágenes de producción y usar `IMAGE:TAG` en `compose.prod.yaml` (evitar build en servidor). + - Añadir **healthchecks** a `app`/`auth` (ya hay ejemplos comentados). +- **Frontend** + - Reemplazar páginas HTML de prueba por un **frontend** (React/Vite) o una UI admin mínima. +- **Pequeños fixes** + - En los HTML de ejemplo corregir las referencias a campos `id_rol`, `id_categoria`, etc. + - Centralizar constantes (nombres de tablas/campos) y normalizar respuestas API. + +--- \ No newline at end of file diff --git a/services/auth/src/index.js b/services/auth/src/index.js index 0d3ece8..a5479f6 100644 --- a/services/auth/src/index.js +++ b/services/auth/src/index.js @@ -72,19 +72,18 @@ app.get('/',(req, res) => res.sendFile(path.join(__dirname, 'pages', 'index.html app.get('/planes', async (req, res) => { try { - const result = await pool.query(` - SELECT id, nombre, descripcion, precio - FROM plan - WHERE activo = true - ORDER BY id - `); - res.json(result.rows); + const { rows: [row] } = await pool.query( + 'SELECT api.get_planes_json($1) AS data;', + [true] + ); + res.type('application/json').send(row.data); } catch (err) { console.error(err); res.status(500).json({ error: 'Error al cargar planes' }); } }); + app.post('/api/registro', async (req, res) => { const { nombre_empresa,