// Anti-Pattern: Ein einzelner Workflow, der alles macht
// Kunden-Onboarding mit 47 Knoten, 12 Zweigen, 8 Error-Handlern
// Ergebnis: Unmöglich zu testen, zu debuggen oder zu modifizieren, ohne etwas zu brechen

// Symptome, dass Sie das Limit erreicht haben:
// - Das Hinzufügen eines neuen Schritts erfordert das Scrollen durch 5 Bildschirme
// - Die Änderung eines Zweigs bricht drei unabhängige Zweige
// - Das Onboarding neuer Entwickler dauert über 3 Wochen
// - "Berühren Sie diesen Workflow nicht, er funktioniert irgendwie"

// Workflow A modifiziert Daten, von denen Workflow B abhängt
// Workflow C ruft Workflow D auf, der dieselben Datensätze aktualisiert
// Workflow E schlägt stillschweigend fehl, weil Workflow F sein Ausgabeformat geändert hat

// Ergebnis: Änderungen erfordern das Verständnis des gesamten Systems
// Risiko: Jede Modifikation kann sich unvorhersehbar ausweiten
// Realität: Die Entwicklungsgeschwindigkeit kommt zum Stillstand

// Wie testen Sie einen Workflow mit:
// - 15 externen API-Abhängigkeiten
// - 8 verschiedenen Ausführungspfaden
// - Zustand, der über mehrere Ausführungen hinweg bestehen bleibt
// - Zeitbasierten Triggern mit externen Bedingungen

// Antwort: Die meisten Teams tun es nicht. Sie testen in Produktion.
// Konsequenz: 73% der Produktionsvorfälle werden durch ungetestete Änderungen verursacht

// Problem: Sie müssen einen fehlgeschlagenen Vorgang mit modifizierten Parametern wiederholen
// DAG-Beschränkung: Kann nicht zum selben Knoten zurückkehren
// Workaround: Komplexes Branching, das Logik dupliziert

// Ergebnis: "Spaghetti-Workflows", bei denen Logik über mehrere Zweige
// dupliziert wird, um Iteration zu simulieren

// Jeder Knoten hat seine eigenen Ausgabedaten
// Das Übergeben von Zustand zwischen Knoten erfordert explizite Verbindungen
// Komplexe Workflows werden zu "Verdrahtungsdiagrammen", bei denen der Datenfluss
// die Geschäftslogik verschleiert

// Beispiel: Ein Workflow mit 20 Knoten könnte
// 60+ Datenverbindungen haben, die jeweils Wartung erfordern

// Geschäftsregel eingebettet in IF-Knoten-Ausdruck:
{{ $json.order.total > 1000 && $json.customer.tier === 'premium' && $json.items.length > 5 && !$json.flags.rush_order }}

// Frage: Wo ist "Premium-Kunden mit großen Bestellungen erhalten kostenlosen Versand" dokumentiert?
// Antwort: Das ist es nicht. Es ist in der Knotenkonfiguration vergraben.
// Konsequenz: Geschäftslogik wird zu Stammeswissen

// Gut: Jeder Workflow erledigt EINE Sache gut
// Workflow: validate-customer-data
// Verantwortung: Validieren und Normalisieren von Kundeneingaben
// Eingaben: Rohe Kundendaten
// Ausgaben: Validierter Kundenobjekt oder Validierungsfehler

// Schlecht: Workflow versucht alles zu tun
// Workflow: customer-onboarding-complete
// Versucht: Validierung + CRM-Erstellung + E-Mail-Versand +
//           Slack-Benachrichtigung + Analytics-Tracking + Dokumentengenerierung
// Ergebnis: 47 Knoten, unmöglich zu testen, Änderungen sind riskant

// Vertrag für customer-validation Workflow

// Input-Schema:
{
  "customer": {
    "email": "string (erforderlich, gültige E-Mail)",
    "name": "string (erforderlich, min. 2 Zeichen)",
    "company": "string (optional)",
    "phone": "string (optional, gültiges Format)"
  },
  "context": {
    "source": "string (web|api|import)",
    "timestamp": "ISO 8601 datetime"
  }
}

// Output-Schema (Erfolg):
{
  "status": "valid",
  "customer": {
    "id": "generated-uuid",
    "email": "[email protected]",
    "name": "Normalized Name",
    // ... normalisierte Felder
  },
  "validation": {
    "passed": ["email", "name"],
    "warnings": ["Telefonformat angepasst"]
  }
}

// Output-Schema (Fehlschlag):
{
  "status": "invalid",
  "errors": [
    { "field": "email", "code": "INVALID_FORMAT", "message": "..." }
  ],
  "suggestions": ["..."]
}

// Orchestrator-Workflow: customer-onboarding-orchestrator
// Enthält KEINE Geschäftslogik
// KOORDINIERT nur andere Workflows

// Schritt 1: Eingabe validieren
// Ruft: workflow-validate-customer-data auf
// Bei Erfolg: Weiter zu Schritt 2
// Bei Fehlschlag: Validierungsfehler zurückgeben

// Schritt 2: Duplikate prüfen
// Ruft: workflow-check-duplicate-customer auf
// Bei gefundenem Duplikat: Zusammenführen oder warnen
// Bei neuem Kunden: Weiter zu Schritt 3

// Schritt 3: CRM-Datensatz erstellen
// Ruft: workflow-create-crm-record auf
// Bei Erfolg: Weiter zu Schritt 4
// Bei Fehlschlag: Rollback, Admin benachrichtigen

