source: Klonkt/src/services/ArchiveImportService.js@ 812fea9

/**
 * Import van een draagbaar inhoudsarchief (shaer-pmr).
 *
 * Leest wat docs/EXPORT-FORMAT.md beschrijft. Vier regels uit dat document zijn
 * geen implementatiekeuze maar eis, en ze staan hier alle vier expliciet:
 *
 *   VERSIE EERST   Een hogere onbekende formatVersion wordt in zijn GEHEEL
 *                  geweigerd. Een half begrepen herstel is erger dan geen
 *                  herstel, want het ziet eruit alsof het gelukt is.
 *   IDENTITEIT     De origin uit het manifest bepaalt of de AP-ids behouden
 *                  blijven. Dat is geen vraag aan de gebruiker: een verkeerd
 *                  antwoord publiceert objecten onder een id dat je niet beheert.
 *   NIETS STILS    Ontbrekende media worden geteld en gemeld.
 *   GEEN UITZENDING Geen Update de fediverse in. Verouderde kopieen elders
 *                  rechttrekken is een aparte, bewuste actie.
 *
 * `readable/` wordt nooit gelezen. Dat is de hele reden dat het afgeleid is.
 */

import fs from 'fs';
import path from 'path';
import zlib from 'zlib';
import crypto from 'crypto';
import { randomUUID } from 'crypto';
import db from '../config/database.js';
import { MEDIA_ROOT } from '../config/paths.js';
import { FORMAT_VERSION } from './ArchiveExportService.js';

const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex');
// De tijdstempel gaat er ONGEWIJZIGD in. Omzetten naar SQL-notatie kostte de
// sub-seconde, en twee posts in dezelfde seconde staan dan in willekeurige
// volgorde. Klonkt schrijft zelf ook ISO in deze kolommen.
const tijd = (iso) => (iso && !isNaN(Date.parse(iso)) ? String(iso) : null);

// ── Inlezen ───────────────────────────────────────────────────────

