.

Nuevo microservicio Plugins + cambios a microservicios anteriores, creación de módulos para conexiones a bases de datos y ajustes en las variables de entorno.

.env.development

@@ -0,0 +1,58 @@
+# Archivo de variables de entorno para docker-compose.yml
+COMPOSE_PROJECT_NAME=suitecoffee_dev
+
+# =======================================================
+# Runtime
+NODE_ENV=development
+
+MANSO_PORT=1010     # MVP Manso Microservicio -> services/manso/src/index.mjs
+APP_PORT=3030       # Microservicio APP-> services/app/src/index.mjs
+AUTH_PORT=4040      # Microservicio AUTH -> services/auth/src/index.mjs
+PLUGINS_PORT=5050    # Microservicio PLUGINS-> services/plugins/src/index.mjs
+# =======================================================
+
+
+
+# =======================================================
+# Configuración de Dases de Datos
+CORE_DB_HOST=dev-db
+CORE_DB_NAME=dev_suitecoffee_core
+CORE_DB_PORT=5432
+CORE_DB_USER=dev-user-suitecoffee
+CORE_DB_PASS=dev-pass-suitecoffee
+
+TENANTS_DB_HOST=dev-tenants
+TENANTS_DB_NAME=dev_suitecoffee_tenants
+TENANTS_DB_PORT=5432
+TENANTS_DB_USER=suitecoffee
+TENANTS_DB_PASS=suitecoffee
+
+AK_HOST_DB=ak-db
+AK_PG_DB=authentik
+AK_PG_USER=authentik
+AK_PG_PASS=gOWjL8V564vyh1aXUcqh4o/xo7eObraaCVZezPi3iw2LzPlU
+# =======================================================
+
+
+
+# =======================================================
+# Authentik
+    # Authentik Cookies
+AUTHENTIK_COOKIE__DOMAIN=dev.sso.suitecoffee.uy
+AUTHENTIK_SECURITY__CSRF_TRUSTED_ORIGINS=https://dev.sso.suitecoffee.uy,https://dev.suitecoffee.uy
+
+    # Authentik Security
+AUTHENTIK_SECRET_KEY=11zMsUL57beO+okjeGh7OB3lQdGUWII+VaATHs/zsw1+6KMSTyGfAY0yHpq3C442+3CwrZ/KtjgHBfbv
+
+    # Authentik Bootstrap
+AUTHENTIK_BOOTSTRAP_PASSWORD=info.suitecoffee@gmail.com
+AUTHENTIK_BOOTSTRAP_EMAIL=info.suitecoffee@gmail.com
+
+AUTHENTIK_EMAIL__HOST=smtp.gmail.com
+AUTHENTIK_EMAIL__PORT=25
+AUTHENTIK_EMAIL__USERNAME=info.suitecoffee@gmail.com
+AUTHENTIK_EMAIL__PASSWORD=Succulent-Sanded7
+AUTHENTIK_EMAIL__USE_TLS=true # Or false if not using TLS
+AUTHENTIK_EMAIL__USE_SSL=false # Or true if using SSL directly
+AUTHENTIK_EMAIL__FROM=info.suitecoffee@gmail.com
+# =======================================================

.gitignore

@@ -33,6 +33,6 @@ tests/
 .gitmodules
 
 # Ignorar archivos personales o privados (si existen)
-.env.*
+# .env.*
 *.pem
 *.key

authentik-media/suitecoffee-logo/SuiteCoffee_BN_1.svg

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Capa_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 1024 1024">
+  <!-- Generator: Adobe Illustrator 29.6.1, SVG Export Plug-In . SVG Version: 2.1.1 Build 9)  -->
+  <defs>
+    <style>
+      .st0 {
+        fill: #fff;
+      }
+    </style>
+  </defs>
+  <path class="st0" d="M1024,0v1024H0V0h1024ZM555.65,53.34c-9.62.5-42.47,33.75-50.29,42.27-52.83,57.58-92.54,133.71-99.27,212.63-9.61,112.64,65.25,175.4,107.41,269.2,52.92,117.75,31.19,241.15-37.67,346.37-5.24,8.01-19.02,22.41-21.61,30.02-2.38,7.01,4.2,10.95,10.05,6.97,98.88-80.26,173.94-198.57,145.59-331.12-19.98-93.4-85.71-170.1-121.65-256.47-40.46-97.24-10.37-194.22,47.61-276.58,5.77-8.2,22.16-24.87,25.06-32.31.97-2.5,1.81-4.69.97-7.43-.72-2.16-3.99-3.67-6.19-3.56Z"/>
+  <path d="M555.65,53.34c2.2-.12,5.46,1.4,6.19,3.56.85,2.74,0,4.92-.97,7.43-2.89,7.44-19.28,24.11-25.06,32.31-57.98,82.36-88.07,179.34-47.61,276.58,35.94,86.37,101.67,163.07,121.65,256.47,28.35,132.55-46.71,250.87-145.59,331.12-5.85,3.99-12.43.04-10.05-6.97,2.59-7.61,16.36-22.01,21.61-30.02,68.86-105.22,90.59-228.62,37.67-346.37-42.16-93.81-117.02-156.57-107.41-269.2,6.74-78.93,46.45-155.06,99.27-212.63,7.81-8.51,40.66-41.77,50.29-42.27Z"/>
+</svg>

authentik-media/suitecoffee-logo/favicon_io/site.webmanifest