// Schritt 4: Willkommens-Sequenz senden
// Ruft: workflow-trigger-welcome-email auf
// Async: Nicht auf Fertigstellung warten

// Schritt 5: Team benachrichtigen
// Ruft: workflow-send-slack-notification auf
// Async: Fire and forget

// Jeder Sub-Workflow ist unabhängig testbar
// Orchestrator-Logik ist auf einen Blick sichtbar
// Neue Schritte können ohne Berührung bestehenden Codes hinzugefügt werden

// Parent-Workflow: order-processing-orchestrator

// Node: Validate Order Input
// Type: Execute Workflow
// Workflow ID: validate-order-data
// Übergibt: {{ $json }}

// Node: Check Inventory
// Type: Execute Workflow  
// Workflow ID: check-inventory-availability
// Übergibt: {{ $json.order.items }}
// Wartet auf: Validierungsabschluss

// Node: Calculate Shipping
// Type: Execute Workflow
// Workflow ID: calculate-shipping-rates
// Übergibt: {{ $json.order }}
// Wartet auf: Inventarprüfung

// Node: Process Payment
// Type: Execute Workflow
// Workflow ID: process-payment-gateway
// Übergibt: {{ $json.order.total }}
// Wartet auf: Versandberechnung

// Node: Send Confirmations
// Type: Execute Workflow
// Workflow ID: send-order-confirmations
// Übergibt: {{ $json.order }}
// Async: true (nicht warten)

// Aufrufender Workflow (Parent):
// Set-Knoten vor Execute Workflow:
{
  "orderId": "{{ $json.id }}",
  "customerEmail": "{{ $json.customer.email }}",
  "items": "{{ $json.items }}",
  "metadata": {
    "source": "web",
    "sessionId": "{{ $json.sessionId }}",
    "timestamp": "{{ $now }}"
  }
}

// Aufgerufener Workflow (Child) empfängt dies als Input
// Zugriff über: {{ $json.orderId }}, {{ $json.customerEmail }}, etc.

// Child-Workflow gibt zurück:
// Output des letzten Knotens wird zum Input des Parents für den nächsten Knoten
// Oder explizit mit Code-Knoten gesetzt:
return {
  json: {
    status: "success",
    processedAt: $now,
    result: processedData
  }
};

// Parent-Workflow Fehlerbehandlungs-Pattern:

// Node: Execute Workflow (process-payment)
// On Error: Continue
// Error Output → Node: Handle Payment Failure

// Handle Payment Failure Knoten (Code):
const error = items[0].json.error;

// Fehlertyp bestimmen
if (error.message.includes('insufficient_funds')) {
  return {
    json: {
      action: 'send_payment_retry_email',
      priority: 'high',
      customer: $('Execute Workflow').item.json.customerEmail
    }
  };
} else if (error.message.includes('card_declined')) {
  return {
    json: {
      action: 'notify_customer_service',
      priority: 'urgent',
      reason: 'card_issue'
    }
  };
} else {
  return {
    json: {
      action: 'alert_technical_team',
      priority: 'critical',
      error: error.message
    }
  };
}

// Workflow: utility-format-phone-number
// Zweck: Telefonnummern in E.164-Format normalisieren
// Eingaben: { "phone": "string", "country": "string (optional)" }
// Ausgaben: { "formatted": "string", "valid": "boolean" }

// Code-Knoten Implementierung:
const phoneUtil = require('google-libphonenumber').PhoneNumberUtil.getInstance();
const PNT = require('google-libphonenumber').PhoneNumberType;

const phone = $json.phone;
const country = $json.country || 'US';

try {
  const number = phoneUtil.parse(phone, country);
  const isValid = phoneUtil.isValidNumber(number);
  
  if (isValid) {
    return {
      json: {
        formatted: phoneUtil.format(number, PhoneNumberFormat.E164),
        valid: true,
        type: phoneUtil.getNumberType(number)
      }
    };
  }
} catch (e) {
  // Ungültige Nummer
}

return {
  json: {
    formatted: null,
    valid: false,
    error: 'Ungültiges Telefonnummernformat'
  }
};

// Workflow: utility-error-handler
// Erstellt konsistente Fehlerantworten über alle Workflows

// Eingaben: { "error": "Error object", "context": "..." }

// Code-Knoten:
const error = $json.error;
const context = $json.context;

const standardizedError = {
  error: {
    code: error.code || 'UNKNOWN_ERROR',
    message: error.message || 'Ein unerwarteter Fehler ist aufgetreten',
    timestamp: new Date().toISOString(),
    workflowId: $workflow.id,
    executionId: $execution.id,
    context: context
  },
  retryable: isRetryableError(error),
  nextSteps: suggestRecoveryActions(error)
};

function isRetryableError(err) {
  const retryableCodes = [
    'RATE_LIMITED',
    'TIMEOUT',
    'NETWORK_ERROR',
    'SERVICE_UNAVAILABLE'
  ];
  return retryableCodes.includes(err.code);
}

function suggestRecoveryActions(err) {
  // Gibt umsetzbare nächste Schritte basierend auf Fehlertyp zurück
  // ...
}

return { json: standardizedError };

// Statt verschachtelter IF-Knoten strukturierte Entscheidungstabellen verwenden

// Workflow: calculate-discount
// Verwendet: Code-Knoten mit Entscheidungstabelle