/** Lees een archiefmap in als pad -> Buffer. */
export function readArchiveDir(dir) {
  const files = new Map();
  const loop = (sub) => {
    for (const naam of fs.readdirSync(path.join(dir, sub), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
      const rel = sub ? `${sub}/${naam.name}` : naam.name;
      if (naam.isDirectory()) loop(rel);
      else files.set(rel, fs.readFileSync(path.join(dir, rel)));
    }
  };
  loop('');
  return files;
}

/**
 * Lees een zip in. Onze eigen export is store-only, maar een archief dat elders
 * gemaakt is mag deflate gebruiken -- anders is het geen uitwisselformaat.
 */
export function readArchiveZip(buf) {
  const files = new Map();
  const eocd = (() => {
    for (let i = buf.length - 22; i >= 0 && i > buf.length - 66000; i--) if (buf.readUInt32LE(i) === 0x06054b50) return i;
    return -1;
  })();
  if (eocd < 0) throw new Error('geen zip: het eind-record ontbreekt');
  const aantal = buf.readUInt16LE(eocd + 10);
  let p = buf.readUInt32LE(eocd + 16);
  for (let n = 0; n < aantal; n++) {
    if (buf.readUInt32LE(p) !== 0x02014b50) throw new Error('beschadigde zip: centrale ingang klopt niet');
    const methode = buf.readUInt16LE(p + 10);
    const gecomp = buf.readUInt32LE(p + 20);
    const naamLen = buf.readUInt16LE(p + 28);
    const extraLen = buf.readUInt16LE(p + 30);
    const commentLen = buf.readUInt16LE(p + 32);
    const lokaalOffset = buf.readUInt32LE(p + 42);
    const naam = buf.toString('utf8', p + 46, p + 46 + naamLen);
    const lNaam = buf.readUInt16LE(lokaalOffset + 26);
    const lExtra = buf.readUInt16LE(lokaalOffset + 28);
    const start = lokaalOffset + 30 + lNaam + lExtra;
    const rauw = buf.subarray(start, start + gecomp);
    if (!naam.endsWith('/')) {
      files.set(naam, methode === 8 ? zlib.inflateRawSync(rauw) : Buffer.from(rauw));
    }
    p += 46 + naamLen + extraLen + commentLen;
  }
  return files;
}

export function readArchive(bron) {
  const st = fs.statSync(bron);
  return st.isDirectory() ? readArchiveDir(bron) : readArchiveZip(fs.readFileSync(bron));
}

// ── Importeren ────────────────────────────────────────────────────

/** Een pad onder MEDIA_ROOT houden. Een archief van elders is invoer, geen vriend. */
function veiligMediaPad(urlPad) {
  if (!urlPad || !urlPad.startsWith('/media/')) return null;
  const abs = path.resolve(MEDIA_ROOT, decodeURIComponent(urlPad.slice('/media/'.length)));
  const root = path.resolve(MEDIA_ROOT);
  return (abs !== root && abs.startsWith(`${root}${path.sep}`)) ? abs : null;
}

/** Het pad-deel van een originele media-URL, of null als het er niet een van ons is. */
function padVanOrigineel(u) {
  const s = String(u || '');
  if (s.startsWith('/media/')) return s;
  try { const x = new URL(s); return x.pathname.startsWith('/media/') ? x.pathname : null; } catch { return null; }
}

/**
 * Zet een archief terug in een site.
 *
 * @param {Map<string,Buffer>} files  het ingelezen archief
 * @param {object} opts  { slug, dryRun, overwrite, origin }
 */
export function importArchive(files, opts = {}) {
  const rapport = {
    formatVersion: null, origin: null, idsBehouden: null,
    posts: 0, overgeslagen: 0, overschreven: 0,
    replies: 0, media: 0, mediaMissing: 0, gemist: [], waarschuwingen: [],
  };

  const manifestBuf = files.get('manifest.json');
  if (!manifestBuf) throw new Error('geen manifest.json: dit is geen inhoudsarchief');
  const manifest = JSON.parse(manifestBuf.toString('utf8'));
  rapport.formatVersion = manifest.formatVersion;

  // VERSIE EERST, voordat er ook maar iets gelezen wordt.
  if (!Number.isInteger(manifest.formatVersion)) throw new Error('manifest zonder bruikbare formatVersion');
  if (manifest.formatVersion > FORMAT_VERSION) {
    throw new Error(`archiefversie ${manifest.formatVersion} is nieuwer dan deze Klonkt kent (${FORMAT_VERSION}); geweigerd`);
  }

  const site = db.prepare('SELECT * FROM sites WHERE slug = ?').get(opts.slug);
  if (!site) throw new Error(`onbekende site: ${opts.slug}`);
  const eigenOrigin = (opts.origin || process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
  rapport.origin = manifest.origin || null;

  // IDENTITEIT. Gelijke origin -> de AP-ids blijven, en daarmee vinden de boosts
  // en antwoorden die er al naar wijzen hun post terug. Anders nieuwe ids, want
  // een id op andermans domein publiceren is een vervalsingsoppervlak en andere
  // servers halen het daar toch op.
  const idsBehouden = !!(manifest.origin && eigenOrigin && manifest.origin === eigenOrigin);
  rapport.idsBehouden = idsBehouden;
  if (!idsBehouden) {
    rapport.waarschuwingen.push(
      `origin verschilt (archief ${manifest.origin || '?'} vs deze site ${eigenOrigin || '?'}): nieuwe AP-ids, de oude blijven als verwijzing staan`,
    );
  }

  const postPaden = [...files.keys()].filter((p) => p.startsWith('posts/') && p.endsWith('.json')).sort();
  const bestaatId = db.prepare('SELECT 1 FROM posts WHERE id = ?');
  const bestaatSlug = db.prepare('SELECT id FROM posts WHERE site_id = ? AND slug = ?');
  const idKaart = new Map();     // oud post-id -> nieuw post-id

  const schrijf = [];            // alles eerst uitrekenen, dan in EEN transactie

  for (const pad of postPaden) {
    const o = JSON.parse(files.get(pad).toString('utf8'));
    const oudId = decodeURIComponent(String(o.id || '').split('/ap/notes/')[1] || path.basename(pad, '.json'));
    const nieuwId = idsBehouden ? oudId : randomUUID();
    idKaart.set(oudId, nieuwId);

    const botsing = !!bestaatId.get(nieuwId) || !!bestaatSlug.get(site.id, o['shaer:slug']);
    if (botsing && !opts.overwrite) {
      // EEN gedocumenteerde regel, geen gok per post: bestaande inhoud wordt niet
      // overschreven tenzij dat expliciet gevraagd is. Dit is ook wat de import
      // idempotent maakt.
      rapport.overgeslagen += 1;
      continue;
    }
    if (botsing) rapport.overschreven += 1;

    // Media: terug naar hun oorspronkelijke plek onder /media, want de content
    // van de post verwijst daarnaar. Dat pad is site-relatief, dus het werkt ook
    // op een ander domein.
    for (const a of (Array.isArray(o.attachment) ? o.attachment : [])) {
      if (a['shaer:availability'] === 'missing') {
        rapport.mediaMissing += 1;
        rapport.gemist.push({ post: o['shaer:slug'], url: a['shaer:originalUrl'] || a.url });
        continue;
      }
      const bytes = files.get(a.url);
      if (!bytes) {
        // Het archief zegt 'included' maar het bestand ontbreekt. Dat is een kapot
        // archief, geen ontbrekende media -- apart melden, niet stil optellen.
        rapport.waarschuwingen.push(`archief verwijst naar ${a.url}, dat er niet in zit`);
        continue;
      }
      if (a['shaer:sha256'] && sha256(bytes) !== a['shaer:sha256']) {
        rapport.waarschuwingen.push(`${a.url}: checksum klopt niet, overgeslagen`);
        continue;
      }
      const doel = veiligMediaPad(padVanOrigineel(a['shaer:originalUrl']))
        || veiligMediaPad(`/media/archief/${path.basename(a.url)}`);
      if (!doel) { rapport.waarschuwingen.push(`${a.url}: onbruikbaar doelpad, overgeslagen`); continue; }
      schrijf.push({ soort: 'media', doel, bytes });
      rapport.media += 1;
    }

    schrijf.push({ soort: 'post', id: nieuwId, oudId, obj: o });
    rapport.posts += 1;
  }

  // Antwoorden: alleen-lezen archief. Nooit opnieuw bezorgd, geen meldingen.
  for (const pad of [...files.keys()].filter((p) => p.startsWith('replies/')).sort()) {
    const coll = JSON.parse(files.get(pad).toString('utf8'));
    if (coll['shaer:archive'] !== true) {
      rapport.waarschuwingen.push(`${pad}: niet gemarkeerd als archief, overgeslagen`);
      continue;
    }
    const oudId = path.basename(pad, '.json');
    const postId = idKaart.get(oudId);
    if (!postId) continue;                       // post overgeslagen -> antwoorden ook
    for (const it of (coll.orderedItems || [])) {
      schrijf.push({ soort: 'reply', postId, it });
      rapport.replies += 1;
    }
  }

  if (opts.dryRun) return rapport;

  // Schrijven pas nu, in EEN transactie: een half ingelezen archief is de ergste
  // uitkomst, want dan lijkt het gelukt.
  const insPost = db.prepare(`INSERT OR REPLACE INTO posts
    (id, site_id, slug, author_id, title, content, excerpt, status, cover_image_url, cover_alt, cover_video_url,
     pinned, type, tags, published_at, created_at, updated_at, noindex, publish_at, fan_only, nsfw, language,
     content_warning, poll_json, quote_uri, quote_actor, ap_visibility, paid, paid_min_cents, view_count, c2s_attachments, origin_server)
    VALUES (@id, @site_id, @slug, @author_id, @title, @content, @excerpt, @status, @cover_image_url, @cover_alt, @cover_video_url,
     @pinned, @type, @tags, @published_at, @created_at, @updated_at, @noindex, @publish_at, @fan_only, @nsfw, @language,
     @content_warning, @poll_json, @quote_uri, @quote_actor, @ap_visibility, @paid, @paid_min_cents, @view_count, @c2s_attachments, 'import')`);
  const insReply = db.prepare(`INSERT OR IGNORE INTO ap_interactions
    (kind, post_id, object_uri, actor_uri, actor_name, actor_handle, content, published, parent_uri, created_at)
    VALUES ('reply', ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`);

  db.transaction(() => {
    for (const s of schrijf) {
      if (s.soort === 'media') {
        fs.mkdirSync(path.dirname(s.doel), { recursive: true });
        fs.writeFileSync(s.doel, s.bytes);
        continue;
      }
      if (s.soort === 'reply') {
        insReply.run(s.postId, s.it.id || '', s.it.attributedTo || '', s.it['shaer:actorName'] || null,
          s.it['shaer:actorHandle'] || null, s.it.content || '', s.it.published || null, s.it.inReplyTo || null);
        continue;
      }
      const o = s.obj;
      const opties = (Array.isArray(o.oneOf) ? o.oneOf : (Array.isArray(o.anyOf) ? o.anyOf : null));
      // De rollen uit het archief terug naar de kolommen. Zonder dit staat het
      // bestand er wel, maar komt de post zonder cover en zonder speler terug --
      // en dat zie je pas als je alle kolommen vergelijkt.
      const bijlagen = Array.isArray(o.attachment) ? o.attachment : [];
      const padVan = (a) => (a ? padVanOrigineel(a['shaer:originalUrl']) : null);
      const metRol = (r) => bijlagen.find((a) => a['shaer:role'] === r);
      const c2s = bijlagen.filter((a) => a['shaer:role'] === 'c2s').map((a) => {
        const poster = bijlagen.find((x) => x['shaer:role'] === 'poster' && x['shaer:posterFor'] === padVan(a));
        return {
          url: padVan(a), mediaType: a.mediaType, name: a.name || undefined,
          poster: poster ? padVan(poster) : undefined,
        };
      }).filter((a) => a.url);
      insPost.run({
        id: s.id, site_id: site.id, slug: o['shaer:slug'] || s.id, author_id: site.owner_id,
        title: o.name || null, content: o.content || '', excerpt: o['shaer:excerpt'] || null,
        status: o['shaer:status'] || 'draft',
        cover_image_url: padVan(metRol('cover')), cover_alt: o['shaer:coverAlt'] || null,
        cover_video_url: padVan(metRol('coverVideo')),
        c2s_attachments: c2s.length ? JSON.stringify(c2s) : null,
        pinned: o['shaer:pinned'] ? 1 : 0, type: o['shaer:type'] || 'post',
        tags: Array.isArray(o.tag) ? o.tag.filter((t) => t && t.type === 'Hashtag').map((t) => String(t.name).replace(/^#/, '')).join(', ') : null,
        published_at: tijd(o.published), created_at: tijd(o.published), updated_at: tijd(o.updated || o.published),
        noindex: o['shaer:noindex'] ? 1 : 0, publish_at: tijd(o['shaer:publishAt']),
        fan_only: o['shaer:fanOnly'] ? 1 : 0, nsfw: o.sensitive ? 1 : 0,
        language: (o.contentMap && Object.keys(o.contentMap)[0]) || null,
        content_warning: o.summary || null,
        poll_json: opties ? JSON.stringify({ multiple: Array.isArray(o.anyOf), options: opties.map((x) => ({ name: x.name })), endTime: o.endTime || null, closed: !!o.closed }) : null,
        quote_uri: o.quoteUrl || null, quote_actor: o['shaer:quoteActor'] || null,
        ap_visibility: o['shaer:apVisibility'] || null,
        paid: o['shaer:paid'] ? 1 : 0, paid_min_cents: o['shaer:paidMinCents'] || null,
        view_count: o['shaer:viewCount'] || 0,
      });
      // Gehoste audio terug: [[track:]] in de content valt anders op niets terug.
      for (const t of (o['shaer:audio'] || [])) {
        const trackId = String(t['shaer:ref'] || '').replace(/^\[\[track:|\]\]$/g, '');
        if (!trackId) continue;
        let mediaId = null;
        const bij = (o.attachment || []).find((a) => a.url === t['shaer:media']);
        const doel = bij && veiligMediaPad(padVanOrigineel(bij['shaer:originalUrl']));
        if (doel) {
          mediaId = randomUUID();
          try {
            db.prepare('INSERT INTO media (id, site_id, filename, mime_type, size, storage_path) VALUES (?,?,?,?,?,?)')
              .run(mediaId, site.id, path.basename(doel), bij.mediaType || 'audio/mpeg', (files.get(bij.url) || []).length || 0, doel);
          } catch { mediaId = null; }
        }
        try {
          db.prepare(`INSERT OR REPLACE INTO audio_tracks (id, site_id, title, artist, album, duration, media_id, credit, license, link_spotify, link_youtube, link_soundcloud)
                      VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`)
            .run(trackId, site.id, t.name || 'zonder titel', t.artist || null, t.album || null, t.duration || null,
              mediaId, t.credit || null, t.license || null,
              ...['spotify', 'youtube', 'soundcloud'].map((k) => (t.url || []).find((u) => String(u).includes(k)) || null));
        } catch { /* geen audio-tabellen op deze installatie */ }
      }
    }
  })();

  return rapport;
}