// src/errores/error-api.js

/**
 * Error de dominio de la API.
 *
 * Lleva la información necesaria para construir la respuesta, pero se lanza
 * desde los servicios sin que estos sepan nada de Express: 'estado' es un
 * número, no una llamada a res.status().
 */
export class ErrorApi extends Error {
  /**
   * @param {number} estado    Código HTTP (404, 409, ...)
   * @param {string} codigo    Código del catálogo de 02-04 ('cafe_no_encontrado')
   * @param {string} mensaje   Mensaje legible para el consumidor
   * @param {object[]} detalles Lista de problemas concretos; SIEMPRE presente
   */
  constructor(estado, codigo, mensaje, detalles = []) {
    super(mensaje);

    // Sin esto, error.name sería 'Error' y los logs perderían información.
    this.name = 'ErrorApi';
    this.estado = estado;
    this.codigo = codigo;
    this.detalles = detalles;

    // Marca explícita: el middleware la usa para distinguir un error
    // previsto del catálogo de un fallo inesperado del programa.
    this.esErrorApi = true;

    // Recorta la traza para que empiece donde se lanzó, no en el constructor.
    Error.captureStackTrace?.(this, ErrorApi);
  }
}

// src/errores/error-api.js  (continuación)

export const errores = {
  // --- 400 ---
  datosInvalidos(detalles = []) {
    return new ErrorApi(
      400,
      'datos_invalidos',
      'El cuerpo de la petición contiene errores de validación.',
      detalles
    );
  },

  parametroInvalido(detalles = []) {
    return new ErrorApi(
      400,
      'parametro_invalido',
      'Los parámetros de la petición contienen errores.',
      detalles
    );
  },

  // --- 401 ---
  noAutenticado(mensaje = 'Se requiere autenticación para esta operación.') {
    return new ErrorApi(401, 'no_autenticado', mensaje);
  },

  tokenCaducado() {
    return new ErrorApi(401, 'token_caducado', 'El token ha caducado. Inicia sesión de nuevo.');
  },

  // --- 403 ---
  permisoDenegado(rolesPermitidos = []) {
    const detalle =
      rolesPermitidos.length > 0
        ? ` Se requiere uno de estos roles: ${rolesPermitidos.join(', ')}.`
        : '';
    return new ErrorApi(403, 'permisos_insuficientes', `No tienes permiso.${detalle}`);
  },

  // --- 404 ---
  noEncontrado(tipo, id) {
    // Mapa entidad → código del catálogo. Un tipo nuevo se añade aquí.
    const codigos = {
      cafe: 'cafe_no_encontrado',
      cliente: 'cliente_no_encontrado',
      pedido: 'pedido_no_encontrado',
      resena: 'resena_no_encontrada',
      carrito: 'carrito_no_encontrado',
    };
    return new ErrorApi(
      404,
      codigos[tipo] ?? 'ruta_no_encontrada',
      `No existe ning${tipo === 'resena' ? 'una' : 'ún'} ${tipo} con el identificador '${id}'.`
    );
  },

  rutaNoEncontrada(metodo, url) {
    return new ErrorApi(404, 'ruta_no_encontrada', `No existe el recurso ${metodo} ${url}.`);
  },

  // --- 405 / 409 / 413 / 415 ---
  metodoNoPermitido(metodo, ruta) {
    return new ErrorApi(405, 'metodo_no_permitido', `${metodo} no está permitido sobre ${ruta}.`);
  },

  conflicto(codigo, mensaje, detalles = []) {
    return new ErrorApi(409, codigo, mensaje, detalles);
  },

  cuerpoDemasiadoGrande() {
    return new ErrorApi(413, 'cuerpo_demasiado_grande', 'El cuerpo supera el tamaño máximo (100 kB).');
  },

  formatoNoSoportado(tipo) {
    return new ErrorApi(
      415,
      'formato_no_soportado',
      `El tipo de contenido '${tipo}' no se admite en esta operación.`
    );
  },

  // --- 500 ---
  errorInterno() {
    return new ErrorApi(500, 'error_interno', 'Se ha producido un error inesperado.');
  },
};

// ANTES: convenios ad hoc que el controlador tenía que conocer
obtener(id) {
  return repositorioCafes.buscarPorId(id);   // undefined si no existe
},