const decisionTable = [
  // Kundenstufe, Bestellwert, Saison, Rabatt %
  { tier: 'bronze',  minValue: 0,    maxValue: 100,  season: 'regular', discount: 0 },
  { tier: 'bronze',  minValue: 100,  maxValue: 500,  season: 'regular', discount: 5 },
  { tier: 'bronze',  minValue: 500,  maxValue: Infinity, season: 'regular', discount: 10 },
  { tier: 'silver',  minValue: 0,    maxValue: 100,  season: 'regular', discount: 5 },
  { tier: 'silver',  minValue: 100,  maxValue: 500,  season: 'regular', discount: 10 },
  { tier: 'silver',  minValue: 500,  maxValue: Infinity, season: 'regular', discount: 15 },
  { tier: 'gold',    minValue: 0,    maxValue: 100,  season: 'regular', discount: 10 },
  { tier: 'gold',    minValue: 100,  maxValue: 500,  season: 'regular', discount: 15 },
  { tier: 'gold',    minValue: 500,  maxValue: Infinity, season: 'regular', discount: 20 },
  { tier: 'any',     minValue: 1000, maxValue: Infinity, season: 'holiday', discount: 25 },
];

const order = $json.order;
const customer = $json.customer;

const applicableRules = decisionTable.filter(rule => {
  const tierMatch = rule.tier === 'any' || rule.tier === customer.tier;
  const valueMatch = order.total >= rule.minValue && order.total < rule.maxValue;
  const seasonMatch = rule.season === 'any' || rule.season === order.season;
  return tierMatch && valueMatch && seasonMatch;
});

// Höchsten Rabatt anwenden
const maxDiscount = Math.max(...applicableRules.map(r => r.discount));

return {
  json: {
    originalTotal: order.total,
    discountPercent: maxDiscount,
    discountAmount: order.total * (maxDiscount / 100),
    finalTotal: order.total * (1 - maxDiscount / 100),
    appliedRules: applicableRules
  }
};

// Für komplexe Prozesse mit mehreren Zuständen und Übergängen
// Workflow: order-state-machine

const validTransitions = {
  'pending': ['confirmed', 'cancelled'],
  'confirmed': ['processing', 'cancelled'],
  'processing': ['shipped', 'backordered'],
  'shipped': ['delivered', 'lost'],
  'delivered': ['completed', 'returned'],
  'backordered': ['processing', 'cancelled'],
  'cancelled': [],
  'completed': [],
  'returned': ['refunded'],
  'refunded': [],
  'lost': ['refunded', 'replaced']
};

const stateActions = {
  'pending': {
    onEnter: ['validateInventory', 'checkFraud'],
    onExit: ['clearHold'],
    timeout: { hours: 24, action: 'autoCancel' }
  },
  'confirmed': {
    onEnter: ['reserveInventory', 'processPayment'],
    onExit: ['releaseInventoryIfFailed']
  },
  'processing': {
    onEnter: ['createPickingList', 'notifyWarehouse'],
    timeout: { hours: 48, action: 'escalate' }
  }
  // ... weitere Zustände
};

// Aktueller Zustand und angeforderter Übergang
const currentState = $json.currentState;
const requestedState = $json.requestedState;

// Übergang validieren
const allowed = validTransitions[currentState]?.includes(requestedState);

if (!allowed) {
  return {
    json: {
      success: false,
      error: `Ungültiger Übergang von ${currentState} zu ${requestedState}`,
      validTransitions: validTransitions[currentState] || []
    }
  };
}

// Zustandsaktionen ausführen
const actions = stateActions[requestedState]?.onEnter || [];

return {
  json: {
    success: true,
    previousState: currentState,
    newState: requestedState,
    actions: actions,
    timestamp: $now
  }
};

// Deklarative Geschäftsregeln, die Nicht-Entwickler verstehen können

const rules = [
  {
    name: 'High Value Order Alert',
    condition: (data) => data.order.total > 10000,
    action: 'notify_manager',
    priority: 1
  },
  {
    name: 'VIP Customer Fast Track',
    condition: (data) => data.customer.tier === 'vip' && data.order.items.length < 10,
    action: 'priority_processing',
    priority: 2
  },
  {
    name: 'International Order Check',
    condition: (data) => data.order.shipping.country !== 'US',
    action: 'customs_review',
    priority: 3
  },
  {
    name: 'Subscription Discount',
    condition: (data) => data.customer.subscriptionActive && data.order.type === 'subscription',
    action: 'apply_subscription_discount',
    priority: 4
  }
];

// Alle Regeln auswerten
const orderData = $json;
const matchedRules = rules
  .filter(rule => rule.condition(orderData))
  .sort((a, b) => a.priority - b.priority);

// Aktionen in Prioritätsreihenfolge ausführen
const actions = matchedRules.map(rule => ({
  action: rule.action,
  rule: rule.name,
  priority: rule.priority
}));

return {
  json: {
    orderId: orderData.order.id,
    matchedRules: matchedRules.length,
    actions: actions,
    requiresApproval: actions.some(a => ['notify_manager', 'customs_review'].includes(a.action))
  }
};

// Verarbeitungsstrategie basierend auf Bestellmerkmalen auswählen

const strategies = {
  'digital': {
    processor: 'processDigitalOrder',
    fulfillment: 'immediateDelivery',
    payment: 'chargeImmediately'
  },
  'physical': {
    processor: 'processPhysicalOrder',
    fulfillment: 'warehousePicking',
    payment: 'chargeOnShip'
  },
  'subscription': {
    processor: 'processSubscription',
    fulfillment: 'scheduleRecurring',
    payment: 'setupRecurringBilling'
  },
  'mixed': {
    processor: 'processMixedOrder',
    fulfillment: 'splitFulfillment',
    payment: 'chargeInStages'
  }
};