@@ -0,0 +1 @@
+{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

backup.sql

@@ -0,0 +1,2 @@
+
+

compose.dev.yaml

@@ -1,58 +1,81 @@
-# docker-compose.overrride.yml
+# compose.dev.yaml
-# Docker Comose para entorno de desarrollo o development.
+# Docker Compose para entorno de desarrollo.
-
 
 services:
 
   app:
-    image: node:20-bookworm
+    image: node:20.19.5-bookworm
-    expose: 
-      - ${APP_LOCAL_PORT}
     working_dir: /app
     user: "${UID:-1000}:${GID:-1000}"
     volumes:
       - ./services/app:/app:rw
       - ./services/app/node_modules:/app/node_modules
+      - ./packages:/packages
     env_file:
       - ./services/app/.env.development
     environment:
-      - NODE_ENV=${NODE_ENV}
+      NODE_ENV: development          # <- fuerza el entorno para que el loader tome .env.development
+      NODE_OPTIONS: --preserve-symlinks # la resolución por symlinks (y que @suitecoffee/db encuentre pg instalado en services/app/node_modules
+    expose:
+      - ${APP_PORT}
     networks:
       net:
         aliases: [dev-app]
     command: npm run dev
 
+  plugins:
+    image: node:20.19.5-bookworm
+    working_dir: /app
+    user: "${UID:-1000}:${GID:-1000}"
+    volumes:
+      - ./services/plugins:/app:rw
+      - ./services/plugins/node_modules:/app/node_modules
+      - ./packages:/packages
+    env_file:
+      - ./services/plugins/.env.development
+    environment:
+      NODE_ENV: development          # <- fuerza el entorno para que el loader tome .env.development
+      NODE_OPTIONS: --preserve-symlinks
+    expose:
+      - ${PLUGINS_PORT}
+    networks:
+      net:
+        aliases: [dev-plugins]
+    command: npm run dev
+
   auth:
-    image: node:20-bookworm
+    image: node:20.19.5-bookworm
-    expose: 
-      - ${AUTH_LOCAL_PORT}
     working_dir: /app
     user: "${UID:-1000}:${GID:-1000}"
     volumes:
       - ./services/auth:/app:rw
       - ./services/auth/node_modules:/app/node_modules
+      - ./packages:/packages
     env_file:
       - ./services/auth/.env.development
     environment:
-      - NODE_ENV=${NODE_ENV}
+      NODE_ENV: development          # <- fuerza el entorno para que el loader tome .env.development
-    command: npm run dev 
+      NODE_OPTIONS: --preserve-symlinks
+    expose:
+      - ${AUTH_PORT}
     networks:
       net:
         aliases: [dev-auth]
+    command: npm run dev
 
-  db:
+  dbCore:
     image: postgres:16
     environment:
-      POSTGRES_DB: ${DB_NAME}
+      POSTGRES_DB: ${CORE_DB_NAME}
-      POSTGRES_USER: ${DB_USER}
+      POSTGRES_USER: ${CORE_DB_USER}
-      POSTGRES_PASSWORD: ${DB_PASS}
+      POSTGRES_PASSWORD: ${CORE_DB_PASS}
     volumes:
       - suitecoffee-db:/var/lib/postgresql/data
     networks:
       net:
         aliases: [dev-db]
 
-  tenants:
+  dbTenants:
     image: postgres:16
     environment:
       POSTGRES_DB: ${TENANTS_DB_NAME}
@@ -63,91 +86,90 @@ services:
     networks:
       net:
         aliases: [dev-tenants]
-  
+
   #################
   ### Authentik ###
   #################
-  # --- Authentik db (solo interno)
+
-  authentik-db:
+  ak-db:
-    # image: postgres:16-alpine
+    image: docker.io/library/postgres:16-alpine
+    env_file:
+    - .env.development
     environment:
-      POSTGRES_DB: authentik
+      POSTGRES_DB: ${AK_PG_DB:-authentik}
-      POSTGRES_USER: authentik
+      POSTGRES_PASSWORD: ${AK_PG_PASS:?database password required}
-      POSTGRES_PASSWORD: ${AUTHENTIK_DB_PASS}
+      POSTGRES_USER: ${AK_PG_USER:-authentik}
-    # healthcheck:
-    #   test: ["CMD-SHELL", "pg_isready -U authentik -d authentik"]
-    #   interval: 10s
-    #   timeout: 3s
-    #   retries: 10
     volumes:
       - authentik-db:/var/lib/postgresql/data
     networks:
       net:
-        aliases: [ak-db] 
+        aliases: [dev-ak-db]
-    # restart: unless-stopped
 
-  # --- Authentik Redis (solo interno)
+  ak-redis:
-  authentik-redis:
+    image: docker.io/library/redis:alpine
-    # image: redis:7-alpine
+    command: --save 60 1 --loglevel warning
-    command: ["redis-server", "--save", "", "--appendonly", "no"]
     networks:
-      net: 
+      net:
-        aliases: [ak-redis]
+        aliases: [dev-ak-redis]
-    # restart: unless-stopped
+    volumes:
+      - ak-redis:/data
 
-  # --- Authentik Server (sin puertos públicos)
+  ak:
-  authentik:
+    image: ghcr.io/goauthentik/server:latest
-    # image: ghcr.io/goauthentik/server:latest
+    env_file:
-    # depends_on:
+      - .env.development
-    #   authentik-db: { condition: service_healthy }
+    command: server
-    #   authentik-redis: { condition: service_started }
     environment:
-      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
+      AUTHENTIK_DEBUG: false
-      AUTHENTIK_DEBUG: "false"
+      AUTHENTIK_POSTGRESQL__HOST: ak-db
-      AUTHENTIK_POSTGRESQL__HOST: authentik-db
+      AUTHENTIK_POSTGRESQL__NAME: ${AK_PG_DB:-authentik}
-      AUTHENTIK_POSTGRESQL__USER: authentik
+      AUTHENTIK_POSTGRESQL__PASSWORD: ${AK_PG_PASS}
-      AUTHENTIK_POSTGRESQL__NAME: authentik
+      AUTHENTIK_POSTGRESQL__USER: ${AK_PG_USER:-authentik}
-      AUTHENTIK_POSTGRESQL__PASSWORD: ${AUTHENTIK_DB_PASS}
+      AUTHENTIK_REDIS__HOST: ak-redis
-      AUTHENTIK_REDIS__HOST: authentik-redis
+      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
-      # Opcional: bootstrap automático del admin
+
       AUTHENTIK_BOOTSTRAP_PASSWORD: ${AUTHENTIK_BOOTSTRAP_PASSWORD}
       AUTHENTIK_BOOTSTRAP_EMAIL: ${AUTHENTIK_BOOTSTRAP_EMAIL}
-    # expose:
+      AUTHENTIK_HTTP__TRUSTED_PROXY__CIDRS: "0.0.0.0/0,::/0"
-    #   - "9000"   # HTTP interno
+      AUTHENTIK_SECURITY__CSRF_TRUSTED_ORIGINS: ${AUTHENTIK_SECURITY__CSRF_TRUSTED_ORIGINS}
-    #   - "9443"   # HTTPS interno
+      AUTHENTIK_COOKIE__DOMAIN: ${AUTHENTIK_COOKIE__DOMAIN}
-    networks:  
+    networks:
-      net:  
+      net:
-        aliases: [authentik] 
+        aliases: [dev-authentik]
-    # restart: unless-stopped
+    volumes:
-    # Habilitá ESTO SOLO si querés abrir la UI local:
+      - ./authentik-media:/media
-    profiles: ["ak-ui"]
+      - ./authentik-custom-templates:/templates
-    ports:
-      - 9000:9000
-      - 9443:9443
 
-  # --- Authentik Worker
+  ak-worker:
-  authentik-worker:
+    image: ghcr.io/goauthentik/server:latest
-    # image: ghcr.io/goauthentik/server:latest
     command: worker
-    depends_on:
-      authentik-db: { condition: service_healthy }
-      authentik-redis: { condition: service_started }
     environment:
-      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
+      AUTHENTIK_POSTGRESQL__HOST: ak-db
-      AUTHENTIK_POSTGRESQL__HOST: authentik-db
+      AUTHENTIK_POSTGRESQL__NAME: ${AK_PG_DB:-authentik}
-      AUTHENTIK_POSTGRESQL__USER: authentik
+      AUTHENTIK_POSTGRESQL__PASSWORD: ${AK_PG_PASS}
-      AUTHENTIK_POSTGRESQL__NAME: authentik
+      AUTHENTIK_POSTGRESQL__USER: ${AK_PG_USER:-authentik}
-      AUTHENTIK_POSTGRESQL__PASSWORD: ${AUTHENTIK_DB_PASS}
+      AUTHENTIK_REDIS__HOST: ak-redis
-      AUTHENTIK_REDIS__HOST: authentik-redis
+      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
-    networks: 
+
-      net: 
+      AUTHENTIK_HTTP__TRUSTED_PROXY__CIDRS: "0.0.0.0/0,::/0"
-        aliases: [ak-work]
+      AUTHENTIK_SECURITY__CSRF_TRUSTED_ORIGINS: ${AUTHENTIK_SECURITY__CSRF_TRUSTED_ORIGINS}
+      AUTHENTIK_COOKIE__DOMAIN: ${AUTHENTIK_COOKIE__DOMAIN}
+    networks:
+      net:
+        aliases: [dev-ak-work]
+    user: root
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ./authentik-media:/media
+      - ./authentik-certs:/certs
+      - ./authentik-custom-templates:/templates
 
 volumes:
   tenants-db:
   suitecoffee-db:
   authentik-db:
+  ak-redis:
 
 networks:
   net:
-    driver: bridge
+    driver: bridge

compose.manso.yaml

@@ -1,4 +1,4 @@
-# docker-compose.overrride.yml
+# compose.manso.yml
 # Docker Comose para entorno de desarrollo o development.
 
 
@@ -6,13 +6,13 @@ services:
 
   manso:
     image: node:20-bookworm
-    depends_on:
+    # depends_on:
-      db:
+    #   db:
-        condition: service_healthy
+    #     condition: service_healthy
-      tenants:
+    #   tenants:
-        condition: service_healthy
+    #     condition: service_healthy
     expose: 
-      - ${APP_LOCAL_PORT}
+      - ${MANSO_PORT}
     working_dir: /app
     user: "${UID:-1000}:${GID:-1000}"
     volumes:
@@ -21,43 +21,43 @@ services:
     env_file:
       - ./services/manso/.env.development
     environment:
-      - NODE_ENV=${NODE_ENV}
+      NODE_ENV: development
     networks:
       net:
         aliases: [manso]
-    healthcheck:
+    #healthcheck:
-      test: ["CMD-SHELL", "curl -fsS http://localhost:${APP_DOCKER_PORT}/health || exit 1"]
+    # test: ["CMD-SHELL", "curl -fsS http://localhost:${MANSO_PORT}/health || exit 1"]
-      interval: 10s
+    # interval: 10s
-      timeout: 3s
+    # timeout: 3s
-      retries: 10
+    # retries: 10
-      start_period: 20s
+    # start_period: 20s
     command: npm run dev
     profiles: [manso]
     restart: unless-stopped
 
-  db:
+  # db:
-    image: postgres:16
+  #   image: postgres:16
-    environment:
+  #   environment:
-      POSTGRES_DB: ${DB_NAME}
+  #     POSTGRES_DB: ${DB_NAME}
-      POSTGRES_USER: ${DB_USER}
+  #     POSTGRES_USER: ${DB_USER}
-      POSTGRES_PASSWORD: ${DB_PASS}
+  #     POSTGRES_PASSWORD: ${DB_PASS}
-    volumes:
+  #   volumes:
-      - suitecoffee-db:/var/lib/postgresql/data
+  #     - suitecoffee-db:/var/lib/postgresql/data
-    networks:
+  #   networks:
-      net:
+  #     net:
-        aliases: [dev-db]
+  #       aliases: [dev-db]
 
-  tenants:
+  # tenants:
-    image: postgres:16
+  #   image: postgres:16
-    environment:
+  #   environment:
-      POSTGRES_DB: ${TENANTS_DB_NAME}
+  #     POSTGRES_DB: ${TENANTS_DB_NAME}
-      POSTGRES_USER: ${TENANTS_DB_USER}
+  #     POSTGRES_USER: ${TENANTS_DB_USER}
-      POSTGRES_PASSWORD: ${TENANTS_DB_PASS}
+  #     POSTGRES_PASSWORD: ${TENANTS_DB_PASS}
-    volumes:
+  #   volumes:
-      - tenants-db:/var/lib/postgresql/data
+  #     - tenants-db:/var/lib/postgresql/data
-    networks:
+  #   networks:
-      net:
+  #     net:
-        aliases: [dev-tenants]
+  #       aliases: [dev-tenants]
       
 volumes:
   tenants-db:

compose.prod.yaml

@@ -9,16 +9,33 @@ services:
       context: ./services/app
       dockerfile: Dockerfile.production
     expose: 
-      - ${APP_LOCAL_PORT}
+      - ${APP_PORT}
     volumes:
       - ./services/app:/app
     env_file:
       - ./services/app/.env.production
     environment:
-      - NODE_ENV=${NODE_ENV}
+      - NODE_ENV: production 
     networks:
       net:
-        aliases: [prod-app]
+        aliases: [app]
+    command: npm run start
+
+  plugins:
+    build:
+      context: ./services/plugins
+      dockerfile: Dockerfile.production
+    expose: 
+      - ${PLUGIN_PORT}
+    volumes:
+      - ./services/plugins:/app
+    env_file:
+      - ./services/plugins/.env.production
+    environment:
+      - NODE_ENV: production
+    networks:
+      net:
+        aliases: [plugins]
     command: npm run start
 
   auth:
@@ -26,46 +43,47 @@ services:
       context: ./services/auth
       dockerfile: Dockerfile.production
     expose: 
-      - ${AUTH_LOCAL_PORT}
+      - ${AUTH_PORT}
     volumes:
       - ./services/auth:/app
     env_file:
       - ./services/auth/.env.production
     environment:
-      - NODE_ENV=${NODE_ENV}
+      - NODE_ENV: production
-    command: npm run start
     networks:
       net:
-        aliases: [prod-auth]
+        aliases: [auth]
+    command: npm run start
 
-  db:
+  dbCore:
     image: postgres:16
     environment:
       POSTGRES_DB: ${DB_NAME}
       POSTGRES_USER: ${DB_USER}
       POSTGRES_PASSWORD: ${DB_PASS}
     volumes:
-      - suitecoffee-db:/var/lib/postgresql/data
+      - dbCore_data:/var/lib/postgresql/data
     networks:
       net:
-        aliases: [prod-db]
+        aliases: [dbCore]
 
-  tenants:
+  dbTenants:
     image: postgres:16
     environment:
       POSTGRES_DB: ${TENANTS_DB_NAME}
       POSTGRES_USER: ${TENANTS_DB_USER}
       POSTGRES_PASSWORD: ${TENANTS_DB_PASS}
     volumes:
-      - tenants-db:/var/lib/postgresql/data
+      - dbTenants_data:/var/lib/postgresql/data
     networks:
       net:
-        aliases: [prod-tenants]
+        aliases: [dbTenants]
+
+falta implementar authentik en compose.prod.yaml
 
 volumes:
-  tenants-db:
+  dbCore_data:
-  suitecoffee-db:
+  dbTenants_data:
-
 networks:
   net:
     driver: bridge

compose.yaml

@@ -3,15 +3,28 @@
 name: ${COMPOSE_PROJECT_NAME:-suitecoffee}
 
 services:
-
   app:
     depends_on:
-      db:
+      dbCore:
         condition: service_healthy
-      tenants:
+      dbTenants:
         condition: service_healthy
     healthcheck:
-      test: ["CMD-SHELL", "curl -fsS http://localhost:${APP_DOCKER_PORT}/health || exit 1"]
+     test: ["CMD-SHELL", "curl -fsS http://localhost:${APP_PORT}/health || exit 1"]
+     interval: 10s
+     timeout: 3s
+     retries: 10
+     start_period: 20s
+    restart: unless-stopped
+
+  plugins:
+    depends_on:
+      app:
+        condition: service_healthy
+      auth:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD-SHELL", "curl -fsS http://localhost:${PLUGINS_PORT}/health || exit 1"]
       interval: 10s
       timeout: 3s
       retries: 10
@@ -20,29 +33,31 @@ services:
 
   auth:
     depends_on:
-      db:
+      dbCore:
+        condition: service_healthy
+      ak:
         condition: service_healthy
     healthcheck:
-      test: ["CMD-SHELL", "curl -fsS http://localhost:${AUTH_DOCKER_PORT}/health || exit 1"]
+      test: ["CMD-SHELL", "curl -fsS http://localhost:${AUTH_PORT}/health || exit 1"]
       interval: 10s
       timeout: 3s
       retries: 10
-      start_period: 15s
+      start_period: 20s
     restart: unless-stopped
 
-  db:
+  dbCore:
     image: postgres:16
     environment:
       TZ: America/Montevideo
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
+      test: ["CMD-SHELL", "pg_isready -U ${CORE_DB_USER} -d ${CORE_DB_NAME}"]
       interval: 5s
       timeout: 3s
       retries: 20
       start_period: 10s
     restart: unless-stopped
 
-  tenants:
+  dbTenants:
     image: postgres:16
     environment:
       TZ: America/Montevideo
@@ -54,27 +69,41 @@ services:
       start_period: 10s
     restart: unless-stopped
 
-  authentik-db:
+  ak-db:
     image: postgres:16-alpine
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U authentik -d authentik"]
+      test: ["CMD-SHELL", "pg_isready -d ${AK_PG_DB} -U ${AK_PG_USER} || exit 1"]
-      interval: 10s
+      interval: 30s
-      timeout: 3s
+      retries: 5
-      retries: 10
+      start_period: 20s
+      timeout: 5s
     restart: unless-stopped
 
-  authentik-redis:
+  ak-redis:
     image: redis:7-alpine
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 5s
+      retries: 5
+      start_period: 10s
     restart: unless-stopped
 
-  authentik:
+  ak:
     image: ghcr.io/goauthentik/server:latest
     depends_on:
-      authentik-db: { condition: service_healthy }
+      ak-db:
-      authentik-redis: { condition: service_started }
+        condition: service_healthy
+      ak-redis:
+        condition: service_healthy
     restart: unless-stopped
 
-  authentik-worker:
+  ak-worker:
     image: ghcr.io/goauthentik/server:latest
+    depends_on:
+      ak-db:
+        condition: service_healthy
+      ak-redis:
+        condition: service_healthy
     restart: unless-stopped
-    
+    

docs/ak.md

@@ -0,0 +1,316 @@
+# Documentación detallada de funciones: `ak.js`
+
+Este documento fue generado automáticamente a partir del archivo `ak.js` proporcionado. Incluye una sección por función detectada, con firma, ubicación, descripción, parámetros, valores de retorno, posibles errores y un ejemplo de uso.
+
+> **Nota:** Las descripciones y tipos se infieren heurísticamente a partir de los nombres, comentarios y cuerpo de cada función. Revise y ajuste donde corresponda.
+
+---
+
+### `getConfig`
+
+**Firma:** `function getConfig()`  
+**Ubicación:** línea 28
+
+**Comentario previo en el código:**
+```js
+// ------------------------------------------------------------
+// Cliente para la API Admin de Authentik (v3)
+// - Sin dependencias externas (usa fetch nativo de Node >=18)
+// - ESM compatible
+// - Timeouts, reintentos opcionales y mensajes de error claros
+// - Compatible con services/auth/src/index.js actual
+// ------------------------------------------------------------
+
+// Utiliza AUTHENTIK_BASE_URL y AUTHENTIK_TOKEN para validar y devuelve la configuración (base URL y token) desde variables de entorno.
+// Devuelve la URL base y el Token que se leyó desde .env 
+
+/**
+ * @typedef {Object} AkCfg
+ * @property {string} BASE   // p.ej. "https://idp.example.com"
+ * @property {string} TOKEN  // bearer
+ */
+
+/**
+ * @typedef {Object} AkOpts
+ * @property {Record<string, string|number|boolean|Array<string|number|boolean>>} [qs]
+ * @property {any} [body]
+ * @property {number} [timeoutMs=10000]
+ * @property {number} [retries=0]
+ * @property {Record<string,string>} [headers]
+ */
+```
+**Descripción:** Obtiene Config.
+
+**Parámetros:** *(sin parámetros)*
+
+**Retorna (aprox.):** `{ BASE, TOKEN }`
+
+**Errores/excepciones:**
+- Puede lanzar `Error('[AK_CONFIG] Falta variable AUTHENTIK_BASE_URL')`.
+- Puede lanzar `Error('[AK_CONFIG] Falta variable AUTHENTIK_TOKEN')`.
+
+**Ejemplo de uso:**
+```js
+const result = getConfig();
+console.log(result);
+```
+
+---
+### `akListGroups`
+
+**Firma:** `export async function akListGroups(search = "")`  
+**Ubicación:** línea 60
+
+**Comentario previo en el código:**
+```js
+// Listar grupos con búsqueda por nombre/slug
+```
+**Descripción:** Función `akListGroups`. Interactúa con una API HTTP.
+
+**Parámetros:**
+- `search` (opcional, por defecto = `""`): descripción.
+
+**Retorna (aprox.):** `[]`
+
+**Ejemplo de uso:**
+```js
+const result = await akListGroups(search);
+console.log(result);
+```
+
+---
+### `akPatchUserAttributes`
+
+**Firma:** `export async function akPatchUserAttributes(userPk, partialAttrs = {})`  
+**Ubicación:** línea 73
+
+**Descripción:** Función `akPatchUserAttributes`.
+
+**Parámetros:**
+- `userPk`: descripción.
+- `partialAttrs` (opcional, por defecto = `{}`): descripción.
+
+**Retorna:** Puede no retornar valor explícito (`void`) o retorna según la rama de ejecución.
+
+**Ejemplo de uso:**
+```js
+const result = await akPatchUserAttributes(userPk, partialAttrs);
+console.log(result);
+```
+
+---
+### `akEnsureGroupForTenant`
+
+**Firma:** `export async function akEnsureGroupForTenant(tenantHex)`  
+**Ubicación:** línea 97
+
+**Descripción:** Función `akEnsureGroupForTenant`. Interactúa con una API HTTP. Maneja errores con bloques try/catch.
+
+**Parámetros:**
+- `tenantHex`: descripción.
+
+**Retorna (aprox.):** `found.pk ?? found.id`
+
+**Errores/excepciones:**
+- Puede lanzar `TypeError("akEnsureGroupForTenant: `tenantHex` is required")`.
+
+**Ejemplo de uso:**
+```js
+const result = await akEnsureGroupForTenant(tenantHex);
+console.log(result);
+```
+
+---
+### `akAddUserToGroup`
+
+**Firma:** `export async function akAddUserToGroup(userPk, groupPk)`  
+**Ubicación:** línea 130
+
+**Descripción:** Función `akAddUserToGroup`. Interactúa con una API HTTP. Maneja errores con bloques try/catch.
+
+**Parámetros:**
+- `userPk`: descripción.
+- `groupPk`: descripción.
+
+**Retorna (aprox.):** `await akPOST("/core/group_memberships/", { body: { user, group } })`
+
+**Errores/excepciones:**
+- Puede lanzar `TypeError("akAddUserToGroup: `userPk` is required")`.
+- Puede lanzar `TypeError("akAddUserToGroup: `groupPk` is required")`.
+
+**Ejemplo de uso:**
+```js
+const result = await akAddUserToGroup(userPk, groupPk);
+console.log(result);
+```
+
+---
+### `request`
+
+**Firma:** `export async function request(method, path, opts = {}, cfg)`  
+**Ubicación:** línea 167
+
+**Comentario previo en el código:**
+```js
+/**
+ * Llamada HTTP genérica con fetch + timeout + manejo de errores.
+ * @param {'GET'|'POST'|'PUT'|'PATCH'|'DELETE'} method
+ * @param {string} path   Ruta relativa (ej. "/core/users/") o absoluta; si es relativa se antepone "/api/v3".
+ * @param {AkOpts} [opts]
+ * @param {AkCfg}  [cfg]  Config inyectada; si se omite se usa getConfig()
+ * @returns {Promise<any|null>}
+ */
+```
+**Descripción:** Función `request`.
+
+**Parámetros:**
+- `method`: descripción.
+- `path`: descripción.
+- `opts` (opcional, por defecto = `{}`): descripción.
+- `cfg`: descripción.
+
+**Retorna:** Puede no retornar valor explícito (`void`) o retorna según la rama de ejecución.
+
+**Ejemplo de uso:**
+```js
+const result = await request(method, path, opts, cfg);
+console.log(result);
+```
+
+---
+### `akFindUserByEmail`
+
+**Firma:** `export async function akFindUserByEmail(email)`  
+**Ubicación:** línea 262
+
+**Comentario previo en el código:**
+```js
+// ------------------------------------------------------------
+// Funciones públicas
+// ------------------------------------------------------------
+```
+**Descripción:** Función `akFindUserByEmail`. Interactúa con una API HTTP.
+
+**Parámetros:**
+- `email`: descripción.
+
+**Retorna (aprox.):** `null`
+
+**Errores/excepciones:**
+- Puede lanzar `TypeError("akFindUserByEmail: `email` is required")`.
+
+**Ejemplo de uso:**
+```js
+const result = await akFindUserByEmail(email);
+console.log(result);
+```
+
+---
+### `akCreateUser`
+
+**Firma:** `export async function akCreateUser(p = {})`  
+**Ubicación:** línea 298
+
+**Descripción:** Función `akCreateUser`.
+
+**Parámetros:**
+- `p` (opcional, por defecto = `{}`): descripción.
+
+**Retorna:** Puede no retornar valor explícito (`void`) o retorna según la rama de ejecución.
+
+**Ejemplo de uso:**
+```js
+const result = await akCreateUser(p);
+console.log(result);
+```
+
+---
+### `akSetPassword`
+
+**Firma:** `export async function akSetPassword(userPk, password, requireChange = true)`  
+**Ubicación:** línea 349
+
+**Descripción:** Función `akSetPassword`. Interactúa con una API HTTP. Maneja errores con bloques try/catch.
+
+**Parámetros:**
+- `userPk`: descripción.
+- `password`: descripción.
+- `requireChange` (opcional, por defecto = `true`): descripción.
+
+**Retorna (aprox.):** `true`
+
+**Errores/excepciones:**
+- Puede lanzar `TypeError("akSetPassword: `userPk` is required")`.
+- Puede lanzar `TypeError("akSetPassword: `password` is required")`.
+
+**Ejemplo de uso:**
+```js
+const result = await akSetPassword(userPk, password, requireChange);
+console.log(result);
+```
+
+---
+### `akResolveGroupIdByName`
+
+**Firma:** `export async function akResolveGroupIdByName(name)`  
+**Ubicación:** línea 373
+
+**Descripción:** Función `akResolveGroupIdByName`.
+
+**Parámetros:**
+- `name`: descripción.
+
+**Retorna (aprox.):** `byName?.pk ?? byName?.id ?? null`
+
+**Errores/excepciones:**
+- Puede lanzar `TypeError("akResolveGroupIdByName: `name` is required")`.
+
+**Ejemplo de uso:**
+```js
+const result = await akResolveGroupIdByName(name);
+console.log(result);
+```
+
+---
+### `akResolveGroupId`
+
+**Firma:** `export async function akResolveGroupId({ id, pk, uuid, name, slug } = {})`  
+**Ubicación:** línea 389
+
+**Descripción:** Función `akResolveGroupId`.
+
+**Parámetros:**
+- `{ id`: descripción.
+- `pk`: descripción.
+- `uuid`: descripción.
+- `name`: descripción.
+- `slug }` (opcional, por defecto = `{}`): descripción.
+
+**Retorna:** Puede no retornar valor explícito (`void`) o retorna según la rama de ejecución.
+
+**Ejemplo de uso:**
+```js
+const result = await akResolveGroupId({ id, pk, uuid, name, slug });
+console.log(result);
+```
+
+---
+### `toPk`
+
+**Firma:** `const => toPk(v)`  
+**Ubicación:** línea 390
+
+**Descripción:** Función `toPk`.
+
+**Parámetros:**
+- `v`: descripción.
+
+**Retorna (aprox.):** `Number.isFinite(n) ? n : String(v)`
+
+**Ejemplo de uso:**
+```js
+const result = toPk(v);
+console.log(result);
+```
+
+---

package.json

@@ -2,6 +2,8 @@
   "name": "suitecoffee",
   "version": "1.0.0",
   "description": "Software para gestión de cafeterías",
+  "private": true,
+  "workspaces": [],
   "keywords": [
     "coffee",
     "suite",

packages/api/api.mjs

@@ -0,0 +1,5 @@
+// @suitecoffee/api/api.mjs
+// packages/api/api.mjs
+// Punto de entrada general del paquete de api.
+
+export { default as apiv1 } from './v1/apiv1.mjs';

packages/api/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@suitecoffee/api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./api.mjs",
+  "exports": {
+    ".": {
+      "import": "./api.mjs",
+      "default": "./api.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    ".api.mjs"
+  ]
+}

packages/api/v1/apiv1.mjs

@@ -0,0 +1,21 @@
+// packages/api/v1/apiv1.mjs
+import { Router } from 'express';
+
+// Sub-routers (cada uno define sus propios paths absolutos)
+import comandasApiRouter from './routes/comandas.mjs';
+// import productosApiRouter from './routes/productos.mjs'; // cuando exista
+// import clientesApiRouter from './routes/clientes.mjs';  // etc.
+
+const apiv1 = Router();
+
+// Monta routers (no pongas prefijo aquí porque ya lo tienen adentro)
+apiv1.use(comandasApiRouter);
+// apiv1.use(productosApiRouter);
+// apiv1.use(clientesApiRouter);
+
+
+export default apiv1;
+
+// (Opcional) re-export para tests puntuales
+// export { comandasApiRouter };
+// export { productosApiRouter };

packages/api/v1/repositories/comandasRepo.mjs

@@ -0,0 +1,111 @@
+// packages/api/v1/repositories/comandasRepo.mjs
+
+import { withTenantClient } from './db.mjs';
+import { loadColumns, loadPrimaryKey } from '../routes/utils/schemaInspector.mjs';
+
+const TABLE = 'comandas';
+const VALID_IDENT = /^[a-z_][a-z0-9_]*$/i;
+
+export async function listComandas({ schema, abierta, limit }) {
+  return withTenantClient(schema, async (db) => {
+    const max = Math.min(parseInt(limit || 200, 10), 1000);
+    const { rows } = await db.query(
+      `SELECT * FROM public.f_comandas_resumen($1, $2)`,
+      [abierta, max]
+    );
+    return rows;
+  });
+}
+
+export async function getDetalleItems({ schema, id }) {
+  return withTenantClient(schema, async (db) => {
+    const { rows } = await db.query(
+      `SELECT id_det_comanda, id_producto, producto_nombre,
+              cantidad, pre_unitario, subtotal, observaciones
+         FROM public.v_comandas_detalle_items
+        WHERE id_comanda = $1::int
+        ORDER BY id_det_comanda`,
+      [id]
+    );
+    return rows;
+  });
+}
+
+export async function abrirComanda({ schema, id }) {
+  return withTenantClient(schema, async (db) => {
+    const st = await db.query(`SELECT eliminada FROM public.${q(TABLE)} WHERE id_comanda = $1`, [id]);
+    if (!st.rowCount) return null;
+    if (st.rows[0].eliminada === true) {
+      const err = new Error('Comanda eliminada. Debe restaurarse antes de abrir.');
+      err.http = { status: 409 };
+      throw err;
+    }
+    const { rows } = await db.query(`SELECT public.f_abrir_comanda($1) AS data`, [id]);
+    return rows[0]?.data || null;
+  });
+}
+
+export async function cerrarComanda({ schema, id }) {
+  return withTenantClient(schema, async (db) => {
+    const { rows } = await db.query(`SELECT public.f_cerrar_comanda($1) AS data`, [id]);
+    return rows[0]?.data || null;
+  });
+}
+
+export async function restaurarComanda({ schema, id }) {
+  return withTenantClient(schema, async (db) => {
+    const { rows } = await db.query(`SELECT public.f_restaurar_comanda($1) AS data`, [id]);
+    return rows[0]?.data || null;
+  });
+}
+
+export async function eliminarComanda({ schema, id }) {
+  return withTenantClient(schema, async (db) => {
+    const { rows } = await db.query(`SELECT public.f_eliminar_comanda($1) AS data`, [id]);
+    return rows[0]?.data || null;
+  });
+}
+
+export async function patchComanda({ schema, id, payload }) {
+  return withTenantClient(schema, async (db) => {
+    const columns = await loadColumns(db, TABLE);
+    const updatable = new Set(
+      columns
+        .filter(c =>
+          !c.is_primary &&
+          !c.is_identity &&
+          !(String(c.column_default || '').startsWith('nextval('))
+        )
+        .map(c => c.column_name)
+    );
+
+    const sets = [];
+    const params = [];
+    let idx = 1;
+    for (const [k, v] of Object.entries(payload || {})) {
+      if (!VALID_IDENT.test(k)) continue;
+      if (!updatable.has(k)) continue;
+      sets.push(`${q(k)} = $${idx++}`);
+      params.push(v);
+    }
+    if (!sets.length) return { error: 'Nada para actualizar' };
+
+    const pks = await loadPrimaryKey(db, TABLE);
+    if (pks.length !== 1) {
+      const err = new Error('PK compuesta no soportada');
+      err.http = { status: 400 };
+      throw err;
+    }
+    params.push(id);
+
+    const { rows } = await db.query(
+      `UPDATE ${q(TABLE)} SET ${sets.join(', ')} WHERE ${q(pks[0])} = $${idx} RETURNING *`,
+      params
+    );
+    return rows[0] || null;
+  });
+}
+
+function q(ident) {
+  return `"${String(ident).replace(/"/g, '""')}"`;
+}

packages/api/v1/repositories/db.mjs

@@ -0,0 +1,29 @@
+// packages/api/v1/repositories/db.mjs
+
+import { poolTenants } from '@suitecoffee/db';
+
+const VALID_IDENT = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+export async function withTenantClient(req, fn, { trx = false } = {}) {
+  const schema = req?.tenant?.schema;
+  if (!schema || !VALID_IDENT.test(schema)) {
+    throw new Error('Schema de tenant no resuelto/ inválido');
+  }
+  const client = await poolTenants.connect();
+  try {
+    if (trx) await client.query('BEGIN');
+    await client.query(`SET LOCAL search_path = "${schema}", public`);
+    const result = await fn(client);
+    if (trx) await client.query('COMMIT');
+    return result;
+  } catch (e) {
+    if (trx) await client.query('ROLLBACK');
+    throw e;
+  } finally {
+    client.release();
+  }
+}
+
+export async function tquery(req, sql, params = [], opts = {}) {
+  return withTenantClient(req, (c) => c.query(sql, params), opts);
+}

packages/api/v1/routes/comandas.mjs

@@ -0,0 +1,50 @@
+// packages/api/v1/routes/comandas.mjs
+
+import { Router } from 'express';
+
+import { tenantContext } from '@suitecoffee/middlewares';
+import { listarComandas, detalleComanda, actualizarComanda, eliminarComanda } from './handlers/comandasHand.mjs';
+
+const comandasApiRouter = Router();
+
+comandasApiRouter.use(tenantContext);
+
+// Colección
+comandasApiRouter.route('/comandas').get(listarComandas);
+
+// Recurso
+comandasApiRouter.route('/comandas/:id').get(detalleComanda)
+  .put(actualizarComanda)
+  .delete(eliminarComanda);
+
+export default comandasApiRouter;
+
+
+// ----------------------------------------------------------
+// API Comandas
+/*
+Escalabilidad: si luego agregás PUT /comandas/:id o DELETE /comandas/:id,
+lo hacés en la misma ruta encadenando métodos:
+
+router
+  .route('/comandas/:id')
+  .get(detalleComanda)
+  .put(actualizarComanda)
+  .delete(eliminarComanda);
+
+  Middleware común: podrías usar .all(requireAuth) o .all(validarTenant) si necesitás autenticación o contexto del tenant.
+*/
+// ----------------------------------------------------------
+/*
+router.route('/comandas').get(listarComandas);  // GET /comandas
+
+// router.route('/comandas/:id').get(detalleComanda);  // GET /comandas/:id
+// router.route('/comandas/:id/abrir').post(abrirComanda);   // POST /comandas/:id/abrir
+// router.route('/comandas/:id/cerrar').post(cerrarComanda);  // POST /comandas/:id/cerrar
+
+// Recurso
+router.route('/comandas/:id')
+.get(detalleComanda)            // GET /comandas/:id
+.put(actualizarComanda)         // PUT /comandas/:id  (accion: abrir|cerrar|restaurar) o patch genérico
+.delete(eliminarComanda);       // DELETE /comandas/:id -> borrado lógico (eliminada=true)
+*/

packages/api/v1/routes/handlers/comandasHand.mjs

@@ -0,0 +1,91 @@
+// packages/api/v1/routes/handlers/comandas.js
+
+import {
+  listComandas,
+  getDetalleItems,
+  abrirComanda,
+  cerrarComanda,
+  restaurarComanda,
+  eliminarComanda as eliminarComandaRepo,
+  patchComanda
+} from '../../repositories/comandasRepo.mjs';
+
+const asBoolean = (v) => {
+  const s = (v ?? '').toString().trim().toLowerCase();
+  return s === 'true' ? true : s === 'false' ? false : null;
+};
+
+export async function listarComandas(req, res, next) {
+  try {
+    const abierta = asBoolean(req.query.abierta);
+    const limit = req.query.limit;
+    const rows = await listComandas({ schema: req.tenant.schema, abierta, limit });
+    res.json(rows);
+  } catch (e) { next(e); }
+}
+
+export async function detalleComanda(req, res, next) {
+  try {
+    const id = parseId(req.params.id);
+    const rows = await getDetalleItems({ schema: req.tenant.schema, id });
+    res.json(rows);
+  } catch (e) { next(e); }
+}
+
+export async function actualizarComanda(req, res, next) {
+  try {
+    const id = parseId(req.params.id);
+    const { accion, ...patch } = req.body || {};
+
+    if (accion === 'abrir') {
+      const data = await abrirComanda({ schema: req.tenant.schema, id });
+      return data ? res.json(data) : res.status(404).json({ error: 'Comanda no encontrada' });
+    }
+    if (accion === 'cerrar') {
+      const data = await cerrarComanda({ schema: req.tenant.schema, id });
+      return data ? res.json(data) : res.status(404).json({ error: 'Comanda no encontrada' });
+    }
+    if (accion === 'restaurar') {
+      const data = await restaurarComanda({ schema: req.tenant.schema, id });
+      return data ? res.json(data) : res.status(404).json({ error: 'Comanda no encontrada' });
+    }
+
+    const result = await patchComanda({ schema: req.tenant.schema, id, payload: patch });
+    if (!result) return res.status(404).json({ error: 'Comanda no encontrada' });
+    if (result?.error) return res.status(400).json({ error: result.error });
+    res.json(result);
+  } catch (e) {
+    if (e?.http?.status) return res.status(e.http.status).json({ error: e.message });
+    // PG codes comunes
+    if (e?.code === '23503') return res.status(409).json({ error: 'Violación de clave foránea', detail: e.detail });
+    if (e?.code === '23505') return res.status(400).json({ error: 'Violación de unicidad', detail: e.detail });
+    if (e?.code === '23514') return res.status(400).json({ error: 'Violación de CHECK', detail: e.detail });
+    if (e?.code === '23502') return res.status(400).json({ error: 'Campo NOT NULL faltante', detail: e.detail });
+    next(e);
+  }
+}
+
+export async function eliminarComanda(req, res, next) {
+  try {
+    const id = parseId(req.params.id);
+    const data = await eliminarComandaRepo({ schema: req.tenant.schema, id });
+    return data ? res.json(data) : res.status(404).json({ error: 'Comanda no encontrada' });
+  } catch (e) {
+    if (e?.http?.status) return res.status(e.http.status).json({ error: e.message });
+    if (e?.code === '23503') return res.status(409).json({ error: 'Violación de clave foránea', detail: e.detail });
+    if (e?.code === '23505') return res.status(400).json({ error: 'Violación de unicidad', detail: e.detail });
+    if (e?.code === '23514') return res.status(400).json({ error: 'Violación de CHECK', detail: e.detail });
+    if (e?.code === '23502') return res.status(400).json({ error: 'Campo NOT NULL faltante', detail: e.detail });
+    next(e);
+  }
+}
+
+function parseId(value) {
+  const id = Number(value);
+  if (!Number.isInteger(id) || id <= 0) {
+    const err = new Error('id inválido');
+    err.http = { status: 400 };
+    throw err;
+  }
+  return id;
+}

packages/api/v1/routes/routes.js

@@ -0,0 +1,449 @@
+// packages/api/v1/routes/routes.js
+
+import { Router } from 'express';
+import { withTenantClient, tquery } from '../repositories/db.mjs'
+import { listarComandas, detalleComanda, actualizarComanda, eliminarComanda } from './handlers/comandasHand.mjs';
+import { loadColumns, loadForeignKeys, loadPrimaryKey, pickLabelColumn } from './utils/schemaInspector.mjs';
+
+const router = Router();
+
+const ALLOWED_TABLES = [
+  'roles', 'usuarios', 'usua_roles',
+  'categorias', 'productos',
+  'clientes', 'mesas',
+  'comandas', 'deta_comandas',
+  'proveedores', 'compras', 'deta_comp_producto',
+  'mate_primas', 'deta_comp_materias',
+  'prov_producto', 'prov_mate_prima',
+  'receta_producto', 'asistencia_resumen_diario',
+  'asistencia_intervalo', 'asistencia_detalle',
+  'vw_compras'
+];
+
+const VALID_IDENT = /^[a-z_][a-z0-9_]*$/i;
+const q = (ident) => `"${String(ident).replace(/"/g, '""')}"`;
+
+function ensureTable(name) {
+  if (!VALID_IDENT.test(name)) throw new Error('Identificador inválido');
+  if (!ALLOWED_TABLES.includes(name)) throw new Error('Tabla no permitida');
+  return name;
+}
+
+// ==========================================================
+// Rutas de API v1
+// ==========================================================
+
+// ----------------------------------------------------------
+// API Tablas
+/*router.route('/tables').get( async (_req, res) => {
+  res.json(ALLOWED_TABLES);
+});*/
+
+// GET /api/schema/:table → columnas + foreign keys
+/*router.get('/schema/:table', async (req, res) => {
+  try {
+    const table = ensureTable(req.params.table);
+    const client = await poolTenants.getClient();
+    try {
+      const columns = await loadColumns(client, table);
+      const fks = await loadForeignKeys(client, table);
+      const enriched = columns.map(c => ({ ...c, foreign: fks[c.column_name] || null }));
+      res.json({ table, columns: enriched });
+    } finally {
+      client.release();
+    }
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});*/
+
+// GET /api/options/:table/:column → opciones FK
+/*router.get('/options/:table/:column', async (req, res) => {
+  try {
+    const table = ensureTable(req.params.table);
+    const column = req.params.column;
+    if (!VALID_IDENT.test(column)) throw new Error('Columna inválida');
+
+    const client = await poolTenants.getClient();
+    try {
+      const fks = await loadForeignKeys(client, table);
+      const fk = fks[column];
+      if (!fk) return res.json([]);
+
+      const refTable = fk.foreign_table;
+      const refId = fk.foreign_column;
+      const labelCol = await pickLabelColumn(client, refTable);
+
+      const sql = `SELECT ${q(refId)} AS id, ${q(labelCol)} AS label
+                   FROM ${q(refTable)} ORDER BY ${q(labelCol)} LIMIT 1000`;
+      const result = await client.query(sql);
+      res.json(result.rows);
+    } finally {
+      client.release();
+    }
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});*/
+
+// GET /api/table/:table → preview de datos
+/*router.get('/table/:table', async (req, res) => {
+  try {
+    const table = ensureTable(req.params.table);
+    const limit = Math.min(parseInt(req.query.limit || '100', 10), 1000);
+    await withTenantClient(req, async (client) => {
+      const pks = await loadPrimaryKey(client, table);
+      const orderBy = pks.length ? `ORDER BY ${pks.map(q).join(', ')} DESC` : '';
+      const sql = `SELECT * FROM ${q(table)} ${orderBy} LIMIT ${limit}`;
+      const { rows } = await client.query(sql);
+      res.json(rows);
+    });
+  } catch (e) {
+    res.status(400).json({ error: e.message, code: e.code, detail: e.detail });
+  }
+});*/
+
+// POST /api/table/:table → insertar fila
+/*router.post('/table/:table', async (req, res) => {
+  const table = ensureTable(req.params.table);
+  const payload = req.body || {};
+  try {
+    const client = await poolTenants.getClient();
+    try {
+      const columns = await loadColumns(client, table);
+      const insertable = columns.filter(c =>
+        !c.is_primary &&
+        !c.is_identity &&
+        !(c.column_default || '').startsWith('nextval(')
+      );
+      const allowedCols = new Set(insertable.map(c => c.column_name));
+
+      const cols = [];
+      const vals = [];
+      const params = [];
+      let idx = 1;
+      for (const [k, v] of Object.entries(payload)) {
+        if (!allowedCols.has(k)) continue;
+        if (!VALID_IDENT.test(k)) continue;
+        cols.push(q(k));
+        vals.push(`$${idx++}`);
+        params.push(v);
+      }
+
+      let rows;
+      if (!cols.length) {
+        ({ rows } = await client.query(
+          `INSERT INTO ${q(table)} DEFAULT VALUES RETURNING *`
+        ));
+      } else {
+        ({ rows } = await client.query(
+          `INSERT INTO ${q(table)} (${cols.join(', ')})
+           VALUES (${vals.join(', ')}) RETURNING *`,
+          params
+        ));
+      }
+      res.status(201).json({ inserted: rows[0] });
+    } catch (e) {
+      if (e.code === '23503') return res.status(400).json({ error: 'Violación de clave foránea', detail: e.detail });
+      if (e.code === '23505') return res.status(400).json({ error: 'Violación de unicidad', detail: e.detail });
+      if (e.code === '23514') return res.status(400).json({ error: 'Violación de CHECK', detail: e.detail });
+      if (e.code === '23502') return res.status(400).json({ error: 'Campo NOT NULL faltante', detail: e.detail });
+      throw e;
+    } finally {
+      client.release();
+    }
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// ----------------------------------------------------------
+// API Productos
+// ----------------------------------------------------------
+
+// GET producto + receta
+/*router.route('/rpc/get_producto/:id').get( async (req, res) => {
+  const client = await poolTenants.getClient()
+  const id = Number(req.params.id);
+  const { rows } = await client.query('SELECT public.get_producto($1) AS data', [id]);
+  res.json(rows[0]?.data || {});
+  client.release();
+});*/
+
+// POST guardar producto + receta
+/*router.route('/rpc/save_producto').post(async (req, res) => {
+  try {
+    // console.debug('receta payload:', req.body?.receta); // habilitalo si lo necesitás
+    const client = await poolTenants.getClient()
+    const q = 'SELECT public.save_producto($1,$2,$3,$4,$5,$6,$7::jsonb) AS id_producto';
+    const { id_producto=null, nombre, img_producto=null, precio=0, activo=true, id_categoria=null, receta=[] } = req.body || {};
+    const params = [id_producto, nombre, img_producto, precio, activo, id_categoria, JSON.stringify(receta||[])];
+    const { rows } = await client.query(q, params);
+    res.json(rows[0] || {});
+    client.release();
+  } catch(e) {
+    console.error(e);
+    res.status(500).json({ error: 'save_producto failed' });
+  }
+});*/
+
+
+
+// ----------------------------------------------------------
+// API Materias Primas
+// ----------------------------------------------------------
+
+// GET MP + proveedores
+/*router.route('/rpc/get_materia/:id').get(async (req, res) => {
+  const id = Number(req.params.id);
+  try {
+    const client = await poolTenants.getClient()
+    const { rows } = await client.query('SELECT public.get_materia_prima($1) AS data', [id]);
+    res.json(rows[0]?.data || {});
+    client.release();
+  } catch (e) {
+    console.error(e);
+    res.status(500).json({ error: 'get_materia failed' });
+  }
+});
+
+// SAVE MP + proveedores (array)
+router.route('/rpc/save_materia').post( async (req, res) => {
+  const { id_mat_prima=null, nombre, unidad, activo=true, proveedores=[] } = req.body || {};
+  try {
+    const q = 'SELECT public.save_materia_prima($1,$2,$3,$4,$5::jsonb) AS id_mat_prima';
+    const params = [id_mat_prima, nombre, unidad, activo, JSON.stringify(proveedores||[])];
+    const { rows } = await poolTenants.query(q, params);
+    res.json(rows[0] || {});
+  } catch (e) {
+    console.error(e);
+    res.status(500).json({ error: 'save_materia failed' });
+  }
+});
+
+
+
+// ----------------------------------------------------------
+// API Usuarios y Asistencias
+// ----------------------------------------------------------
+
+// POST /api/rpc/find_usuarios_por_documentos  { docs: ["12345678","09123456", ...] }
+router.route('/rpc/find_usuarios_por_documentos').post( async (req, res) => {
+  try {
+    const docs = Array.isArray(req.body?.docs) ? req.body.docs : [];
+    const sql  = 'SELECT public.find_usuarios_por_documentos($1::jsonb) AS data';
+    const { rows } = await poolTenants.query(sql, [JSON.stringify(docs)]);
+    res.json(rows[0]?.data || {});
+  } catch (e) {
+    console.error(e);
+    res.status(500).json({ error: 'find_usuarios_por_documentos failed' });
+  }
+});
+
+// POST /api/rpc/import_asistencia  { registros: [...], origen?: "AGL_001.txt" }
+router.route('/rpc/import_asistencia').post( async (req, res) => {
+  try {
+    const registros = Array.isArray(req.body?.registros) ? req.body.registros : [];
+    const origen    = req.body?.origen || null;
+    const sql = 'SELECT public.import_asistencia($1::jsonb,$2) AS data';
+    const { rows } = await poolTenants.query(sql, [JSON.stringify(registros), origen]);
+    res.json(rows[0]?.data || {});
+  } catch (e) {
+    console.error(e);
+    res.status(500).json({ error: 'import_asistencia failed' });
+  }
+});
+
+// Consultar datos de asistencia (raw + pares) para un usuario y rango
+router.route('/rpc/asistencia_get').post( async (req, res) => {
+  try {
+    const { doc, desde, hasta } = req.body || {};
+    const sql = 'SELECT public.asistencia_get($1::text,$2::date,$3::date) AS data';
+    const { rows } = await poolTenants.query(sql, [doc, desde, hasta]);
+    res.json(rows[0]?.data || {});
+  } catch (e) {
+    console.error(e); res.status(500).json({ error: 'asistencia_get failed' });
+  }
+});
+
+// Editar un registro crudo y recalcular pares
+router.route('/rpc/asistencia_update_raw').post( async (req, res) => {
+  try {
+    const { id_raw, fecha, hora, modo } = req.body || {};
+    const sql = 'SELECT public.asistencia_update_raw($1::bigint,$2::date,$3::text,$4::text) AS data';
+    const { rows } = await poolTenants.query(sql, [id_raw, fecha, hora, modo ?? null]);
+    res.json(rows[0]?.data || {});
+  } catch (e) {
+    console.error(e); res.status(500).json({ error: 'asistencia_update_raw failed' });
+  }
+});
+
+// Eliminar un registro crudo y recalcular pares
+router.route('/rpc/asistencia_delete_raw').post( async (req, res) => {
+  try {
+    const { id_raw } = req.body || {};
+    const sql = 'SELECT public.asistencia_delete_raw($1::bigint) AS data';
+    const { rows } = await poolTenants.query(sql, [id_raw]);
+    res.json(rows[0]?.data || {});
+  } catch (e) {
+    console.error(e); res.status(500).json({ error: 'asistencia_delete_raw failed' });
+  }
+});
+
+
+// ----------------------------------------------------------
+// API Reportes
+// ----------------------------------------------------------
+
+// POST /api/rpc/report_tickets { year }
+router.route('/rpc/report_tickets').post( async (req, res) => {
+  try {
+    const y = parseInt(req.body?.year ?? req.query?.year, 10);
+    const year = (Number.isFinite(y) && y >= 2000 && y <= 2100)
+      ? y
+      : (new Date()).getFullYear();
+
+    const { rows } = await poolTenants.query(
+      'SELECT public.report_tickets_year($1::int) AS j', [year]
+    );
+    res.json(rows[0].j);
+  } catch (e) {
+    console.error('report_tickets error:', e);
+    res.status(500).json({
+      error: 'report_tickets failed',
+      message: e.message, detail: e.detail, where: e.where, code: e.code
+    });
+  }
+});
+
+// POST /api/rpc/report_asistencia { desde: 'YYYY-MM-DD', hasta: 'YYYY-MM-DD' }
+router.route('/rpc/report_asistencia').post( async (req, res) => {
+  try {
+    let { desde, hasta } = req.body || {};
+    // defaults si vienen vacíos/invalidos
+    const re = /^\d{4}-\d{2}-\d{2}$/;
+    if (!re.test(desde) || !re.test(hasta)) {
+      const end   = new Date();
+      const start = new Date(end); start.setDate(end.getDate()-30);
+      desde = start.toISOString().slice(0,10);
+      hasta = end.toISOString().slice(0,10);
+    }
+
+    const { rows } = await poolTenants.query(
+      'SELECT public.report_asistencia($1::date,$2::date) AS j', [desde, hasta]
+    );
+    res.json(rows[0].j);
+  } catch (e) {
+    console.error('report_asistencia error:', e);
+    res.status(500).json({
+      error: 'report_asistencia failed',
+      message: e.message, detail: e.detail, where: e.where, code: e.code
+    });
+  }
+});
+
+// ----------------------------------------------------------
+// API Compras y Gastos
+// ----------------------------------------------------------
+
+// Guardar (insert/update)
+router.route('/rpc/save_compra').post( async (req, res) => {
+  try {
+    const { id_compra, id_proveedor, fec_compra, detalles } = req.body || {};
+    const sql  = 'SELECT * FROM public.save_compra($1::int,$2::int,$3::timestamptz,$4::jsonb)';
+    const args = [id_compra ?? null, id_proveedor, fec_compra ? new Date(fec_compra) : null, JSON.stringify(detalles)];
+    const { rows } = await poolTenants.query(sql, args);
+    res.json(rows[0]); // { id_compra, total }
+  } catch (e) {
+    console.error('save_compra error:', e);
+    res.status(500).json({ error: 'save_compra failed', message: e.message, detail: e.detail, where: e.where, code: e.code });
+  }
+});
+
+
+// Obtener para editar
+router.route('/rpc/get_compra').post( async (req, res) => {
+  try {
+    const { id_compra } = req.body || {};
+    const sql = `SELECT public.get_compra($1::int) AS data`;
+    const { rows } = await poolTenants.query(sql, [id_compra]);
+    res.json(rows[0]?.data || {});
+  } catch (e) {
+    console.error(e); res.status(500).json({ error: 'get_compra failed' });
+  }
+});
+
+// Eliminar
+router.route('/rpc/delete_compra').post( async (req, res) => {
+  try {
+    const { id_compra } = req.body || {};
+    await poolTenants.query(`SELECT public.delete_compra($1::int)`, [id_compra]);
+    res.json({ ok: true });
+  } catch (e) {
+    console.error(e); res.status(500).json({ error: 'delete_compra failed' });
+  }
+});
+
+
+// POST /api/rpc/report_gastos  { year: 2025 }
+router.route('/rpc/report_gastos').post( async (req, res) => {
+  try {
+    const year = parseInt(req.body?.year ?? new Date().getFullYear(), 10);
+    const { rows } = await poolTenants.query(
+      'SELECT public.report_gastos($1::int) AS j', [year]
+    );
+    res.json(rows[0].j);
+  } catch (e) {
+    console.error('report_gastos error:', e);
+    res.status(500).json({
+      error: 'report_gastos failed',
+      message: e.message, detail: e.detail, code: e.code
+    });
+  }
+});*/
+
+
+export default router;

packages/api/v1/routes/utils/schemaInspector.mjs

@@ -0,0 +1,76 @@
+// services/app/src/api/v1/routes/utils/schemaInspector.mjs
+// Utilidades para inspeccionar columnas, claves y relaciones en PostgreSQL.
+
+export async function loadColumns(client, table) {
+  const sql = `
+    SELECT
+      c.column_name,
+      c.data_type,
+      c.is_nullable = 'YES' AS is_nullable,
+      c.column_default,
+      (SELECT EXISTS (
+         SELECT 1 FROM pg_attribute a
+         JOIN pg_class t ON t.oid = a.attrelid
+         JOIN pg_index i ON i.indrelid = t.oid AND a.attnum = ANY(i.indkey)
+         WHERE t.relname = $1 AND i.indisprimary AND a.attname = c.column_name
+      )) AS is_primary,
+      (SELECT a.attgenerated = 's' OR a.attidentity IN ('a','d')
+       FROM pg_attribute a
+       JOIN pg_class t ON t.oid = a.attrelid
+       WHERE t.relname = $1 AND a.attname = c.column_name
+      ) AS is_identity
+    FROM information_schema.columns c
+    WHERE c.table_schema='public' AND c.table_name=$1
+    ORDER BY c.ordinal_position
+  `;
+  const { rows } = await client.query(sql, [table]);
+  return rows;
+}
+
+export async function loadForeignKeys(client, table) {
+  const sql = `
+    SELECT
+      kcu.column_name,
+      ccu.table_name AS foreign_table,
+      ccu.column_name AS foreign_column
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+    JOIN information_schema.constraint_column_usage ccu
+      ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+    WHERE tc.table_schema='public' AND tc.table_name=$1 AND tc.constraint_type='FOREIGN KEY'
+  `;
+  const { rows } = await client.query(sql, [table]);
+  const map = {};
+  for (const r of rows)
+    map[r.column_name] = { foreign_table: r.foreign_table, foreign_column: r.foreign_column };
+  return map;
+}
+
+export async function loadPrimaryKey(client, table) {
+  const sql = `
+    SELECT a.attname AS column_name
+    FROM pg_index i
+    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+    JOIN pg_class t ON t.oid = i.indrelid
+    WHERE t.relname = $1 AND i.indisprimary
+  `;
+  const { rows } = await client.query(sql, [table]);
+  return rows.map(r => r.column_name);
+}
+
+export async function pickLabelColumn(client, refTable) {
+  const preferred = ['nombre','raz_social','apodo','documento','correo','telefono'];
+  const { rows } = await client.query(
+    `SELECT column_name, data_type
+     FROM information_schema.columns
+     WHERE table_schema='public' AND table_name=$1
+     ORDER BY ordinal_position`, [refTable]
+  );
+  for (const cand of preferred)
+    if (rows.find(r => r.column_name === cand)) return cand;
+
+  const textish = rows.find(r => /text|character varying|varchar/i.test(r.data_type));
+  if (textish) return textish.column_name;
+  return rows[0]?.column_name || 'id';
+}

packages/core/db/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@suitecoffee/db",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./poolSingleton.mjs",
+  "types": "./poolSingleton.d.ts",
+  "exports": {
+    ".": {
+      "types": "./poolSingleton.d.ts",
+      "import": "./poolSingleton.mjs",
+      "default": "./poolSingleton.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "pg": "^8.16.3"
+  },
+  "files": [
+    "poolSingleton.mjs",
+    "poolSingleton.d.ts"
+  ]
+}

packages/core/db/poolSingleton.d.ts

@@ -0,0 +1,68 @@
+// packages/core/db/poolSingleton.d.ts
+// Declaraciones de tipos para @suitecoffee/db
+// Refleja el módulo ESM que expone poolCore y poolTenants (ambos Singletons)
+
+import type {
+  Pool,
+  PoolClient,
+  PoolConfig,
+  QueryResult,
+  QueryResultRow,
+  QueryConfig
+} from 'pg';
+
+export type { Pool, PoolClient, PoolConfig, QueryResult, QueryResultRow, QueryConfig };
+
+// Clases modeladas según la implementación JS (no se exportan como valores en runtime,
+// pero se exponen como tipos para el consumidor que quiera tipar sus variables).
+export declare class DatabaseCore {
+  /** Instancia singleton interna (solo informativa para tipado). */
+  static instance?: DatabaseCore;
+
+  /** Pool real de `pg`. */
+  connection: Pool;
+
+  constructor();
+
+  /** Ejecuta una consulta utilizando el pool. */
+  query<T extends QueryResultRow = any>(
+    sql: string | QueryConfig<any[]>,
+    params?: any[]
+  ): Promise<QueryResult<T>>;
+
+  /** Alias al `pool.connect()`; devuelve un `PoolClient`. */
+  connect(): Promise<PoolClient>;
+
+  /** Alias al `pool.connect()`; devuelve un `PoolClient`. */
+  getClient(): Promise<PoolClient>;
+
+  /** Cierra el pool subyacente. */
+  release(): Promise<void>;
+}
+
+export declare class DatabaseTenants {
+  static instance?: DatabaseTenants;
+  connection: Pool;
+
+  constructor();
+
+  query<T extends QueryResultRow = any>(
+    sql: string | QueryConfig<any[]>,
+    params?: any[]
+  ): Promise<QueryResult<T>>;
+
+  connect(): Promise<PoolClient>;
+  getClient(): Promise<PoolClient>;
+  release(): Promise<void>;
+}
+
+/** Singletons creados por el módulo. */
+export declare const poolCore: DatabaseCore;
+export declare const poolTenants: DatabaseTenants;
+
+/** Export por defecto del módulo: objeto con ambos pools. */
+declare const _default: {
+  poolCore: DatabaseCore;
+  poolTenants: DatabaseTenants;
+};
+export default _default;

packages/core/db/poolSingleton.mjs

@@ -0,0 +1,148 @@
+// poolSingleton.mjs
+// Conexión Singleton a base de datos (pg/Pool) para CORE y TENANTS.
+// Cambios mínimos respecto a tu versión original.
+
+import { Pool } from 'pg';
+
+// Utilidad mínima para booleans
+const isTrue = (v) => String(v).toLowerCase() === 'true';
+
+// --------------------- CORE ---------------------
+class DatabaseCore {
+  static instance = null;
+
+  constructor() {
+    if (DatabaseCore.instance) {
+      return DatabaseCore.instance; // <-- corrección: antes devolvía Database.instance
+    }
+
+    const host = process.env.CORE_DB_HOST;
+    const user = process.env.CORE_DB_USER;
+    const password = process.env.CORE_DB_PASS;
+    const database = process.env.CORE_DB_NAME;
+    const port = process.env.CORE_DB_PORT;
+    const ssl =
+      isTrue(process.env.CORE_PGSSL ?? process.env.PGSSL)
+        ? { rejectUnauthorized: false }
+        : undefined;
+
+    const config = {
+      host,
+      user,
+      password,
+      database,
+      port: port ? Number(port) : undefined,
+      ssl,
+    };
+
+    this.host = host;
+    this.dbName = database;
+    this.connection = new Pool(config);
+
+    DatabaseCore.instance = this;
+  }
+
+  async query(sql, params) {
+    return this.connection.query(sql, params);
+  }
+
+  async connect() { // idempotente a nivel de pool; retorna un client
+    return this.connection.connect();
+  }
+
+  async getClient() { // alias simple, conserva tu API
+    return this.connection.connect();
+  }
+
+  async release() { // cierra TODO el pool (uso excepcional)
+    await this.connection.end();
+  }
+}
+
+// --------------------- TENANTS ---------------------
+class DatabaseTenants {
+  static instance = null;
+
+  constructor() {
+    if (DatabaseTenants.instance) {
+      return DatabaseTenants.instance; // <-- corrección: antes devolvía Database.instance
+    }
+
+    const host = process.env.TENANTS_DB_HOST;
+    const user = process.env.TENANTS_DB_USER;
+    const password = process.env.TENANTS_DB_PASS;
+    const database = process.env.TENANTS_DB_NAME;
+    const port = process.env.TENANTS_DB_PORT;
+    const ssl =
+      isTrue(process.env.TENANTS_PGSSL ?? process.env.PGSSL)
+        ? { rejectUnauthorized: false }
+        : undefined;
+
+    const config = {
+      host,
+      user,
+      password,
+      database,
+      port: port ? Number(port) : undefined,
+      ssl,
+    };
+
+    this.host = host;
+    this.dbName = database;
+    this.connection = new Pool(config);
+
+    DatabaseTenants.instance = this;
+  }
+
+  async query(sql, params) {
+    return this.connection.query(sql, params);
+  }
+
+  async connect() { // idempotente a nivel de pool; retorna un client
+    return this.connection.connect();
+  }
+
+  async getClient() { // alias simple, conserva tu API
+    return this.connection.connect();
+  }
+
+  async release() { // cierra TODO el pool (uso excepcional)
+    await this.connection.end();
+  }
+}
+
+// Instancias únicas por el cache de módulos de Node/ESM + guardas estáticas
+const poolCore = new DatabaseCore();
+const poolTenants = new DatabaseTenants();
+
+// --------------------- Healthchecks aquí dentro ---------------------
+async function verificarConexionCore() {
+  try {
+    console.log(`[ PG ] Comprobando accesibilidad a la db ${poolCore.dbName} del host ${poolCore.host} ...`);
+    const client = await poolCore.getClient();
+    const { rows } = await client.query('SELECT NOW() AS ahora');
+    console.log(`[ PG ] Conexión con ${poolCore.dbName} OK. Hora DB:`, rows[0].ahora);
+    client.release();
+  } catch (error) {
+    console.error('[ PG ] Error al conectar con la base de datos al iniciar:', error.message);
+    console.error('[ PG ] Revisar credenciales, accesos de red y firewall.');
+  }
+}
+
+async function verificarConexionTenants() {
+  try {
+    console.log(`[ PG ] Comprobando accesibilidad a la db ${poolTenants.dbName} del host ${poolTenants.host} ...`);
+    const client = await poolTenants.getClient();
+    const { rows } = await client.query('SELECT NOW() AS ahora');
+    console.log(`[ PG ] Conexión con ${poolTenants.dbName} OK. Hora DB:`, rows[0].ahora);
+    client.release();
+  } catch (error) {
+    console.error('[ PG ] Error al conectar con la base de datos al iniciar:', error.message);
+    console.error('[ PG ] Revisar credenciales, accesos de red y firewall.');
+  }
+}
+
+// Exports (mantengo tu patrón)
+export default { poolCore, poolTenants, verificarConexionCore, verificarConexionTenants };
+export { poolCore, poolTenants, verificarConexionCore, verificarConexionTenants };
+// export { DatabaseCore, DatabaseTenants }; // si lo necesitás para tests

packages/core/middlewares/datosGlobales.mjs

@@ -0,0 +1,14 @@
+// @suitecoffee/middlewares/datosGlobales.mjs
+// packages/core/middlewares/datosGlobales.mjs
+
+import { Router } from 'express';
+export const datosGlobales = Router();
+
+datosGlobales.use((req, res, next) => {
+  res.locals.currentPath = req.path;
+  res.locals.pageTitle = 'SuiteCoffee';
+  res.locals.pageId = '';
+  next();
+});
+
+export default datosGlobales; // opcional, pero útil si alguien quiere import default

packages/core/middlewares/index.mjs

@@ -0,0 +1,7 @@
+// @suitecoffee/middlewares/src/index.mjs
+// Punto de entrada general del paquete de middlewares.
+
+export * from './requireAuth.mjs';
+export * from './datosGlobales.mjs';
+export * from './tenantContext.mjs';
+export * from './resolveTenantFromCore.mjs';

packages/core/middlewares/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@suitecoffee/middlewares",
+  "version": "1.0.0",
+  "type": "module",
+  "main": ".index.mjs",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "default": "./index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    ".index.mjs"
+  ]
+}

