Changes in src/services/ArchiveExportService.js [ba76bf5:e9ec5e4] in Klonkt

File:

• src/services/ArchiveExportService.js (modified) (4 diffs)

src/services/ArchiveExportService.js

@@ -38 +38 @@
 
 const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex');
-// SQLite's CURRENT_TIMESTAMP schrijft 'YYYY-MM-DD HH:MM:SS' in UTC, zonder marker.
-// Kale Date.parse leest dat als LOKALE tijd, dus op een server op UTC+2 ging er twee
-// uur van elke stempel af voordat hij het archief in ging. Die verschuiving wordt bij
-// het exporteren ingebakken en valt niet weg bij het importeren: exporteer je in
-// Amsterdam, dan is die post overal permanent twee uur te vroeg, en in zomer- en
-// wintertijd verschillend. Het raakte de stempels die de database zelf zet (concepten,
-// ingeplande posts, gearchiveerde antwoorden), niet die uit de editor, dus de schade
-// was stil en gedeeltelijk. EXPORT-FORMAT.md schreef altijd al "ISO 8601, UTC" voor.
-// Zelfde regel als isoStamp() in ActivityPubService en stampMs() in guardianship/offers.
-const SQL_STAMP = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(\.\d+)?$/;
+/**
+ * Naar ISO 8601 in UTC.
+ *
+ * SQLite schrijft CURRENT_TIMESTAMP als "2026-07-01 12:56:10" -- in UTC, maar
+ * ZONDER zone erbij. Date.parse leest die vorm als LOKALE tijd, en dan schuift
+ * elk tijdstempel in het archief mee met de tijdzone van de machine die de export
+ * draait. Op een server in Amsterdam is dat twee uur, en dat merk je pas als je
+ * ergens anders importeert.
+ *
+ * Gevonden doordat Bart vroeg of dit wel naar UTC normaliseert. De testmachine
+ * draait op UTC, dus geen enkele test kon het zien.
+ */
 const toISO = (d) => {
-  const s = String(d == null ? '' : d);
-  const t = Date.parse(SQL_STAMP.test(s) ? `${s.replace(' ', 'T')}Z` : s);
+  if (!d) return null;
+  const s = String(d).trim();
+  const zonderZone = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/.test(s);
+  const t = Date.parse(zonderZone ? `${s.replace(' ', 'T')}Z` : s);
   return isNaN(t) ? null : new Date(t).toISOString();
 };
@@ -234 +238 @@
 }
 