function determineStrategy(order) {
  const hasDigital = order.items.some(i => i.type === 'digital');
  const hasPhysical = order.items.some(i => i.type === 'physical');
  const isSubscription = order.type === 'subscription';
  
  if (isSubscription) return 'subscription';
  if (hasDigital && hasPhysical) return 'mixed';
  if (hasDigital) return 'digital';
  return 'physical';
}

const order = $json.order;
const strategy = determineStrategy(order);
const config = strategies[strategy];

return {
  json: {
    orderId: order.id,
    strategy: strategy,
    config: config,
    // Output bestimmt, welcher Sub-Workflow aufgerufen wird
    nextWorkflow: `process-order-${strategy}`
  }
};

// Bestellung durch mehrere Handler verarbeiten, bis einer sie verarbeitet

const handlers = [
  {
    name: 'Fraud Check',
    canHandle: (order) => order.total > 5000 || order.flags?.risky,
    handle: (order) => ({ action: 'hold_for_review', reason: 'fraud_check' })
  },
  {
    name: 'Inventory Check',
    canHandle: (order) => order.items.some(i => i.stock < i.quantity),
    handle: (order) => ({ action: 'backorder', reason: 'insufficient_stock' })
  },
  {
    name: 'Customs Check',
    canHandle: (order) => order.shipping.country !== order.warehouse.country,
    handle: (order) => ({ action: 'customs_hold', reason: 'international_shipment' })
  },
  {
    name: 'Standard Processing',
    canHandle: () => true, // Default-Handler
    handle: (order) => ({ action: 'process_normally', reason: 'standard_flow' })
  }
];

const order = $json.order;

// Ersten Handler finden, der diese Bestellung verarbeiten kann
const handler = handlers.find(h => h.canHandle(order));
const result = handler.handle(order);

return {
  json: {
    orderId: order.id,
    handler: handler.name,
    result: result,
    canProceed: result.action !== 'hold_for_review'
  }
};

// Workflow: expense-approval-process

// Schritt 1: Spesenabreichtung empfangen
// Input: { expense: {...}, submitter: {...} }

// Schritt 2: Auto-Genehmigung für kleine Beträge
// Code-Knoten:
const expense = $json.expense;
const autoApproveLimit = 100; // 100$

if (expense.amount <= autoApproveLimit && expense.category !== 'travel') {
  return {
    json: {
      status: 'auto_approved',
      approvedAt: $now,
      approvedBy: 'system',
      nextStep: 'process_payment'
    }
  };
}

// Schritt 3: An zuständigen Genehmiger basierend auf Betrag weiterleiten
let approverLevel;
if (expense.amount <= 500) approverLevel = 'manager';
else if (expense.amount <= 2000) approverLevel = 'director';
else approverLevel = 'vp';

// Schritt 4: Genehmigungsaufgabe in Projektmanagement-Tool erstellen
// Verwendet HTTP-Knoten, um Aufgabe in Asana/Monday/etc. zu erstellen

// Schritt 5: Auf Genehmigung warten (mit Wait-Knoten)
// Webhook-Trigger für Genehmigungsantwort

// Schritt 6: Basierend auf Genehmigungsentscheidung verarbeiten
// Bei Genehmigung: process_payment Workflow
// Bei Ablehnung: notify_submitter Workflow

// Workflow: customer-support-triage

const ticket = $json.ticket;
const customer = $json.customer;

// Bewertungssystem für automatische vs. manuelle Bearbeitung
const riskScore = calculateRiskScore(ticket, customer);

function calculateRiskScore(ticket, customer) {
  let score = 0;
  
  // Dringlichkeitsfaktoren
  if (ticket.priority === 'urgent') score += 30;
  if (ticket.tags.includes('billing')) score += 20;
  if (ticket.tags.includes('security')) score += 40;
  
  // Kundenfaktoren
  if (customer.tier === 'enterprise') score += 25;
  if (customer.lifetimeValue > 50000) score += 15;
  
  // Inhaltsanalyse
  if (ticket.sentiment === 'angry') score += 20;
  if (ticket.previousTickets > 3) score += 10;
  
  return score;
}

// Entscheidungsweiterleitung
if (riskScore < 30) {
  // Geringes Risiko: Automatisierte Antwort
  return {
    json: {
      action: 'auto_respond',
      template: 'standard_response',
      score: riskScore
    }
  };
} else if (riskScore < 60) {
  // Mittleres Risiko: Warteschlange für menschliche Überprüfung innerhalb von 4 Stunden
  return {
    json: {
      action: 'queue_for_agent',
      priority: 'normal',
      sla: '4_hours',
      score: riskScore
    }
  };
} else {
  // Hohes Risiko: Sofortige menschliche Aufmerksamkeit
  return {
    json: {
      action: 'immediate_escalation',
      priority: 'critical',
      notify: ['support_manager', 'customer_success'],
      score: riskScore,
      reason: 'High-value customer or sensitive issue'
    }
  };
}

// Workflow: content-moderation-pipeline

const content = $json.content;

// Schritt 1: KI-Vorscreening
const aiScore = await callModerationAPI(content);