packages/core/middlewares/requireAuth.mjs

@@ -0,0 +1,43 @@
+// packages/core/middlewares/src/requireAuth.mjs
+// @suitecoffee/middlewares/src/requireAuth.mjs
+
+/**
+ * requireAuth
+ * Verifica que exista una sesión válida en req.session.user (con `sub`).
+ * - Si hay sesión, llama a next().
+ * - Si no hay sesión:
+ *   - Si se define `redirectTo`, redirige (302) cuando el cliente acepta HTML.
+ *   - En caso contrario, responde 401 con { error: 'unauthenticated' }.
+ *
+ * @param {Object} [options]
+ * @param {string|null} [options.redirectTo=null] Ruta a la que redirigir si no hay sesión (p.ej. '/auth/login')
+ * @param {(req: import('express').Request) => any} [options.getSessionUser] Cómo leer el usuario de la sesión
+ * @returns {import('express').RequestHandler}
+ *
+ * Uso típico:
+ *   import { requireAuth } from '@suitecoffee/middlewares';
+ *   app.get('/me', requireAuth(), (req,res)=> res.json({ user: req.session.user }));
+ *   app.get('/dashboard', requireAuth({ redirectTo: '/auth/login' }), handler);
+ */
+export function requireAuth(options = {}) {
+  const {
+    redirectTo = null,
+    getSessionUser = (req) => req?.session?.user,
+  } = options;
+
+  return function requireAuthMiddleware(req, res, next) {
+    const user = getSessionUser(req);
+
+    if (user && user.sub) {
+      return next();
+    }
+
+    // Si el cliente acepta HTML y tenemos redirectTo, redirigimos (útil para front web)
+    if (redirectTo && req.accepts('html')) {
+      return res.redirect(302, redirectTo);
+    }
+
+    // Fallback JSON
+    return res.status(401).json({ error: 'unauthenticated' });
+  };
+}

packages/core/middlewares/resolveTenantFromCore.mjs

@@ -0,0 +1,140 @@
+// packages/core/middlewares/resolveTenantFromCore.mjs
+import { poolCore, poolTenants } from '@suitecoffee/db';
+
+const UUID_RX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+/**
+ * Verifica si existe el esquema en la DB de tenants.
+ * No requiere setear search_path.
+ */
+async function schemaExists(schemaName) {
+  if (!schemaName) return false;
+  const q = `
+    SELECT 1
+    FROM information_schema.schemata
+    WHERE schema_name = $1
+    LIMIT 1
+  `;
+  const { rowCount } = await poolTenants.query(q, [schemaName]);
+  return rowCount === 1;
+}
+
+/**
+ * Devuelve { id, schema } o null.
+ * Reglas:
+ * 1) Si el usuario tiene default_tenant => usarlo (y validar estado y existencia del schema).
+ * 2) Si no, buscar membresías:
+ *    - si hay exactamente 1 => usarla (validando schema).
+ *    - si hay 0 o >1 => devolver null (forzar selección explícita).
+ *
+ * @param {import('express').Request} req
+ * @param {any} sess  (req.session)
+ * @param {Object} [opts]
+ * @param {boolean} [opts.debug=false]
+ * @param {Console} [opts.logger=console]
+ * @param {string[]} [opts.acceptStates=['ready']]  // estados de sc_tenants aceptados
+ * @returns {Promise<{id:string, schema:string} | null>}
+ */
+export async function resolveTenantFromCore(req, sess, opts = {}) {
+  const {
+    debug = false,
+    logger = console,
+    acceptStates = ['ready'],
+  } = opts;
+
+  const log = (msg, obj) => {
+    if (debug) logger.debug?.(`[resolveTenantFromCore] ${msg}`, obj ?? '');
+  };
+
+  const sub = sess?.user?.sub;
+  if (!sub) {
+    log('no-sub-in-session');
+    return null;
+  }
+
+  try {
+    // 1) sc_users: obtener user_id y default_tenant
+    const uSql = `
+      SELECT user_id, default_tenant
+      FROM sc_users
+      WHERE sub = $1
+      LIMIT 1
+    `;
+    const ures = await poolCore.query(uSql, [sub]);
+    if (ures.rowCount === 0) {
+      log('user-not-found', { sub });
+      return null;
+    }
+
+    const { user_id, default_tenant } = ures.rows[0] ?? {};
+
+    // Helper para validar fila de tenant y existencia de schema
+    const validateTenantRow = async (row) => {
+      if (!row) return null;
+      const { tenant_id, schema_name, state } = row;
+      if (!UUID_RX.test(String(tenant_id))) return null;
+      if (!schema_name) return null;
+      if (acceptStates.length && !acceptStates.includes(String(state))) return null;
+
+      // Comprobar que el schema exista realmente en la DB de tenants
+      const exists = await schemaExists(schema_name);
+      if (!exists) {
+        log('schema-missing-in-tenants-db', { schema_name });
+        return null;
+      }
+      return { id: String(tenant_id), schema: String(schema_name) };
+    };
+
+    // 2) Si hay default_tenant, cargar su schema y validar
+    if (default_tenant) {
+      const tSql = `
+        SELECT tenant_id, schema_name, state
+        FROM sc_tenants
+        WHERE tenant_id = $1
+        LIMIT 1
+      `;
+      const tres = await poolCore.query(tSql, [default_tenant]);
+      if (tres.rowCount === 1) {
+        const ok = await validateTenantRow(tres.rows[0]);
+        if (ok) {
+          sess.tenant = ok;
+          log('resolved-from-default_tenant', ok);
+          return ok;
+        }
+        // default_tenant roto → seguimos a membresías
+        log('default_tenant-invalid', { default_tenant });
+      }
+    }
+
+    // 3) Sin default_tenant válido: ver membresías (aceptando sólo tenants en estados permitidos)
+    const mSql = `
+      SELECT m.tenant_id, t.schema_name, t.state, t.created_at, m.role
+      FROM sc_memberships m
+      JOIN sc_tenants t USING (tenant_id)
+      WHERE m.user_id = $1
+        ${acceptStates.length ? `AND t.state = ANY($2)` : ''}
+      ORDER BY (m.role = 'owner') DESC, t.created_at ASC
+      LIMIT 2
+    `;
+    const mParams = acceptStates.length ? [user_id, acceptStates] : [user_id];
+    const mres = await poolCore.query(mSql, mParams);
+
+    if (mres.rowCount === 1) {
+      const ok = await validateTenantRow(mres.rows[0]);
+      if (ok) {
+        sess.tenant = ok;
+        log('resolved-from-single-membership', ok);
+        return ok;
+      }
+      log('single-membership-invalid-row', mres.rows[0]);
+      return null;
+    }
+
+    // 0 o >1 membresías → el usuario debe elegir explícitamente
+    log('ambiguous-or-no-memberships', { count: mres.rowCount });
+    return null;
+  } catch (err) {
+    logger.error?.('[resolveTenantFromCore] error', { message: err?.message });
+    return null; // preferimos no romper el request; el middleware decidirá
+  }
+}

packages/core/middlewares/tenantContext.mjs

@@ -0,0 +1,155 @@
+// packages/core/middlewares/src/tenantContext.mjs
+
+const VALID_IDENT = /^[a-zA-Z_][a-zA-Z0-9_]*$/;              // schema seguro
+const UUID_RX     = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function redact(obj) {
+  // Evita loggear datos sensibles; muestra sólo lo útil para diagnóstico
+  if (!obj || typeof obj !== 'object') return obj;
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    if (['token', 'access_token', 'id_token', 'refresh_token'].includes(k)) {
+      out[k] = '[redacted]';
+    } else if (k === 'sub' || k === 'email' || k === 'name') {
+      out[k] = obj[k];
+    } else if (k === 'tenant') {
+      const t = obj[k] || {};
+      out[k] = { id: t.id ?? null, schema: t.schema ?? null };
+    } else if (k === 'user') {
+      const u = obj[k] || {};
+      out[k] = {
+        sub: u.sub ?? null,
+        email: u.email ?? null,
+        default_tenant: u.default_tenant ?? u.defaultTenant ?? null,
+        memberships: Array.isArray(u.memberships) ? `[${u.memberships.length}]` : null,
+      };
+    } else {
+      // no inundar el log; deja constancia de que existe
+      out[k] = '[present]';
+    }
+  }
+  return out;
+}
+
+export function tenantContext(opts = {}) {
+  const {
+    requireUser = true,
+    debug = false,
+    log = console,                     // podés inyectar tu logger
+    autoDeriveFromDefault = true,
+    // callback opcional para buscar tenant (p.ej., en CORE) si no está en sesión
+    // Debe devolver { id: uuid, schema: string } o null
+    resolveTenant = null,
+    schemaPrefixes = [
+      process.env.TENANT_SCHEMA_PREFIX || 'empresa_',
+    ].filter(Boolean),
+  } = opts;
+
+  const diag = (msg, data) => {
+    if (!debug) return;
+    try { log.debug?.(`[tenantContext] ${msg}`, data !== undefined ? redact(data) : ''); }
+    catch { /* noop */ }
+  };
+  const setDiagHeader = (res, kv) => {
+    if (!debug) return;
+    const cur = res.getHeader('X-Tenant-Diag');
+    const base = typeof cur === 'string' ? String(cur) + '; ' : '';
+    res.setHeader('X-Tenant-Diag', base + kv);
+  };
+
+  return async (req, res, next) => {
+    try {
+      diag('incoming', { sid: req.sessionID, headers: { accept: req.headers.accept } });
+
+      const sess = req.session;
+      if (!sess) {
+        setDiagHeader(res, 'no-session');
+        return res.status(401).json({ error: 'unauthenticated' });
+      }
+      diag('session.present', { keys: Object.keys(sess) });
+
+      if (requireUser && !sess.user?.sub) {
+        diag('user.missing', { session: sess });
+        setDiagHeader(res, 'no-user');
+        return res.status(401).json({ error: 'unauthenticated' });
+      }
+      if (requireUser) diag('user.ok', sess.user);
+
+      // 1) Leer tenant desde sesión
+      let t = sess.tenant ?? null;
+      diag('session.tenant', t);
+
+      // 2) Derivar automáticamente si falta
+      if ((!t?.id || !t?.schema) && autoDeriveFromDefault) {
+        const fallbackId =
+          sess.user?.tenant?.id ||
+          sess.user?.default_tenant ||
+          sess.user?.defaultTenant ||
+          null;
+
+        if (fallbackId && UUID_RX.test(String(fallbackId))) {
+          const prefix = String(schemaPrefixes[0] || 'empresa_');
+          const schema = `${prefix}${String(fallbackId).replace(/-/g, '').toLowerCase()}`;
+          t = { id: String(fallbackId), schema };
+          sess.tenant = t; // persistir para siguientes requests
+          diag('derived.fromDefault', t);
+          setDiagHeader(res, 'derived-default');
+        } else {
+          diag('derived.fromDefault.skipped', { fallbackId });
+        }
+      }
+
+      // 3) Resolver con callback si aún falta
+      if ((!t?.id || !t?.schema) && typeof resolveTenant === 'function') {
+        try {
+          t = await resolveTenant(req, sess);
+          if (t) {
+            sess.tenant = t;
+            diag('derived.fromResolver', t);
+            setDiagHeader(res, 'derived-resolver');
+          } else {
+            diag('resolver.returned-null');
+          }
+        } catch (e) {
+          diag('resolver.error', { message: e?.message });
+        }
+      }
+
+      // 4) Validaciones
+      if (!t?.id || !t?.schema) {
+        diag('missing-tenant.final');
+        setDiagHeader(res, 'missing-tenant');
+        return res.status(401).json({ error: 'Sesión inválida o tenant no seleccionado' });
+      }
+      if (!UUID_RX.test(String(t.id))) {
+        diag('invalid-tenant-id', t);
+        setDiagHeader(res, 'bad-tenant-id');
+        return res.status(400).json({ error: 'TenantID inválido' });
+      }
+      if (!VALID_IDENT.test(t.schema)) {
+        diag('invalid-schema', t);
+        setDiagHeader(res, 'bad-schema');
+        return res.status(400).json({ error: 'Schema inválido' });
+      }
+      const okPrefix = schemaPrefixes.some(p =>
+        t.schema.toLowerCase().startsWith(String(p).toLowerCase()),
+      );
+      if (!okPrefix) {
+        diag('schema-prefix.rejected', { schema: t.schema, schemaPrefixes });
+        setDiagHeader(res, 'schema-prefix-rejected');
+        return res.status(400).json({ error: 'Schema no permitido' });
+      }
+
+      // 5) OK
+      req.tenant = { id: String(t.id), schema: String(t.schema) };
+      res.locals.tenant = req.tenant;
+      setDiagHeader(res, `ok schema=${req.tenant.schema}`);
+      diag('attach.req.tenant', req.tenant);
+
+      return next();
+    } catch (err) {
+      diag('exception', { message: err?.message });
+      return next(err);
+    }
+  };
+}

packages/core/redis/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@suitecoffee/redis",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./redisSingleton.mjs",
+  "types": "./redisSingleton.d.ts",
+  "exports": {
+    ".": {
+      "types": "./redisSingleton.d.ts",
+      "import": "./redisSingleton.mjs",
+      "default": "./redisSingleton.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "pg": "^8.16.3"
+  },
+  "files": [
+    "redisSingleton.mjs",
+    "redisSingleton.d.ts"
+  ]
+}

packages/core/redis/redisSingleton.mjs

@@ -0,0 +1,93 @@
+// redisSingleton.mjs
+// Conexión Singleton a Redis para Authentik (AK)
+
+import { createClient } from 'redis';
+
+class RedisAuthentik {
+  static instance = null;
+
+  constructor() {
+    if (RedisAuthentik.instance) {
+      return RedisAuthentik.instance;
+    }
+
+    const url = process.env.AK_REDIS_URL;
+    if (!url) {
+      throw new Error('Falta AK_REDIS_URL Ej: redis://:pass@host:6379/0');
+    }
+    if (!/^redis(s)?:\/\//i.test(url)) {
+      throw new Error('AK_REDIS_URL inválida: debe comenzar con "redis://" o "rediss://".');
+    }
+
+    this.url = url;
+    this.client = createClient({
+      url: this.url,
+      socket: { connectTimeout: 5000 },
+    });
+
+    this.client.on('connect',      () => console.log(`[REDIS AK] Conectando a ${this.url}`));
+    this.client.on('ready',        () => console.log('[REDIS AK] Conexión lista.'));
+    this.client.on('end',          () => console.warn('[REDIS AK] Conexión cerrada.'));
+    this.client.on('reconnecting', () => console.warn('[REDIS AK] Reintentando conexión...'));
+    this.client.on('error',        (err) => console.error('[REDIS AK] Error:', err?.message || err));
+
+    this._connectingPromise = null;
+    RedisAuthentik.instance = this;
+  }
+
+  async connect() {
+    if (this.client.isOpen) return this.client;
+    if (this._connectingPromise) return this._connectingPromise;
+
+    this._connectingPromise = this.client.connect()
+      .then(() => this.client)
+      .catch((err) => {
+        this._connectingPromise = null;
+        console.error('[REDIS AK] Falló la conexión inicial:', err?.message || err);
+        throw err;
+      });
+
+    return this._connectingPromise;
+  }
+
+  getClient() {
+    return this.client;
+  }
+
+  async release() {
+    try {
+      if (this.client?.isOpen) await this.client.quit();
+    } catch (e) {
+      console.warn('[REDIS AK] Error al cerrar:', e?.message || e);
+    } finally {
+      this._connectingPromise = null;
+    }
+  }
+}
+
+// Instancia única
+const redisAuthentik = new RedisAuthentik();
+
+// --------------------- Healthcheck ---------------------
+async function verificarConexionRedisAuthentik() {
+  try {
+    console.log(`[REDIS AK] Comprobando accesibilidad a Redis en ${redisAuthentik.url} ...`);
+    await redisAuthentik.connect();
+    const client = redisAuthentik.getClient();
+
+    const pong = await client.ping();
+    const timeArr = await client.sendCommand(['TIME']);
+    const serverDate = new Date(Number(timeArr?.[0] || 0) * 1000);
+
+    await client.set('hc:authentik', String(Date.now()), { EX: 10 });
+
+    console.log(`[REDIS AK] Conexión OK. PING=${pong}. Hora Redis:`, serverDate.toISOString());
+  } catch (error) {
+    console.error('[REDIS AK] Error al conectar:', error?.message || error);
+    console.error('[REDIS AK] Revisar AK_REDIS_URL, credenciales, red y firewall.');
+  }
+}
+
+// Export al estilo de poolSingleton.mjs
+export default { redisAuthentik, verificarConexionRedisAuthentik };
+export { redisAuthentik, verificarConexionRedisAuthentik };

packages/core/scripts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@suitecoffee/scripts",
+  "version": "1.0.0",
+  "type": "module",
+  "main": ".src/index.mjs",
+  "types": ".src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.mjs",
+      "default": "./src/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "srcindex.mjs",
+    "srcindex.d.ts"
+  ]
+}

packages/core/scripts/src/index.mjs

@@ -0,0 +1,4 @@
+// @suitecoffee/scripts/src/index.mjs
+// Punto de entrada general del paquete de utilidades.
+
+export * from './utils/env.mjs';

packages/core/scripts/src/utils/env.mjs

@@ -0,0 +1,24 @@
+// @suitecoffee/scripts/src/utils/env.mjs
+
+/**
+ * checkRequiredEnvVars
+ * Verifica que todas las variables de entorno requeridas existan en process.env.
+ * Muestra advertencias si alguna falta.
+ *
+ * @param  {...string} requiredKeys - Lista de nombres de variables esperadas
+ */
+
+
+export function checkRequiredEnvVars(...requiredKeys) {
+  const missingKeys = requiredKeys.filter((key) => !process.env[key]);
+
+  if (missingKeys.length > 0) {
+    console.warn(
+      `[ ENV ] No se encontraron las siguientes variables de entorno:\n\n` +
+      missingKeys.map((k) => `-> ${k}`).join('\n') +
+      `\n`
+    );
+  } else {
+    console.log(`[ ENV ] Todas las variables de entorno requeridas están definidas.`);
+  }
+}

