Directus als Daten-/Auth-Schicht + Backend-Anbindung

Directus (Postgres, hinter NPM) wird die zentrale Datenquelle für Kunden,
Aufträge, Produkte, Preise und Gutscheine; das skrift-backend bleibt reine
Generierungs-Engine.

- Docker/directus: docker-compose (Directus 11 + Postgres), Bootstrap-Skript
  legt Collections, Rollen/Policies/Rechte und Seed idempotent an.
- Extension skrift-auth: passwortloser Login per E-Mail-Code (Codes nur als
  Hash, Ablauf, Versuchslimit) sowie Kontoanlage aus dem Checkout.
- Extension skrift-orders: kontrollierter Bestell-Endpunkt für Gäste und
  eingeloggte Kunden; Preis wird immer serverseitig berechnet (editierbare
  Formel via sicherem Interpreter, Werte aus price_items).
- skrift-backend: neuer Endpunkt /api/order/from-directus erzeugt SVGs aus
  einem Directus-Auftrag und schreibt Status + artifact_path zurück. Dafür
  wurde die Kernlogik aus generateOrder als runGeneration herausgelöst
  (Verhalten unverändert); generateOrder ist jetzt ein HTTP-Wrapper.
- compose: NPM-Netz ergänzt, API_TOKEN/DIRECTUS_* werden durchgereicht.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Docker/skrift-backend/src/api/controllers/directus-controller.js

@@ -0,0 +1,158 @@
+/**
+ * Generierung auf Basis eines Directus-Auftrags.
+ *
+ * Ablauf: Directus meldet "Auftrag X ist bezahlt" → dieser Endpunkt holt den
+ * Auftrag samt Empfängerzeilen aus Directus, baut daraus die Dokumentliste für
+ * die bestehende Pipeline (runGeneration) und schreibt Ergebnis + Status zurück.
+ *
+ * Antwortet sofort mit 202 – die Generierung läuft im Hintergrund weiter, weil
+ * sie je nach Menge deutlich länger dauern kann als ein HTTP-Timeout erlaubt.
+ */
+
+const { runGeneration } = require('./order-controller');
+const directus = require('../../services/directus-service');
+
+// Directus-Formatschlüssel → Backend-Formate
+const LETTER_FORMAT = { a4: 'a4', a6_hoch: 'a6p', a6_quer: 'a6l' };
+const ENVELOPE_FORMAT = { c6: 'c6', dinlang: 'din_lang' };
+
+/** Baut den Adressblock für einen Umschlag aus einer Empfängerzeile. */
+function addressText(entry) {
+  if (entry.free_text) return String(entry.free_text).trim();
+  const name = [entry.first_name, entry.last_name].filter(Boolean).join(' ');
+  const street = [entry.street, entry.house_no].filter(Boolean).join(' ');
+  const city = [entry.zip, entry.city].filter(Boolean).join(' ');
+  const isForeign = entry.country && !/^(de|deutschland|germany)$/i.test(String(entry.country).trim());
+  return [name, street, city, isForeign ? entry.country : null]
+    .filter(Boolean).join('\n');
+}
+
+/** Platzhalterwerte einer Zeile (strukturierte Felder + freie Platzhalter). */
+function placeholdersOf(entry) {
+  return {
+    Anrede: entry.salutation || '',
+    Vorname: entry.first_name || '',
+    Nachname: entry.last_name || '',
+    Strasse: [entry.street, entry.house_no].filter(Boolean).join(' '),
+    PLZ: entry.zip || '',
+    Ort: entry.city || '',
+    Land: entry.country || '',
+    Briefnummer: entry.letter_number ?? '',
+    ...(entry.placeholders && typeof entry.placeholders === 'object' ? entry.placeholders : {}),
+  };
+}
+
+/** Übersetzt einen Directus-Auftrag in die Dokumentliste für runGeneration. */
+function buildDocuments(order, entries) {
+  const font = order.font || 'tilda';
+  const letterFormat = LETTER_FORMAT[order.format?.key] || 'a4';
+  const envFormat = ENVELOPE_FORMAT[order.envelope_format] || 'c6';
+  const wantsEnvelope = !!order.needs_envelope && order.envelope_labeling !== 'keine';
+  const envelopeType = order.envelope_labeling === 'freitext' ? 'custom' : 'recipient';
+
+  const documents = [];
+
+  entries.forEach((entry, i) => {
+    const placeholders = placeholdersOf(entry);
+
+    documents.push({
+      index: i,
+      type: 'letter',
+      text: order.text_template || '',
+      format: letterFormat,
+      font,
+      placeholders,
+    });
+
+    if (wantsEnvelope) {
+      documents.push({
+        index: i,
+        type: 'envelope',
+        envelopeType,
+        text: envelopeType === 'recipient' ? addressText(entry) : (order.text_template || ''),
+        format: envFormat,
+        font,
+        placeholders,
+      });
+    }
+  });
+
+  return { documents, letterFormat, envFormat, wantsEnvelope };
+}
+
+/**
+ * POST /api/order/from-directus
+ * Body: { orderId }
+ */
+async function generateFromDirectus(req, res, next) {
+  const { orderId } = req.body || {};
+  if (!orderId) {
+    return res.status(400).json({ error: 'Invalid request', message: 'orderId is required' });
+  }
+
+  let order;
+  try {
+    const loaded = await directus.fetchOrder(orderId);
+    order = loaded.order;
+
+    if (!loaded.entries.length) {
+      return res.status(400).json({
+        error: 'Invalid order',
+        message: `Auftrag ${order.order_number} hat keine Empfängerzeilen.`
+      });
+    }
+
+    // Sofort quittieren – der Rest läuft im Hintergrund.
+    res.status(202).json({
+      accepted: true,
+      orderId,
+      orderNumber: order.order_number,
+      documents: loaded.entries.length * (order.needs_envelope ? 2 : 1),
+    });
+
+    const { documents, letterFormat, envFormat, wantsEnvelope } = buildDocuments(order, loaded.entries);
+
+    console.log(`[Directus] Generiere ${order.order_number}: ${documents.length} Dokumente`);
+
+    const result = await runGeneration({
+      orderNumber: order.order_number,
+      letters: documents,
+      metadata: {
+        letterFormat,
+        envelopeFormat: wantsEnvelope ? envFormat : null,
+        envelopeBeschriftung: wantsEnvelope ? order.envelope_labeling : null,
+        directusOrderId: orderId,
+        customerEmail: order.customer_email,
+      },
+    });
+
+    await directus.updateOrder(orderId, {
+      status: 'in_queue',
+      artifact_path: result.outputPath,
+    });
+    await directus.addStatusHistory(orderId, 'in_queue',
+      `${result.letters.length} Schriftstücke, ${result.envelopes.length} Umschläge generiert.`);
+
+    console.log(`[Directus] ${order.order_number} fertig → in_queue`);
+
+  } catch (err) {
+    console.error('[Directus] Generierung fehlgeschlagen:', err.message);
+
+    // Fehler in Directus sichtbar machen, statt still zu scheitern.
+    if (order?.id || orderId) {
+      try {
+        await directus.addStatusHistory(orderId, 'fehler', `Generierung fehlgeschlagen: ${err.message}`);
+      } catch (e) {
+        console.error('[Directus] Konnte Fehler nicht zurückschreiben:', e.message);
+      }
+    }
+
+    // Antwort wurde ggf. schon gesendet (202) – dann nur noch loggen.
+    if (!res.headersSent) {
+      if (err.status) return res.status(err.status).json({ error: 'Generation failed', message: err.message });
+      return next(err);
+    }
+  }
+}
+
+module.exports = { generateFromDirectus };