// Schritt 2: Weiterleitung basierend auf Konfidenz
if (aiScore.confidence > 0.95 && aiScore.category === 'safe') {
  // Hohe Konfidenz sicher: Auto-Genehmigung
  return { json: { action: 'auto_approve', confidence: aiScore.confidence } };
} else if (aiScore.confidence > 0.9 && aiScore.category === 'violating') {
  // Hohe Konfidenz Verstoß: Auto-Ablehnung
  return { json: { action: 'auto_reject', confidence: aiScore.confidence, reason: aiScore.reason } };
} else {
  // Unsicher: Warteschlange für menschliche Überprüfung
  // Überprüfungsaufgabe mit KI-Kontext erstellen
  const reviewTask = {
    contentId: content.id,
    aiPrediction: aiScore.category,
    aiConfidence: aiScore.confidence,
    flags: aiScore.flags,
    suggestedAction: aiScore.suggestedAction,
    reviewUrl: `https://moderation.example.com/review/${content.id}`,
    sla: '24_hours'
  };
  
  // An Überprüfungswarteschlange senden (Redis, Datenbank oder Task-Queue)
  await sendToReviewQueue(reviewTask);
  
  return {
    json: {
      action: 'queued_for_review',
      queuePosition: await getQueuePosition(),
      estimatedReviewTime: await getEstimatedTime(),
      contentId: content.id
    }
  };
}

// Workflow: send-approval-request

const request = $json.request;

// Umfassenden Kontext für Genehmiger aufbauen
const approvalContext = {
  // Was muss genehmigt werden
  requestType: request.type,
  title: request.title,
  description: request.description,
  amount: request.amount,
  currency: request.currency,
  
  // Warum es wichtig ist
  businessJustification: request.justification,
  expectedRoi: request.roi,
  riskLevel: request.risk,
  
  // Wer ist involviert
  requester: {
    name: request.requester.name,
    department: request.requester.department,
    history: request.requester.approvalHistory
  },
  
  // Historischer Kontext
  similarRequests: await getSimilarRequests(request),
  departmentBudget: await getDepartmentBudget(request.requester.department),
  remainingBudget: await getRemainingBudget(request.requester.department),
  
  // KI-Empfehlung (falls anwendbar)
  aiRecommendation: request.aiAnalysis?.recommendation,
  aiConfidence: request.aiAnalysis?.confidence,
  aiRationale: request.aiAnalysis?.rationale,
  
  // Schnellaktionen
  actions: [
    { label: 'Approve', value: 'approve', color: 'green' },
    { label: 'Reject', value: 'reject', color: 'red' },
    { label: 'Request Info', value: 'info', color: 'blue' },
    { label: 'Escalate', value: 'escalate', color: 'yellow' }
  ],
  
  // Antwortmechanismus
  respondUrl: `https://approvals.example.com/respond/${request.id}`,
  expiresAt: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString()
};

// Senden über Slack mit reichhaltiger Formatierung
// oder E-Mail mit klaren CTAs
// oder Microsoft Teams mit adaptiven Karten

return {
  json: {
    sent: true,
    notificationType: 'slack',
    context: approvalContext,
    expiresAt: approvalContext.expiresAt
  }
};

// Workflow: daily-expense-batch-review

// Läuft täglich um 9 Uhr
// Sammelt alle ausstehenden Spesen und erstellt Batch-Überprüfung

const pendingExpenses = await getPendingExpenses();

// Nach Abteilung gruppieren für effiziente Überprüfung
const byDepartment = pendingExpenses.reduce((acc, exp) => {
  const dept = exp.department;
  if (!acc[dept]) acc[dept] = [];
  acc[dept].push(exp);
  return acc;
}, {});

// Batch-Überprüfung für jede Abteilungsleitung erstellen
for (const [department, expenses] of Object.entries(byDepartment)) {
  const totalAmount = expenses.reduce((sum, e) => sum + e.amount, 0);
  const departmentHead = await getDepartmentHead(department);
  
  const batchReview = {
    batchId: `batch-${$now}-${department}`,
    department: department,
    reviewer: departmentHead,
    summary: {
      totalExpenses: expenses.length,
      totalAmount: totalAmount,
      averageAmount: totalAmount / expenses.length,
      categories: groupByCategory(expenses),
      highestExpense: Math.max(...expenses.map(e => e.amount)),
      flaggedExpenses: expenses.filter(e => e.flags?.length > 0)
    },
    expenses: expenses.map(e => ({
      id: e.id,
      amount: e.amount,
      category: e.category,
      submitter: e.submitter,
      description: e.description,
      flags: e.flags,
      daysPending: daysSince(e.submittedAt)
    })),
    actions: {
      approveAll: { url: `...`, label: 'Approve All' },
      reviewIndividual: { url: `...`, label: 'Review Each' },
      rejectAll: { url: `...`, label: 'Reject All' }
    }
  };
  
  await sendBatchReviewNotification(departmentHead, batchReview);
}

return {
  json: {
    batchesCreated: Object.keys(byDepartment).length,
    totalExpenses: pendingExpenses.length,
    totalAmount: pendingExpenses.reduce((sum, e) => sum + e.amount, 0)
  }
};

// Workflow: long-running-document-processing

const documentId = $json.documentId;

// Schritt 1: Checkpoint laden, falls vorhanden
const checkpoint = await loadCheckpoint(documentId);

if (checkpoint) {
  // Von Checkpoint fortsetzen
  $json.resumeFrom = checkpoint.step;
  $json.partialResults = checkpoint.results;
}