packages/devices/attendance/core/BaseFileDriver.mjs

@@ -0,0 +1,99 @@
+// BaseFileDriver.mjs
+import { DeviceInterface } from './DeviceInterface.mjs';
+import { fmtHMSUTC, fmtHM } from '../utils/dates.mjs';
+import * as intervalsCross from '../strategies/intervals/cross-day.mjs';
+import * as intervalsSame from '../strategies/intervals/same-day.mjs';
+
+/**
+ * Template Method para drivers basados en archivos .txt
+ * Define el pipeline y delega el parseo de línea en this.parserStrategy.parseLine
+ */
+export class BaseFileDriver extends DeviceInterface {
+  constructor(opts = {}) {
+    super(opts);
+    if (!this.parserStrategy || typeof this.parserStrategy.parseLine !== 'function') {
+      throw new Error('BaseFileDriver requiere parserStrategy.parseLine(line)');
+    }
+  }
+
+  /**
+   * @param {string} text contenido completo del .txt en UTF-8
+   */
+  async processFile(text) {
+    if (!text || typeof text !== 'string') {
+      this.setStatus('Elegí un .txt válido');
+      return { parsedRows: [], pairs: [], payloadDB: [], missing_docs: [], error: 'Archivo vacío o inválido' };
+    }
+
+    this.setStatus('Leyendo archivo…');
+
+    // 1) Parseo línea a línea (Strategy)
+    const lines = text.split(/\n/);
+    const parsedRows = [];
+    for (let i = 0; i < lines.length; i++) {
+      const r = this.parserStrategy.parseLine(lines[i]);
+      if (r) parsedRows.push(r);
+      if ((i & 511) === 0) this.emit('progress', { at: i, total: lines.length });
+    }
+
+    // 2) Resolver nombres por documento (inyectado)
+    const uniqueDocs = [...new Set(parsedRows.map(r => r.doc))];
+    this.setStatus(`Leyendo archivo… | consultando ${uniqueDocs.length} documentos…`);
+    const map = await this._safeNamesResolver(uniqueDocs);
+
+    // 3) Detectar documentos faltantes
+    const missing_docs = uniqueDocs.filter(d => {
+      const hit = map?.[d];
+      if (!hit) return true;
+      if (typeof hit.found === 'boolean') return !hit.found;
+      return !(hit?.nombre || '').trim() && !(hit?.apellido || '').trim();
+    });
+
+    if (missing_docs.length) {
+      this.setStatus('Hay documentos sin usuario. Corrigí y volvé a procesar.');
+      return { parsedRows, pairs: [], payloadDB: [], missing_docs,
+               error: `No se encontraron ${missing_docs.length} documento(s) en la base` };
+    }
+
+    // 4) Enriquecer nombre desde DB
+    parsedRows.forEach(r => {
+      const hit = map?.[r.doc];
+      if (hit && (hit.nombre || hit.apellido)) r.name = `${hit.nombre || ''} ${hit.apellido || ''}`.trim();
+    });
+
+    // 5) Construcción de intervalos (Strategy)
+    const pairs = (this.intervalBuilder === 'sameDay')
+      ? intervalsSame.buildIntervals(parsedRows)
+      : intervalsCross.buildIntervalsCrossDay(parsedRows);
+
+    // 6) Payload "raw" para DB
+    const payloadDB = parsedRows.map(r => ({
+      doc: r.doc, isoDate: r.isoDate, time: r.time, mode: r.mode || null
+    }));
+
+    this.setStatus(`${parsedRows.length} registros · ${pairs.length} intervalos`);
+    return { parsedRows, pairs, payloadDB, missing_docs: [] };
+  }
+
+  exportCSV(pairs) {
+    const list = Array.isArray(pairs) ? pairs : [];
+    if (!list.length) return '';
+    const head = ['documento','nombre','fecha','desde','hasta','duracion_hhmm','duracion_min','obs'];
+    const rows = list.map(p => {
+      const iso = p.isoDate || p.fecha || '';
+      const desdeStr = (p.desde_ms!=null) ? fmtHMSUTC(p.desde_ms) : '';
+      const hastaStr = (p.hasta_ms!=null) ? fmtHMSUTC(p.hasta_ms) : '';
+      const durStr   = (p.durMins!=null) ? fmtHM(p.durMins) : '';
+      const durMin   = (p.durMins!=null) ? Math.round(p.durMins) : '';
+      return [
+        p.doc, p.name || '', iso, desdeStr, hastaStr, durStr, durMin, p.obs || ''
+      ].map(v => `"${String(v).replaceAll('"','""')}"`).join(',');
+    });
+    return head.join(',') + '\n' + rows.join('\n');
+  }
+
+  async _safeNamesResolver(docs) {
+    try { return await this.namesResolver(docs); }
+    catch { return {}; }
+  }
+}

packages/devices/attendance/core/DeviceInterface.mjs

@@ -0,0 +1,46 @@
+// DeviceInterface.mjs
+import { EventEmitter } from 'node:events';
+
+/**
+ * Contrato común que todos los drivers deben implementar.
+ * Drivers de archivo (.txt) pueden dejar connect/fetchLogs/parseLogData como no-op.
+ */
+export class DeviceInterface extends EventEmitter {
+  /**
+   * @param {object} [opts]
+   * @param {(docs:string[])=>Promise<Record<string,{nombre?:string,apellido?:string,found?:boolean}>>} [opts.namesResolver]
+   * @param {'crossDay'|'sameDay'} [opts.intervalBuilder]
+   * @param {{ parseLine:(line:string)=>object|null }} [opts.parserStrategy]
+   */
+  constructor(opts = {}) {
+    super();
+    this.namesResolver  = typeof opts.namesResolver === 'function' ? opts.namesResolver : async () => ({});
+    this.intervalBuilder = opts.intervalBuilder || 'crossDay';
+    this.parserStrategy = opts.parserStrategy || null;
+  }
+
+  // ------- API esperada (drivers file) -------
+  /**
+   * Procesa el contenido completo de un .txt y devuelve:
+   * { parsedRows, pairs, payloadDB, missing_docs, error? }
+   */
+  async processFile(/* text:string */) {
+    throw new Error('processFile not implemented');
+  }
+
+  /**
+   * Retorna CSV como string (no descarga).
+   */
+  exportCSV(/* pairs?:object[] */) {
+    throw new Error('exportCSV not implemented');
+  }
+
+  // ------- API opcional (drivers TCP/IP) ----
+  async connect() { /* no-op */ }
+  async disconnect() { /* no-op */ }
+  async fetchLogs() { throw new Error('fetchLogs not implemented'); }
+  async parseLogData(/* raw */) { throw new Error('parseLogData not implemented'); }
+
+  // ------- Utilidad: emitir estado -------
+  setStatus(text) { this.emit('status', text || ''); }
+}

packages/devices/attendance/core/errors/DeviceErrors.mjs

@@ -0,0 +1,4 @@
+// DeviceErrors.mjs
+export class DeviceError extends Error { constructor(msg){ super(msg); this.name='DeviceError'; } }
+export class DriverNotFoundError extends DeviceError { constructor(key){ super(`Driver no registrado: ${key}`); this.name='DriverNotFoundError'; } }
+export class ParseError extends DeviceError { constructor(line){ super(`No se pudo parsear la línea: ${line}`); this.name='ParseError'; } }

packages/devices/attendance/core/factories/DeviceFactory.mjs

@@ -0,0 +1,22 @@
+// DeviceFactory.mjs
+import { DriverRegistry } from './DriverRegistry.mjs';
+
+export class DeviceFactory {
+  static register(key, ctor, manifest) {
+    DriverRegistry.register(key, ctor, manifest);
+  }
+
+  /**
+   * @param {string} key "vendor:model"
+   * @param {object} opts opciones para el constructor del driver
+   */
+  static create(key, opts = {}) {
+    const reg = DriverRegistry.get(key);
+    if (!reg) throw new Error(`DeviceFactory: driver no registrado: ${key}`);
+    return new reg.ctor(opts);
+  }
+
+  static listSupported() {
+    return DriverRegistry.list();
+  }
+}

packages/devices/attendance/core/factories/DriverRegistry.mjs

@@ -0,0 +1,20 @@
+// DriverRegistry.mjs
+const _registry = new Map();
+/**
+ * Clave: "vendor:model" en minúsculas
+ * Valor: { ctor: DriverClass, manifest?: object }
+ */
+export const DriverRegistry = {
+  register(key, ctor, manifest = null) {
+    const k = String(key || '').trim().toLowerCase();
+    if (!k) throw new Error('DriverRegistry.register: key vacío');
+    if (typeof ctor !== 'function') throw new Error('DriverRegistry.register: ctor inválido');
+    _registry.set(k, { ctor, manifest: manifest || {} });
+  },
+  get(key) {
+    return _registry.get(String(key || '').trim().toLowerCase()) || null;
+  },
+  list() {
+    return [..._registry.entries()].map(([k, v]) => ({ key: k, manifest: v.manifest || {} }));
+  }
+};

packages/devices/attendance/core/index.mjs

@@ -0,0 +1,18 @@
+// index.mjs (Facade del dominio attendance)
+export { DeviceInterface } from './DeviceInterface.mjs';
+export { BaseFileDriver } from './BaseFileDriver.mjs';
+export { DeviceFactory } from './factories/DeviceFactory.mjs';
+export { DriverRegistry } from './factories/DriverRegistry.mjs';
+
+// Facade helpers
+import { DeviceFactory } from './factories/DeviceFactory.mjs';
+
+export function registerDriver(key, Ctor, manifest) {
+  DeviceFactory.register(key, Ctor, manifest);
+}
+export function createDevice(key, opts) {
+  return DeviceFactory.create(key, opts);
+}
+export function listSupported() {
+  return DeviceFactory.listSupported();
+}

packages/devices/attendance/core/schema/manifest.schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Device Driver Manifest",
+  "type": "object",
+  "required": ["vendor", "model", "transport", "version"],
+  "properties": {
+    "vendor": { "type": "string", "minLength": 1 },
+    "model": { "type": "string", "minLength": 1 },
+    "transport": { "type": "string", "enum": ["file", "tcp", "http"] },
+    "capabilities": { "type": "array", "items": { "type": "string" } },
+    "version": { "type": "string" }
+  },
+  "additionalProperties": true
+}

packages/devices/attendance/core/strategies/intervals/cross-day.mjs

@@ -0,0 +1,29 @@
+// cross-day.mjs
+// Pares ordenados para jornadas que pueden cruzar medianoche.
+// rows: [{ doc, name, isoDate, dt_ms, ... }, ...]
+export function buildIntervalsCrossDay(rows){
+  const byDoc = new Map();
+  rows.forEach(r => {
+    (byDoc.get(r.doc) || byDoc.set(r.doc, []).get(r.doc))
+      .push({ ms: r.dt_ms, date: r.isoDate, name: r.name });
+  });
+
+  const out = [];
+  for (const [doc, arr] of byDoc.entries()){
+    arr.sort((a,b)=>a.ms-b.ms);
+    for (let i=0;i<arr.length;i+=2){
+      const a = arr[i], b = arr[i+1];
+      if (!b){
+        out.push({doc, name:a.name, fecha:a.date, desde_ms:a.ms, hasta_ms:null, durMins:null, obs:'incompleto'});
+        break;
+      }
+      const dur = Math.max(0,(b.ms-a.ms)/60000);
+      out.push({doc, name:a.name, fecha:a.date, desde_ms:a.ms, hasta_ms:b.ms, durMins:dur, obs:''});
+    }
+  }
+
+  out.sort((x,y)=> x.doc.localeCompare(y.doc) ||
+                   x.fecha.localeCompare(y.fecha) ||
+                   (x.desde_ms - y.desde_ms));
+  return out;
+}

packages/devices/attendance/core/strategies/intervals/same-day.mjs

@@ -0,0 +1,34 @@
+// same-day.mjs
+// Agrupa por (doc, fecha) y arma pares 1-2, 3-4, ...
+export function buildIntervals(rows) {
+  const nameByDoc = new Map();
+  const byKey = new Map(); // doc|isoDate -> [ms]
+
+  for (const r of rows) {
+    nameByDoc.set(r.doc, r.name);
+    const key = `${r.doc}|${r.isoDate}`;
+    (byKey.get(key) || byKey.set(key, []).get(key)).push(r.dt_ms);
+  }
+
+  const result = [];
+  for (const [key, arr] of byKey.entries()) {
+    arr.sort((a,b)=>a-b);
+    const [doc, isoDate] = key.split('|');
+    const name = nameByDoc.get(doc) || '';
+    for (let i=0; i<arr.length; i+=2) {
+      const desde = arr[i];
+      const hasta = arr[i+1] ?? null;
+      let durMins = null, obs = '';
+      if (hasta != null) durMins = Math.max(0, (hasta - desde)/60000);
+      else obs = 'incompleto';
+      result.push({ doc, name, isoDate, desde_ms: desde, hasta_ms: hasta, durMins, obs });
+    }
+  }
+
+  result.sort((a,b)=>{
+    if (a.doc !== b.doc) return a.doc.localeCompare(b.doc);
+    if (a.isoDate !== b.isoDate) return a.isoDate.localeCompare(b.isoDate);
+    return (a.desde_ms||0) - (b.desde_ms||0);
+  });
+  return result;
+}

packages/devices/attendance/core/strategies/parsers/LineParserInterface.mjs

@@ -0,0 +1,6 @@
+// LineParserInterface.mjs
+export class LineParserInterface {
+  parseLine(/* line:string */) {
+    throw new Error('parseLine not implemented');
+  }
+}

packages/devices/attendance/core/utils/dates.mjs

@@ -0,0 +1,31 @@
+// dates.mjs
+export const z2 = n => String(n).padStart(2,'0');
+
+export function toUTCms(isoDate, time) {
+  const [Y,M,D] = isoDate.split('-').map(n=>parseInt(n,10));
+  const [h,m,s] = time.split(':').map(n=>parseInt(n,10));
+  return Date.UTC(Y, (M||1)-1, D||1, h||0, m||0, s||0);
+}
+
+export function fmtHMSUTC(ms){
+  const d = new Date(ms);
+  const z = n => String(n).padStart(2,'0');
+  return `${z(d.getUTCHours())}:${z(d.getUTCMinutes())}:${z(d.getUTCSeconds())}`;
+}
+
+export const fmtHM = mins => {
+  const h = Math.floor(mins/60); const m = Math.round(mins%60);
+  return `${z2(h)}:${z2(m)}`;
+};
+
+// "YY/MM/DD" o "YYYY/MM/DD" (o '-') -> "YYYY-MM-DD"
+export function normDateStr(s) {
+  const m = String(s || '').trim().match(/^(\d{2,4})[\/\-](\d{1,2})[\/\-](\d{1,2})$/);
+  if (!m) return null;
+  let [_, y, mo, d] = m;
+  let yy = parseInt(y, 10);
+  if (y.length === 2) yy = 2000 + yy;
+  const mm = parseInt(mo, 10), dd = parseInt(d, 10);
+  if (!(mm >= 1 && mm <= 12 && dd >= 1 && dd <= 31)) return null;
+  return `${yy}-${String(mm).padStart(2,'0')}-${String(dd).padStart(2,'0')}`;
+}

packages/devices/attendance/core/utils/docs.mjs

@@ -0,0 +1,20 @@
+// docs.mjs
+import { z2 } from './dates.mjs';
+
+export const normDoc = s => {
+  const v = String(s||'').replace(/\D/g,'').replace(/^0+/,'');
+  return v || '0';
+};
+
+export const cleanDoc = s => {
+  const v = String(s||'').trim().replace(/^0+/, '');
+  return v === '' ? '0' : v;
+};
+
+// HH:MM o HH:MM:SS -> HH:MM:SS
+export const normTime = s => {
+  if (!s) return '';
+  const m = String(s).trim().match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+  if (!m) return '';
+  return `${z2(+m[1])}:${z2(+m[2])}:${z2(+m[3]||0)}`;
+};

packages/devices/attendance/drivers/generic/i60/GenericI60Driver.mjs

@@ -0,0 +1,17 @@
+// GenericI60Driver.mjs
+import { BaseFileDriver } from '../../core/BaseFileDriver.mjs';
+import * as Parser from './parser.mjs';
+
+/**
+ * Driver genérico i60 (sin conectividad). Lee archivos .txt exportados del equipo.
+ * Implementa el "Template Method" heredado de BaseFileDriver.
+ */
+export default class GenericI60Driver extends BaseFileDriver {
+  constructor(opts = {}) {
+    super({
+      ...opts,
+      parserStrategy: { parseLine: Parser.parseLine },
+      intervalBuilder: opts.intervalBuilder || 'crossDay'
+    });
+  }
+}

packages/devices/attendance/drivers/generic/i60/index.mjs

@@ -0,0 +1,13 @@
+// index.mjs
+import GenericI60Driver from './GenericI60Driver.mjs';
+
+export const manifest = {
+  vendor: 'generic',
+  model: 'i60',
+  transport: 'file',
+  capabilities: ['import', 'intervals:cross-day'],
+  version: '1.0.0'
+};
+
+export default GenericI60Driver;
+export { manifest };

packages/devices/attendance/drivers/generic/i60/parser.mjs

@@ -0,0 +1,54 @@
+// parser.mjs
+import { normDateStr, toUTCms } from '../../core/utils/dates.mjs';
+import { cleanDoc, normTime } from '../../core/utils/docs.mjs';
+
+/**
+ * Parsea una línea con prioridad por TAB; si no hay, cae a espacios;
+ * separa fecha/hora si vienen juntas.
+ * Devuelve { doc, name, isoDate, time, dt_ms, mode } o null.
+ */
+export function parseLine(line) {
+  const raw = String(line || '').replace(/\r/g, '').trim();
+  if (!raw) return null;
+
+  // omitir encabezados comunes
+  if (/^no[\t ]|^mchn[\t ]|^enno[\t ]|^name[\t ]|^datetime[\t ]/i.test(raw)) return null;
+
+  let parts = raw.split(/\t+/);
+
+  // Fallback: dos o más espacios + DateTime al final
+  if (parts.length < 7) {
+    const dtMatch = raw.match(/(\d{2,4}[\/-]\d{1,2}[\/-]\d{1,2})\s+(\d{1,2}:\d{2}:\d{2})$/);
+    if (dtMatch) {
+      const head = raw.slice(0, dtMatch.index).trim();
+      const headParts = head.split(/\t+|\s{2,}/).filter(Boolean);
+      parts = [...headParts, dtMatch[1], dtMatch[2]];
+    } else {
+      parts = raw.split(/\s{2,}/).filter(Boolean);
+    }
+  }
+  if (parts.length < 7) return null;
+
+  // Indices "normales": 0:No, 1:Mchn, 2:EnNo(doc), 3:Name, 4:Mode, 5:Fecha, 6:Hora
+  const doc  = cleanDoc(parts[2]);
+  const name = String(parts[3] || '').trim();
+  const mode = String(parts[4] || '').trim();
+
+  let dateStr = String(parts[5] || '').trim();
+  let timeStr = String(parts[6] || '').trim();
+
+  // Caso: la última columna es "YYYY/MM/DD HH:MM:SS"
+  const last = parts[parts.length - 1];
+  const dtBoth = /(\d{2,4}[\/-]\d{1,2}[\/-]\d{1,2})\s+(\d{1,2}:\d{2}:\d{2})/.exec(last);
+  if (dtBoth) { dateStr = dtBoth[1]; timeStr = dtBoth[2]; }
+  else if (!timeStr && /\d{1,2}:\d{2}:\d{2}/.test(dateStr)) {
+    const m = dateStr.match(/^(.+?)\s+(\d{1,2}:\d{2}:\d{2})$/);
+    if (m) { dateStr = m[1]; timeStr = m[2]; }
+  }
+
+  const iso = normDateStr(dateStr);
+  const timeNorm = normTime(timeStr);
+  if (!iso || !timeNorm) return null;
+
+  return { doc, name, isoDate: iso, time: timeNorm, dt_ms: toUTCms(iso, timeNorm), mode };
+}

packages/devices/attendance/drivers/generic/src/DeviceFactory.mjs

@@ -0,0 +1,11 @@
+import { GenericI60Driver } from './drivers/Generic/i60/GenericI60Driver';
+
+export class DeviceFactory {
+  static create(model, config) {
+    switch (model) {
+      case 'Generic-i60': return new GenericI60Driver(config);
+      default:
+        throw new Error(`El modelo indicado no esta soportado. ${model}\n Porfavor ponerse en contacto con el equipo para implementarlo.`);
+    }
+  }
+}

packages/devices/attendance/drivers/generic/src/DeviceInterface.mjs

@@ -0,0 +1,6 @@
+// DeviceInterface.mjs
+export class DeviceInterface {
+  async connect() { throw new Error('Not implemented'); }
+  async fetchLogs() { throw new Error('Not implemented'); }
+  async parseLogData(raw) { throw new Error('Not implemented'); }
+}

packages/devices/i60/DriverFactory.mjs

@@ -0,0 +1,13 @@
+import { GenericDriver } from './GenericDriver.mjs';
+
+export class DriverFactory {
+  static create(model = 'Generico'){
+    switch (String(model).toLowerCase()) {
+      case 'generico':
+      case 'generic':
+      default:
+        // El constructor de GenericDriver es Singleton; devolverá siempre la misma instancia
+        return new GenericDriver();
+    }
+  }
+}

packages/devices/i60/GenericDriver.mjs

@@ -0,0 +1,74 @@
+import { readFile } from 'node:fs/promises';
+import { parseLine } from './parsing.mjs';
+import { buildIntervalsCrossDay } from './intervals.mjs';
+import { exportCSV } from './csv.mjs';
+import { NamesServiceProxy } from './namesProxy.mjs';
+
+class GenericDriver {
+  constructor(){
+    if (GenericDriver._instance) return GenericDriver._instance;
+    /** @type {Array<Object>} */ this.parsedRows = [];
+    /** @type {Array<Object>} */ this.payloadDB  = [];
+    /** @type {Array<Object>} */ this.pairs      = [];
+    GenericDriver._instance = this;
+  }
+
+  // Orquesta el proceso a partir de texto plano
+  async processText(text, { fetchNamesForDocs } = {}){
+    const lines = String(text||'').split(/\n/);
+    const rows = [];
+    for (const line of lines) {
+      const r = parseLine(line);
+      if (r) rows.push(r);
+    }
+    this.parsedRows = rows;
+
+    const uniqueDocs = [...new Set(this.parsedRows.map(r => r.doc))];
+
+    const namesProxy = new NamesServiceProxy(fetchNamesForDocs);
+    const map = await namesProxy.get(uniqueDocs);
+
+    const missingDocs = uniqueDocs.filter(d => {
+      const hit = map?.[d];
+      if (!hit) return true;
+      if (typeof hit.found === 'boolean') return !hit.found;
+      return !(hit?.nombre||'').trim() && !(hit?.apellido||'').trim();
+    });
+
+    // sobreescribir nombre cuando DB provee
+    this.parsedRows.forEach(r => {
+      const hit = map?.[r.doc];
+      if (hit && (hit.nombre || hit.apellido)) {
+        r.name = `${hit.nombre || ''} ${hit.apellido || ''}`.trim();
+      }
+    });
+
+    // Pairs (permitiendo cruce de medianoche)
+    this.pairs = buildIntervalsCrossDay(this.parsedRows);
+
+    // Payload crudo para insertar
+    this.payloadDB = this.parsedRows.map(r => ({
+      doc: r.doc,
+      isoDate: r.isoDate,
+      time: r.time,
+      mode: r.mode || null
+    }));
+
+    return { parsedRows: this.parsedRows, pairs: this.pairs, payloadDB: this.payloadDB, missingDocs };
+  }
+
+  // Conveniencia: leer desde ruta en disco
+  async processFileFromPath(filePath, opts = {}){
+    const txt = await readFile(filePath, 'utf8');
+    return await this.processText(txt, opts);
+  }
+
+  // CSV server-side (devuelve string)
+  exportCSV(pairs = this.pairs){
+    return exportCSV(pairs);
+  }
+}
+
+const instance = new GenericDriver();
+export default instance;
+export { GenericDriver };

packages/devices/i60/GenericDriverFacade.mjs

@@ -0,0 +1,8 @@
+import { DriverFactory } from './DriverFactory.mjs';
+
+export class GenericDriverFacade {
+  constructor(driver = DriverFactory.create('Generico')){ this.driver = driver; }
+  async processTxt(text, services = {}){ return await this.driver.processText(text, services); }
+  async processFile(filePath, services = {}){ return await this.driver.processFileFromPath(filePath, services); }
+  exportCSV(pairs){ return this.driver.exportCSV(pairs); }
+}

packages/devices/i60/csv.mjs

@@ -0,0 +1,17 @@
+import { fmtHM, fmtHMSUTC } from './helpers.mjs';
+
+// Genera CSV (server-side: retorna string) — nombre preservado
+export function exportCSV(pairs) {
+  if (!pairs?.length) return '';
+  const head = ['documento','nombre','fecha','desde','hasta','duracion_hhmm','duracion_min','obs'];
+  const rows = pairs.map(p => {
+    const fecha = p.fecha || p.isoDate || '';
+    const desde = p.desde_ms!=null ? fmtHMSUTC(p.desde_ms) : '';
+    const hasta = p.hasta_ms!=null ? fmtHMSUTC(p.hasta_ms) : '';
+    const durHHMM = p.durMins!=null ? fmtHM(p.durMins) : '';
+    const durMin  = p.durMins!=null ? Math.round(p.durMins) : '';
+    return [p.doc, p.name || '', fecha, desde, hasta, durHHMM, durMin, p.obs || '']
+      .map(v => `"${String(v).replaceAll('"','""')}"`).join(',');
+  });
+  return head.join(',') + '\n' + rows.join('\n');
+}

packages/devices/i60/helpers.mjs

@@ -0,0 +1,40 @@
+// Helpers comunes (nombres preservados)
+export const z2 = n => String(n).padStart(2,'0');
+export const pad2 = z2;
+export const fmtHM = mins => { const h = Math.floor(mins/60); const m = Math.round(mins%60); return `${z2(h)}:${z2(m)}`; };
+export const ymd = s => String(s||'').slice(0,10);  // '2025-08-29T..' -> '2025-08-29'
+
+// Normaliza fecha "YY/MM/DD" o "YYYY/MM/DD" a "YYYY-MM-DD"
+export function normDateStr(s) {
+  const m = String(s || '').trim().match(/^(\d{2,4})[\/\-](\d{1,2})[\/\-](\d{1,2})$/);
+  if (!m) return null;
+  let [_, y, mo, d] = m;
+  let yy = parseInt(y, 10);
+  if (y.length === 2) yy = 2000 + yy; // 20YY
+  const mm = parseInt(mo, 10), dd = parseInt(d, 10);
+  if (!(mm >= 1 && mm <= 12 && dd >= 1 && dd <= 31)) return null;
+  return `${yy}-${String(mm).padStart(2,'0')}-${String(dd).padStart(2,'0')}`;
+}
+
+// Normaliza documento quitando ceros a la izquierda
+export const cleanDoc = s => {
+  const v = String(s||'').trim().replace(/^0+/, '');
+  return v === '' ? '0' : v;
+};
+
+// Compat alias (mantener nombre)
+export const normDoc = s => {
+  const v = String(s||'').replace(/\D/g,'').replace(/^0+/,'');
+  return v || '0';
+};
+
+export function toUTCms(isoDate, time) {
+  const [Y,M,D] = isoDate.split('-').map(n=>parseInt(n,10));
+  const [h,m,s] = time.split(':').map(n=>parseInt(n,10));
+  return Date.UTC(Y, (M||1)-1, D||1, h||0, m||0, s||0); // UTC fijo
+}
+export function fmtHMSUTC(ms){
+  const d = new Date(ms);
+  const z = n => String(n).padStart(2,'0');
+  return `${z(d.getUTCHours())}:${z(d.getUTCMinutes())}:${z(d.getUTCSeconds())}`;
+}

packages/devices/i60/index.mjs

@@ -0,0 +1,32 @@
+export { default as GenericDriverDefault, GenericDriver } from './GenericDriver.mjs';
+export { DriverFactory } from './DriverFactory.mjs';
+export { GenericDriverFacade } from './GenericDriverFacade.mjs';
+export { NamesServiceProxy } from './namesProxy.mjs';
+
+export * from './helpers.mjs';
+export * from './parsing.mjs';
+export * from './intervals.mjs';
+export * from './csv.mjs';
+
+
+
+/*
+Uso mínimo (en tu servidor, al recibir un .txt subido):
+
+// ejemplo en tu ruta de subida
+import { GenericDriverFacade } from './drivers/generic/i60/GenericDriverFacade.mjs';
+
+const facade = new GenericDriverFacade();
+
+const { parsedRows, pairs, payloadDB, missingDocs } =
+  await facade.processFile(tempFilePath, {
+    // opcional: integra tu búsqueda de usuarios por documento
+    fetchNamesForDocs: async (docs) => {
+      // devuelve: { "12345678": { nombre, apellido, found:true } , ... }
+      return await dbFindUsuariosPorDocumentos(docs);
+    }
+  });
+
+// luego persistes payloadDB y/o pairs según tu lógica
+
+*/

packages/devices/i60/intervals.mjs