// src/servicios/cafes.js  (modificado)
import { errores } from '../errores/error-api.js';

export const servicioCafes = {
  /** Devuelve un café. Lanza si no existe. */
  obtener(id) {
    const cafe = repositorioCafes.buscarPorId(id);
    if (!cafe) throw errores.noEncontrado('cafe', id);
    return cafe;
  },

  reemplazar(id, datos) {
    this.obtener(id);   // lanza 404 si no existe: sin duplicar el mensaje
    return repositorioCafes.actualizar(id, { /* ...campos... */ });
  },

  borrar(id) {
    if (!repositorioCafes.borrar(id)) throw errores.noEncontrado('cafe', id);
  },
};

// src/servicios/pedidos.js  (modificado)
import { errores } from '../errores/error-api.js';
import { crearPedidoAtomico } from '../repositorios/pedidos-sqlite.js';

export const servicioPedidos = {
  obtenerPara(id, usuario) {
    const pedido = repositorioPedidos.buscarPorId(id);
    const esPersonal = ['empleado', 'administrador'].includes(usuario.rol);

    // Pedido inexistente y pedido ajeno dan EXACTAMENTE el mismo error,
    // para no filtrar la existencia (03-06, sección 14).
    if (!pedido || (pedido.clienteId !== usuario.id && !esPersonal)) {
      throw errores.noEncontrado('pedido', id);
    }
    return pedido;
  },

  crear({ clienteId, lineas }) {
    try {
      const id = crearPedidoAtomico({ clienteId, lineas });
      return repositorioPedidos.buscarPorId(id);
    } catch (error) {
      // El repositorio lanza errores con 'codigoDominio' (03-05); aquí se
      // convierten en ErrorApi. La traducción vive en el servicio porque
      // es él quien decide que un stock insuficiente es un 409.
      if (error.codigoDominio === 'stock_insuficiente') {
        throw errores.conflicto('stock_insuficiente', error.message);
      }
      if (error.codigoDominio === 'cafe_no_encontrado') {
        throw errores.noEncontrado('cafe', 'de alguna línea del pedido');
      }
      throw error;   // no es nuestro: que lo trate el middleware como 500
    }
  },

  pagar(id, usuario) {
    const pedido = this.obtenerPara(id, usuario);
    if (pedido.estado === 'pagado') {
      throw errores.conflicto('pedido_ya_pagado', `El pedido '${id}' ya está pagado.`);
    }
    // ...marcar como pagado...
  },
};

// src/controladores/cafes.js  (modificado)
obtener(req, res) {
  const cafe = servicioCafes.obtener(req.params.id);   // si falla, lanza
  res.status(200).json(proyectar(cafeARepresentacion(cafe), req.query.campos));
},

// src/middleware/asincrono.js

/**
 * Envuelve un manejador para que cualquier rechazo de promesa acabe en
 * next(error) y, por tanto, en el middleware de errores.
 *
 * Promise.resolve() funciona igual si fn es síncrona (devuelve una promesa
 * ya resuelta) o asíncrona, así que se puede envolver TODO sin pensarlo.
 */