// Schritt 2: In Phasen mit Checkpoints verarbeiten
const stages = [
  { name: 'extract_text', function: extractText },
  { name: 'classify_document', function: classifyDocument },
  { name: 'extract_entities', function: extractEntities },
  { name: 'validate_data', function: validateData },
  { name: 'store_results', function: storeResults }
];

const startIndex = checkpoint ? stages.findIndex(s => s.name === checkpoint.step) : 0;

for (let i = startIndex; i < stages.length; i++) {
  const stage = stages[i];
  
  try {
    const result = await stage.function($json);
    
    // Checkpoint nach jeder Phase speichern
    await saveCheckpoint(documentId, {
      step: stage.name,
      results: result,
      completedAt: $now
    });
    
  } catch (error) {
    // Fehlgeschlagenen Zustand für Recovery speichern
    await saveCheckpoint(documentId, {
      step: stage.name,
      error: error.message,
      failedAt: $now,
      retryCount: (checkpoint?.retryCount || 0) + 1
    });
    
    throw error; // Lassen Sie n8n Retry/Error-Workflow handhaben
  }
}

// Schritt 3: Checkpoint bei Erfolg bereinigen
await deleteCheckpoint(documentId);

// Workflow: order-saga-orchestrator
// Koordiniert mehrere Dienste mit kompensierenden Aktionen

const order = $json.order;
const sagaId = generateUUID();

const sagaSteps = [
  {
    name: 'reserve_inventory',
    execute: async () => await reserveInventory(order.items),
    compensate: async () => await releaseInventory(order.items)
  },
  {
    name: 'process_payment',
    execute: async () => await chargePayment(order.payment),
    compensate: async () => await refundPayment(order.payment)
  },
  {
    name: 'create_shipment',
    execute: async () => await createShippingLabel(order),
    compensate: async () => await cancelShippingLabel(order)
  },
  {
    name: 'send_confirmation',
    execute: async () => await sendEmail(order.customer.email, 'confirmation'),
    compensate: null // E-Mail kann nicht rückgängig gemacht werden, aber nicht kritisch
  }
];

const completedSteps = [];

for (const step of sagaSteps) {
  try {
    const result = await step.execute();
    completedSteps.push({ name: step.name, result: result });
    
    // Fortschritt protokollieren
    await logSagaProgress(sagaId, step.name, 'completed');
    
  } catch (error) {
    // Fehler protokollieren
    await logSagaProgress(sagaId, step.name, 'failed', error);
    
    // Abgeschlossene Schritte in umgekehrter Reihenfolge kompensieren
    for (const completed of completedSteps.reverse()) {
      const stepDef = sagaSteps.find(s => s.name === completed.name);
      if (stepDef.compensate) {
        try {
          await stepDef.compensate();
          await logSagaProgress(sagaId, completed.name, 'compensated');
        } catch (compError) {
          await logSagaProgress(sagaId, completed.name, 'compensation_failed', compError);
          // Warnung für manuelles Eingreifen
          await alertManualIntervention(sagaId, completed.name, compError);
        }
      }
    }
    
    return {
      json: {
        success: false,
        sagaId: sagaId,
        failedAt: step.name,
        error: error.message,
        compensationStatus: 'attempted'
      }
    };
  }
}

return {
  json: {
    success: true,
    sagaId: sagaId,
    completedSteps: completedSteps.map(s => s.name),
    orderStatus: 'confirmed'
  }
};

// Workflow: api-call-with-circuit-breaker

const serviceName = $json.service;
const circuitState = await getCircuitState(serviceName);

// Schaltungszustand prüfen
if (circuitState.status === 'OPEN') {
  // Schaltung ist offen - schnell scheitern
  const timeSinceOpened = Date.now() - circuitState.openedAt;
  const timeout = circuitState.timeoutMs || 60000;
  
  if (timeSinceOpened < timeout) {
    return {
      json: {
        success: false,
        error: 'Circuit breaker is OPEN',
        retryAfter: new Date(circuitState.openedAt + timeout).toISOString(),
        circuitState: circuitState
      }
    };
  } else {
    // Halb-offenen Zustand versuchen
    await setCircuitState(serviceName, 'HALF_OPEN');
  }
}

// API-Aufruf durchführen
try {
  const response = await makeAPICall($json);
  
  // Erfolg - aufzeichnen
  await recordSuccess(serviceName);
  
  // Falls halb-offen, Schaltung schließen
  if (circuitState.status === 'HALF_OPEN') {
    await setCircuitState(serviceName, 'CLOSED', { consecutiveSuccesses: 0 });
  }
  
  return { json: { success: true, data: response } };
  
} catch (error) {
  // Fehler aufzeichnen
  await recordFailure(serviceName);
  
  const consecutiveFailures = await getConsecutiveFailures(serviceName);
  const threshold = circuitState.failureThreshold || 5;
  
  if (consecutiveFailures >= threshold) {
    // Schaltung öffnen
    await setCircuitState(serviceName, 'OPEN', {
      openedAt: Date.now(),
      reason: error.message,
      consecutiveFailures: consecutiveFailures
    });
  }
  
  return {
    json: {
      success: false,
      error: error.message,
      circuitState: await getCircuitState(serviceName)
    }
  };
}

// Workflow: resilient-api-call

const operation = $json.operation;
const maxRetries = operation.maxRetries || 3;
const baseDelay = operation.baseDelayMs || 1000;