@@ -0,0 +1,53 @@
+// Agrupa por empleado, ordena cronológicamente y arma pares 1-2, 3-4, ... permitiendo cruzar medianoche.
+export function buildIntervalsCrossDay(rows){
+  const byDoc = new Map();
+  for (const r of rows) {
+    if (!byDoc.has(r.doc)) byDoc.set(r.doc, []);
+    byDoc.get(r.doc).push({ ms: r.dt_ms, date: r.isoDate, name: r.name });
+  }
+  const out = [];
+  for (const [doc, arr] of byDoc.entries()){
+    arr.sort((a,b)=>a.ms-b.ms);
+    for (let i=0;i<arr.length;i+=2){
+      const a = arr[i], b = arr[i+1];
+      if (!b){ out.push({doc, name:a.name, fecha:a.date, desde_ms:a.ms, hasta_ms:null, durMins:null, obs:'incompleto'}); break; }
+      const dur = Math.max(0,(b.ms-a.ms)/60000);
+      out.push({doc, name:a.name, fecha:a.date, desde_ms:a.ms, hasta_ms:b.ms, durMins:dur, obs:''});
+    }
+  }
+  // ordenar por doc, fecha (inicio), desde
+  out.sort((x,y)=> x.doc.localeCompare(y.doc) || x.fecha.localeCompare(y.fecha) || (x.desde_ms - y.desde_ms));
+  return out;
+}
+
+// Alternativa por (doc, fecha) exacta (conservar nombre y firma)
+export function buildIntervals(rows) {
+  const nameByDoc = new Map();
+  const byKey = new Map(); // doc|isoDate -> [ms]
+  for (const r of rows) {
+    nameByDoc.set(r.doc, r.name);
+    const key = `${r.doc}|${r.isoDate}`;
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(r.dt_ms);
+  }
+  const result = [];
+  for (const [key, arr] of byKey.entries()) {
+    arr.sort((a,b)=>a-b);
+    const [doc, isoDate] = key.split('|');
+    const name = nameByDoc.get(doc) || '';
+    for (let i=0; i<arr.length; i+=2) {
+      const desde = arr[i];
+      const hasta = arr[i+1] ?? null;
+      let durMins = null, obs = '';
+      if (hasta != null) durMins = Math.max(0, (hasta - desde)/60000);
+      else obs = 'incompleto';
+      result.push({ doc, name, isoDate, desde_ms: desde, hasta_ms: hasta, durMins, obs });
+    }
+  }
+  result.sort((a,b)=>{
+    if (a.doc !== b.doc) return a.doc.localeCompare(b.doc);
+    if (a.isoDate !== b.isoDate) return a.isoDate.localeCompare(b.isoDate);
+    return (a.desde_ms||0) - (b.desde_ms||0);
+  });
+  return result;
+}

packages/devices/i60/namesProxy.mjs

@@ -0,0 +1,18 @@
+// Proxy de servicio de nombres (caché + normalización)
+export class NamesServiceProxy {
+  constructor(fetchNamesForDocs){
+    this._fetch = typeof fetchNamesForDocs === 'function' ? fetchNamesForDocs : async () => ({});
+    this._cache = new Map();
+  }
+  async get(docs){
+    const ask = [];
+    for (const d of docs) if (!this._cache.has(d)) ask.push(d);
+    if (ask.length){
+      const map = await this._fetch(ask);
+      for (const [k,v] of Object.entries(map || {})) this._cache.set(String(k), v || {});
+    }
+    const out = {};
+    for (const d of docs) out[d] = this._cache.get(d) || {};
+    return out;
+  }
+}

packages/devices/i60/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@suitecoffee/driver-i60",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "description": "Driver genérico para lector I60 (asistencia)",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "files": ["src"],
+  "dependencies": {
+    "@suitecoffee/db": "workspace:*",
+    "@suitecoffee/utils": "workspace:*"
+  }
+}

packages/devices/i60/parsing.mjs

@@ -0,0 +1,64 @@
+import { cleanDoc, normDateStr, toUTCms } from './helpers.mjs';
+
+// Parsea una línea (nombres preservados)
+export function parseLine(line) {
+  const raw = String(line || '').replace(/\r/g, '').trim();
+  if (!raw) return null;
+
+  // omitir encabezado
+  if (/^no[\t ]|^mchn[\t ]|^enno[\t ]|^name[\t ]|^datetime[\t ]/i.test(raw)) return null;
+
+  let parts = raw.split(/\t+/);
+
+  // Si no alcanzan 7 campos, intentar fallback con dos o más espacios
+  if (parts.length < 7) {
+    const dtMatch = raw.match(/(\d{2,4}[\/-]\d{1,2}[\/-]\d{1,2})\s+(\d{1,2}:\d{2}:\d{2})$/);
+    if (dtMatch) {
+      const head = raw.slice(0, dtMatch.index).trim();
+      const headParts = head.split(/\t+|\s{2,}/).filter(Boolean);
+      parts = [...headParts, dtMatch[1], dtMatch[2]];
+    } else {
+      parts = raw.split(/\s{2,}/).filter(Boolean);
+    }
+  }
+  if (parts.length < 7) return null;
+
+  // 0:No, 1:Mchn, 2:EnNo(doc), 3:Name, 4:Mode, 5:Fecha, 6:Hora
+  const DOC_IDX  = 2;
+  const NAME_IDX = 3;
+  const MODE_IDX = 4;
+
+  const doc  = cleanDoc(parts[DOC_IDX]);
+  const name = String(parts[NAME_IDX] || '').trim();
+  const mode = String(parts[MODE_IDX] || '').trim();
+
+  let dateStr = String(parts[5] || '').trim();
+  let timeStr = String(parts[6] || '').trim();
+
+  // Caso: 7 columnas y última es "DateTime"
+  const last = parts[parts.length - 1];
+  const dtBoth = /(\d{2,4}[\/-]\d{1,2}[\/-]\d{1,2})\s+(\d{1,2}:\d{2}:\d{2})/.exec(last);
+  if (dtBoth) {
+    dateStr = dtBoth[1];
+    timeStr = dtBoth[2];
+  } else if (!timeStr && /\d{1,2}:\d{2}:\d{2}/.test(dateStr)) {
+    const m = dateStr.match(/^(.+?)\s+(\d{1,2}:\d{2}:\d{2})$/);
+    if (m) { dateStr = m[1]; timeStr = m[2]; }
+  }
+
+  const iso = normDateStr(dateStr);               // YY/MM/DD o YYYY/MM/DD -> YYYY-MM-DD
+  if (!iso || !/^\d{1,2}:\d{2}:\d{2}$/.test(timeStr)) return null;
+
+  const [H, M, S] = timeStr.split(':').map(n => parseInt(n, 10));
+  // mantener construcción local solo por paridad con el snippet original
+  // eslint-disable-next-line no-unused-vars
+  const dt = new Date(`${iso}T${String(H).padStart(2,'0')}:${String(M).padStart(2,'0')}:${String(S).padStart(2,'0')}`);
+
+  return {
+    doc, name,
+    isoDate: iso,
+    time: timeStr,
+    dt_ms: toUTCms(iso, timeStr),   // ⬅️ clave
+    mode
+  };
+}

packages/devices/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@suitecoffee/devices",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Utilidades de acceso a Postgres para SuiteCoffee (pool por proceso + helpers multi-tenant).",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "main": "./src/index.mjs",
+  "files": ["src"],
+  "sideEffects": false,
+  "peerDependencies": {
+    "pg": "^8.12.0"
+  }
+}

packages/oidc/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@suitecoffee/oidc",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "src/index.mjs",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "dependencies": {
+    "openid-client": "^6.0.0"
+  }
+}

packages/oidc/src/index.mjs

@@ -0,0 +1,70 @@
+// @suitecoffee/oidc/src/index.mjs
+// OIDC minimal (ESM) — siempre usa discovery vía OIDC_CONFIG_URL
+
+import { Issuer } from 'openid-client';
+
+let _cached = null;
+
+/**
+ * ENV requeridas:
+ *  - OIDC_CONFIG_URL        -> https://.../.well-known/openid-configuration
+ *  - OIDC_CLIENT_ID
+ *  - OIDC_CLIENT_SECRET     -> opcional (si tu client es confidencial)
+ *  - OIDC_REDIRECT_URI
+ */
+export async function initOIDCFromEnv() {
+  if (_cached) return _cached;
+
+  const configUrl    = process.env.OIDC_CONFIG_URL;
+  const clientId     = process.env.OIDC_CLIENT_ID;
+  const clientSecret = process.env.OIDC_CLIENT_SECRET || undefined;
+  const redirectUri  = process.env.OIDC_REDIRECT_URI;
+
+  // Discovery directo (assume OK)
+  const issuer = await Issuer.discover(configUrl);
+
+  const client = new issuer.Client({
+    client_id: clientId,
+    client_secret: clientSecret,
+    redirect_uris: [redirectUri],
+    response_types: ['code'],
+    token_endpoint_auth_method: clientSecret ? 'client_secret_post' : 'none',
+  });
+
+  _cached = {
+    issuer,
+    client,
+
+    // Construye la URL de autorización (PKCE)
+    getAuthUrl({ state, nonce, code_challenge, scope = 'openid email profile' }) {
+      return client.authorizationUrl({
+        scope,
+        redirect_uri: redirectUri,
+        code_challenge,
+        code_challenge_method: 'S256',
+        state,
+        nonce,
+      });
+    },
+
+    // Intercambia el authorization code en el callback
+    async handleCallback(req, expected) {
+      const params = client.callbackParams(req);
+      return client.callback(redirectUri, params, expected);
+    },
+
+    // URL de fin de sesión (si el OP la expone)
+    endSessionUrl({ id_token_hint, post_logout_redirect_uri }) {
+      return client.endSessionUrl
+        ? client.endSessionUrl({ id_token_hint, post_logout_redirect_uri })
+        : null;
+    },
+  };
+
+  return _cached;
+}
+
+export function getOIDC() {
+  if (!_cached) throw new Error('[OIDC] initOIDCFromEnv() no fue llamado aún');
+  return _cached;
+}

services/app/.env.development

@@ -0,0 +1,54 @@
+# =======================================================
+# Runtime
+NODE_ENV=development
+PORT=3030
+APP_BASE_URL=https://dev.suitecoffee.uy
+# =======================================================
+
+
+
+# =======================================================
+# Configuración de Dases de Datos
+CORE_DB_HOST=dev-db
+CORE_DB_NAME=dev_suitecoffee_core
+CORE_DB_PORT=5432
+CORE_DB_USER=dev-user-suitecoffee
+CORE_DB_PASS=dev-pass-suitecoffee
+
+TENANTS_DB_HOST=dev-tenants
+TENANTS_DB_NAME=dev_suitecoffee_tenants
+TENANTS_DB_PORT=5432
+TENANTS_DB_USER=suitecoffee
+TENANTS_DB_PASS=suitecoffee
+# =======================================================
+
+
+
+# =======================================================
+# Sesiones 
+SESSION_SECRET=Neon*Mammal*Boaster*Ludicrous*Fender8*Crablike
+SESSION_NAME=sc.sid
+# COOKIE_DOMAIN=dev.suitecoffee.uy
+# =======================================================
+
+
+
+# =======================================================
+# Authentik y OIDC
+AK_TOKEN=h2apVHbd3ApMcnnSwfQPXbvximkvP8HnUE25ot3zXWuEEtJFaNCcOzDHB6Xw
+AK_REDIS_URL=redis://ak-redis:6379
+
+OIDC_LOGIN_URL=https://sso.suitecoffee.uy
+OIDC_REDIRECT_URI=https://suitecoffee.uy/auth/callback
+
+OIDC_CLIENT_ID=1orMM8vOvf3WkN2FejXYvUFpPtONG0Lx1eMlwIpW
+OIDC_CLIENT_SECRET=t5wx13qBcM0EFQ3cGnUIAmLzvbdsQrUVPv1OGWjszWkEp35pJQ55t7vZeeShqG49kuRAaiXv6PSGJLhRfGaponGaJl8gH1uCL7KIxdmm7UihgYoAXB2dFhZV4zRxfze2
+
+OIDC_CONFIG_URL=https://sso.suitecoffee.uy/application/o/suitecoffee/.well-known/openid-configuration
+OIDC_AUTHORIZE_URL=https://sso.suitecoffee.uy/application/o/authorize/
+OIDC_TOKEN_URL=https://sso.suitecoffee.uy/application/o/token/
+OIDC_USERINFO_URL=https://sso.suitecoffee.uy/application/o/userinfo/
+OIDC_LOGOUT_URL=https://sso.suitecoffee.uy/application/o/suitecoffee/end-session/
+OIDC_JWKS_URL=https://sso.suitecoffee.uy/application/o/suitecoffee/jwks/
+
+# =======================================================

services/app/Dockerfile.production

@@ -1,5 +1,5 @@
 # Dockerfile.dev
-FROM node:22.18
+FROM node:20.19.5-bookworm
 
 # Definir variables de entorno con valores predeterminados
 # ARG NODE_ENV=production

services/app/package-lock.json

@@ -9,14 +9,33 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
+        "@suitecoffee/api": "file:../../packages/api/",
+        "@suitecoffee/db": "file:../../packages/core/db",
+        "@suitecoffee/middlewares": "file:../../packages/core/middlewares",
+        "@suitecoffee/redis": "file:../../packages/core/redis",
+        "@suitecoffee/repositories": "file:../../packages/core/repositories",
+        "@suitecoffee/scripts": "file:../../packages/core/scripts",
+        "bcrypt": "^6.0.0",
         "chalk": "^5.6.0",
+        "connect-redis": "^9.0.0",
+        "cookie-parser": "^1.4.7",
         "cors": "^2.8.5",
         "dotenv": "^17.2.1",
         "ejs": "^3.1.10",
         "express": "^5.1.0",
         "express-ejs-layouts": "^2.5.1",
+        "express-session": "^1.18.2",
+        "ioredis": "^5.7.0",
+        "jose": "^6.1.0",
+        "jsonwebtoken": "^9.0.2",
+        "jwks-rsa": "^3.2.0",
+        "mime": "^4.1.0",
+        "morgan": "^1.10.1",
+        "node-appwrite": "^20.2.1",
+        "node-fetch": "^3.3.2",
         "pg": "^8.16.3",
         "pg-format": "^1.0.4",
+        "redis": "^5.8.2",
         "serve-favicon": "^2.5.1"
       },
       "devDependencies": {
@@ -24,11 +43,207 @@
         "nodemon": "^3.1.10"
       }
     },
+    "../../packages/api": {
+      "name": "@suitecoffee/api",
+      "version": "1.0.0"
+    },
+    "../../packages/core": {},
+    "../../packages/core/db": {
+      "name": "@suitecoffee/db",
+      "version": "1.0.0",
+      "peerDependencies": {
+        "pg": "^8.16.3"
+      }
+    },
+    "../../packages/core/middlewares": {
+      "name": "@suitecoffee/middlewares",
+      "version": "1.0.0"
+    },
+    "../../packages/core/redis": {
+      "name": "@suitecoffee/redis",
+      "version": "1.0.0",
+      "peerDependencies": {
+        "pg": "^8.16.3"
+      }
+    },
+    "../../packages/core/repositories": {
+      "name": "@suitecoffee/repositories",
+      "version": "0.0.1"
+    },
+    "../../packages/core/scripts": {
+      "name": "@suitecoffee/scripts",
+      "version": "1.0.0"
+    },
     "node_modules/@epic-web/invariant": {
       "version": "1.0.0",
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@ioredis/commands": {
+      "version": "1.3.1",
+      "license": "MIT"
+    },
+    "node_modules/@redis/bloom": {
+      "version": "5.8.2",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@redis/client": "^5.8.2"
+      }
+    },
+    "node_modules/@redis/client": {
+      "version": "5.8.2",
+      "license": "MIT",
+      "dependencies": {
+        "cluster-key-slot": "1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@redis/json": {
+      "version": "5.8.2",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@redis/client": "^5.8.2"
+      }
+    },
+    "node_modules/@redis/search": {
+      "version": "5.8.2",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@redis/client": "^5.8.2"
+      }
+    },
+    "node_modules/@redis/time-series": {
+      "version": "5.8.2",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@redis/client": "^5.8.2"
+      }
+    },
+    "node_modules/@suitecoffee/api": {
+      "resolved": "../../packages/api",
+      "link": true
+    },
+    "node_modules/@suitecoffee/db": {
+      "resolved": "../../packages/core/db",
+      "link": true
+    },
+    "node_modules/@suitecoffee/middlewares": {
+      "resolved": "../../packages/core/middlewares",
+      "link": true
+    },
+    "node_modules/@suitecoffee/redis": {
+      "resolved": "../../packages/core/redis",
+      "link": true
+    },
+    "node_modules/@suitecoffee/repositories": {
+      "resolved": "../../packages/core/repositories",
+      "link": true
+    },
+    "node_modules/@suitecoffee/scripts": {
+      "resolved": "../../packages/core/scripts",
+      "link": true
+    },
+    "node_modules/@types/body-parser": {
+      "version": "1.19.6",
+      "license": "MIT",
+      "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.38",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/express": {
+      "version": "4.17.23",
+      "license": "MIT",
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "*"
+      }
+    },
+    "node_modules/@types/express-serve-static-core": {
+      "version": "4.19.6",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.5",
+      "license": "MIT"
+    },
+    "node_modules/@types/jsonwebtoken": {
+      "version": "9.0.10",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/mime": {
+      "version": "1.3.5",
+      "license": "MIT"
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "24.3.1",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.10.0"
+      }
+    },
+    "node_modules/@types/qs": {
+      "version": "6.14.0",
+      "license": "MIT"
+    },
+    "node_modules/@types/range-parser": {
+      "version": "1.2.7",
+      "license": "MIT"
+    },
+    "node_modules/@types/send": {
+      "version": "0.17.5",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mime": "^1",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/serve-static": {
+      "version": "1.15.8",
+      "license": "MIT",
+      "dependencies": {
+        "@types/http-errors": "*",
+        "@types/node": "*",
+        "@types/send": "*"
+      }
+    },
     "node_modules/accepts": {
       "version": "2.0.0",
       "license": "MIT",
@@ -60,6 +275,32 @@
       "version": "1.0.2",
       "license": "MIT"
     },
+    "node_modules/basic-auth": {
+      "version": "2.0.1",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.1.2"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/basic-auth/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "license": "MIT"
+    },
+    "node_modules/bcrypt": {
+      "version": "6.0.0",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "node-addon-api": "^8.3.0",
+        "node-gyp-build": "^4.8.4"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/binary-extensions": {
       "version": "2.3.0",
       "dev": true,
@@ -109,6 +350,10 @@
         "node": ">=8"
       }
     },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/bytes": {
       "version": "3.1.2",
       "license": "MIT",
@@ -174,11 +419,31 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/cluster-key-slot": {
+      "version": "1.1.2",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/connect-redis": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/connect-redis/-/connect-redis-9.0.0.tgz",
+      "integrity": "sha512-QwzyvUePTMvEzG1hy45gZYw3X3YHrjmEdSkayURlcZft7hqadQ3X39wYkmCqblK2rGlw+XItELYt6GnyG6DEIQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "express-session": ">=1",
+        "redis": ">=5"
+      }
+    },
     "node_modules/content-disposition": {
       "version": "1.0.0",
       "license": "MIT",
@@ -198,11 +463,32 @@
     },
     "node_modules/cookie": {
       "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.6"
       }
     },
+    "node_modules/cookie-parser": {
+      "version": "1.4.7",
+      "resolved": "https://registry.npmjs.org/cookie-parser/-/cookie-parser-1.4.7.tgz",
+      "integrity": "sha512-nGUvgXnotP3BsjiLX2ypbQnWoGUPIIfHQNZkkC668ntrzGWEZVW70HDEB1qnNGMicPje6EttlIgzo51YSwNQGw==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "0.7.2",
+        "cookie-signature": "1.0.6"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/cookie-parser/node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
     "node_modules/cookie-signature": {
       "version": "1.2.2",
       "license": "MIT",
@@ -250,6 +536,13 @@
         "node": ">= 8"
       }
     },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/debug": {
       "version": "4.4.1",
       "license": "MIT",
@@ -265,6 +558,13 @@
         }
       }
     },