export function asincrono(fn) {
  return (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
}

// src/rutas/cafes.js  (modificado)
import { asincrono } from '../middleware/asincrono.js';

rutasCafes.get('/', validar(esquemaConsultaCafes, 'query'), asincrono(controladorCafes.listar));
rutasCafes.get('/:id', validar(esquemaIdCafe, 'params'), asincrono(controladorCafes.obtener));
rutasCafes.post(
  '/',
  autenticar,
  exigirRol('empleado', 'administrador'),
  validar(esquemaCrearCafe),
  asincrono(controladorCafes.crear)
);
// ...y así en todas

// src/middleware/errores.js
import { ZodError } from 'zod';
import { ErrorApi, errores } from '../errores/error-api.js';
import { entorno } from '../config/entorno.js';

/**
 * Middleware de errores.
 *
 * LA FIRMA DE CUATRO ARGUMENTOS ES OBLIGATORIA. Express distingue un
 * middleware de errores de uno normal contando los parámetros de la
 * función: con tres es normal, con cuatro es de errores. Por eso 'next'
 * debe declararse aunque no se use, y por eso ESLint necesitaba la regla
 * argsIgnorePattern: '^_' que configuramos en 03-01.
 */
// eslint-disable-next-line no-unused-vars
export function manejadorErrores(err, req, res, next) {
  const errorApi = traducir(err);

  // --- Registro para el equipo ---
  if (errorApi.estado >= 500) {
    // Los 5xx son fallos NUESTROS: se registran enteros, con traza.
    console.error(
      JSON.stringify({
        nivel: 'error',
        trazaId: req.trazaId,
        metodo: req.method,
        ruta: req.originalUrl,
        usuario: req.usuario?.id ?? null,
        mensaje: err.message,
        pila: err.stack,
      })
    );
  } else {
    // Los 4xx son fallos del cliente: basta una línea informativa.
    console.warn(
      JSON.stringify({
        nivel: 'aviso',
        trazaId: req.trazaId,
        metodo: req.method,
        ruta: req.originalUrl,
        codigo: errorApi.codigo,
      })
    );
  }

  // --- Cabeceras que exige el contrato según el caso ---
  if (errorApi.estado === 401) {
    res.set('WWW-Authenticate', 'Bearer realm="api.tiendaaroma.example"');
  }
  if (errorApi.estado === 405 && err.metodosPermitidos) {
    res.set('Allow', err.metodosPermitidos.join(', '));
  }
  if (errorApi.codigo === 'formato_no_soportado' && req.method === 'PATCH') {
    res.set('Accept-Patch', 'application/merge-patch+json');
  }

  // --- Cuerpo del contrato (02-04) ---
  const cuerpo = {
    error: {
      codigo: errorApi.codigo,
      mensaje: errorApi.mensaje ?? errorApi.message,
      detalles: errorApi.detalles ?? [],
    },
  };

  // trazaId SOLO en los 5xx, como decidimos en 02-04.
  if (errorApi.estado >= 500) {
    cuerpo.error.trazaId = req.trazaId;

    // En desarrollo ayuda ver la causa; en producción, JAMÁS.
    if (entorno.nodeEnv !== 'produccion') {
      cuerpo.error.depuracion = err.message;
    }
  }

  res.status(errorApi.estado).json(cuerpo);
}

// src/middleware/errores.js  (continuación)

/** Convierte cualquier excepción en un ErrorApi del catálogo. */
function traducir(err) {
  // 1. Ya es nuestro: se usa tal cual.
  if (err?.esErrorApi) return err;

  // 2. Validación de Zod que se ha escapado del middleware de validación.
  if (err instanceof ZodError) {
    return errores.datosInvalidos(
      err.issues.map((i) => ({
        campo: i.path.join('.') || '(cuerpo)',
        codigo: 'valor_invalido',
        mensaje: i.message,
      }))
    );
  }

  // 3. JSON mal formado, detectado por express.json().
  if (err instanceof SyntaxError && 'body' in err) {
    return new ErrorApi(400, 'datos_invalidos', 'El cuerpo no es JSON válido.', [
      { campo: '(cuerpo)', codigo: 'json_mal_formado', mensaje: err.message },
    ]);
  }

  // 4. Cuerpo demasiado grande (limit de express.json).
  if (err?.type === 'entity.too.large') return errores.cuerpoDemasiadoGrande();

  // 5. Errores de SQLite.
  const deSqlite = traducirSqlite(err);
  if (deSqlite) return deSqlite;

  // 6. Cualquier otra cosa es un bug nuestro: 500 sin filtrar nada.
  return errores.errorInterno();
}

{
  "error": {
    "codigo": "error_interno",
    "mensaje": "Se ha producido un error inesperado.",
    "detalles": [],
    "trazaId": "trz_8f4a1c92"
  }
}

// src/middleware/traza.js
import { randomBytes } from 'node:crypto';

/**
 * Asigna un identificador único a cada petición.
 * Si viene de un proxy o gateway que ya lo generó, se respeta: así la
 * traza es continua a lo largo de todo el sistema (04-07).
 */
export function asignarTrazaId(req, res, next) {
  const heredado = req.get('Aroma-Traza-Id');
  req.trazaId = heredado ?? `trz_${randomBytes(4).toString('hex')}`;

  // Se devuelve siempre, no solo en los errores: permite al cliente
  // referenciar cualquier petición al abrir una incidencia.
  res.set('Aroma-Traza-Id', req.trazaId);
  next();
}

// src/middleware/validacion.js  (modificado)
import { errores } from '../errores/error-api.js';

export function validar(esquema, origen = 'body') {
  return (req, res, next) => {
    const resultado = esquema.safeParse(req[origen]);

    if (!resultado.success) {
      const detalles = aDetalles(resultado.error);
      // El middleware de errores se encarga del formato y del registro.
      return next(
        origen === 'body' ? errores.datosInvalidos(detalles) : errores.parametroInvalido(detalles)
      );
    }

    req[origen] = resultado.data;
    next();
  };
}

// src/middleware/errores.js  (continuación)

/** Errores de SQLite → errores del catálogo. Devuelve null si no lo es. */
function traducirSqlite(err) {
  const codigo = err?.code;
  if (typeof codigo !== 'string' || !codigo.startsWith('SQLITE_')) return null;

  switch (codigo) {
    case 'SQLITE_CONSTRAINT_UNIQUE':
    case 'SQLITE_CONSTRAINT_PRIMARYKEY':
      // Alguien intentó duplicar un valor único (un email, por ejemplo).
      return new ErrorApi(409, 'recurso_duplicado', 'Ya existe un recurso con ese valor único.');

    case 'SQLITE_CONSTRAINT_FOREIGNKEY':
      // Se referencia algo que no existe: un pedido de un cliente inexistente.
      return new ErrorApi(
        409,
        'referencia_invalida',
        'La operación referencia un recurso que no existe.'
      );

    case 'SQLITE_CONSTRAINT_CHECK':
      // Un CHECK del esquema (tueste inválido, stock negativo). Si llega
      // aquí es que la validación de 03-04 tiene un hueco: se registra
      // como 5xx para que el equipo lo vea, aunque la culpa parezca del cliente.
      return new ErrorApi(400, 'datos_invalidos', 'Los datos no cumplen una restricción del modelo.');

    case 'SQLITE_BUSY':
      return new ErrorApi(503, 'servicio_no_disponible', 'La base de datos está ocupada. Reintenta.');

    default:
      return null;   // desconocido: que sea un 500 con su log completo
  }
}

# JSON mal formado: falta una comilla
curl -s -X POST http://localhost:3000/v1/cafes \
  -H "Content-Type: application/json" \
  -d '{"nombre": "Kenia, "origen": "Kenia"}' | jq

{
  "error": {
    "codigo": "datos_invalidos",
    "mensaje": "El cuerpo no es JSON válido.",
    "detalles": [
      {
        "campo": "(cuerpo)",
        "codigo": "json_mal_formado",
        "mensaje": "Unexpected token o in JSON at position 22"
      }
    ]
  }
}

# Cuerpo de 2 MB contra un límite de 100 kB
curl -s -X POST http://localhost:3000/v1/cafes \
  -H "Content-Type: application/json" \
  --data-binary @gigante.json | jq .error.codigo

"cuerpo_demasiado_grande"

// src/middleware/no-encontrado.js
import { errores } from '../errores/error-api.js';

/** Ninguna ruta ha coincidido: 404 ruta_no_encontrada. */
export function manejadorNoEncontrado(req, res, next) {
  next(errores.rutaNoEncontrada(req.method, req.originalUrl));
}

// src/middleware/no-encontrado.js  (continuación)
import { ErrorApi } from '../errores/error-api.js';

/**
 * Devuelve un manejador que responde 405 con Allow.
 * Se registra con router.all() al final de cada grupo de rutas, así que
 * solo se alcanza si la URI coincidió pero ningún método lo hizo.
 */
export function metodoNoPermitido(...metodosPermitidos) {
  return (req, res, next) => {
    const error = new ErrorApi(
      405,
      'metodo_no_permitido',
      `${req.method} no está permitido sobre ${req.baseUrl}${req.path}.`
    );
    // El middleware de errores leerá esta propiedad para poner Allow.
    error.metodosPermitidos = [...metodosPermitidos, 'OPTIONS'];
    next(error);
  };
}

// src/rutas/cafes.js  (al final del fichero, tras todas las rutas)
import { metodoNoPermitido } from '../middleware/no-encontrado.js';

rutasCafes.all('/', metodoNoPermitido('GET', 'POST'));
rutasCafes.all('/:id', metodoNoPermitido('GET', 'PUT', 'PATCH', 'DELETE'));

curl -i -s -X DELETE http://localhost:3000/v1/cafes | head -5

HTTP/1.1 405 Method Not Allowed
Allow: GET, POST, OPTIONS
Content-Type: application/json; charset=utf-8

{"error":{"codigo":"metodo_no_permitido","mensaje":"DELETE no está permitido sobre /v1/cafes.","detalles":[]}}

// src/app.js  (versión final del módulo)
import express from 'express';
import { rutasV1 } from './rutas/index.js';
import { asignarTrazaId } from './middleware/traza.js';
import { manejadorNoEncontrado } from './middleware/no-encontrado.js';
import { manejadorErrores } from './middleware/errores.js';

export const app = express();

app.disable('x-powered-by');

// --- 1. Identidad de la petición: lo PRIMERO, para que todo pueda usarla ---
app.use(asignarTrazaId);

// --- 2. Registro de peticiones (04-07 lo sustituirá por logs estructurados) ---
app.use((req, res, next) => {
  const inicio = Date.now();
  res.on('finish', () => {
    console.log(`${req.method} ${req.originalUrl} → ${res.statusCode} (${Date.now() - inicio} ms)`);
  });
  next();
});

// --- 3. Parsers del cuerpo ---
app.use(
  express.json({
    limit: '100kb',
    type: ['application/json', 'application/merge-patch+json'],
  })
);
app.use(express.urlencoded({ extended: false, limit: '10kb' }));

// --- 4. Salud (fuera de /v1: no forma parte del contrato) ---
app.get('/salud', (req, res) => {
  res.status(200).json({ estado: 'ok', version: '1.0.0', momento: new Date().toISOString() });
});

// --- 5. API versionada ---
app.use('/v1', rutasV1);

// --- 6. Ninguna ruta ha coincidido ---
app.use(manejadorNoEncontrado);

// --- 7. Middleware de errores: SIEMPRE EL ÚLTIMO ---
app.use(manejadorErrores);

// src/servidor.js  (versión final del módulo)
import { app } from './app.js';
import { entorno } from './config/entorno.js';
import { cerrarBaseDatos } from './config/base-datos.js';

const servidor = app.listen(entorno.puerto, () => {
  console.log(`API de Tienda Aroma escuchando en ${entorno.baseUrl}/v1`);
});

let cerrando = false;

function cerrarOrdenadamente(motivo, codigoSalida = 0) {
  if (cerrando) return;   // dos señales seguidas no deben duplicar el cierre
  cerrando = true;

  console.log(`Cerrando por: ${motivo}`);

  servidor.close(() => {
    cerrarBaseDatos();
    console.log('Servidor y base de datos cerrados.');
    process.exit(codigoSalida);
  });

  // Red de seguridad: si en 10 s no ha terminado, se fuerza la salida.
  // Sin esto, una conexión abierta puede impedir el apagado para siempre.
  setTimeout(() => {
    console.error('Cierre forzado tras el tiempo de espera.');
    process.exit(1);
  }, 10000).unref();
}

process.on('SIGINT', () => cerrarOrdenadamente('SIGINT'));
process.on('SIGTERM', () => cerrarOrdenadamente('SIGTERM'));

/**
 * Excepción no capturada: el proceso está en un estado DESCONOCIDO.
 * Se registra y se sale. Intentar continuar es peor: puede haber
 * transacciones a medias, ficheros abiertos y estado corrupto.
 */
process.on('uncaughtException', (error) => {
  console.error(
    JSON.stringify({ nivel: 'fatal', tipo: 'uncaughtException', mensaje: error.message, pila: error.stack })
  );
  cerrarOrdenadamente('uncaughtException', 1);
});

/** Promesa rechazada sin catch. Desde Node 15, también termina el proceso. */
process.on('unhandledRejection', (razon) => {
  console.error(
    JSON.stringify({ nivel: 'fatal', tipo: 'unhandledRejection', mensaje: String(razon) })
  );
  cerrarOrdenadamente('unhandledRejection', 1);
});

{
  "type": "https://api.tiendaaroma.example/errores/stock-insuficiente",
  "title": "Stock insuficiente",
  "status": 409,
  "detail": "Solo quedan 3 unidades de 'Etiopía Yirgacheffe' y se piden 5.",
  "instance": "/v1/pedidos"
}

rutasPedidos.post('/', autenticar, async (req, res) => {
  try {
    const pedido = await servicioPedidos.crear(req.body);
    res.status(201).json(pedidoARepresentacion(pedido));
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// src/middleware/idempotencia.js
import { createHash } from 'node:crypto';
import { ErrorApi, errores } from '../errores/error-api.js';
import { baseDatos } from '../config/base-datos.js';

// Tabla necesaria (migración 003):
//   CREATE TABLE claves_idempotencia (
//     clave TEXT PRIMARY KEY, huella TEXT NOT NULL,
//     respuesta TEXT, fecha TEXT NOT NULL
//   );

const buscarClave = baseDatos.prepare('SELECT * FROM claves_idempotencia WHERE clave = ?');
const guardarClave = baseDatos.prepare(
  'INSERT INTO claves_idempotencia (clave, huella, fecha) VALUES (?, ?, ?)'
);

export function exigirClaveIdempotencia(req, res, next) {
  const clave = req.get('Idempotency-Key');

  if (!clave) {
    return next(
      new ErrorApi(
        400,
        'clave_idempotencia_requerida',
        'Esta operación requiere la cabecera Idempotency-Key.'
      )
    );
  }

  // Huella del cuerpo: identifica "la misma petición".
  const huella = createHash('sha256').update(JSON.stringify(req.body ?? {})).digest('hex');
  const registro = buscarClave.get(clave);

  if (registro) {
    if (registro.huella !== huella) {
      // Misma clave, cuerpo distinto: contradicción del cliente.
      return next(
        new ErrorApi(
          422,
          'clave_idempotencia_reutilizada',
          'Esa Idempotency-Key ya se usó con un cuerpo diferente.'
        )
      );
    }
    if (registro.respuesta) {
      // Reintento legítimo: se devuelve la respuesta original.
      return res.status(200).json(JSON.parse(registro.respuesta));
    }
    return next(
      new ErrorApi(409, 'operacion_en_curso', 'Una petición idéntica se está procesando.')
    );
  }

  guardarClave.run(clave, huella, new Date().toISOString());
  req.claveIdempotencia = clave;
  next();
}

rutasPedidos.post(
  '/',
  autenticar,
  exigirRol('cliente', 'empleado', 'administrador'),
  exigirClaveIdempotencia,
  validar(esquemaCrearPedido),
  asincrono(controladorPedidos.crear)
);

// src/controladores/pedidos.js
crear: async (req, res) => {
  const pedido = await servicioPedidos.crear({
    clienteId: req.usuario.id,        // del token, NUNCA del cuerpo (03-06)
    lineas: req.body.lineas,
  });
  res.set('Location', `/v1/pedidos/${pedido.id}`);
  res.status(201).json(pedidoARepresentacion(pedido));
},

// src/rutas/pedidos.js
rutasPedidos.post(
  '/',
  autenticar,
  exigirClaveIdempotencia,
  validar(esquemaCrearPedido),
  asincrono(controladorPedidos.crear)
);

HTTP/1.1 415 Unsupported Media Type
Accept-Patch: application/merge-patch+json
Aroma-Traza-Id: trz_1a2b3c4d

{"error":{"codigo":"formato_no_soportado","mensaje":"El tipo de contenido 'application/json-patch+json' no se admite en esta operación.","detalles":[]}}

HTTP/1.1 404 Not Found
Aroma-Traza-Id: trz_5e6f7a8b

{"error":{"codigo":"pedido_no_encontrado","mensaje":"No existe ningún pedido con el identificador 'ped_5001'.","detalles":[]}}

HTTP/1.1 403 Forbidden
Aroma-Traza-Id: trz_9c0d1e2f

{"error":{"codigo":"permisos_insuficientes","mensaje":"No tienes permiso. Se requiere uno de estos roles: empleado, administrador.","detalles":[]}}

HTTP/1.1 500 Internal Server Error
Aroma-Traza-Id: trz_3a4b5c6d

{"error":{"codigo":"error_interno","mensaje":"Se ha producido un error inesperado.","detalles":[],"trazaId":"trz_3a4b5c6d"}}

{"nivel":"error","trazaId":"trz_3a4b5c6d","metodo":"GET","ruta":"/v1/cafes/caf_007","usuario":null,
 "mensaje":"Cannot read properties of null (reading 'map')",
 "pila":"TypeError: ... at cafeARepresentacion (/app/src/servicios/mapeadores.js:31:29) ..."}