for (let attempt = 0; attempt <= maxRetries; attempt++) {
  try {
    const result = await executeOperation(operation);
    
    // Erfolg nach Retry protokollieren
    if (attempt > 0) {
      await logEvent('operation_succeeded_after_retry', {
        operation: operation.name,
        attempts: attempt + 1
      });
    }
    
    return {
      json: {
        success: true,
        attempts: attempt + 1,
        result: result
      }
    };
    
  } catch (error) {
    const isLastAttempt = attempt === maxRetries;
    const isRetryable = isRetryableError(error);
    
    if (isLastAttempt || !isRetryable) {
      // Aufgeben
      return {
        json: {
          success: false,
          attempts: attempt + 1,
          error: error.message,
          retryable: false
        }
      };
    }
    
    // Verzögerung mit exponentiellem Backoff und Jitter berechnen
    const delay = Math.min(
      baseDelay * Math.pow(2, attempt) + Math.random() * 1000,
      30000 // Max 30 Sekunden
    );
    
    await logEvent('retry_scheduled', {
      operation: operation.name,
      attempt: attempt + 1,
      nextAttemptDelay: delay,
      error: error.message
    });
    
    // Vor Retry warten
    await sleep(delay);
  }
}

function isRetryableError(error) {
  const retryableCodes = [
    'ECONNRESET',
    'ETIMEDOUT',
    'ENOTFOUND',
    'ECONNREFUSED',
    '503',
    '502',
    '504',
    '429'
  ];
  
  return retryableCodes.some(code => 
    error.code?.includes(code) || 
    error.message?.includes(code) ||
    error.statusCode?.toString() === code
  );
}

// Workflow: process-with-dlq

const message = $json.message;
const processingStartTime = Date.now();
const timeoutMs = 30000;

try {
  // Timeout einrichten
  const timeoutPromise = new Promise((_, reject) => 
    setTimeout(() => reject(new Error('Processing timeout')), timeoutMs)
  );
  
  // Wettlauf zwischen Verarbeitung und Timeout
  const result = await Promise.race([
    processMessage(message),
    timeoutPromise
  ]);
  
  return {
    json: {
      success: true,
      processingTime: Date.now() - processingStartTime,
      result: result
    }
  };
  
} catch (error) {
  // An Dead Letter Queue für spätere Analyse senden
  const deadLetter = {
    originalMessage: message,
    error: {
      message: error.message,
      stack: error.stack,
      code: error.code
    },
    context: {
      workflowId: $workflow.id,
      executionId: $execution.id,
      timestamp: $now,
      attemptCount: message.attemptCount || 1
    },
    metadata: {
      source: message.source,
      receivedAt: message.receivedAt,
      processingTime: Date.now() - processingStartTime
    }
  };
  
  await sendToDeadLetterQueue(deadLetter);
  
  // Warnung, wenn dies häufig vorkommt
  const dlqMetrics = await getDLQMetrics(timeWindow = '1h');
  if (dlqMetrics.count > dlqMetrics.threshold) {
    await alertOperationsTeam({
      alert: 'DLQ_THRESHOLD_EXCEEDED',
      count: dlqMetrics.count,
      threshold: dlqMetrics.threshold,
      recentErrors: dlqMetrics.recentErrors
    });
  }
  
  return {
    json: {
      success: false,
      sentToDLQ: true,
      error: error.message
    }
  };
}

// Workflow: batch-processor

const items = $json.items;
const batchSize = $json.batchSize || 100;
const results = [];

// In Batches verarbeiten
for (let i = 0; i < items.length; i += batchSize) {
  const batch = items.slice(i, i + batchSize);
  const batchNumber = Math.floor(i / batchSize) + 1;
  const totalBatches = Math.ceil(items.length / batchSize);
  
  // Batch verarbeiten
  const batchResults = await Promise.all(
    batch.map(item => processItem(item))
  );
  
  results.push(...batchResults);
  
  // Fortschritt protokollieren
  await logProgress({
    batch: batchNumber,
    totalBatches: totalBatches,
    processed: results.length,
    total: items.length,
    percentComplete: Math.round((results.length / items.length) * 100)
  });
  
  // Kurze Pause zwischen Batches, um Rate-Limiting zu verhindern
  if (i + batchSize < items.length) {
    await sleep(100);
  }
}

return {
  json: {
    success: true,
    totalProcessed: results.length,
    successful: results.filter(r => r.success).length,
    failed: results.filter(r => !r.success).length,
    results: results
  }
};

// Workflow: enqueue-for-async-processing

const request = $json.request;

// Nicht synchron verarbeiten - für Hintergrundverarbeitung einreihen
const job = {
  id: generateUUID(),
  type: request.type,
  payload: request.payload,
  priority: request.priority || 'normal',
  submittedAt: $now,
  estimatedDuration: estimateDuration(request),
  dependencies: request.dependencies || []
};

// In Verarbeitungswarteschlange einfügen
await enqueueJob(job);

// Sofort mit Job-ID zurückgeben
return {
  json: {
    accepted: true,
    jobId: job.id,
    status: 'queued',
    estimatedStartTime: await getEstimatedStartTime(job),
    statusUrl: `https://api.example.com/jobs/${job.id}/status`
  }
};

// Separate Workflow: async-job-processor
// Durch Warteschlange getriggert, verarbeitet Jobs im Hintergrund
// Aktualisiert Status, der über statusUrl abgefragt werden kann

// Workflow: stream-large-dataset