+// ── Wie je volgt, als CSV ─────────────────────────────────────────
+//
+// Kolomvorm van Mastodon, zodat deze lijst ook DAAR te importeren is en die van
+// daar hier. Dat is het hele punt van een verhuisformaat: het moet ook werken
+// als je naar iets anders vertrekt dan waar je vandaan kwam.
+//
+//   Account address,Show boosts,Notify on new posts,Languages,Featured
+//
+// `Featured` is onze kolom en draagt `auto_boost`: het vinkje dat in de UI
+// "Uitgelicht" heet (tl.autoboost) en hun posts in jouw Cirkel laat meelopen.
+//
+// `Show boosts` blijft LEEG. Dat is bij Mastodon "toon de reblogs van deze
+// persoon in mijn tijdlijn", en dat kent Klonkt niet. De verleiding is groot om
+// er auto_boost in te schrijven omdat in beide het woord boost zit, maar het is
+// een ander ding: dat van ons gaat over hun eigen posts in JOUW Cirkel, niet
+// over andermans posts die zij doorgeven. `Notify` en `Languages` kent Klonkt
+// evenmin. Die drie staan er omdat Mastodon de POSITIES telt.
+const CSV_KOP = 'Account address,Show boosts,Notify on new posts,Languages,Featured';
+
+/** Een veld dat een komma, aanhalingsteken of nieuwe regel bevat moet geciteerd. */
+function csvVeld(v) {
+  const s = String(v == null ? '' : v);
+  return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+/**
+ * De volglijst van een site als CSV, of null als er niets te melden valt.
+ *
+ * Alleen `accepted`: een openstaand verzoek is geen relatie, en het opnieuw
+ * versturen ervan op de nieuwe plek zou een tweede verzoek zijn bij iemand die
+ * de eerste misschien bewust liet liggen.
+ *
+ * Het adres is de handle zonder de leidende @, want zo schrijft Mastodon hem.
+ * Ontbreekt de handle, dan valt hij terug op de actor-URI: die is altijd te
+ * herleiden, ook als de webfinger-naam ooit verloren ging.
+ */
+export function followingCsv(slug) {
+  let rijen = [];
+  try {
+    rijen = db.prepare(`SELECT actor_uri, handle, auto_boost FROM ap_following
+                         WHERE slug = ? AND status = 'accepted'
+                         ORDER BY handle IS NULL, handle, actor_uri`).all(slug);
+  } catch { return null; }        // oude database zonder de kolom
+  if (!rijen.length) return null;
+  const regels = rijen.map((r) => [
+    csvVeld((r.handle || r.actor_uri || '').replace(/^@/, '')),
+    '',                                    // Show boosts: niet van ons
+    '',                                    // Notify on new posts: idem
+    '',                                    // Languages: idem
+    r.auto_boost ? 'true' : 'false',       // Featured: het vinkje "Uitgelicht"
+  ].join(','));
+  return `${CSV_KOP}\n${regels.join('\n')}\n`;
+}
+
+/**
+ * Lees zo'n CSV terug. Puur, zodat de vorm te toetsen is zonder database.
+ *
+ * Vergeeflijk met opzet: een bestand uit Mastodon heeft vier kolommen en geen
+ * `Featured`, een handgemaakt bestand heeft misschien alleen adressen. Beide
+ * moeten werken, want anders is het geen uitwisselformaat maar een eigen
+ * bestandje dat toevallig op een CSV lijkt.
+ */
+export function parseFollowingCsv(text) {
+  const uit = [];
+  const regels = String(text || '').split(/\r?\n/).filter((r) => r.trim());
+  if (!regels.length) return uit;
+  // Een kopregel herkennen we aan het eerste veld; anders is regel 1 al data.
+  const start = /^\s*"?account address"?\s*(,|$)/i.test(regels[0]) ? 1 : 0;
+  for (const regel of regels.slice(start)) {
+    const velden = splitsCsvRegel(regel);
+    const adres = (velden[0] || '').trim().replace(/^@/, '');
+    if (!adres) continue;
+    uit.push({
+      address: adres,
+      // Alleen kolom 5. Een bestand uit Mastodon heeft die niet en levert dus
+      // `false`, en dat is juist: hun "Show boosts" in kolom 2 gaat over iets
+      // anders en mag hier niet als uitgelicht binnenkomen.
+      featured: /^(true|1|yes)$/i.test((velden[4] || '').trim()),
+    });
+  }
+  return uit;
+}
+
+/** Eén CSV-regel, met respect voor geciteerde velden en verdubbelde aanhalingstekens. */
+function splitsCsvRegel(regel) {
+  const velden = [];
+  let veld = '';
+  let inCitaat = false;
+  for (let i = 0; i < regel.length; i++) {
+    const c = regel[i];
+    if (inCitaat) {
+      if (c === '"') {
+        if (regel[i + 1] === '"') { veld += '"'; i++; } else inCitaat = false;
+      } else veld += c;
+    } else if (c === '"') inCitaat = true;
+    else if (c === ',') { velden.push(veld); veld = ''; }
+    else veld += c;
+  }
+  velden.push(veld);
+  return velden;
+}
+
 /**
  * Bouw het archief als een lijst bestanden: pad -> inhoud (Buffer).
@@ -243 +349 @@
   const origin = (opts.origin || process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
   const site = db.prepare('SELECT * FROM sites WHERE slug = ?').get(slug);
-  if (!site) throw new Error(`onbekende site: ${slug}`);
+  if (!site) {
+    // De naam van de INSTANCE (de map, de unit) en de slug van de SITE in zijn
+    // database zijn twee dingen. Ze vallen vaak samen en soms niet, en dan zat je
+    // met een foutmelding die je liet raden. Zeg dus wat er wel in staat.
+    let bestaand = [];
+    try { bestaand = db.prepare('SELECT slug FROM sites ORDER BY rowid').all().map((r) => r.slug); } catch { /* geen sites-tabel */ }
+    const wat = slug ? `onbekende site: ${slug}` : 'geen site opgegeven';
+    throw new Error(bestaand.length
+      ? `${wat}. In deze database staat: ${bestaand.join(', ')}`
+      : `${wat}. In deze database staat geen enkele site -- wijst DATABASE_PATH naar de juiste?`);
+  }
 
   const bestanden = new Map();       // pad -> Buffer
@@ -322 +438 @@
   }
 
+  // Wie je volgt. Dit ontbrak, en daarmee was een "verhuizing" halfslachtig: de
+  // Move vertelt je VOLGERS waar je heen ging, maar niets vertelde JOU wie jij
+  // volgde. Die lijst stond alleen in de oude database, en die laat je achter.
+  const volgCsv = followingCsv(slug);
+  if (volgCsv) { bestanden.set('following.csv', Buffer.from(volgCsv, 'utf8')); tellingen.following = volgCsv.trim().split('\n').length - 1; }
+
   const files = {};
   for (const pad of [...bestanden.keys()].sort()) files[pad] = sha256(bestanden.get(pad));