+    "node_modules/denque": {
+      "version": "2.1.0",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
     "node_modules/depd": {
       "version": "2.0.0",
       "license": "MIT",
@@ -294,6 +594,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "license": "MIT"
@@ -396,6 +703,61 @@
     "node_modules/express-ejs-layouts": {
       "version": "2.5.1"
     },
+    "node_modules/express-session": {
+      "version": "1.18.2",
+      "resolved": "https://registry.npmjs.org/express-session/-/express-session-1.18.2.tgz",
+      "integrity": "sha512-SZjssGQC7TzTs9rpPDuUrR23GNZ9+2+IkA/+IJWmvQilTr5OSliEHGF+D9scbIpdC6yGtTI0/VhaHoVes2AN/A==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "0.7.2",
+        "cookie-signature": "1.0.7",
+        "debug": "2.6.9",
+        "depd": "~2.0.0",
+        "on-headers": "~1.1.0",
+        "parseurl": "~1.3.3",
+        "safe-buffer": "5.2.1",
+        "uid-safe": "~2.1.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/express-session/node_modules/cookie-signature": {
+      "version": "1.0.7",
+      "license": "MIT"
+    },
+    "node_modules/express-session/node_modules/debug": {
+      "version": "2.6.9",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/express-session/node_modules/ms": {
+      "version": "2.0.0",
+      "license": "MIT"
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
     "node_modules/filelist": {
       "version": "1.0.4",
       "license": "Apache-2.0",
@@ -446,6 +808,16 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
     "node_modules/forwarded": {
       "version": "0.2.0",
       "license": "MIT",
@@ -589,6 +961,28 @@
       "version": "2.0.4",
       "license": "ISC"
     },
+    "node_modules/ioredis": {
+      "version": "5.7.0",
+      "license": "MIT",
+      "dependencies": {
+        "@ioredis/commands": "^1.3.0",
+        "cluster-key-slot": "^1.1.0",
+        "debug": "^4.3.4",
+        "denque": "^2.1.0",
+        "lodash.defaults": "^4.2.0",
+        "lodash.isarguments": "^3.1.0",
+        "redis-errors": "^1.2.0",
+        "redis-parser": "^3.0.0",
+        "standard-as-callback": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=12.22.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/ioredis"
+      }
+    },
     "node_modules/ipaddr.js": {
       "version": "1.9.1",
       "license": "MIT",
@@ -658,6 +1052,133 @@
         "node": ">=10"
       }
     },
+    "node_modules/jose": {
+      "version": "6.1.0",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
+    "node_modules/jsonwebtoken": {
+      "version": "9.0.2",
+      "license": "MIT",
+      "dependencies": {
+        "jws": "^3.2.2",
+        "lodash.includes": "^4.3.0",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isinteger": "^4.0.4",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.isstring": "^4.0.1",
+        "lodash.once": "^4.0.0",
+        "ms": "^2.1.1",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      }
+    },
+    "node_modules/jwa": {
+      "version": "1.4.2",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jwks-rsa": {
+      "version": "3.2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@types/express": "^4.17.20",
+        "@types/jsonwebtoken": "^9.0.4",
+        "debug": "^4.3.4",
+        "jose": "^4.15.4",
+        "limiter": "^1.1.5",
+        "lru-memoizer": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/jwks-rsa/node_modules/jose": {
+      "version": "4.15.9",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
+    "node_modules/jws": {
+      "version": "3.2.2",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^1.4.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/limiter": {
+      "version": "1.1.5"
+    },
+    "node_modules/lodash.clonedeep": {
+      "version": "4.5.0",
+      "license": "MIT"
+    },
+    "node_modules/lodash.defaults": {
+      "version": "4.2.0",
+      "license": "MIT"
+    },
+    "node_modules/lodash.includes": {
+      "version": "4.3.0",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isarguments": {
+      "version": "3.1.0",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isinteger": {
+      "version": "4.0.4",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isnumber": {
+      "version": "3.0.3",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isstring": {
+      "version": "4.0.1",
+      "license": "MIT"
+    },
+    "node_modules/lodash.once": {
+      "version": "4.1.1",
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "6.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/lru-memoizer": {
+      "version": "2.3.0",
+      "license": "MIT",
+      "dependencies": {
+        "lodash.clonedeep": "^4.5.0",
+        "lru-cache": "6.0.0"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "license": "MIT",
@@ -682,6 +1203,21 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/mime": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-4.1.0.tgz",
+      "integrity": "sha512-X5ju04+cAzsojXKes0B/S4tcYtFAJ6tTMuSPBEn9CPGlrWr8Fiw7qYeLT0XyH80HSoAoqWCaz+MWKh22P7G1cw==",
+      "funding": [
+        "https://github.com/sponsors/broofa"
+      ],
+      "license": "MIT",
+      "bin": {
+        "mime": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
     "node_modules/mime-db": {
       "version": "1.54.0",
       "license": "MIT",
@@ -710,6 +1246,41 @@
         "node": "*"
       }
     },
+    "node_modules/morgan": {
+      "version": "1.10.1",
+      "license": "MIT",
+      "dependencies": {
+        "basic-auth": "~2.0.1",
+        "debug": "2.6.9",
+        "depd": "~2.0.0",
+        "on-finished": "~2.3.0",
+        "on-headers": "~1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/morgan/node_modules/debug": {
+      "version": "2.6.9",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/morgan/node_modules/ms": {
+      "version": "2.0.0",
+      "license": "MIT"
+    },
+    "node_modules/morgan/node_modules/on-finished": {
+      "version": "2.3.0",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "license": "MIT"
@@ -721,6 +1292,70 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/node-addon-api": {
+      "version": "8.5.0",
+      "license": "MIT",
+      "engines": {
+        "node": "^18 || ^20 || >= 21"
+      }
+    },
+    "node_modules/node-appwrite": {
+      "version": "20.2.1",
+      "resolved": "https://registry.npmjs.org/node-appwrite/-/node-appwrite-20.2.1.tgz",
+      "integrity": "sha512-RweIh+3RHjprsxhWaJzcQr/UDMBMsZCma50TIJ9t3onVgs5jAT9aqFnsMlaaC9QZn1sXpPUQV90W6uvtm64DnQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "node-fetch-native-with-agent": "1.7.2"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/node-fetch-native-with-agent": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/node-fetch-native-with-agent/-/node-fetch-native-with-agent-1.7.2.tgz",
+      "integrity": "sha512-5MaOOCuJEvcckoz7/tjdx1M6OusOY6Xc5f459IaruGStWnKzlI1qpNgaAwmn4LmFYcsSlj+jBMk84wmmRxfk5g==",
+      "license": "MIT"
+    },
+    "node_modules/node-gyp-build": {
+      "version": "4.8.4",
+      "license": "MIT",
+      "bin": {
+        "node-gyp-build": "bin.js",
+        "node-gyp-build-optional": "optional.js",
+        "node-gyp-build-test": "build-test.js"
+      }
+    },
     "node_modules/nodemon": {
       "version": "3.1.10",
       "dev": true,
@@ -783,6 +1418,13 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/on-headers": {
+      "version": "1.1.0",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/once": {
       "version": "1.4.0",
       "license": "ISC",
@@ -814,6 +1456,8 @@
     },
     "node_modules/pg": {
       "version": "8.16.3",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.16.3.tgz",
+      "integrity": "sha512-enxc1h0jA/aq5oSDMvqyW3q89ra6XIIDZgCX9vkMrnz5DFTw/Ny3Li2lFQ+pt3L6MCgm/5o2o8HW9hiJji+xvw==",
       "license": "MIT",
       "dependencies": {
         "pg-connection-string": "^2.9.1",
@@ -839,11 +1483,15 @@
     },
     "node_modules/pg-cloudflare": {
       "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.2.7.tgz",
+      "integrity": "sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==",
       "license": "MIT",
       "optional": true
     },
     "node_modules/pg-connection-string": {
       "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.9.1.tgz",
+      "integrity": "sha512-nkc6NpDcvPVpZXxrreI/FOtX3XemeLl8E0qFr6F2Lrm/I8WOnaWNhIPK2Z7OHpw7gh5XJThi6j6ppgNoaT1w4w==",
       "license": "MIT"
     },
     "node_modules/pg-format": {
@@ -855,6 +1503,8 @@
     },
     "node_modules/pg-int8": {
       "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
       "license": "ISC",
       "engines": {
         "node": ">=4.0.0"
@@ -862,6 +1512,8 @@
     },
     "node_modules/pg-pool": {
       "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.10.1.tgz",
+      "integrity": "sha512-Tu8jMlcX+9d8+QVzKIvM/uJtp07PKr82IUOYEphaWcoBhIYkoHpLXN3qO59nAI11ripznDsEzEv8nUxBVWajGg==",
       "license": "MIT",
       "peerDependencies": {
         "pg": ">=8.0"
@@ -869,10 +1521,14 @@
     },
     "node_modules/pg-protocol": {
       "version": "1.10.3",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.10.3.tgz",
+      "integrity": "sha512-6DIBgBQaTKDJyxnXaLiLR8wBpQQcGWuAESkRBX/t6OwA8YsqP+iVSiond2EDy6Y/dsGk8rh/jtax3js5NeV7JQ==",
       "license": "MIT"
     },
     "node_modules/pg-types": {
       "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
       "license": "MIT",
       "dependencies": {
         "pg-int8": "1.0.1",
@@ -887,6 +1543,8 @@
     },
     "node_modules/pgpass": {
       "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
       "license": "MIT",
       "dependencies": {
         "split2": "^4.1.0"
@@ -909,6 +1567,8 @@
     },
     "node_modules/postgres-array": {
       "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -916,6 +1576,8 @@
     },
     "node_modules/postgres-bytea": {
       "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz",
+      "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -923,6 +1585,8 @@
     },
     "node_modules/postgres-date": {
       "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -930,6 +1594,8 @@
     },
     "node_modules/postgres-interval": {
       "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
       "license": "MIT",
       "dependencies": {
         "xtend": "^4.0.0"
@@ -967,6 +1633,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/random-bytes": {
+      "version": "1.0.0",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/range-parser": {
       "version": "1.2.1",
       "license": "MIT",
@@ -998,6 +1671,37 @@
         "node": ">=8.10.0"
       }
     },
+    "node_modules/redis": {
+      "version": "5.8.2",
+      "license": "MIT",
+      "dependencies": {
+        "@redis/bloom": "5.8.2",
+        "@redis/client": "5.8.2",
+        "@redis/json": "5.8.2",
+        "@redis/search": "5.8.2",
+        "@redis/time-series": "5.8.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/redis-errors": {
+      "version": "1.2.0",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/redis-parser": {
+      "version": "3.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "redis-errors": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/router": {
       "version": "2.2.0",
       "license": "MIT",
@@ -1036,7 +1740,6 @@
     },
     "node_modules/semver": {
       "version": "7.7.2",
-      "dev": true,
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -1199,11 +1902,17 @@
     },
     "node_modules/split2": {
       "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
       "license": "ISC",
       "engines": {
         "node": ">= 10.x"
       }
     },
+    "node_modules/standard-as-callback": {
+      "version": "2.1.0",
+      "license": "MIT"
+    },
     "node_modules/statuses": {
       "version": "2.0.2",
       "license": "MIT",
@@ -1260,11 +1969,25 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/uid-safe": {
+      "version": "2.1.5",
+      "license": "MIT",
+      "dependencies": {
+        "random-bytes": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/undefsafe": {
       "version": "2.0.5",
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/undici-types": {
+      "version": "7.10.0",
+      "license": "MIT"
+    },
     "node_modules/unpipe": {
       "version": "1.0.0",
       "license": "MIT",
@@ -1279,6 +2002,13 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "dev": true,
@@ -1299,10 +2029,16 @@
     },
     "node_modules/xtend": {
       "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
       "license": "MIT",
       "engines": {
         "node": ">=0.4"
       }
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "license": "ISC"
     }
   }
 }

services/app/package.json

@@ -1,11 +1,11 @@
 {
   "name": "aplication",
   "version": "1.0.0",
-  "main": "src/index.js",
+  "main": "src/index.mjs",
   "scripts": {
-    "start": "NODE_ENV=production node ./src/index.js",
+    "start": "NODE_ENV=production node ./src/index.mjs",
-    "dev": "NODE_ENV=development npx nodemon ./src/index.js",
+    "dev": "NODE_ENV=development npx nodemon ./src/index.mjs",
-    "test": "NODE_ENV=stage node ./src/index.js"
+    "test": "NODE_ENV=stage node ./src/index.mjs"
   },
   "author": "Mateo Saldain",
   "license": "ISC",
@@ -15,16 +15,39 @@
     "nodemon": "^3.1.10"
   },
   "dependencies": {
+    
+    "@suitecoffee/scripts": "file:../../packages/core/scripts",
+    "@suitecoffee/db": "file:../../packages/core/db",
+    "@suitecoffee/redis": "file:../../packages/core/redis",
+    "@suitecoffee/middlewares": "file:../../packages/core/middlewares",
+    
+    "@suitecoffee/api": "file:../../packages/api/",
+    "@suitecoffee/repositories": "file:../../packages/core/repositories",
+
+    "bcrypt": "^6.0.0",
     "chalk": "^5.6.0",
+    "connect-redis": "^9.0.0",
+    "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
     "dotenv": "^17.2.1",
     "ejs": "^3.1.10",
     "express": "^5.1.0",
     "express-ejs-layouts": "^2.5.1",
+    "express-session": "^1.18.2",
+    "ioredis": "^5.7.0",
+    "jose": "^6.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "jwks-rsa": "^3.2.0",
+    "mime": "^4.1.0",
+    "morgan": "^1.10.1",
+    "node-appwrite": "^20.2.1",
+    "node-fetch": "^3.3.2",
     "pg": "^8.16.3",
     "pg-format": "^1.0.4",
+    "redis": "^5.8.2",
     "serve-favicon": "^2.5.1"
   },
+  "imports": {  },
   "keywords": [],
   "description": ""
 }

services/app/src/index.js

@@ -1,842 +0,0 @@
-// app/src/index.js
-import chalk from 'chalk'; // Colores!
-import favicon from 'serve-favicon'; // Favicon
-import express from 'express';
-import expressLayouts from 'express-ejs-layouts';
-import cors from 'cors';
-import { Pool } from 'pg';
-
-// Rutas
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Variables de Entorno
-import dotenv from 'dotenv';
-
-// Cargar .env según entorno
-if (process.env.NODE_ENV === 'development') {
-  dotenv.config({ path: path.resolve(__dirname, '../.env.development') });
-} else if (process.env.NODE_ENV === 'test') {
-  dotenv.config({ path: path.resolve(__dirname, '../.env.test') });
-} else if (process.env.NODE_ENV === 'production') {
-  dotenv.config({ path: path.resolve(__dirname, '../.env.production') });
-} else {
-  dotenv.config(); // .env por defecto
-}
-
-// ----------------------------------------------------------
-// App
-// ----------------------------------------------------------
-const app = express();
-app.set('trust proxy', true);
-app.use(cors());
-app.use(express.json());
-app.use(express.json({ limit: '1mb' }));
-app.use(express.static(path.join(__dirname, 'pages')));
-
-
-// ----------------------------------------------------------
-// Motor de vistas EJS
-// ----------------------------------------------------------
-app.set("views", path.join(__dirname, "views"));
-app.set("view engine", "ejs");
-app.use(expressLayouts);
-app.set("layout", "layouts/main");
-
-// Archivos estáticos
-app.use(express.static(path.join(__dirname, "public")));
-
-app.use('/favicon', express.static(path.join(__dirname, 'public', 'favicon'), {
-  maxAge: '1y'
-}));
-
-app.use(favicon(path.join(__dirname, 'public', 'favicon', 'favicon.ico'), {
-  maxAge: '1y'
-}));
-
-const url = v => !v ? "" : (v.startsWith("http") ? v : `/img/productos/${v}`);
-
-// ----------------------------------------------------------
-// Configuración de conexión PostgreSQL
-// ----------------------------------------------------------
-const dbConfig = {
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASS,
-  database: process.env.DB_NAME,
-  port: process.env.DB_LOCAL_PORT ? Number(process.env.DB_LOCAL_PORT) : undefined,
-  ssl: process.env.PGSSL === 'true' ? { rejectUnauthorized: false } : undefined,
-};
-
-const pool = new Pool(dbConfig);
-
-// ----------------------------------------------------------
-// Seguridad: Tablas permitidas
-// ----------------------------------------------------------
-const ALLOWED_TABLES = [
-  'roles','usuarios','usua_roles',
-  'categorias','productos',
-  'clientes','mesas',
-  'comandas','deta_comandas',
-  'proveedores','compras','deta_comp_producto',
-  'mate_primas','deta_comp_materias',
-  'prov_producto','prov_mate_prima',
-  'receta_producto', 'asistencia_resumen_diario',
-  'asistencia_intervalo', 'vw_compras'
-];
-
-const VALID_IDENT = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-
-// Identificadores SQL -> comillas dobles y escape correcto
-const q = (s) => `"${String(s).replace(/"/g, '""')}"`;
-
-function ensureTable(name) {
-  const t = String(name || '').toLowerCase();
-  if (!ALLOWED_TABLES.includes(t)) throw new Error('Tabla no permitida');
-  return t;
-}
-
-async function getClient() {
-  const client = await pool.connect();
-  return client;
-}
-
-// ----------------------------------------------------------
-// Introspección de esquema
-// ----------------------------------------------------------
-async function loadColumns(client, table) {
-  const sql = `
-    SELECT
-      c.column_name,
-      c.data_type,
-      c.is_nullable = 'YES' AS is_nullable,
-      c.column_default,
-      (SELECT EXISTS (
-         SELECT 1 FROM pg_attribute a
-         JOIN pg_class t ON t.oid = a.attrelid
-         JOIN pg_index i ON i.indrelid = t.oid AND a.attnum = ANY(i.indkey)
-         WHERE t.relname = $1 AND i.indisprimary AND a.attname = c.column_name
-      )) AS is_primary,
-      (SELECT a.attgenerated = 's' OR a.attidentity IN ('a','d')
-       FROM pg_attribute a
-       JOIN pg_class t ON t.oid = a.attrelid
-       WHERE t.relname = $1 AND a.attname = c.column_name
-      ) AS is_identity
-    FROM information_schema.columns c
-    WHERE c.table_schema='public' AND c.table_name=$1
-    ORDER BY c.ordinal_position
-  `;
-  const { rows } = await client.query(sql, [table]);
-  return rows;
-}
-
-async function loadForeignKeys(client, table) {
-  const sql = `
-    SELECT
-      kcu.column_name,
-      ccu.table_name AS foreign_table,
-      ccu.column_name AS foreign_column
-    FROM information_schema.table_constraints tc
-    JOIN information_schema.key_column_usage kcu
-      ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
-    JOIN information_schema.constraint_column_usage ccu
-      ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
-    WHERE tc.table_schema='public' AND tc.table_name=$1 AND tc.constraint_type='FOREIGN KEY'
-  `;
-  const { rows } = await client.query(sql, [table]);
-  const map = {};
-  for (const r of rows) map[r.column_name] = { foreign_table: r.foreign_table, foreign_column: r.foreign_column };
-  return map;
-}
-
-async function loadPrimaryKey(client, table) {
-  const sql = `
-    SELECT a.attname AS column_name
-    FROM pg_index i
-    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
-    JOIN pg_class t ON t.oid = i.indrelid
-    WHERE t.relname = $1 AND i.indisprimary
-  `;
-  const { rows } = await client.query(sql, [table]);
-  return rows.map(r => r.column_name);
-}
-
-// label column for FK options
-async function pickLabelColumn(client, refTable) {
-  const preferred = ['nombre','raz_social','apodo','documento','correo','telefono'];
-  const { rows } = await client.query(
-    `SELECT column_name, data_type
-     FROM information_schema.columns
-     WHERE table_schema='public' AND table_name=$1
-     ORDER BY ordinal_position`, [refTable]
-  );
-  for (const cand of preferred) {
-    if (rows.find(r => r.column_name === cand)) return cand;
-  }
-  const textish = rows.find(r => /text|character varying|varchar/i.test(r.data_type));
-  if (textish) return textish.column_name;
-  return rows[0]?.column_name || 'id';
-}
-
-// ----------------------------------------------------------
-// Middleware para datos globales
-// ----------------------------------------------------------
-app.use((req, res, next) => {
-  res.locals.currentPath = req.path;
-  res.locals.pageTitle = "SuiteCoffee"; 
-  res.locals.pageId = "";               
-  next();
-});
-
-
-// ----------------------------------------------------------
-// Rutas de UI
-// ----------------------------------------------------------
-
-app.get("/", (req, res) => {
-  res.locals.pageTitle = "Dashboard";
-  res.locals.pageId = "home"; // para el sidebar contextual
-  res.render("dashboard");
-});
-
-app.get("/dashboard", (req, res) => {
-  res.locals.pageTitle = "Dashboard";
-  res.locals.pageId = "dashboard";   // <- importante
-  res.render("dashboard");
-});
-
-// app.get('/', (req, res) => {
-//   res.sendFile(path.join(__dirname, 'pages', 'dashboard.html'));
-// });
-
-app.get("/comandas", (req, res) => {
-  res.locals.pageTitle = "Comandas";
-  res.locals.pageId = "comandas"; // <- importante para el sidebar contextual
-  res.render("comandas");
-});
-
-// app.get('/comandas', (req, res) => {
-//   res.sendFile(path.join(__dirname, 'pages', 'comandas.html'));
-// });
-
-app.get("/estadoComandas", (req, res) => {
-  res.locals.pageTitle = "Estado de Comandas";
-  res.locals.pageId = "estadoComandas";
-  res.render("estadoComandas");
-});
-
-// app.get('/estadoComandas', (req, res) => {
-//   res.sendFile(path.join(__dirname, 'pages', 'estadoComandas.html'));
-// });
-
-app.get("/productos", (req, res) => {
-  res.locals.pageTitle = "Productos";
-  res.locals.pageId = "productos";
-  res.render("productos");
-});
-
-app.get('/usuarios', (req, res) => {
-  res.locals.pageTitle = 'Usuarios';
-  res.locals.pageId = 'usuarios';
-  res.render('usuarios');
-});
-
-app.get('/reportes', (req, res) => {
-  res.locals.pageTitle = 'Reportes';
-  res.locals.pageId = 'reportes';
-  res.render('reportes');
-});
-
-app.get('/compras', (req, res) => {
-  res.locals.pageTitle = 'Compras';
-  res.locals.pageId = 'compras';
-  res.render('compras');
-});
-
-// ----------------------------------------------------------
-// API
-// ----------------------------------------------------------
-app.get('/api/tables', async (_req, res) => {
-  res.json(ALLOWED_TABLES);
-});
-
-app.get('/api/schema/:table', async (req, res) => {
-  try {
-    const table = ensureTable(req.params.table);
-    const client = await getClient();
-    try {
-      const columns = await loadColumns(client, table);
-      const fks = await loadForeignKeys(client, table);
-      const enriched = columns.map(c => ({ ...c, foreign: fks[c.column_name] || null }));
-      res.json({ table, columns: enriched });
-    } finally { client.release(); }
-  } catch (e) {
-    res.status(400).json({ error: e.message });
-  }
-});
-
-app.get('/api/options/:table/:column', async (req, res) => {
-  try {
-    const table = ensureTable(req.params.table);
-    const column = req.params.column;
-    if (!VALID_IDENT.test(column)) throw new Error('Columna inválida');
-
-    const client = await getClient();
-    try {
-      const fks = await loadForeignKeys(client, table);
-      const fk = fks[column];
-      if (!fk) return res.json([]);
-
-      const refTable = fk.foreign_table;
-      const refId = fk.foreign_column;
-      const labelCol = await pickLabelColumn(client, refTable);
-
-      const sql = `SELECT ${q(refId)} AS id, ${q(labelCol)} AS label FROM ${q(refTable)} ORDER BY ${q(labelCol)} LIMIT 1000`;
-      const result = await client.query(sql);
-      res.json(result.rows);
-    } finally { client.release(); }
-  } catch (e) {
-    res.status(400).json({ error: e.message });
-  }
-});
-
-app.get('/api/table/:table', async (req, res) => {
-  try {
-    const table = ensureTable(req.params.table);
-    const limit = Math.min(parseInt(req.query.limit || '100', 10), 1000);
-    const client = await getClient();
-    try {
-      const pks = await loadPrimaryKey(client, table);
-      const orderBy = pks.length ? `ORDER BY ${pks.map(q).join(', ')} DESC` : '';
-      const sql = `SELECT * FROM ${q(table)} ${orderBy} LIMIT ${limit}`;
-      const result = await client.query(sql);
-
-      // Normalizar: siempre devolver objetos {col: valor}
-      const colNames = result.fields.map(f => f.name);
-      let rows = result.rows;
-      if (rows.length && Array.isArray(rows[0])) {
-        rows = rows.map(r => Object.fromEntries(r.map((v, i) => [colNames[i], v])));
-      }
-      res.json(rows);
-    } finally { client.release(); }
-  } catch (e) {
-    res.status(400).json({ error: e.message, code: e.code, detail: e.detail });
-  }
-});
-
-app.post('/api/table/:table', async (req, res) => {
-  const table = ensureTable(req.params.table);
-  const payload = req.body || {};
-  try {
-    const client = await getClient();
-    try {
-      const columns = await loadColumns(client, table);
-      const insertable = columns.filter(c =>
-        !c.is_primary && !c.is_identity && !(c.column_default || '').startsWith('nextval(')
-      );
-      const allowedCols = new Set(insertable.map(c => c.column_name));
-
-      const cols = [];
-      const vals = [];
-      const params = [];
-      let idx = 1;
-      for (const [k, v] of Object.entries(payload)) {
-        if (!allowedCols.has(k)) continue;
-        if (!VALID_IDENT.test(k)) continue;
-        cols.push(q(k));
-        vals.push(`$${idx++}`);
-        params.push(v);
-      }
-
-      if (!cols.length) {
-        const { rows } = await client.query(`INSERT INTO ${q(table)} DEFAULT VALUES RETURNING *`);
-        res.status(201).json({ inserted: rows[0] });
-      } else {
-        const { rows } = await client.query(
-          `INSERT INTO ${q(table)} (${cols.join(', ')}) VALUES (${vals.join(', ')}) RETURNING *`,
-          params
-        );
-        res.status(201).json({ inserted: rows[0] });
-      }
-    } catch (e) {
-      if (e.code === '23503') return res.status(400).json({ error: 'Violación de clave foránea', detail: e.detail });
-      if (e.code === '23505') return res.status(400).json({ error: 'Violación de unicidad', detail: e.detail });
-      if (e.code === '23514') return res.status(400).json({ error: 'Violación de CHECK', detail: e.detail });
-      if (e.code === '23502') return res.status(400).json({ error: 'Campo NOT NULL faltante', detail: e.detail });
-      throw e;
-    }
-  } catch (e) {
-    res.status(400).json({ error: e.message });
-  }
-});
-
-app.get('/api/comandas', async (req, res, next) => {
-  try {
-    const estado = (req.query.estado || '').trim() || null;
-    const limit  = Math.min(parseInt(req.query.limit || '200', 10), 1000);
-
-    const { rows } = await pool.query(
-      `SELECT * FROM public.f_comandas_resumen($1, $2)`,
-      [estado, limit]
-    );
-    res.json(rows);
-  } catch (e) { next(e); }
-});
-
-
-// app.get('/api/comandas', async (req, res, next) => {
-//   try {
-//     const estado = (req.query.estado || '').trim();
-//     const limit = Math.min(parseInt(req.query.limit || '200', 10), 1000);
-//     const params = [];
-//     let where = '';
-//     if (estado) { params.push(estado); where = `WHERE c.estado = $${params.length}`; }
-//     params.push(limit);
-
-//     const sql = `
-//       WITH items AS (
-//         SELECT d.id_comanda,
-//                COUNT(*) AS items,
-//                SUM(d.cantidad * d.pre_unitario) AS total
-//         FROM deta_comandas d
-//         GROUP BY d.id_comanda
-//       )
-//       SELECT
-//         c.id_comanda, c.fec_creacion, c.estado, c.observaciones,
-//         u.id_usuario, u.nombre AS usuario_nombre, u.apellido AS usuario_apellido,
-//         m.id_mesa, m.numero AS mesa_numero, m.apodo AS mesa_apodo,
-//         COALESCE(i.items, 0) AS items,
-//         COALESCE(i.total, 0) AS total
-//       FROM comandas c
-//       JOIN usuarios u ON u.id_usuario = c.id_usuario
-//       JOIN mesas m ON m.id_mesa = c.id_mesa
-//       LEFT JOIN items i ON i.id_comanda = c.id_comanda
-//       ${where}
-//       ORDER BY c.id_comanda DESC
-//       LIMIT $${params.length}
-//     `;
-//     const client = await pool.connect();
-//     try {
-//       const { rows } = await client.query(sql, params);
-//       res.json(rows);
-//     } finally { client.release(); }
-//   } catch (e) { next(e); }
-// });
-
-
-// Detalle de una comanda (con nombres de productos)
-
-// GET /api/comandas/:id/detalle
-app.get('/api/comandas/:id/detalle', (req, res, next) =>
-  pool.query(
-    `SELECT id_det_comanda, id_producto, producto_nombre,
-            cantidad, pre_unitario, subtotal, observaciones
-       FROM public.v_comandas_detalle_items
-      WHERE id_comanda = $1::int
-      ORDER BY id_det_comanda`,
-    [req.params.id]
-  )
-  .then(r => res.json(r.rows))
-  .catch(next)
-);
-
-
-// app.get('/api/comandas/:id/detalle', async (req, res, next) => {
-//   try {
-//     const id = parseInt(req.params.id, 10);
-//     if (!Number.isInteger(id) || id <= 0) {
-//       return res.status(400).json({ error: 'id inválido' });
-//     }
-
-//     const sql = `
-//       SELECT
-//         id_det_comanda, id_producto, producto_nombre,
-//         cantidad, pre_unitario, subtotal, observaciones
-//       FROM public.v_comandas_detalle_items
-//       WHERE id_comanda = $1::int
-//       ORDER BY id_det_comanda
-//     `;
-//     const { rows } = await pool.query(sql, [id]);
-//     res.json(rows);
-//   } catch (e) { next(e); }
-// });
-
-
-// app.get('/api/comandas/:id/detalle', async (req, res, next) => {
-//   try {
-//     const id = parseInt(req.params.id, 10);
-//     if (!id) return res.status(400).json({ error: 'id inválido' });
-
-//     const sql = `
-//       SELECT d.id_det_comanda, d.id_producto, p.nombre AS producto_nombre,
-//              d.cantidad, d.pre_unitario, (d.cantidad * d.pre_unitario) AS subtotal,
-//              d.observaciones
-//       FROM deta_comandas d
-//       JOIN productos p ON p.id_producto = d.id_producto
-//       WHERE d.id_comanda = $1
-//       ORDER BY d.id_det_comanda
-//     `;
-//     const { rows } = await pool.query(sql, [id]);
-//     res.json(rows);
-//   } catch (e) { next(e); }
-// });
-
-
-
-// Cerrar comanda (setea estado y fec_cierre en DB)
-app.post('/api/comandas/:id/cerrar', async (req, res, next) => {
-  try {
-    const id = Number(req.params.id);
-    if (!Number.isInteger(id) || id <= 0) {
-      return res.status(400).json({ error: 'id inválido' });
-    }
-    const { rows } = await pool.query(
-      `SELECT public.f_cerrar_comanda($1) AS data`,
-      [id]
-    );
-    if (!rows.length || rows[0].data === null) {
-      return res.status(404).json({ error: 'Comanda no encontrada' });
-    }
-    res.json(rows[0].data);
-  } catch (err) { next(err); }
-});
-
-// Abrir (reabrir) comanda
-app.post('/api/comandas/:id/abrir', async (req, res, next) => {
-  try {
-    const id = Number(req.params.id);
-    if (!Number.isInteger(id) || id <= 0) {
-      return res.status(400).json({ error: 'id inválido' });
-    }
-    const { rows } = await pool.query(
-      `SELECT public.f_abrir_comanda($1) AS data`,
-      [id]
-    );
-    if (!rows.length || rows[0].data === null) {
-      return res.status(404).json({ error: 'Comanda no encontrada' });
-    }
-    res.json(rows[0].data);
-  } catch (err) { next(err); }
-});
-
-// // Cambiar estado (abrir/cerrar)
-// app.post('/api/comandas/:id/estado', async (req, res, next) => {
-//   try {
-//     const id = parseInt(req.params.id, 10);
-//     let { estado } = req.body || {};
-//     if (!id) return res.status(400).json({ error: 'id inválido' });
-
-//     const allowed = new Set(['abierta','cerrada','pagada','anulada']);
-//     if (!allowed.has(estado)) return res.status(400).json({ error: 'estado inválido' });
-
-//     const { rows } = await pool.query(
-//       `UPDATE comandas SET estado = $2 WHERE id_comanda = $1 RETURNING *`,
-//       [id, estado]
-//     );
-//     if (!rows.length) return res.status(404).json({ error: 'comanda no encontrada' });
-//     res.json({ updated: rows[0] });
-//   } catch (e) { next(e); }
-// });
-
-// GET producto + receta
-app.get('/api/rpc/get_producto/:id', async (req, res) => {
-  const id = Number(req.params.id);
-  const { rows } = await pool.query('SELECT public.get_producto($1) AS data', [id]);
-  res.json(rows[0]?.data || {});
-});
-
-// POST guardar producto + receta
-
-app.post('/api/rpc/save_producto', async (req, res) => {
-  try {
-    // console.debug('receta payload:', req.body?.receta); // habilitalo si lo necesitás
-    const q = 'SELECT public.save_producto($1,$2,$3,$4,$5,$6,$7::jsonb) AS id_producto';
-    const { id_producto=null, nombre, img_producto=null, precio=0, activo=true, id_categoria=null, receta=[] } = req.body || {};
-    const params = [id_producto, nombre, img_producto, precio, activo, id_categoria, JSON.stringify(receta||[])];
-    const { rows } = await pool.query(q, params);
-    res.json(rows[0] || {});
-  } catch(e) {
-    console.error(e);
-    res.status(500).json({ error: 'save_producto failed' });
-  }
-});
-
-
-// app.post('/api/rpc/save_producto', async (req, res) => {
-//   const { id_producto=null, nombre, img_producto=null, precio=0, activo=true, id_categoria=null, receta=[] } = req.body || {};
-//   const q = 'SELECT * FROM public.save_producto($1,$2,$3,$4,$5,$6,$7::jsonb)';
-//   const params = [id_producto, nombre, img_producto, precio, activo, id_categoria, JSON.stringify(receta||[])];
-//   const { rows } = await pool.query(q, params);
-//   res.json(rows[0] || {});
-// });
-
-// GET MP + proveedores
-app.get('/api/rpc/get_materia/:id', async (req, res) => {
-  const id = Number(req.params.id);
-  try {
-    const { rows } = await pool.query('SELECT public.get_materia_prima($1) AS data', [id]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e);
-    res.status(500).json({ error: 'get_materia failed' });
-  }
-});
-
-// SAVE MP + proveedores (array)
-app.post('/api/rpc/save_materia', async (req, res) => {
-  const { id_mat_prima=null, nombre, unidad, activo=true, proveedores=[] } = req.body || {};
-  try {
-    const q = 'SELECT public.save_materia_prima($1,$2,$3,$4,$5::jsonb) AS id_mat_prima';
-    const params = [id_mat_prima, nombre, unidad, activo, JSON.stringify(proveedores||[])];
-    const { rows } = await pool.query(q, params);
-    res.json(rows[0] || {});
-  } catch (e) {
-    console.error(e);
-    res.status(500).json({ error: 'save_materia failed' });
-  }
-});
-
-// POST /api/rpc/find_usuarios_por_documentos  { docs: ["12345678","09123456", ...] }
-app.post('/api/rpc/find_usuarios_por_documentos', async (req, res) => {
-  try {
-    const docs = Array.isArray(req.body?.docs) ? req.body.docs : [];
-    const sql  = 'SELECT public.find_usuarios_por_documentos($1::jsonb) AS data';
-    const { rows } = await pool.query(sql, [JSON.stringify(docs)]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e);
-    res.status(500).json({ error: 'find_usuarios_por_documentos failed' });
-  }
-});
-
-// POST /api/rpc/import_asistencia  { registros: [...], origen?: "AGL_001.txt" }
-app.post('/api/rpc/import_asistencia', async (req, res) => {
-  try {
-    const registros = Array.isArray(req.body?.registros) ? req.body.registros : [];
-    const origen    = req.body?.origen || null;
-    const sql = 'SELECT public.import_asistencia($1::jsonb,$2) AS data';
-    const { rows } = await pool.query(sql, [JSON.stringify(registros), origen]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e);
-    res.status(500).json({ error: 'import_asistencia failed' });
-  }
-});
-
-// Consultar datos de asistencia (raw + pares) para un usuario y rango
-app.post('/api/rpc/asistencia_get', async (req, res) => {
-  try {
-    const { doc, desde, hasta } = req.body || {};
-    const sql = 'SELECT public.asistencia_get($1::text,$2::date,$3::date) AS data';
-    const { rows } = await pool.query(sql, [doc, desde, hasta]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e); res.status(500).json({ error: 'asistencia_get failed' });
-  }
-});
-
-// Editar un registro crudo y recalcular pares
-app.post('/api/rpc/asistencia_update_raw', async (req, res) => {
-  try {
-    const { id_raw, fecha, hora, modo } = req.body || {};
-    const sql = 'SELECT public.asistencia_update_raw($1::bigint,$2::date,$3::text,$4::text) AS data';
-    const { rows } = await pool.query(sql, [id_raw, fecha, hora, modo ?? null]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e); res.status(500).json({ error: 'asistencia_update_raw failed' });
-  }
-});
-
-// Eliminar un registro crudo y recalcular pares
-app.post('/api/rpc/asistencia_delete_raw', async (req, res) => {
-  try {
-    const { id_raw } = req.body || {};
-    const sql = 'SELECT public.asistencia_delete_raw($1::bigint) AS data';
-    const { rows } = await pool.query(sql, [id_raw]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e); res.status(500).json({ error: 'asistencia_delete_raw failed' });
-  }
-});
-
-// POST /api/rpc/report_tickets { year }
-app.post('/api/rpc/report_tickets', async (req, res) => {
-  try {
-    const y = parseInt(req.body?.year ?? req.query?.year, 10);
-    const year = (Number.isFinite(y) && y >= 2000 && y <= 2100)
-      ? y
-      : (new Date()).getFullYear();
-
-    const { rows } = await pool.query(
-      'SELECT public.report_tickets_year($1::int) AS j', [year]
-    );
-    res.json(rows[0].j);
-  } catch (e) {
-    console.error('report_tickets error:', e);
-    res.status(500).json({
-      error: 'report_tickets failed',
-      message: e.message, detail: e.detail, where: e.where, code: e.code
-    });
-  }
-});
-
-// POST /api/rpc/report_asistencia { desde: 'YYYY-MM-DD', hasta: 'YYYY-MM-DD' }
-app.post('/api/rpc/report_asistencia', async (req, res) => {
-  try {
-    let { desde, hasta } = req.body || {};
-    // defaults si vienen vacíos/invalidos
-    const re = /^\d{4}-\d{2}-\d{2}$/;
-    if (!re.test(desde) || !re.test(hasta)) {
-      const end   = new Date();
-      const start = new Date(end); start.setDate(end.getDate()-30);
-      desde = start.toISOString().slice(0,10);
-      hasta = end.toISOString().slice(0,10);
-    }
-
-    const { rows } = await pool.query(
-      'SELECT public.report_asistencia($1::date,$2::date) AS j', [desde, hasta]
-    );
-    res.json(rows[0].j);
-  } catch (e) {
-    console.error('report_asistencia error:', e);
-    res.status(500).json({
-      error: 'report_asistencia failed',
-      message: e.message, detail: e.detail, where: e.where, code: e.code
-    });
-  }
-});
-
-
-// app.post('/api/rpc/report_asistencia', async (req,res)=>{
-//   try{
-//     const {desde, hasta} = req.body||{};
-//     const sql = 'SELECT * FROM public.report_asistencia($1::date,$2::date)';
-//     const {rows} = await pool.query(sql,[desde, hasta]);
-//     res.json(rows);
-//   } catch (e) {
-//     console.error(e);
-//     res.status(500).json({ error: 'report_tickets failed' + e });
-//   }
-// });
-
-// app.post('/api/rpc/report_tickets', async (req, res) => {
-//   try {
-//     const { year } = req.body || {};
-//     const sql = 'SELECT public.report_tickets_year($1::int) AS data';
-//     const { rows } = await pool.query(sql, [year]);
-//     res.json(rows[0]?.data || {});
-//   } catch (e) {
-//     console.error(e);
-//     res.status(500).json({ error: 'report_tickets failed' + e });
-//   }
-// });
-
-
-// Guardar (insert/update)
-app.post('/api/rpc/save_compra', async (req, res) => {
-  try {
-    const { id_compra, id_proveedor, fec_compra, detalles } = req.body || {};
-    const sql  = 'SELECT * FROM public.save_compra($1::int,$2::int,$3::timestamptz,$4::jsonb)';
-    const args = [id_compra ?? null, id_proveedor, fec_compra ? new Date(fec_compra) : null, JSON.stringify(detalles)];
-    const { rows } = await pool.query(sql, args);
-    res.json(rows[0]); // { id_compra, total }
-  } catch (e) {
-    console.error('save_compra error:', e);
-    res.status(500).json({ error: 'save_compra failed', message: e.message, detail: e.detail, where: e.where, code: e.code });
-  }
-});
-
-
-// Obtener para editar
-app.post('/api/rpc/get_compra', async (req, res) => {
-  try {
-    const { id_compra } = req.body || {};
-    const sql = `SELECT public.get_compra($1::int) AS data`;
-    const { rows } = await pool.query(sql, [id_compra]);
-    res.json(rows[0]?.data || {});
-  } catch (e) {
-    console.error(e); res.status(500).json({ error: 'get_compra failed' });
-  }
-});
-
-// Eliminar
-app.post('/api/rpc/delete_compra', async (req, res) => {
-  try {
-    const { id_compra } = req.body || {};
-    await pool.query(`SELECT public.delete_compra($1::int)`, [id_compra]);
-    res.json({ ok: true });
-  } catch (e) {
-    console.error(e); res.status(500).json({ error: 'delete_compra failed' });
-  }
-});
-
-
-// POST /api/rpc/report_gastos  { year: 2025 }
-app.post('/api/rpc/report_gastos', async (req, res) => {
-  try {
-    const year = parseInt(req.body?.year ?? new Date().getFullYear(), 10);
-    const { rows } = await pool.query(
-      'SELECT public.report_gastos($1::int) AS j', [year]
-    );
-    res.json(rows[0].j);
-  } catch (e) {
-    console.error('report_gastos error:', e);
-    res.status(500).json({
-      error: 'report_gastos failed',
-      message: e.message, detail: e.detail, code: e.code
-    });
-  }
-});
-
-// (Opcional) GET para probar rápido desde el navegador:
-// /api/rpc/report_gastos?year=2025
-app.get('/api/rpc/report_gastos', async (req, res) => {
-  try {
-    const year = parseInt(req.query.year ?? new Date().getFullYear(), 10);
-    const { rows } = await pool.query(
-      'SELECT public.report_gastos($1::int) AS j', [year]
-    );
-    res.json(rows[0].j);
-  } catch (e) {
-    console.error('report_gastos error:', e);
-    res.status(500).json({
-      error: 'report_gastos failed',
-      message: e.message, detail: e.detail, code: e.code
-    });
-  }
-});
-
-
-// ----------------------------------------------------------
-// Verificación de conexión
-// ----------------------------------------------------------
-async function verificarConexion() {
-  try {
-    const client = await pool.connect();
-    const res = await client.query('SELECT NOW() AS hora');
-    console.log(`\nConexión con la base de datos ${chalk.green(process.env.DB_NAME)} fue exitosa.`);
-    console.log('Fecha y hora actual de la base de datos:', res.rows[0].hora);
-    client.release();
-  } catch (error) {
-    console.error('Error al conectar con la base de datos al iniciar:', error.message);
-    console.error('Revisar credenciales y accesos de red.');
-  }
-}
-
-// ----------------------------------------------------------
-// Inicio del servidor
-// ----------------------------------------------------------
-
-const PORT = process.env.PORT ? Number(process.env.PORT) : 3000;
-app.listen(PORT, () => {
-  console.log(`Servidor de aplicación escuchando en ${chalk.yellow(`http://localhost:${PORT}`)}`);
-  console.log(chalk.grey(`Comprobando accesibilidad a la db ${chalk.white(process.env.DB_NAME)} del host ${chalk.white(process.env.DB_HOST)} ...`));
-  verificarConexion();
-});
-
-// Healthcheck
-app.get('/health', async (_req, res) => {
-  res.status(200).json({ status: 'ok' });
-});

services/app/src/index.mjs

@@ -0,0 +1,146 @@
+// services/app/src/index.js
+// ------------------------------------------------------------
+// SuiteCoffee — Aplicación Principal (Express)
+// ------------------------------------------------------------
+
+import 'dotenv/config';
+import favicon from 'serve-favicon';        // Favicon
+import session from 'express-session';
+import express from 'express';              // Framework para enderizado de apps Web
+import expressLayouts from 'express-ejs-layouts';
+import { RedisStore } from 'connect-redis';
+
+import { checkRequiredEnvVars } from '@suitecoffee/scripts';
+import { verificarConexionCore, verificarConexionTenants } from '@suitecoffee/db'; // dbCore y dbTenants desde paquete
+import { redisAuthentik, verificarConexionRedisAuthentik} from '@suitecoffee/redis';
+import { requireAuth, datosGlobales, tenantContext, resolveTenantFromCore } from '@suitecoffee/middlewares';
+import { apiv1 } from '@suitecoffee/api'; // Rutas API v1
+
+import expressPages from './views/routes.js'; // Rutas "/", "/dashboard", ...
+import path from 'path';
+import { fileURLToPath } from 'url';        // Converts a file:// URL string or URL object into a platform-specific file 
+import cookieParser from 'cookie-parser';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+// -----------------------------------------------------------------------------
+// Validación de entorno mínimo (ajusta nombres si difieren)
+// -----------------------------------------------------------------------------
+checkRequiredEnvVars(
+  'PORT', 'APP_BASE_URL',
+  'SESSION_SECRET', 'SESSION_NAME', 'AK_REDIS_URL',
+  'OIDC_CLIENT_ID', 'OIDC_REDIRECT_URI',
+  'OIDC_CONFIG_URL' // o 'OIDC_ISSUER'
+);
+
+
+
+// ----------------------------------------------------------
+// Variables del sistema
+// ----------------------------------------------------------
+
+// De entorno
+const PORT            = process.env.PORT;
+const SESSION_NAME    = process.env.SESSION_NAME;
+const SESSION_SECRET  = process.env.SESSION_SECRET;
+const COOKIE_DOMAIN   = process.env.COOKIE_DOMAIN;
+
+
+
+// ----------------------------------------------------------
+// App + Motor de vistas EJS
+// ----------------------------------------------------------
+const app = express();
+app.disable("x-powered-by");
+app.set('trust proxy', true);
+app.set("views", path.join(__dirname, "views/pages"));
+app.set("layout", path.join(__dirname, "views/layouts/main"));
+// app.set("layout", "layouts/main");
+app.set("view engine", "ejs");
+app.use(favicon(path.join(__dirname, 'public', 'favicon', 'favicon.ico'), { maxAge: '1y' }));
+
+app.use(express.json());
+app.use(express.json({ limit: '1mb' }));
+app.use(express.urlencoded({ extended: true }));
+
+app.use(express.static(path.join(__dirname,"public"), { etag: false, maxAge: 0, setHeaders: (res, path) => { res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate'); }}));
+app.use(expressLayouts);
+
+
+
+// -----------------------------------------------------------------------------
+// Redis
+// -----------------------------------------------------------------------------
+await redisAuthentik.connect();
+const redisClient = redisAuthentik.getClient();
+
+
+
+// -----------------------------------------------------------------------------
+// Cookies de sesión
+// -----------------------------------------------------------------------------
+app.use(cookieParser(SESSION_SECRET));
+
+app.use(session({
+  name: SESSION_NAME,
+  store: new RedisStore({ client: redisClient, prefix: 'sess:' }),
+  secret: SESSION_SECRET,
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    httpOnly: true,
+    sameSite: 'lax',                    // 'none' si necesitás third-party estricto
+    secure: process.env.NODE_ENV === 'production',
+    ...(COOKIE_DOMAIN ? { domain: COOKIE_DOMAIN } : {}), // ✅ compatibilidad subdominios
+  },
+}));
+
+
+
+// ----------------------------------------------------------
+// Renderizado de las páginas importadas desde '#pages' + configuración global
+// ----------------------------------------------------------
+// app.use(expressPages); // Renderizado trae las paginas desde ./services/manso/src/routes/routes.js
+// app.use(requireAuth({ redirectTo: '/auth/login' }), expressPages); // Renderizado trae las paginas desde ./services/manso/src/routes/routes.js
+// app.use(requireAuth({ redirectTo: '/auth/login' }), tenantContext({ debug: true }), expressPages); // Renderizado trae las paginas desde ./services/manso/src/routes/routes.js
+
+app.use(
+  requireAuth({ redirectTo: '/auth/login' }),
+  tenantContext({
+    debug: true,
+    resolveTenant: (req, sess) => resolveTenantFromCore(req, sess, { debug: true }),
+    // acceptStates: ['ready'] // (default) o ['ready','provisioning'] si querés permitir provisión
+  }),
+  expressPages
+);
+
+app.use(datosGlobales); 
+
+
+
+
+// ----------------------------------------------------------
+// API v1
+// ----------------------------------------------------------
+app.use("/api/v1", requireAuth({ redirectTo: '/auth/login' }), tenantContext(), apiv1);
+
+// ----------------------------------------------------------
+// Inicio del servidor
+// ----------------------------------------------------------
+
+app.listen(PORT, async () => {
+  console.log(`[APP] SuiteCoffee corriendo en http://localhost:${PORT}`);
+  await verificarConexionCore();
+  await verificarConexionTenants();
+  await verificarConexionRedisAuthentik();
+});
+
+// -----------------------------------------------------------------------------
+// Healthcheck
+// -----------------------------------------------------------------------------
+app.get('/health', (_req, res) => {
+  res.status(200).json({ status: 'ok'})
+  // console.log(`[APP] Saludable`)
+});

services/app/src/pages/comandas.html.bak

@@ -1,355 +0,0 @@
-<!DOCTYPE html>
-<html lang="es">
-<head>
-  <meta charset="utf-8"/>
-  <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Comandas</title>
-  <style>
-    :root { --gap: 12px; --radius: 10px; }
-    * { box-sizing: border-box; }
-    body { margin:0; font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, 'Helvetica Neue', Arial; background:#f6f7fb; color:#111; }
-    header { position: sticky; top: 0; background:#fff; border-bottom:1px solid #e7e7ef; padding:14px 18px; display:flex; gap:10px; align-items:center; z-index:2; }
-    header h1 { margin:0; font-size:16px; font-weight:600; }
-    main { padding: 18px; max-width: 1200px; margin: 0 auto; display:grid; grid-template-columns: 1.15fr 0.85fr; gap: var(--gap); }
-    .card { background:#fff; border:1px solid #e7e7ef; border-radius: var(--radius); }
-    .card .hd { padding:12px 14px; border-bottom:1px solid #eee; display:flex; align-items:center; gap:10px; }
-    .card .bd { padding:14px; }
-    .row { display:flex; gap:10px; align-items:center; flex-wrap: wrap; }
-    .grid { display:grid; gap:10px; }
-    .grid.cols-2 { grid-template-columns: 1fr 1fr; }
-    .muted { color:#666; }
-    select, input, textarea, button { font: inherit; padding:10px; border:1px solid #dadbe4; border-radius:8px; background:#fff; }
-    select:focus, input:focus, textarea:focus { outline:none; border-color:#999; }
-    input[type="number"] { width: 100%; }
-    textarea { width:100%; min-height: 68px; resize: vertical; }
-    button { cursor: pointer; }
-    .btn { padding:10px 12px; border-radius:8px; border:1px solid #dadbe4; background:#fafafa; }
-    .btn.primary { background:#111; border-color:#111; color:#fff; }
-    .btn.ghost { background:#fff; }
-    .btn.small { padding:6px 8px; font-size: 13px; }
-    .pill { font-size:12px; padding:2px 8px; border-radius:99px; border:1px solid #e0e0ea; background:#fafafa; display:inline-block; }
-    .toolbar { display:flex; gap:10px; align-items:center; }
-    .spacer { flex:1 }
-    .search { display:flex; gap:8px; }
-    .search input { flex:1; }
-    table { width:100%; border-collapse: collapse; }
-    thead th { text-align:left; font-size:12px; text-transform: uppercase; letter-spacing:.04em; color:#555; background:#fafafa; }
-    th, td { padding:8px 10px; border-bottom:1px solid #eee; vertical-align: middle; }
-    .qty { display:flex; align-items:center; gap:6px; }
-    .qty input { width: 90px; }
-    .right { text-align:right; }
-    .total { font-size: 22px; font-weight: 700; }
-    .notice { padding:10px; border-radius:8px; border:1px solid #e7e7ef; background:#fafafa; }
-    .ok { color:#0a7d28; }
-    .err { color:#b00020; }
-    .sticky-footer { position: sticky; bottom: 0; background:#fff; padding:12px 14px; border-top:1px solid #eee; display:flex; gap:10px; align-items:center; }
-    .kpi { display:flex; gap:6px; align-items: baseline; }
-  </style>
-</head>
-<body>
-  <header>
-    <h1>📋 Nueva Comanda</h1>
-    <div class="spacer"></div>
-    <span class="pill muted">/api/*</span>
-  </header>
-
-  <main>
-    <!-- Panel izquierdo: productos -->
-    <section class="card" id="panelProductos">
-      <div class="hd">
-        <strong>Productos</strong>
-        <div class="spacer"></div>
-        <div class="toolbar">
-          <span class="muted" id="prodCount">0 ítems</span>
-        </div>
-      </div>
-      <div class="bd">
-        <div class="row search" style="margin-bottom:10px;">
-          <input id="busqueda" type="search" placeholder="Buscar por nombre o categoría…"/>
-          <button class="btn" id="limpiarBusqueda">Limpiar</button>
-        </div>
-        <div id="listadoProductos" style="max-height: 58vh; overflow:auto;">
-          <!-- tabla productos -->
-        </div>
-      </div>
-    </section>
-
-    <!-- Panel derecho: datos + carrito + crear -->
-    <section class="card" id="panelComanda">
-      <div class="hd"><strong>Detalles</strong></div>
-      <div class="bd grid" style="gap:14px;">
-        <div class="grid cols-2">
-          <div>
-            <label class="muted">Mesa</label>
-            <select id="selMesa"></select>
-          </div>
-          <div>
-            <label class="muted">Usuario</label>
-            <select id="selUsuario"></select>
-          </div>
-        </div>
-
-        <div>
-          <label class="muted">Observaciones</label>
-          <textarea id="obs"></textarea>
-        </div>
-
-        <div class="notice muted">La fecha se completa automáticamente y los estados/activos usan sus valores por defecto.</div>
-
-        <div class="card">
-          <div class="hd"><strong>Carrito</strong></div>
-          <div class="bd" id="carritoWrap">
-            <div class="muted">Aún no agregaste productos.</div>
-          </div>
-          <div class="sticky-footer">
-            <div class="kpi"><span class="muted">Ítems:</span><strong id="kpiItems">0</strong></div>
-            <div class="kpi" style="margin-left:8px;"><span class="muted">Total:</span><strong id="kpiTotal">$ 0.00</strong></div>
-            <div class="spacer"></div>
-            <button class="btn ghost" id="vaciar">Vaciar</button>
-            <button class="btn primary" id="crear">Crear Comanda</button>
-          </div>
-        </div>
-
-        <div id="msg" class="muted"></div>
-      </div>
-    </section>
-  </main>
-
-  <script>
-    const $ = (s, r=document) => r.querySelector(s);
-    const $$ = (s, r=document) => Array.from(r.querySelectorAll(s));
-
-    const state = {
-      productos: [],
-      mesas: [],
-      usuarios: [],
-      carrito: [], // [{id_producto, nombre, pre_unitario, cantidad}]
-      filtro: ''
-    };
-
-    // ---------- Utils ----------
-    const money = (n) => (isNaN(n) ? '—' : new Intl.NumberFormat('es-UY', { style:'currency', currency:'UYU' }).format(Number(n)));
-    const toast = (msg, ok=false) => { const el = $('#msg'); el.className = ok ? 'ok' : 'err'; el.textContent = msg; setTimeout(()=>{ el.textContent=''; el.className='muted'; }, 3500); };
-    async function jget(url) {
-      const res = await fetch(url);
-      let data; try { data = await res.json(); } catch { data = null; }
-      if (!res.ok) throw new Error(data?.error || `${res.status} ${res.statusText}`);
-      return data;
-    }
-    async function jpost(url, body) {
-      const res = await fetch(url, { method:'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify(body) });
-      const data = await res.json().catch(()=>null);
-      if (!res.ok) throw new Error(data?.error || `${res.status} ${res.statusText}`);
-      return data;
-    }
-
-    // ---------- Load data ----------
-    async function init() {
-      // productos, mesas, usuarios
-      const [prods, mesas, usuarios] = await Promise.all([
-        jget('/api/table/productos?limit=1000'),
-        jget('/api/table/mesas?limit=1000'),
-        jget('/api/table/usuarios?limit=1000')
-      ]);
-
-      state.productos = prods.filter(p => p.activo !== false); // si existe activo=false, filtrarlo
-      state.mesas = mesas;
-      state.usuarios = usuarios.filter(u => u.activo !== false);
-
-      hydrateMesas();
-      hydrateUsuarios();
-      renderProductos();
-      renderCarrito();
-
-      $('#busqueda').addEventListener('input', () => { state.filtro = $('#busqueda').value.trim().toLowerCase(); renderProductos(); });
-      $('#limpiarBusqueda').addEventListener('click', () => { $('#busqueda').value=''; state.filtro=''; renderProductos(); });
-      $('#vaciar').addEventListener('click', () => { state.carrito=[]; renderCarrito(); });
-      $('#crear').addEventListener('click', crearComanda);
-    }
-
-    function hydrateMesas() {
-      const sel = $('#selMesa'); sel.innerHTML = '';
-      for (const m of state.mesas) {
-        const o = document.createElement('option');
-        o.value = m.id_mesa;
-        o.textContent = `#${m.numero} · ${m.apodo} (${m.estado})`;
-        sel.appendChild(o);
-      }
-    }
-
-    function hydrateUsuarios() {
-      const sel = $('#selUsuario'); sel.innerHTML = '';
-      for (const u of state.usuarios) {
-        const o = document.createElement('option');
-        o.value = u.id_usuario;
-        o.textContent = `${u.nombre} ${u.apellido}`.trim();
-        sel.appendChild(o);
-      }
-    }
-
-    // ---------- Productos ----------
-    function renderProductos() {
-      let rows = state.productos.slice();
-      if (state.filtro) {
-        rows = rows.filter(p =>
-          (p.nombre || '').toLowerCase().includes(state.filtro) ||
-          String(p.id_categoria ?? '').includes(state.filtro)
-        );
-      }
-      $('#prodCount').textContent = `${rows.length} ítems`;
-
-      if (!rows.length) {
-        $('#listadoProductos').innerHTML = '<div class="muted">Sin resultados.</div>';
-        return;
-      }
-
-      const tbl = document.createElement('table');
-      tbl.innerHTML = `
-        <thead>
-          <tr>
-            <th>Producto</th>
-            <th class="right">Precio</th>
-            <th style="width:180px;">Cantidad</th>
-            <th style="width:90px;"></th>
-          </tr>
-        </thead>
-        <tbody></tbody>
-      `;
-      const tb = tbl.querySelector('tbody');
-
-      for (const p of rows) {
-        const tr = document.createElement('tr');
-        tr.innerHTML = `
-          <td>${p.nombre}</td>
-          <td class="right">${money(p.precio)}</td>
-          <td>
-            <div class="qty">
-              <input type="number" min="0.001" step="0.001" value="1.000" data-qty />
-              <button class="btn small" data-dec>-</button>
-              <button class="btn small" data-inc>+</button>
-            </div>
-          </td>
-          <td><button class="btn primary small" data-add>Agregar</button></td>
-        `;
-        const qty = tr.querySelector('[data-qty]');
-        tr.querySelector('[data-dec]').addEventListener('click', () => { qty.value = Math.max(0.001, (parseFloat(qty.value||'0') - 1)).toFixed(3); });
-        tr.querySelector('[data-inc]').addEventListener('click', () => { qty.value = (parseFloat(qty.value||'0') + 1).toFixed(3); });
-        tr.querySelector('[data-add]').addEventListener('click', () => addToCart(p, parseFloat(qty.value||'1')) );
-        tb.appendChild(tr);
-      }
-
-      $('#listadoProductos').innerHTML = '';
-      $('#listadoProductos').appendChild(tbl);
-    }
-
-    function addToCart(prod, cantidad) {
-      if (!(cantidad > 0)) { toast('Cantidad inválida'); return; }
-      const precio = parseFloat(prod.precio);
-      const it = state.carrito.find(i => i.id_producto === prod.id_producto && i.pre_unitario === precio);
-      if (it) it.cantidad = Number((it.cantidad + cantidad).toFixed(3));
-      else state.carrito.push({ id_producto: prod.id_producto, nombre: prod.nombre, pre_unitario: precio, cantidad: Number(cantidad.toFixed(3)) });
-      renderCarrito();
-    }
-
-    // ---------- Carrito ----------
-    function renderCarrito() {
-      const wrap = $('#carritoWrap');
-      if (!state.carrito.length) { wrap.innerHTML = '<div class="muted">Aún no agregaste productos.</div>'; $('#kpiItems').textContent='0'; $('#kpiTotal').textContent=money(0); return; }
-
-      const tbl = document.createElement('table');
-      tbl.innerHTML = `
-        <thead>
-          <tr>
-            <th>Producto</th>
-            <th class="right">Unitario</th>
-            <th class="right">Cantidad</th>
-            <th class="right">Subtotal</th>
-            <th></th>
-          </tr>
-        </thead>
-        <tbody></tbody>
-      `;
-      const tb = tbl.querySelector('tbody');
-
-      let items = 0, total = 0;
-      state.carrito.forEach((it, idx) => {
-        items += 1;
-        const sub = Number(it.pre_unitario) * Number(it.cantidad);
-        total += sub;
-
-        const tr = document.createElement('tr');
-        tr.innerHTML = `
-          <td>${it.nombre}</td>
-          <td class="right">${money(it.pre_unitario)}</td>
-          <td class="right">
-            <input type="number" min="0.001" step="0.001" value="${it.cantidad.toFixed(3)}" style="width:120px"/>
-          </td>
-          <td class="right">${money(sub)}</td>
-          <td class="right">
-            <button class="btn small" data-del>Quitar</button>
-          </td>
-        `;
-        const qty = tr.querySelector('input[type="number"]');
-        qty.addEventListener('change', () => {
-          const v = parseFloat(qty.value||'0');
-          if (!(v>0)) { toast('Cantidad inválida'); qty.value = it.cantidad.toFixed(3); return; }
-          it.cantidad = Number(v.toFixed(3));
-          renderCarrito();
-        });
-        tr.querySelector('[data-del]').addEventListener('click', () => {
-          state.carrito.splice(idx,1);
-          renderCarrito();
-        });
-
-        tb.appendChild(tr);
-      });
-
-      wrap.innerHTML = '';
-      wrap.appendChild(tbl);
-      $('#kpiItems').textContent = String(items);
-      $('#kpiTotal').textContent = money(total);
-    }
-
-    // ---------- Crear comanda ----------
-    async function crearComanda() {
-      if (!state.carrito.length) { toast('Agrega al menos un producto'); return; }
-      const id_mesa = parseInt($('#selMesa').value, 10);
-      const id_usuario = parseInt($('#selUsuario').value, 10);
-      if (!id_mesa || !id_usuario) { toast('Selecciona mesa y usuario'); return; }
-
-      const observaciones = $('#obs').value.trim() || null;
-
-      try {
-        // 1) encabezado comanda (estado por defecto: 'abierta'; fecha la pone la DB)
-        const { inserted: com } = await jpost('/api/table/comandas', {
-          id_usuario,
-          id_mesa,
-          estado: 'abierta',
-          observaciones
-        });
-
-        // 2) detalle (una inserción por renglón)
-        const id_comanda = com.id_comanda;
-        const payloads = state.carrito.map(it => ({
-          id_comanda,
-          id_producto: it.id_producto,
-          cantidad: it.cantidad,
-          pre_unitario: it.pre_unitario
-        }));
-
-        await Promise.all(payloads.map(p => jpost('/api/table/deta_comandas', p)));
-
-        state.carrito = [];
-        renderCarrito();
-        $('#obs').value = '';
-        toast(`Comanda #${id_comanda} creada`, true);
-      } catch (e) {
-        toast(e.message || 'No se pudo crear la comanda');
-      }
-    }
-
-    // GO
-    init().catch(err => toast(err.message || 'Error cargando datos'));
-  </script>
-</body>
-</html>

services/app/src/pages/dashboard.html.bak

@@ -1,293 +0,0 @@
-<!DOCTYPE html>
-<html lang="es">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Dashboard</title>
-  <style>
-    :root { --radius: 10px; }
-    * { box-sizing: border-box; }
-    body { margin:0; font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, 'Helvetica Neue', Arial, 'Noto Sans', 'Apple Color Emoji', 'Segoe UI Emoji'; background:#f6f7fb; color:#111; }
-    header { position: sticky; top: 0; background:#fff; border-bottom:1px solid #e8e8ef; padding:16px 20px; display:flex; gap:12px; align-items:center; z-index:1;}
-    header h1 { margin:0; font-size:18px; font-weight:600;}
-    main { padding: 20px; max-width: 1200px; margin: 0 auto; }
-    .card { background:#fff; border:1px solid #e8e8ef; border-radius: var(--radius); padding:16px; }
-    .row { display:flex; gap:16px; align-items: center; flex-wrap:wrap; }
-    select, input, button, textarea { font: inherit; padding:10px; border-radius:8px; border:1px solid #d7d7e0; background:#fff; }
-    select:focus, input:focus, textarea:focus { outline: none; border-color:#888; }
-    button { cursor:pointer; }
-    button.primary { background:#111; color:#fff; border-color:#111; }
-    table { width:100%; border-collapse: collapse; }
-    thead th { text-align:left; font-size:12px; text-transform: uppercase; letter-spacing:.04em; color:#555; background:#fafafa; }
-    th, td { padding:10px 12px; border-bottom: 1px solid #eee; vertical-align: top; }
-    .muted { color:#666; }
-    .tabs { display:flex; gap:6px; margin-top:12px; }
-    .tab { padding:8px 10px; border:1px solid #e0e0ea; border-bottom:none; background:#fafafa; border-top-left-radius:8px; border-top-right-radius:8px; cursor:pointer; font-size:14px; }
-    .tab.active { background:#fff; border-color:#e0e0ea; }
-    .panel { border:1px solid #e0e0ea; border-radius: 0 8px 8px 8px; padding:16px; background:#fff; }
-    .grid { display:grid; grid-template-columns: repeat(auto-fill,minmax(220px,1fr)); gap:12px; }
-    .help { font-size:12px; color:#777; margin-top:6px; }
-    .pill { font-size:12px; padding:2px 8px; border-radius:99px; border:1px solid #e0e0ea; background:#fafafa; display:inline-block; }
-    .toolbar { display:flex; gap:10px; align-items:center; }
-    .spacer { flex:1 }
-    .error { color:#b00020; }
-    .success { color:#0a7d28; }
-    .sr-only{ position:absolute; width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0;}
-    details summary { cursor:pointer; }
-  </style>
-</head>
-<body>
-  <header>
-    <h1>Dashboard</h1>
-    <div class="spacer"></div>
-    <span class="pill muted">/api/*</span>
-  </header>
-
-  <main class="card">
-    <div class="row" style="margin-bottom:12px;">
-      <label for="tableSelect" class="sr-only">Tabla</label>
-      <select id="tableSelect"></select>
-      <div class="spacer"></div>
-      <div class="toolbar">
-        <button id="refreshBtn">Recargar</button>
-        <span id="status" class="muted"></span>
-      </div>
-    </div>
-
-    <div class="tabs">
-      <button class="tab active" data-tab="datos">Datos</button>
-      <button class="tab" data-tab="nuevo">Nuevo</button>
-      <button class="tab" data-tab="esquema">Esquema</button>
-    </div>
-    <section class="panel" id="panel-datos">
-      <div class="help">Mostrando hasta <span id="limitInfo">100</span> filas.</div>
-      <div id="tableContainer" style="overflow:auto;"></div>
-    </section>
-    <section class="panel" id="panel-nuevo" hidden>
-      <form id="insertForm" class="grid"></form>
-      <div class="row" style="margin-top:10px;">
-        <div class="spacer"></div>
-        <button id="insertBtn" class="primary">Insertar</button>
-      </div>
-      <div id="insertMsg" class="help"></div>
-    </section>
-    <section class="panel" id="panel-esquema" hidden>
-      <pre id="schemaPre" style="white-space:pre-wrap;"></pre>
-    </section>
-
-    <details style="margin-top:16px;">
-      <summary>Endpoints</summary>
-      <div class="help">GET /api/tables • GET /api/schema/:tabla • GET /api/table/:tabla?limit=100 • POST /api/table/:tabla</div>
-    </details>
-  </main>
-
-  <script>
-    const $ = (s, r=document) => r.querySelector(s);
-    const $$ = (s, r=document) => Array.from(r.querySelectorAll(s));
-    const state = { tables: [], table: null, schema: null, limit: 100 };
-
-    // Tabs
-    $$('.tab').forEach(t => t.addEventListener('click', () => {
-      $$('.tab').forEach(x => x.classList.remove('active'));
-      t.classList.add('active');
-      const tab = t.dataset.tab;
-      $('#panel-datos').hidden = tab !== 'datos';
-      $('#panel-nuevo').hidden = tab !== 'nuevo';
-      $('#panel-esquema').hidden = tab !== 'esquema';
-    }));
-
-    $('#refreshBtn').addEventListener('click', () => {
-      if (state.table) {
-        loadSchema(state.table);
-        loadData(state.table);
-      }
-    });
-
-    async function init() {
-      setStatus('Cargando tablas…');
-      const res = await fetch('/api/tables');
-      const tables = await res.json();
-      state.tables = tables;
-      const sel = $('#tableSelect');
-      sel.innerHTML = '';
-      tables.forEach(name => {
-        const o = document.createElement('option');
-        o.value = name; o.textContent = name;
-        sel.appendChild(o);
-      });
-      sel.addEventListener('change', () => selectTable(sel.value));
-      if (tables.length) {
-        selectTable(tables[0]);
-      } else {
-        setStatus('No hay tablas disponibles.');
-      }
-    }
-
-    async function selectTable(tbl) {
-      state.table = tbl;
-      await loadSchema(tbl);
-      await loadData(tbl);
-      buildForm();
-    }
-
-    async function loadSchema(tbl) {
-      const res = await fetch(`/api/schema/${tbl}`);
-      state.schema = await res.json();
-      $('#schemaPre').textContent = JSON.stringify(state.schema, null, 2);
-    }
-
-    async function loadData(tbl) {
-      setStatus('Cargando datos…');
-      const res = await fetch(`/api/table/${tbl}?limit=${state.limit}`);
-      const data = await res.json();
-      $('#limitInfo').textContent = String(state.limit);
-      renderTable(data);
-      clearStatus();
-    }
-
-    function renderTable(rows) {
-      const c = $('#tableContainer');
-      c.innerHTML = '';
-      if (!rows.length) { c.innerHTML = '<div class="muted">Sin datos.</div>'; return; }
-      const headers = Object.keys(rows[0]);
-      const table = document.createElement('table');
-      table.innerHTML = `
-        <thead><tr>${headers.map(h => '<th>'+h+'</th>').join('')}</tr></thead>
-        <tbody></tbody>
-      `;
-      const tbody = table.querySelector('tbody');
-      for (const row of rows) {
-        const tr = document.createElement('tr');
-        tr.innerHTML = headers.map(h => '<td>'+formatCell(row[h])+'</td>').join('');
-        tbody.appendChild(tr);
-      }
-      c.appendChild(table);
-    }
-
-    function formatCell(v) {
-      if (v === null || v === undefined) return '<span class="muted">NULL</span>';
-      if (typeof v === 'boolean') return v ? '✓' : '—';
-      if (typeof v === 'string' && v.match(/^\\d{4}-\\d{2}-\\d{2}/)) return new Date(v).toLocaleString();
-      return String(v);
-    }
-
-    function buildForm() {
-      const form = $('#insertForm');
-      form.innerHTML = '';
-      if (!state.schema) return;
-      for (const col of state.schema.columns) {
-        // Omitir PK auto y columnas generadas
-        if (col.is_primary || col.is_identity || (col.column_default || '').startsWith('nextval(')) continue;
-
-        const wrap = document.createElement('div');
-        const id = 'f_'+col.column_name;
-        wrap.innerHTML = `
-          <label for="${id}" class="muted">${col.column_name} <span class="muted">${col.data_type}</span> ${col.is_nullable ? '' : '<span class="pill">requerido</span>'}</label>
-          <div data-input></div>
-          ${col.column_default ? '<div class="help">DEFAULT: '+col.column_default+'</div>' : ''}
-        `;
-        const holder = wrap.querySelector('[data-input]');
-
-        if (col.foreign) {
-          const sel = document.createElement('select');
-          sel.id = id;
-          holder.appendChild(sel);
-          hydrateOptions(sel, state.schema.table, col.column_name);
-        } else if (col.data_type.includes('boolean')) {
-          const inp = document.createElement('input');
-          inp.id = id; inp.type = 'checkbox';
-          holder.appendChild(inp);
-        } else if (col.data_type.includes('timestamp')) {
-          const inp = document.createElement('input');
-          inp.id = id; inp.type = 'datetime-local'; inp.required = !col.is_nullable && !col.column_default;
-          holder.appendChild(inp);
-        } else if (col.data_type.includes('date')) {
-          const inp = document.createElement('input');
-          inp.id = id; inp.type = 'date'; inp.required = !col.is_nullable && !col.column_default;
-          holder.appendChild(inp);
-        } else if (col.data_type.match(/numeric|integer|real|double/)) {
-          const inp = document.createElement('input');
-          inp.id = id; inp.type = 'number'; inp.step = 'any'; inp.required = !col.is_nullable && !col.column_default;
-          holder.appendChild(inp);
-        } else if (col.data_type.includes('text') || col.data_type.includes('character')) {
-          const inp = document.createElement('input');
-          inp.id = id; inp.type = 'text'; inp.required = !col.is_nullable && !col.column_default;
-          holder.appendChild(inp);
-        } else {
-          const inp = document.createElement('input');
-          inp.id = id; inp.type = 'text'; inp.required = !col.is_nullable && !col.column_default;
-          holder.appendChild(inp);
-        }
-        form.appendChild(wrap);
-      }
-    }
-
-    async function hydrateOptions(selectEl, table, column) {
-      selectEl.innerHTML = '<option value="">Cargando…</option>';
-      const res = await fetch(`/api/options/${table}/${column}`);
-      const opts = await res.json();
-      selectEl.innerHTML = '<option value="">Seleccione…</option>' + opts.map(o => `<option value="${o.id}">${o.label}</option>`).join('');
-    }
-
-    $('#insertBtn').addEventListener('click', async (e) => {
-      e.preventDefault();
-      if (!state.table) return;
-      const payload = {};
-      for (const col of state.schema.columns) {
-        if (col.is_primary || col.is_identity || (col.column_default || '').startsWith('nextval(')) continue;
-        const id = 'f_'+col.column_name;
-        const el = document.getElementById(id);
-        if (!el) continue;
-
-        let val = null;
-        if (el.type === 'checkbox') {
-          val = el.checked;
-        } else if (el.type === 'datetime-local' && el.value) {
-          // Convertir a ISO
-          val = new Date(el.value).toISOString().slice(0,19).replace('T',' ');
-        } else if (el.tagName === 'SELECT') {
-          val = el.value ? (isNaN(el.value) ? el.value : Number(el.value)) : null;
-        } else if (el.type === 'number') {
-          val = el.value === '' ? null : Number(el.value);
-        } else {
-          val = el.value === '' ? null : el.value;
-        }
-
-        if (val === null && !col.is_nullable && !col.column_default) {
-          showInsertMsg('Completa: '+col.column_name, true);
-          return;
-        }
-        if (val !== null) payload[col.column_name] = val;
-      }
-
-      try {
-        const res = await fetch(`/api/table/${state.table}`, {
-          method: 'POST',
-          headers: { 'Content-Type':'application/json' },
-          body: JSON.stringify(payload)
-        });
-        const data = await res.json();
-        if (!res.ok) throw new Error(data.error || 'Error');
-        showInsertMsg('Insertado correctamente (id: '+(data.inserted?.id || '?')+')', false);
-        // Reset form
-        $('#insertForm').reset?.();
-        await loadData(state.table);
-      } catch (e) {
-        showInsertMsg(e.message, true);
-      }
-    });
-
-    function showInsertMsg(msg, isError=false) {
-      const m = $('#insertMsg');
-      m.className = 'help ' + (isError ? 'error' : 'success');
-      m.textContent = msg;
-    }
-
-    function setStatus(text) { $('#status').textContent = text; }
-    function clearStatus() { setStatus(''); }
-
-    // Start
-    init();
-  </script>
-</body>
-</html>

services/app/src/pages/estadoComandas.html.bak

@@ -1,280 +0,0 @@
-<!-- pages/estadoComandas.html -->
-<!DOCTYPE html>
-<html lang="es">
-<head>
-  <meta charset="utf-8"/>
-  <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Estado de Comandas</title>
-  <style>
-    :root { --gap: 12px; --radius: 10px; }
-    * { box-sizing: border-box; }
-    body { margin:0; font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, 'Helvetica Neue', Arial; background:#f6f7fb; color:#111; }
-    header { position: sticky; top: 0; background:#fff; border-bottom:1px solid #e7e7ef; padding:14px 18px; display:flex; gap:10px; align-items:center; z-index:2; }
-    header h1 { margin:0; font-size:16px; font-weight:600; }
-    main { padding: 18px; max-width: 1200px; margin: 0 auto; display:grid; grid-template-columns: 0.9fr 1.1fr; gap: var(--gap); }
-    .card { background:#fff; border:1px solid #e7e7ef; border-radius: var(--radius); }
-    .card .hd { padding:12px 14px; border-bottom:1px solid #eee; display:flex; align-items:center; gap:10px; }
-    .card .bd { padding:14px; }
-    .row { display:flex; gap:10px; align-items:center; flex-wrap: wrap; }
-    .grid { display:grid; gap:10px; }
-    .muted { color:#666; }
-    .pill { font-size:12px; padding:2px 8px; border-radius:99px; border:1px solid #e0e0ea; background:#fafafa; display:inline-block; }
-    .list { max-height: 70vh; overflow:auto; }
-    .list table { width:100%; border-collapse: collapse; }
-    .list th, .list td { padding:8px 10px; border-bottom:1px solid #eee; }
-    .list thead th { text-align:left; font-size:12px; text-transform: uppercase; letter-spacing:.04em; color:#555; background:#fafafa; }
-    .right { text-align:right; }
-    .btn { padding:10px 12px; border-radius:8px; border:1px solid #dadbe4; background:#fafafa; cursor:pointer; }
-    .btn.primary { background:#111; color:#fff; border-color:#111; }
-    .btn.danger { background:#b00020; color:#fff; border-color:#b00020; }
-    .btn.small { font-size: 13px; padding:6px 8px; }
-    select, input, textarea { font: inherit; padding:10px; border:1px solid #dadbe4; border-radius:8px; background:#fff; }
-    .kpi { display:flex; gap:6px; align-items: baseline; }
-    .sticky-footer { position: sticky; bottom: 0; background:#fff; padding:12px 14px; border-top:1px solid #eee; display:flex; gap:10px; align-items:center; }
-    .ok { color:#0a7d28; }
-    .err { color:#b00020; }
-    .tag { font-size:12px; padding:2px 8px; border-radius:6px; border:1px solid #e7e7ef; background:#fafafa; }
-    .tag.abierta { border-color:#0a7d28; color:#0a7d28; }
-    .tag.cerrada { border-color:#555; color:#555; }
-    .tag.pagada { border-color:#1b5e20; color:#1b5e20; }
-    .tag.anulada { border-color:#b00020; color:#b00020; }
-    table { width:100%; border-collapse: collapse; }
-    th, td { padding:8px 10px; border-bottom:1px solid #eee; }
-    thead th { text-align:left; font-size:12px; text-transform: uppercase; letter-spacing:.04em; color:#555; background:#fafafa; }
-  </style>
-</head>
-<body>
-  <header>
-    <h1>🧾 Estado de Comandas</h1>
-    <div style="flex:1"></div>
-    <a class="pill" href="/comandas">➕ Nueva comanda</a>
-  </header>
-
-  <main>
-    <!-- Izquierda: listado -->
-    <section class="card">
-      <div class="hd">
-        <strong>Listado</strong>
-        <div style="flex:1"></div>
-        <label class="muted" style="display:flex; gap:6px; align-items:center;">
-          <input id="soloAbiertas" type="checkbox" checked />
-          Solo abiertas
-        </label>
-      </div>
-      <div class="bd">
-        <div class="row" style="margin-bottom:10px;">
-          <input id="buscar" type="search" placeholder="Buscar por #, mesa o usuario…" style="flex:1"/>
-          <button class="btn" id="limpiar">Limpiar</button>
-        </div>
-        <div class="list" id="lista"></div>
-      </div>
-    </section>
-
-    <!-- Derecha: detalle -->
-    <section class="card">
-      <div class="hd">
-        <strong>Detalle</strong>
-        <div style="flex:1"></div>
-        <span id="detalleEstado" class="tag">—</span>
-      </div>
-      <div class="bd" id="detalle">
-        <div class="muted">Selecciona una comanda para ver el detalle.</div>
-      </div>
-      <div class="sticky-footer">
-        <div class="kpi"><span class="muted">ID:</span><strong id="kpiId">—</strong></div>
-        <div class="kpi" style="margin-left:8px;"><span class="muted">Mesa:</span><strong id="kpiMesa">—</strong></div>
-        <div class="kpi" style="margin-left:8px;"><span class="muted">Total:</span><strong id="kpiTotal">$ 0.00</strong></div>
-        <div style="flex:1"></div>
-        <button class="btn" id="reabrir">Reabrir</button>
-        <button class="btn primary" id="cerrar">Cerrar</button>
-      </div>
-      <div class="bd">
-        <div id="msg" class="muted"></div>
-      </div>
-    </section>
-  </main>
-
-  <script>
-    const $ = (s, r=document) => r.querySelector(s);
-    const $$ = (s, r=document) => Array.from(r.querySelectorAll(s));
-
-    const state = {
-      filtro: '',
-      soloAbiertas: true,
-      lista: [],   // [{ id_comanda, mesa_numero, mesa_apodo, usuario_nombre, usuario_apellido, fec_creacion, estado, observaciones }]
-      sel: null,   // id seleccionado
-      detalle: []  // [{ id_det_comanda, producto_nombre, cantidad, pre_unitario, subtotal, observaciones }]
-    };
-
-    const money = (n) => (isNaN(n) ? '—' : new Intl.NumberFormat('es-UY', { style:'currency', currency:'UYU' }).format(Number(n)));
-    const toast = (msg, ok=false) => { const el = $('#msg'); el.className = ok ? 'ok' : 'err'; el.textContent = msg; setTimeout(()=>{ el.textContent=''; el.className='muted'; }, 3500); };
-
-    async function jget(url) {
-      const res = await fetch(url);
-      const data = await res.json().catch(()=>null);
-      if (!res.ok) throw new Error(data?.error || `${res.status} ${res.statusText}`);
-      return data;
-    }
-    async function jpost(url, body) {
-      const res = await fetch(url, { method:'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify(body) });
-      const data = await res.json().catch(()=>null);
-      if (!res.ok) throw new Error(data?.error || `${res.status} ${res.statusText}`);
-      return data;
-    }
-
-    // ----------- Data -----------
-    async function loadLista() {
-      const estado = state.soloAbiertas ? 'abierta' : '';
-      const url = estado ? `/api/comandas?estado=${encodeURIComponent(estado)}&limit=300` : '/api/comandas?limit=300';
-      const rows = await jget(url);
-      state.lista = rows;
-      renderLista();
-    }
-
-    async function loadDetalle(id) {
-      const det = await jget(`/api/comandas/${id}/detalle`);
-      state.detalle = det;
-      renderDetalle();
-    }
-
-    // ----------- UI: Lista -----------
-    function renderLista() {
-      let rows = state.lista.slice();
-      const f = state.filtro;
-      if (f) {
-        const k = f.toLowerCase();
-        rows = rows.filter(r =>
-          String(r.id_comanda).includes(k) ||
-          (String(r.mesa_numero ?? '').includes(k)) ||
-          ((`${r.usuario_nombre||''} ${r.usuario_apellido||''}`).toLowerCase().includes(k))
-        );
-      }
-      const box = $('#lista');
-      if (!rows.length) { box.innerHTML = '<div class="muted">Sin resultados.</div>'; return; }
-
-      const tbl = document.createElement('table');
-      tbl.innerHTML = `
-        <thead>
-          <tr>
-            <th>#</th>
-            <th>Mesa</th>
-            <th>Usuario</th>
-            <th>Fecha</th>
-            <th>Estado</th>
-            <th class="right">Items</th>
-            <th class="right">Total</th>
-          </tr>
-        </thead>
-        <tbody></tbody>
-      `;
-      const tb = tbl.querySelector('tbody');
-
-      rows.forEach(r => {
-        const tr = document.createElement('tr');
-        tr.style.cursor = 'pointer';
-        tr.innerHTML = `
-          <td>${r.id_comanda}</td>
-          <td>#${r.mesa_numero} · ${r.mesa_apodo || ''}</td>
-          <td>${(r.usuario_nombre||'') + ' ' + (r.usuario_apellido||'')}</td>
-          <td>${new Date(r.fec_creacion).toLocaleString()}</td>
-          <td><span class="tag ${r.estado}">${r.estado}</span></td>
-          <td class="right">${r.items ?? '—'}</td>
-          <td class="right">${money(r.total ?? 0)}</td>
-        `;
-        tr.addEventListener('click', () => { state.sel = r.id_comanda; loadDetalle(r.id_comanda); applyHeader(r); });
-        tb.appendChild(tr);
-      });
-
-      box.innerHTML = '';
-      box.appendChild(tbl);
-    }
-
-    // ----------- UI: Detalle -----------
-    function applyHeader(r) {
-      $('#kpiId').textContent = r.id_comanda ?? '—';
-      $('#kpiMesa').textContent = r.mesa_numero ? `#${r.mesa_numero}` : '—';
-      $('#detalleEstado').className = `tag ${r.estado}`;
-      $('#detalleEstado').textContent = r.estado;
-      $('#kpiTotal').textContent = money(r.total ?? 0);
-
-      // Botones según estado
-      const cerr = $('#cerrar'), reab = $('#reabrir');
-      if (r.estado === 'abierta') {
-        cerr.disabled = false; cerr.title = '';
-        reab.disabled = true;  reab.title = 'Ya está abierta';
-      } else {
-        cerr.disabled = false; // permitir cerrar (idempotente/override)
-        reab.disabled = false;
-      }
-    }
-
-    function renderDetalle() {
-      const box = $('#detalle');
-      if (!state.detalle.length) { box.innerHTML = '<div class="muted">Sin detalle.</div>'; return; }
-
-      const tbl = document.createElement('table');
-      tbl.innerHTML = `
-        <thead>
-          <tr>
-            <th>Producto</th>
-            <th class="right">Unitario</th>
-            <th class="right">Cantidad</th>
-            <th class="right">Subtotal</th>
-            <th>Observaciones</th>
-          </tr>
-        </thead>
-        <tbody></tbody>
-      `;
-      const tb = tbl.querySelector('tbody');
-
-      let total = 0;
-      state.detalle.forEach(r => {
-        total += Number(r.subtotal||0);
-        const tr = document.createElement('tr');
-        tr.innerHTML = `
-          <td>${r.producto_nombre}</td>
-          <td class="right">${money(r.pre_unitario)}</td>
-          <td class="right">${Number(r.cantidad).toFixed(3)}</td>
-          <td class="right">${money(r.subtotal)}</td>
-          <td>${r.observaciones||''}</td>
-        `;
-        tb.appendChild(tr);
-      });
-
-      box.innerHTML = '';
-      box.appendChild(tbl);
-      $('#kpiTotal').textContent = money(total);
-    }
-
-    // ----------- Actions -----------
-    async function setEstado(estado) {
-      if (!state.sel) return;
-      try {
-        const { updated } = await jpost(`/api/comandas/${state.sel}/estado`, { estado });
-        toast(`Comanda #${updated.id_comanda} → ${updated.estado}`, true);
-        await loadLista();
-        // mantener seleccionada si sigue existiendo en filtro
-        const found = state.lista.find(x => x.id_comanda === updated.id_comanda);
-        if (found) { applyHeader(found); await loadDetalle(found.id_comanda); }
-        else {
-          state.sel = null;
-          $('#detalle').innerHTML = '<div class="muted">Selecciona una comanda para ver el detalle.</div>';
-          $('#detalleEstado').textContent = '—'; $('#detalleEstado').className = 'tag';
-          $('#kpiId').textContent = '—'; $('#kpiMesa').textContent='—'; $('#kpiTotal').textContent = money(0);
-        }
-      } catch (e) {
-        toast(e.message || 'No se pudo cambiar el estado');
-      }
-    }
-
-    // ----------- Init -----------
-    $('#soloAbiertas').addEventListener('change', async (e) => { state.soloAbiertas = e.target.checked; await loadLista(); });
-    $('#buscar').addEventListener('input', () => { state.filtro = $('#buscar').value.trim(); renderLista(); });
-    $('#limpiar').addEventListener('click', () => { $('#buscar').value=''; state.filtro=''; renderLista(); });
-    $('#cerrar').addEventListener('click', () => setEstado('cerrada'));
-    $('#reabrir').addEventListener('click', () => setEstado('abierta'));
-
-    (async function main(){ try { await loadLista(); } catch(e){ toast(e.message||'Error cargando comandas'); }})();
-  </script>
-</body>
-</html>

services/app/src/public/scripts/comandas/comandas.mjs

@@ -0,0 +1,341 @@
+// services/app/src/public/scripts/comandas/index.mjs
+// ------------------------------------------------------------
+// SuiteCoffee — Comandas (frontend script)
+// - Resuelve el schema activo desde la sesión (/auth/debug/session)
+// - Setea header X-Tenant-Schema en todos los fetch
+// - Asegura envío de cookies (credentials:'same-origin')
+// - Carga y cachea el catálogo de productos (descubrimiento de endpoint)
+// - Expone helpers globales (jget/jpost/jput/jdel, getActiveSchema, productos)
+// ------------------------------------------------------------
+
+'use strict';
+
+/* =======================
+ * Utils
+ * ======================= */
+const noDash = (v) => (v == null ? '' : String(v).replace(/-/g, ''));
+const isJson = (res) => (res.headers.get('content-type') || '').includes('application/json');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const byId = (id) => document.getElementById(id);
+
+/* =======================
+ * Tenant schema cache
+ * ======================= */
+let SC_ACTIVE_SCHEMA = null;
+
+/**
+ * Lee la sesión desde /auth/debug/session y determina el esquema activo.
+ * Prioriza:
+ *  1) user.active_schema / user.activeSchema
+ *  2) membership de user.current_tenant / user.currentTenant
+ *  3) primer membership disponible
+ * Lanza Error si no puede determinarlo.
+ */
+async function getActiveSchema() {
+  if (SC_ACTIVE_SCHEMA) return SC_ACTIVE_SCHEMA;
+
+  let ses = null;
+  try {
+    const res = await fetch('/auth/debug/session', { credentials: 'same-origin' });
+    ses = res.ok ? await res.json() : null;
+  } catch (_) { /* ignore */ }
+
+  const u = ses?.user ?? null;
+  const memberships = Array.isArray(u?.memberships) ? u.memberships : [];
+
+  // 1) Esquema activo directo
+  let schema =
+    u?.active_schema ||
+    u?.activeSchema ||
+    // 2) Membership del current tenant
+    memberships.find(
+      (m) =>
+        String(m.tenant_id) === String(u?.current_tenant) ||
+        String(m.tenantId) === String(u?.currentTenant)
+    )?.schema_name ||
+    // 3) Primer membership
+    memberships[0]?.schema_name ||
+    null;
+
+  if (!schema) throw new Error('Sesión inválida o tenant no seleccionado');
+
+  SC_ACTIVE_SCHEMA = schema;
+  return SC_ACTIVE_SCHEMA;
+}
+
+/* =======================
+ * Fetch helpers (con schema)
+ * ======================= */
+async function buildHeaders(extra = {}) {
+  const schema = await getActiveSchema();
+  return { Accept: 'application/json', 'X-Tenant-Schema': schema, ...extra };
+}
+
+async function jfetch(url, opts = {}) {
+  const headers = await buildHeaders(opts.headers || {});
+  const res = await fetch(url, {
+    ...opts,
+    headers,
+    credentials: 'same-origin', // imprescindible para que viajen las cookies
+  });
+
+  let payload = null;
+  try {
+    payload = isJson(res) ? await res.json() : await res.text();
+  } catch (_) { /* ignore parse errors */ }
+
+  if (!res.ok) {
+    const msg = (payload && payload.error) || `${res.status} ${res.statusText}`;
+    throw new Error(msg);
+  }
+  return payload;
+}
+
+async function jget(url)  { return jfetch(url, { method: 'GET'  }); }
+async function jpost(url, body) {
+  return jfetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body ?? {}) });
+}
+async function jput(url, body)  {
+  return jfetch(url, { method: 'PUT',  headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body ?? {}) });
+}
+async function jdel(url, body)  {
+  return jfetch(url, { method: 'DELETE', headers: { 'Content-Type': 'application/json' }, body: body ? JSON.stringify(body) : undefined });
+}
+
+/* =======================
+ * Productos (catálogo)
+ * - Descubre endpoint
+ * - Cachea y normaliza
+ * ======================= */
+const productos = (() => {
+  // Posibles endpoints (se prueban en orden)
+  const CANDIDATES = [
+    '/api/v1/productos?limit=1000',
+    '/api/v1/productos',
+    '/api/v1/catalogo?limit=1000',
+    '/api/v1/catalogo',
+    '/api/v1/items?limit=1000',
+    '/api/v1/items',
+  ];
+
+  // Estado en memoria
+  let discoveredEndpoint = null;
+  let cache = /** @type {Array| null} */(null);
+  let lastLoadedAt = null;
+
+  // Normalización a { id, nombre, precio, categoria?, activo? }
+  function normalizeOne(p) {
+    const id =
+      p.id ?? p.id_producto ?? p.producto_id ?? p.productId ?? p.pk ?? null;
+
+    const nombre =
+      p.nombre ?? p.producto_nombre ?? p.name ?? p.titulo ?? p.title ?? '';
+
+    const precio =
+      p.precio ?? p.price ?? p.pre_unitario ?? p.pu ?? p.monto ?? 0;
+
+    const categoria =
+      p.categoria ?? p.category ?? p.nombre_categoria ?? null;
+
+    const activo =
+      p.activo ?? p.enabled ?? p.habilitado ?? true;
+
+    return { id, nombre, precio, categoria, activo, raw: p };
+  }
+
+  function normalizePayload(data) {
+    if (Array.isArray(data)) return data.map(normalizeOne);
+    // objetos comunes: { items: [...] } | { rows: [...] } | { data: [...] }
+    const arr = data?.items || data?.rows || data?.data || data?.productos || null;
+    return Array.isArray(arr) ? arr.map(normalizeOne) : [];
+  }
+
+  async function discoverEndpoint() {
+    // si ya lo descubrimos, reusar
+    if (discoveredEndpoint) return discoveredEndpoint;
+
+    for (const url of CANDIDATES) {
+      try {
+        const data = await jget(url);
+        const list = normalizePayload(data);
+        if (list.length >= 0) { // aceptar 0+ items (catálogo vacío)
+          discoveredEndpoint = url;
+          cache = list;
+          lastLoadedAt = new Date();
+          return discoveredEndpoint;
+        }
+      } catch (_) {
+        // probar el siguiente
+      }
+    }
+    throw new Error('No se pudo descubrir el endpoint de productos');
+  }
+
+  async function ensureLoaded({ force = false } = {}) {
+    await discoverEndpoint();
+    if (!force && cache && Array.isArray(cache)) return cache;
+
+    // recargar desde endpoint descubierto
+    const base = discoveredEndpoint.split('?')[0];
+    const url  = base.includes('?') ? base : `${base}?limit=1000`;
+    const data = await jget(url);
+    cache = normalizePayload(data);
+    lastLoadedAt = new Date();
+    return cache;
+  }
+
+  function all() {
+    return Array.isArray(cache) ? cache.slice() : [];
+  }
+
+  function search(q) {
+    const term = String(q || '').trim().toLowerCase();
+    if (!term) return all();
+    return all().filter(p =>
+      String(p.nombre || '').toLowerCase().includes(term) ||
+      String(p.categoria || '').toLowerCase().includes(term)
+    );
+  }
+
+  function getById(id) {
+    return all().find(p => String(p.id) === String(id)) || null;
+  }
+
+  // Renderización opcional si existe algún selector en la página
+  function renderSelect({ selectorList = ['#productos', '#selProducto', 'select[name="producto"]'] } = {}) {
+    const el = selectorList.map((s) => document.querySelector(s)).find(Boolean);
+    if (!el) return; // nada que renderizar
+
+    const list = all();
+    if (el.tagName === 'SELECT') {
+      el.innerHTML = ''; // limpiar
+      const opt0 = document.createElement('option');
+      opt0.value = ''; opt0.textContent = '— Seleccionar producto —';
+      el.appendChild(opt0);
+
+      for (const p of list) {
+        const opt = document.createElement('option');
+        opt.value = p.id;
+        opt.textContent = `${p.nombre} — ${formatPrecio(p.precio)}`;
+        el.appendChild(opt);
+      }
+    } else {
+      // contenedor genérico (lista)
+      el.innerHTML = '';
+      const ul = document.createElement('ul');
+      ul.className = 'lista-productos';
+      for (const p of list) {
+        const li = document.createElement('li');
+        li.textContent = `${p.nombre} — ${formatPrecio(p.precio)}`;
+        li.dataset.productId = p.id;
+        ul.appendChild(li);
+      }
+      el.appendChild(ul);
+    }
+  }
+
+  function bindSearch({ inputSelectors = ['#buscarProducto', 'input[name="buscar_producto"]'], selectorList } = {}) {
+    const input = inputSelectors.map((s) => document.querySelector(s)).find(Boolean);
+    if (!input) return;
+
+    input.addEventListener('input', () => {
+      const q = input.value;
+      const list = search(q);
+      // re-render mínimo para SELECTs
+      const el = selectorList?.map((s) => document.querySelector(s)).find(Boolean)
+        || document.querySelector('#selProducto')
+        || document.querySelector('#productos');
+      if (!el) return;
+
+      if (el.tagName === 'SELECT') {
+        el.innerHTML = '';
+        const opt0 = document.createElement('option');
+        opt0.value = ''; opt0.textContent = '— Seleccionar producto —';
+        el.appendChild(opt0);
+
+        for (const p of list) {
+          const opt = document.createElement('option');
+          opt.value = p.id;
+          opt.textContent = `${p.nombre} — ${formatPrecio(p.precio)}`;
+          el.appendChild(opt);
+        }
+      } else {
+        el.innerHTML = '';
+        const ul = document.createElement('ul');
+        ul.className = 'lista-productos';
+        for (const p of list) {
+          const li = document.createElement('li');
+          li.textContent = `${p.nombre} — ${formatPrecio(p.precio)}`;
+          li.dataset.productId = p.id;
+          ul.appendChild(li);
+        }
+        el.appendChild(ul);
+      }
+    });
+  }
+
+  function formatPrecio(v) {
+    const n = Number(v || 0);
+    try { return n.toLocaleString(undefined, { style: 'currency', currency: 'UYU' }); }
+    catch { return `${n.toFixed(2)} UYU`; }
+  }
+
+  return {
+    ensureLoaded,
+    all,
+    search,
+    getById,
+    renderSelect,
+    bindSearch,
+    get endpoint() { return discoveredEndpoint; },
+    get lastLoadedAt() { return lastLoadedAt; },
+  };
+})();
+
+/* =======================
+ * Init de página
+ * ======================= */
+async function initPage() {
+  // 1) Fijar esquema activo (lanza si no hay sesión/tenant)
+  await getActiveSchema();
+
+  // 2) Cargar catálogo de productos (descubrimiento + caché)
+  await productos.ensureLoaded().catch((e) => {
+    console.error('[productos.ensureLoaded] fallo:', e);
+    // No cortamos la init de la página; pero mostramos feedback
+    alert(e?.message || 'No fue posible cargar el catálogo de productos');
+  });
+
+  // 3) Render opcional si existen selectores conocidos
+  productos.renderSelect({ selectorList: ['#selProducto', '#productos', 'select[name="producto"]'] });
+  productos.bindSearch({ inputSelectors: ['#buscarProducto', 'input[name="buscar_producto"]'], selectorList: ['#selProducto', '#productos'] });
+
+  // 4) Hooks opcionales del código original (si existen)
+  if (window.nueva?.init)   await window.nueva.init();
+  if (window.estado?.bind)  window.estado.bind();
+  if (window.estado?.loadLista) await window.estado.loadLista();
+}
+
+/* =======================
+ * Arranque
+ * ======================= */
+document.addEventListener('DOMContentLoaded', async () => {
+  try {
+    await initPage();
+  } catch (err) {
+    console.error('Error:', err);
+    alert(err?.message || 'Error inicializando Comandas');
+  }
+});
+
+/* =======================
+ * Export helpers globales
+ * ======================= */
+Object.assign(window, {
+  jget,
+  jpost,
+  jput,
+  jdel,
+  getActiveSchema,
+  productos,
+});