const query = $json.query;
const pageSize = 1000;
let page = 0;
let hasMore = true;
let totalProcessed = 0;

// Output-Stream öffnen (z.B. zu Datei, S3 oder Webhook)
const outputStream = await createOutputStream($json.destination);

while (hasMore) {
  // Seite abrufen
  const pageData = await fetchPage(query, page, pageSize);
  
  if (pageData.length === 0) {
    hasMore = false;
    break;
  }
  
  // Seite transformieren
  const transformed = pageData.map(transformRecord);
  
  // In Stream schreiben (nicht im Speicher halten)
  await outputStream.write(transformed);
  
  totalProcessed += pageData.length;
  page++;
  
  // Fortschritt protokollieren
  if (page % 10 === 0) {
    await logProgress({
      page: page,
      totalProcessed: totalProcessed,
      memoryUsage: process.memoryUsage()
    });
  }
  
  // Prüfen, ob ein Limit erreicht wurde
  if ($json.maxRecords && totalProcessed >= $json.maxRecords) {
    hasMore = false;
  }
}

// Stream schließen
await outputStream.close();

return {
  json: {
    success: true,
    totalRecords: totalProcessed,
    pagesProcessed: page,
    destination: $json.destination
  }
};

// Workflow: rotate-api-credentials

const service = $json.service;
const rotationPolicy = await getRotationPolicy(service);

// Prüfen, ob Rotation nötig ist
const lastRotation = await getLastRotation(service);
const daysSinceRotation = daysBetween(lastRotation, $now);

if (daysSinceRotation < rotationPolicy.days) {
  return {
    json: {
      rotated: false,
      reason: 'Rotation noch nicht fällig',
      nextRotation: addDays(lastRotation, rotationPolicy.days)
    }
  };
}

// Rotation durchführen
const newCredentials = await generateNewCredentials(service);

// In Credential-Store aktualisieren (schrittweises Rollout)
await updateCredentialStore(service, {
  primary: newCredentials,
  secondary: await getCurrentCredentials(service), // Alte als Backup behalten
  rotationTime: $now
});

// Abhängige Systeme benachrichtigen
await notifyCredentialRotation(service, {
  rotationTime: $now,
  affectedWorkflows: await getWorkflowsUsingCredential(service)
});

// Ablauf alte Credentials planen
await scheduleCredentialExpiration(service, {
  expireAt: addHours($now, rotationPolicy.gracePeriodHours)
});

return {
  json: {
    rotated: true,
    service: service,
    rotationTime: $now,
    expiresAt: addHours($now, rotationPolicy.gracePeriodHours)
  }
};

// Workflow: process-with-full-audit

const operation = $json.operation;
const auditId = generateUUID();

// Pre-Operation Audit-Log
await createAuditRecord({
  id: auditId,
  operation: operation.type,
  status: 'started',
  actor: $json.user,
  timestamp: $now,
  input: sanitizeForAudit($json),
  ip: $json.requestIp,
  userAgent: $json.userAgent
});

try {
  const result = await executeOperation(operation);
  
  // Erfolgreiches Audit-Log
  await updateAuditRecord(auditId, {
    status: 'completed',
    completedAt: $now,
    output: sanitizeForAudit(result),
    duration: Date.now() - new Date($now).getTime()
  });
  
  return { json: { success: true, auditId: auditId, result: result } };
  
} catch (error) {
  // Fehlgeschlagenes Audit-Log
  await updateAuditRecord(auditId, {
    status: 'failed',
    failedAt: $now,
    error: sanitizeForAudit(error.message),
    stackTrace: sanitizeForAudit(error.stack)
  });
  
  throw error;
}

function sanitizeForAudit(data) {
  // PII und sensible Daten vor dem Logging entfernen
  const sensitiveFields = ['password', 'ssn', 'creditCard', 'apiKey'];
  const sanitized = { ...data };
  
  for (const field of sensitiveFields) {
    if (sanitized[field]) {
      sanitized[field] = '[REDACTED]';
    }
  }
  
  return sanitized;
}

// Workflow: test-harness-for-subworkflows

const testCases = [
  {
    name: 'Valid customer - standard tier',
    input: { customer: { tier: 'standard', email: '[email protected]' } },
    expected: { status: 'success', tier: 'standard' }
  },
  {
    name: 'Invalid email format',
    input: { customer: { tier: 'standard', email: 'invalid' } },
    expected: { status: 'error', errorCode: 'INVALID_EMAIL' }
  },
  {
    name: 'Missing required field',
    input: { customer: { tier: 'standard' } },
    expected: { status: 'error', errorCode: 'MISSING_EMAIL' }
  }
];

const results = [];

for (const testCase of testCases) {
  try {
    // Workflow unter Test ausführen
    const actual = await executeWorkflow('workflow-under-test', testCase.input);
    
    // Mit Erwartetem vergleichen
    const passed = matchesExpected(actual, testCase.expected);
    
    results.push({
      name: testCase.name,
      passed: passed,
      expected: testCase.expected,
      actual: actual,
      duration: actual.duration
    });
    
  } catch (error) {
    results.push({
      name: testCase.name,
      passed: false,
      error: error.message
    });
  }
}

// Test-Report generieren
const report = {
  total: results.length,
  passed: results.filter(r => r.passed).length,
  failed: results.filter(r => !r.passed).length,
  results: results,
  coverage: calculateCoverage(results)
};

await sendTestReport(report);

return { json: report };