// n8n Function Node: Human Review Checkpoint
const decision = $input.first().json.aiDecision;
const confidence = $input.first().json.confidenceScore;
const requiresReview = confidence < 0.85 || decision.riskLevel === 'high';

// Queue for human review if needed
if (requiresReview) {
  return [{
    json: {
      status: 'pending_review',
      reviewReason: confidence < 0.85 ? 'low_confidence' : 'high_risk',
      assignedTo: 'compliance-team',
      reviewDeadline: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
      aiRecommendation: decision,
      auditTrail: {
        workflowId: $execution.id,
        timestamp: new Date().toISOString(),
        modelVersion: 'v2.3.1',
        inputs: $input.first().json.sanitizedInputs
      }
    }
  }];
}

// Auto-approve if confidence is sufficient
return [{
  json: {
    status: 'approved_automated',
    decision: decision,
    confidence: confidence,
    auditTrail: {
      workflowId: $execution.id,
      timestamp: new Date().toISOString(),
      humanInvolvement: 'none_required',
      exemptionBasis: 'high_confidence_threshold'
    }
  }
}];

Does the system use AI? (Machine learning, logic-based, statistical)
    ↓
Is it a prohibited practice? (Manipulation, social scoring, real-time biometric)
    ↓ Yes → PROHIBITED (cannot deploy)
    ↓ No
Is it listed in Annex III (high-risk categories)?
    ↓ Yes → HIGH RISK (full compliance required)
    ↓ No
Does it interact with humans? (Chatbots, emotion recognition)
    ↓ Yes → LIMITED RISK (transparency required)
    ↓ No → MINIMAL RISK (voluntary codes apply)

// n8n Function Node: Risk Assessment Integration
async function assessRisk(inputs, context) {
  const riskFactors = {
    dataSensitivity: calculateDataSensitivity(inputs),
    decisionImpact: evaluateDecisionImpact(context.purpose),
    populationVulnerability: checkVulnerablePopulations(inputs),
    errorConsequences: assessErrorImpact(context.domain)
  };
  
  const riskScore = Object.values(riskFactors).reduce((a, b) => a + b, 0) / 4;
  
  return {
    riskLevel: riskScore > 0.7 ? 'high' : riskScore > 0.4 ? 'medium' : 'low',
    riskFactors: riskFactors,
    mitigationRequired: riskScore > 0.4,
    humanOversightRequired: riskScore > 0.6,
    documentationRequired: riskScore > 0.4,
    auditFrequency: riskScore > 0.7 ? 'weekly' : riskScore > 0.4 ? 'monthly' : 'quarterly'
  };
}

function calculateDataSensitivity(inputs) {
  const sensitiveCategories = ['health', 'biometric', 'genetic', 'criminal', 'children'];
  return sensitiveCategories.some(cat => inputs.dataCategories?.includes(cat)) ? 1.0 : 0.3;
}

function evaluateDecisionImpact(purpose) {
  const highImpact = ['credit', 'employment', 'housing', 'healthcare', 'legal'];
  return highImpact.some(p => purpose.toLowerCase().includes(p)) ? 1.0 : 0.4;
}

function checkVulnerablePopulations(inputs) {
  return inputs.demographics?.includes('children') || 
         inputs.demographics?.includes('elderly') ||
         inputs.demographics?.includes('disabilities') ? 1.0 : 0.2;
}

function assessErrorImpact(domain) {
  const criticalDomains = ['healthcare', 'safety', 'legal', 'financial'];
  return criticalDomains.some(d => domain.toLowerCase().includes(d)) ? 1.0 : 0.3;
}

// n8n Function Node: Data Quality Validation
function validateDataQuality(dataset) {
  const validations = {
    completeness: checkCompleteness(dataset),
    accuracy: verifyAccuracy(dataset),
    freshness: checkTimeliness(dataset),
    representativeness: assessRepresentativeness(dataset),
    biasIndicators: detectBias(dataset)
  };
  
  const qualityScore = Object.values(validations).reduce((a, b) => a + b.score, 0) / 5;
  
  return {
    isValid: qualityScore >= 0.8,
    qualityScore: qualityScore,
    validations: validations,
    remediationRequired: qualityScore < 0.8,
    recommendations: generateRecommendations(validations)
  };
}

function detectBias(dataset) {
  // Check for demographic disparities
  const protectedAttributes = ['gender', 'age', 'ethnicity', 'disability'];
  const biasMetrics = {};
  
  protectedAttributes.forEach(attr => {
    if (dataset.metadata?.includes(attr)) {
      biasMetrics[attr] = calculateDemographicParity(dataset, attr);
    }
  });
  
  const hasSignificantBias = Object.values(biasMetrics).some(m => m.disparity > 0.2);
  
  return {
    score: hasSignificantBias ? 0.4 : 0.9,
    biasMetrics: biasMetrics,
    requiresMitigation: hasSignificantBias
  };
}

# training-data-manifest.yml
dataset_metadata:
  name: "Customer Credit Risk Training Dataset"
  version: "2.1.0"
  created_date: "2026-01-15"
  last_updated: "2026-04-10"
  
data_sources:
  - source: "Internal CRM System"
    extraction_date: "2026-01-10"
    record_count: 150000
    
  - source: "Credit Bureau API"
    extraction_date: "2026-01-10"
    record_count: 150000
    
preprocessing:
  - step: "Duplicate Removal"
    description: "Removed 2,340 duplicate records"
    
  - step: "Outlier Treatment"
    description: "Capped income values at 99th percentile"
    
  - step: "Missing Value Imputation"
    description: "Median imputation for numeric, mode for categorical"
    
bias_testing:
  gender_parity:
    approval_rate_male: 0.72
    approval_rate_female: 0.71
    disparity: 0.01
    status: "PASS"
    
  age_fairness:
    approval_rate_18_25: 0.45
    approval_rate_26_35: 0.68
    approval_rate_36_50: 0.75
    approval_rate_51_plus: 0.73
    status: "PASS"
    
governance:
  approved_by: "Data Protection Officer"
  approval_date: "2026-01-20"
  review_frequency: "quarterly"
  next_review: "2026-04-20"

# AI System Technical Documentation

## System Overview
- **System Name:** Credit Risk Assessment Workflow
- **Risk Classification:** High Risk (Annex III - Credit Scoring)
- **Version:** 3.2.1
- **Deployment Date:** 2025-09-01
- **Last Updated:** 2026-04-15

## Intended Purpose
Automated assessment of creditworthiness for personal loan applications, supporting human underwriters in making lending decisions.

## System Architecture

## Model Information
- **Algorithm:** Gradient Boosting (XGBoost)
- **Training Data:** 150,000 historical loan records (2019-2024)
- **Features:** 47 input features including income, debt-to-income ratio, credit history
- **Performance Metrics:**
  - AUC-ROC: 0.87
  - Precision: 0.82
  - Recall: 0.79
  - False Positive Rate: 0.08

## Limitations and Constraints
- Not designed for commercial lending (use Commercial Credit Workflow v2.0)
- Minimum loan amount: €1,000
- Maximum loan amount: €50,000
- Requires complete credit history (minimum 2 years)
- Accuracy decreases for applicants with thin credit files

## Human Oversight Design
- All high-risk scores (above 0.7) require human review
- Underwriters can override system recommendations
- Weekly calibration sessions with compliance team
- Quarterly bias audits by external reviewer

## Monitoring and Logging
- Real-time performance monitoring dashboard
- Automated alerts for accuracy degradation
- Complete audit trail for all decisions
- Monthly compliance reporting

// n8n Function Node: Comprehensive Audit Logging
async function createAuditRecord(context) {
  const auditRecord = {
    // System Information
    system: {
      name: 'credit-risk-assessment',
      version: '3.2.1',
      environment: $env.ENVIRONMENT || 'production',
      workflowId: $execution.id,
      nodeId: $node.name,
      executionTimestamp: new Date().toISOString()
    },
    
    // Input Data
    input: {
      requestId: context.requestId,
      applicantId: hashIdentifier(context.applicantId), // Pseudonymized
      features: sanitizeFeatures(context.features),
      featureVersion: 'v2026.04'
    },
    
    // Processing Details
    processing: {
      modelVersion: context.modelVersion,
      inferenceTimestamp: new Date().toISOString(),
      latency: context.inferenceTime,
      featureEngineering: context.featurePipeline,
      preprocessingSteps: context.preprocessing
    },
    
    // Model Output
    output: {
      riskScore: context.riskScore,
      confidence: context.confidence,
      explanation: context.shapValues,
      recommendation: context.recommendation,
      alternativeOutcomes: context.alternativeScenarios
    },
    
    // Human Oversight
    humanOversight: {
      reviewRequired: context.reviewRequired,
      reviewerId: context.reviewerId || null,
      reviewDecision: context.reviewDecision || null,
      reviewNotes: context.reviewNotes || null,
      reviewTimestamp: context.reviewTimestamp || null
    },
    
    // Compliance Metadata
    compliance: {
      aiActClassification: 'high-risk',
      gdprArticle22: 'applicable',
      legalBasis: 'contract-necessity',
      retentionPeriod: '7-years',
      dataSubjectRights: ['access', 'explanation', 'contest']
    },
    
    // Security
    security: {
      accessControl: context.accessControl,
      encryption: 'AES-256',
      integrityHash: await calculateIntegrityHash(context)
    }
  };
  
  // Store in audit database
  await storeAuditRecord(auditRecord);
  
  // Return with audit ID for reference
  return {
    ...context,
    auditId: auditRecord.system.workflowId,
    auditTimestamp: auditRecord.system.executionTimestamp
  };
}

function hashIdentifier(identifier) {
  // One-way hash for pseudonymization
  return crypto.createHash('sha256').update(identifier + $env.PEPPER).digest('hex');
}

function sanitizeFeatures(features) {
  // Remove direct identifiers while preserving model inputs
  const { name, email, phone, address, ...sanitized } = features;
  return sanitized;
}

// n8n Function Node: Lawful Basis Validation
function validateLawfulBasis(processingContext) {
  const lawfulBases = {
    consent: {
      applicable: processingContext.purpose === 'marketing',
      requirements: ['explicit', 'granular', 'withdrawable'],
      verify: () => checkConsentValidity(processingContext.dataSubjectId)
    },
    contract: {
      applicable: processingContext.purpose === 'service-delivery',
      requirements: ['necessary-for-performance'],
      verify: () => verifyContractualNecessity(processingContext)
    },
    legal_obligation: {
      applicable: processingContext.purpose === 'regulatory-compliance',
      requirements: ['explicit-legal-requirement'],
      verify: () => verifyLegalRequirement(processingContext.regulation)
    },
    vital_interests: {
      applicable: processingContext.purpose === 'emergency',
      requirements: ['life-protection'],
      verify: () => verifyEmergencyContext(processingContext)
    },
    public_task: {
      applicable: processingContext.purpose === 'public-authority',
      requirements: ['official-authority'],
      verify: () => verifyPublicAuthority(processingContext)
    },
    legitimate_interests: {
      applicable: processingContext.purpose === 'fraud-prevention',
      requirements: ['balance-test', 'data-minimization'],
      verify: () => conductLegitimateInterestAssessment(processingContext)
    }
  };
  
  const selectedBasis = processingContext.lawfulBasis;
  const basisConfig = lawfulBases[selectedBasis];
  
  if (!basisConfig || !basisConfig.applicable) {
    return {
      valid: false,
      error: `Lawful basis '${selectedBasis}' not applicable for purpose '${processingContext.purpose}'`,
      alternatives: Object.entries(lawfulBases)
        .filter(([_, config]) => config.applicable)
        .map(([basis, _]) => basis)
    };
  }
  
  const verification = basisConfig.verify();
  
  return {
    valid: verification.valid,
    basis: selectedBasis,
    requirements: basisConfig.requirements,
    verification: verification,
    documentation: verification.documentation,
    nextReviewDate: calculateReviewDate(selectedBasis)
  };
}

// n8n Function Node: Data Minimization Enforcement
function enforceDataMinimization(inputData, purpose) {
  const purposeDataRequirements = {
    'account-creation': ['email', 'name', 'phone', 'country'],
    'payment-processing': ['card_token', 'billing_address', 'amount'],
    'shipping': ['name', 'shipping_address', 'phone'],
    'marketing': ['email', 'preferences', 'consent_timestamp'],
    'support': ['ticket_id', 'issue_description', 'contact_preference'],
    'analytics': ['session_id', 'event_type', 'timestamp'], // Pseudonymized only
    'fraud-detection': ['transaction_id', 'risk_indicators', 'device_fingerprint']
  };
  
  const requiredFields = purposeDataRequirements[purpose];
  
  if (!requiredFields) {
    return {
      error: `Unknown processing purpose: ${purpose}`,
      allowed: false
    };
  }
  
  // Extract only required fields
  const minimizedData = {};
  const removedFields = [];
  
  Object.keys(inputData).forEach(field => {
    if (requiredFields.includes(field)) {
      minimizedData[field] = inputData[field];
    } else {
      removedFields.push(field);
    }
  });
  
  // Check for missing required fields
  const missingFields = requiredFields.filter(field => !(field in inputData));
  
  return {
    data: minimizedData,
    purpose: purpose,
    removedFields: removedFields,
    missingFields: missingFields,
    isComplete: missingFields.length === 0,
    fieldCount: {
      original: Object.keys(inputData).length,
      minimized: Object.keys(minimizedData).length,
      reduction: `${((1 - Object.keys(minimizedData).length / Object.keys(inputData).length) * 100).toFixed(1)}%`
    }
  };
}

// n8n Function Node: Retention Policy Enforcement
function applyRetentionPolicy(dataRecord, dataCategory) {
  const retentionPolicies = {
    'customer-profiles': { duration: '7-years', basis: 'contract-performance' },
    'transaction-records': { duration: '10-years', basis: 'legal-obligation' },
    'marketing-consent': { duration: 'consent-withdrawal', basis: 'consent' },
    'support-tickets': { duration: '3-years', basis: 'legitimate-interest' },
    'website-analytics': { duration: '26-months', basis: 'consent' },
    'session-logs': { duration: '90-days', basis: 'security' },
    'failed-login-attempts': { duration: '1-year', basis: 'security' }
  };
  
  const policy = retentionPolicies[dataCategory];
  
  if (!policy) {
    return {
      error: `No retention policy defined for category: ${dataCategory}`,
      action: 'requires-classification'
    };
  }
  
  const createdDate = new Date(dataRecord.createdAt);
  const now = new Date();
  
  let retentionEndDate;
  if (policy.duration === 'consent-withdrawal') {
    retentionEndDate = dataRecord.consentWithdrawnAt || new Date(createdDate.getTime() + 2 * 365 * 24 * 60 * 60 * 1000);
  } else if (policy.duration.endsWith('years')) {
    const years = parseInt(policy.duration);
    retentionEndDate = new Date(createdDate.getTime() + years * 365 * 24 * 60 * 60 * 1000);
  } else if (policy.duration.endsWith('months')) {
    const months = parseInt(policy.duration);
    retentionEndDate = new Date(createdDate);
    retentionEndDate.setMonth(retentionEndDate.getMonth() + months);
  } else if (policy.duration.endsWith('days')) {
    const days = parseInt(policy.duration);
    retentionEndDate = new Date(createdDate.getTime() + days * 24 * 60 * 60 * 1000);
  }
  
  const daysRemaining = Math.ceil((retentionEndDate - now) / (1000 * 60 * 60 * 24));
  const action = daysRemaining <= 0 ? 'delete' : daysRemaining <= 30 ? 'flag-for-review' : 'retain';
  
  return {
    dataCategory: dataCategory,
    createdAt: dataRecord.createdAt,
    retentionPolicy: policy,
    retentionEndDate: retentionEndDate.toISOString(),
    daysRemaining: daysRemaining,
    action: action,
    deletionDate: action === 'delete' ? now.toISOString() : null
  };
}

// n8n Function Node: Generate Decision Explanations
function generateExplanation(decisionContext) {
  const { prediction, features, featureImportance, decisionType } = decisionContext;
  
  // Generate natural language explanation
  const explanation = {
    summary: generateSummary(prediction, decisionType),
    keyFactors: identifyKeyFactors(featureImportance, 5),
    contributingFactors: identifyContributingFeatures(features, featureImportance),
    similarCases: referenceSimilarCases(decisionType, prediction),
    confidence: prediction.confidence,
    limitations: describeLimitations(decisionType),
    humanReview: {
      available: true,
      howToRequest: "Contact [email protected] or call +1-800-555-0123",
      timeline: "Within 30 days of decision",
      rights: ["Explanation", "Human intervention", "Contest decision", "Rectification"]
    }
  };
  
  return explanation;
}

function generateSummary(prediction, decisionType) {
  const templates = {
    'credit-approval': `Your application was ${prediction.outcome === 'approved' ? 'approved' : 'declined'} with a risk score of ${(prediction.score * 100).toFixed(0)}%.`,
    'pricing': `Your personalized price is €${prediction.price}, calculated based on your risk profile and market conditions.`,
    'fraud-detection': `This transaction was flagged as ${prediction.outcome === 'fraudulent' ? 'potentially fraudulent' : 'legitimate'} with ${(prediction.confidence * 100).toFixed(0)}% confidence.`,
    'insurance-risk': `Your insurance premium is set at €${prediction.premium}/year based on your risk assessment.`
  };
  
  return templates[decisionType] || `Decision: ${prediction.outcome} (Confidence: ${(prediction.confidence * 100).toFixed(0)}%)`;
}

function identifyKeyFactors(featureImportance, topN) {
  return Object.entries(featureImportance)
    .sort((a, b) => b[1] - a[1])
    .slice(0, topN)
    .map(([feature, importance]) => ({
      feature: feature,
      impact: importance,
      direction: importance > 0 ? 'positive' : 'negative',
      description: getFeatureDescription(feature)
    }));
}

┌─────────────────────────────────────────────────────────────────┐
│                    AUTOMATED DECISION WORKFLOW                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│   │   Trigger    │───→│ Data Collect │───→│   Validate   │      │
│   └──────────────┘    └──────────────┘    └──────────────┘      │
│                                                  │               │
│                                                  ▼               │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│   │  Log Result  │←───│ Human Review │←───│ AI Decision  │      │
│   └──────────────┘    └──────────────┘    └──────────────┘      │
│          │                  │                                        │
│          │         ┌────────┴────────┐                              │
│          │         │                 │                              │
│          │         ▼                 ▼                              │
│          │   ┌──────────┐     ┌──────────┐                         │
│          │   │ Approve  │     │ Override │                         │
│          │   └────┬─────┘     └────┬─────┘                         │
│          │        │                │                                │
│          │        └────────┬───────┘                                │
│          │                 ▼                                       │
│          │        ┌──────────────┐                                │
│          └───────→│   Notify     │                                │
│                   └──────────────┘                                │
│                                                                    │
└─────────────────────────────────────────────────────────────────┘

// n8n Function Node: Human Review Routing
function routeForHumanReview(decisionContext) {
  const { riskScore, confidence, decisionType, customerSegment } = decisionContext;
  
  // Define review thresholds by decision type
  const reviewRules = {
    'credit-approval': {
      highRisk: riskScore > 0.7,
      lowConfidence: confidence < 0.8,
      amountThreshold: 50000
    },
    'fraud-detection': {
      highRisk: riskScore > 0.6,
      requiresEvidence: true
    },
    'pricing': {
      deviationThreshold: 0.3, // 30% from standard
      vipCustomer: customerSegment === 'vip'
    }
  };
  
  const rules = reviewRules[decisionType];
  const requiresReview = evaluateReviewRules(decisionContext, rules);
  
  if (requiresReview) {
    return {
      route: 'human-review',
      priority: riskScore > 0.8 ? 'urgent' : riskScore > 0.6 ? 'high' : 'normal',
      assignedTeam: getReviewTeam(decisionType, riskScore),
      sla: riskScore > 0.8 ? '4-hours' : '24-hours',
      context: {
        aiRecommendation: decisionContext.recommendation,
        confidence: confidence,
        keyFactors: decisionContext.keyFactors,
        similarCases: decisionContext.referenceCases
      },
      notification: {
        channels: ['email', 'dashboard'],
        recipients: getReviewers(decisionType)
      }
    };
  }
  
  return {
    route: 'auto-approve',
    auditRecord: createAutoApproveRecord(decisionContext)
  };
}

// n8n Function Node: Data Subject Access Request Fulfillment
async function fulfillAccessRequest(requestContext) {
  const { dataSubjectId, requestDate, requestId } = requestContext;
  
  // Verify identity (separate workflow)
  const identityVerification = await verifyIdentity(dataSubjectId, requestContext);
  if (!identityVerification.verified) {
    return {
      status: 'identity_verification_required',
      nextSteps: identityVerification.requiredActions
    };
  }
  
  // Gather data from all systems
  const dataGathering = await gatherPersonalData(dataSubjectId);
  
  // Compile comprehensive report
  const accessReport = {
    requestMetadata: {
      requestId: requestId,
      requestDate: requestDate,
      fulfillmentDate: new Date().toISOString(),
      dataSubjectId: pseudonymizeForReport(dataSubjectId)
    },
    
    processingSummary: {
      isBeingProcessed: true,
      purposes: dataGathering.purposes,
      categories: dataGathering.dataCategories,
      recipients: dataGathering.recipients,
      retentionPeriods: dataGathering.retentionInfo
    },
    
    personalData: {
      identityData: dataGathering.identity,
      contactData: dataGathering.contact,
      financialData: dataGathering.financial,
      behavioralData: dataGathering.behavioral,
      communicationHistory: dataGathering.communications,
      preferences: dataGathering.preferences
    },
    
    automatedDecisionMaking: {
      inUse: dataGathering.automatedDecisions.length > 0,
      decisions: dataGathering.automatedDecisions.map(decision => ({
        type: decision.type,
        logic: decision.logic,
        significance: decision.significance,
        consequences: decision.consequences
      }))
    },
    
    crossBorderTransfers: dataGathering.transfers,
    
    supplementaryInformation: {
      dataSources: dataGathering.sources,
      collectionMethods: dataGathering.collectionMethods,
      thirdPartyData: dataGathering.thirdPartyInfo
    }
  };
  
  // Generate secure download link
  const securePackage = await createSecurePackage(accessReport, dataSubjectId);
  
  // Log fulfillment
  await logAccessRequestFulfillment(requestId, dataSubjectId, accessReport);
  
  return {
    status: 'fulfilled',
    fulfillmentMethod: 'secure-download',
    downloadUrl: securePackage.url,
    expiresAt: securePackage.expiry,
    dataVolume: securePackage.size,
    systemsAccessed: dataGathering.systems.length
  };
}

async function gatherPersonalData(dataSubjectId) {
  const dataSources = [
    { system: 'CRM', query: 'getCustomerProfile' },
    { system: 'E-commerce', query: 'getOrderHistory' },
    { system: 'Marketing', query: 'getCampaignInteractions' },
    { system: 'Support', query: 'getTicketHistory' },
    { system: 'Analytics', query: 'getUserEvents' },
    { system: 'Finance', query: 'getTransactions' }
  ];
  
  const gatheredData = {};
  
  for (const source of dataSources) {
    try {
      const data = await querySystem(source.system, source.query, dataSubjectId);
      gatheredData[source.system.toLowerCase()] = data;
    } catch (error) {
      gatheredData[source.system.toLowerCase()] = {
        error: 'data_retrieval_failed',
        message: error.message
      };
    }
  }
  
  return compileDataReport(gatheredData);
}

// n8n Function Node: Right to Erasure Implementation
async function processErasureRequest(requestContext) {
  const { dataSubjectId, requestDate, requestId, scope } = requestContext;
  
  // Step 1: Identify legal retention obligations
  const retentionAnalysis = await analyzeRetentionObligations(dataSubjectId);
  
  // Step 2: Categorize data for different handling
  const dataCategories = {
    deletable: [],
    retentionRequired: [],
    restricted: [],
    thirdParty: []
  };
  
  // Step 3: Check for legal grounds to retain
  const legalGrounds = retentionAnalysis.legalGrounds;
  
  if (legalGrounds.length > 0) {
    // Some data must be retained
    dataCategories.retentionRequired = legalGrounds.map(ground => ({
      category: ground.dataCategory,
      reason: ground.legalBasis,
      retentionPeriod: ground.retentionUntil,
      fields: ground.fieldsToRetain,
      anonymizationRequired: ground.anonymizationPossible
    }));
    
    // Identify what can be deleted
    dataCategories.deletable = retentionAnalysis.deletableData;
  } else {
    // Full deletion possible
    dataCategories.deletable = await identifyAllPersonalData(dataSubjectId);
  }
  
  // Step 4: Execute deletions
  const deletionResults = await executeDeletions(dataCategories.deletable);
  
  // Step 5: Apply anonymization where required
  const anonymizationResults = await applyAnonymization(
    dataCategories.retentionRequired.filter(r => r.anonymizationRequired)
  );
  
  // Step 6: Notify third parties
  const thirdPartyNotifications = await notifyThirdParties(
    dataCategories.thirdParty,
    requestId
  );
  
  // Step 7: Generate completion report
  const completionReport = {
    requestId: requestId,
    status: legalGrounds.length > 0 ? 'partially_completed' : 'completed',
    completionDate: new Date().toISOString(),
    
    deletions: {
      attempted: deletionResults.attempted,
      successful: deletionResults.successful,
      failed: deletionResults.failed,
      systems: deletionResults.systemsAffected
    },
    
    retention: {
      categoriesRetained: dataCategories.retentionRequired.length,
      reasons: dataCategories.retentionRequired.map(r => r.reason),
      anonymizationApplied: anonymizationResults.applied,
      reviewDates: dataCategories.retentionRequired.map(r => r.retentionPeriod)
    },
    
    thirdParties: {
      notified: thirdPartyNotifications.successful,
      pending: thirdPartyNotifications.pending
    },
    
    dataSubjectCommunication: {
      summary: generateErasureSummary(deletionResults, dataCategories),
      deletionCertificate: await generateCertificate(requestId)
    }
  };
  
  // Step 8: Update records and notify
  await updateDataSubjectRecord(dataSubjectId, 'erasure_requested', completionReport);
  await notifyDataSubject(requestContext.email, completionReport);
  
  return completionReport;
}

async function analyzeRetentionOlegations(dataSubjectId) {
  const obligations = [];
  
  // Check for active contracts
  const activeContracts = await checkActiveContracts(dataSubjectId);
  if (activeContracts.length > 0) {
    obligations.push({
      dataCategory: 'contract-data',
      legalBasis: 'contract-performance',
      retentionUntil: activeContracts[0].endDate,
      fieldsToRetain: ['contract_id', 'service_type', 'billing_records'],
      anonymizationPossible: false
    });
  }
  
  // Check for legal/regulatory requirements
  const legalRequirements = await checkLegalRetention(dataSubjectId);
  if (legalRequirements.requiresRetention) {
    obligations.push({
      dataCategory: 'financial-records',
      legalBasis: 'legal-obligation',
      retentionUntil: legalRequirements.retentionUntil,
      fieldsToRetain: legalRequirements.requiredFields,
      anonymizationPossible: legalRequirements.anonymizationAllowed
    });
  }
  
  // Check for pending legal claims
  const pendingClaims = await checkPendingClaims(dataSubjectId);
  if (pendingClaims.length > 0) {
    obligations.push({
      dataCategory: 'litigation-hold',
      legalBasis: 'legal-claim',
      retentionUntil: pendingClaims[0].resolutionDate,
      fieldsToRetain: ['all_relevant_records'],
      anonymizationPossible: false
    });
  }
  
  return {
    legalGrounds: obligations,
    deletableData: await calculateDeletableData(dataSubjectId, obligations)
  };
}

// n8n Function Node: Data Portability Implementation
async function fulfillPortabilityRequest(requestContext) {
  const { dataSubjectId, format = 'json', requestId } = requestContext;
  
  // Verify the right applies (based on lawful basis)
  const lawfulBasisCheck = await verifyPortabilityEligibility(dataSubjectId);
  if (!lawfulBasisCheck.eligible) {
    return {
      status: 'not_applicable',
      reason: lawfulBasisCheck.reason,
      applicableRights: ['access', 'erasure']
    };
  }
  
  // Gather structured data
  const structuredData = await gatherStructuredData(dataSubjectId);
  
  // Format according to request
  let formattedData;
  switch (format.toLowerCase()) {
    case 'json':
      formattedData = JSON.stringify(structuredData, null, 2);
      break;
    case 'xml':
      formattedData = convertToXML(structuredData);
      break;
    case 'csv':
      formattedData = convertToCSV(structuredData);
      break;
    default:
      formattedData = JSON.stringify(structuredData, null, 2);
  }
  
  // Create portable data package
  const portablePackage = {
    format: format,
    schema: {
      version: '1.0',
      standard: 'data-portability-gdpr',
      specification: 'https://standards.data-portability.org/gdpr-v1'
    },
    metadata: {
      exportDate: new Date().toISOString(),
      dataController: {
        name: 'Your Company Name',
        contact: '[email protected]',
        dpo: '[email protected]'
      },
      dataSubject: {
        id: pseudonymize(dataSubjectId),
        verificationMethod: lawfulBasisCheck.verificationMethod
      }
    },
    data: structuredData
  };
  
  // Secure delivery
  const securePackage = await createSecurePackage(portablePackage, dataSubjectId);
  
  return {
    status: 'fulfilled',
    format: format,
    downloadUrl: securePackage.url,
    expiresAt: securePackage.expiry,
    size: securePackage.size,
    checksum: securePackage.checksum,
    schemaDocumentation: portablePackage.schema.specification
  };
}

┌────────────────────────────────────────────────────────────────────┐
│                  DSAR MANAGEMENT WORKFLOW                         │
├────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   ┌──────────────┐                                                  │
│   │   Receive    │                                                  │
│   │   Request    │                                                  │
│   └──────┬───────┘                                                  │
│          │                                                          │
│          ▼                                                          │
│   ┌──────────────┐                                                  │
│   │   Validate   │───→ Invalid: Request clarification               │
│   │   Identity   │                                                  │
│   └──────┬───────┘                                                  │
│          │ Valid                                                      │
│          ▼                                                          │
│   ┌──────────────┐                                                  │
│   │  Classify    │                                                  │
│   │   Request    │                                                  │
│   └──────┬───────┘                                                  │
│          │                                                          │
│    ┌─────┼─────┬─────────┬─────────┬─────────┐                     │
│    │     │     │         │         │         │                     │
│    ▼     ▼     ▼         ▼         ▼         ▼                     │
│ ┌────┐ ┌────┐ ┌────┐  ┌────┐  ┌────┐  ┌────┐                    │
│ │Access│ │Erasure│ │Rectify│ │Portability│ │Restrict│ │Object│    │
│ └──┬─┘ └──┬─┘ └──┬─┘  └──┬─┘  └──┬─┘  └──┬─┘                    │
│    │      │      │        │        │        │                        │
│    └──────┴──────┴────────┴────────┴────────┘                        │
│                         │                                           │
│                         ▼                                           │
│              ┌─────────────────┐                                   │
│              │  Process Request │                                   │
│              │   (Specific)     │                                   │
│              └────────┬────────┘                                   │
│                       │                                             │
│                       ▼                                             │
│              ┌─────────────────┐                                   │
│              │  Quality Check  │                                   │
│              │   & Approval    │                                   │
│              └────────┬────────┘                                   │
│                       │                                             │
│                       ▼                                             │
│              ┌─────────────────┐                                   │
│              │ Deliver Response│                                   │
│              │  (Secure Portal)│                                   │
│              └────────┬────────┘                                   │
│                       │                                             │
│                       ▼                                             │
│              ┌─────────────────┐                                   │
│              │   Log & Close   │                                   │
│              │   (Audit Trail) │                                   │
│              └─────────────────┘                                   │
│                                                                     │
└────────────────────────────────────────────────────────────────────┘

// n8n Function Node: Consent Collection and Validation
function collectConsent(consentContext) {
  const { dataSubjectId, purposes, mechanisms } = consentContext;
  
  // Define granular consent purposes
  const consentPurposes = {
    marketing_email: {
      description: 'Send marketing emails about our products and services',
      dataUsed: ['email', 'name', 'preferences'],
      retention: 'until-withdrawn',
      lawfulBasis: 'consent',
      required: false
    },
    marketing_sms: {
      description: 'Send SMS promotions and offers',
      dataUsed: ['phone', 'name'],
      retention: 'until-withdrawn',
      lawfulBasis: 'consent',
      required: false
    },
    personalization: {
      description: 'Personalize website experience and recommendations',
      dataUsed: ['browsing_history', 'purchase_history', 'preferences'],
      retention: '2-years',
      lawfulBasis: 'consent',
      required: false
    },
    analytics: {
      description: 'Use data for analytics and improvement',
      dataUsed: ['usage_data', 'aggregated_statistics'],
      retention: '26-months',
      lawfulBasis: 'consent',
      required: false
    },
    third_party_sharing: {
      description: 'Share data with selected partners',
      dataUsed: ['email', 'preferences'],
      retention: 'until-withdrawn',
      lawfulBasis: 'consent',
      required: false,
      thirdParties: ['partner_a', 'partner_b']
    }
  };
  
  // Validate consents
  const consentRecord = {
    dataSubjectId: dataSubjectId,
    timestamp: new Date().toISOString(),
    ipAddress: consentContext.ipAddress,
    userAgent: consentContext.userAgent,
    consentMechanism: mechanisms.uiVersion,
    
    consents: purposes.map(purpose => {
      const config = consentPurposes[purpose.purposeId];
      return {
        purpose: purpose.purposeId,
        granted: purpose.granted,
        config: config,
        timestamp: purpose.timestamp,
        evidence: purpose.affirmativeAction // e.g., "checkbox-checked"
      };
    }),
    
    withdrawalMechanism: {
      available: true,
      methods: ['email', 'web-portal', 'phone'],
      easeOfWithdrawal: 'same-as-consent'
    },
    
    auditTrail: {
      consentId: generateConsentId(),
      storageLocation: 'consent-db',
      retentionSchedule: 'duration-of-relationship-plus-7-years'
    }
  };
  
  // Validate consent meets GDPR standards
  const validation = validateConsentRecord(consentRecord);
  
  if (!validation.valid) {
    return {
      status: 'invalid',
      errors: validation.errors,
      consentRecord: null
    };
  }
  
  return {
    status: 'valid',
    consentRecord: consentRecord,
    validPurposes: consentRecord.consents.filter(c => c.granted).map(c => c.purpose)
  };
}

function validateConsentRecord(record) {
  const errors = [];
  
  // Check for valid timestamp
  const consentAge = Date.now() - new Date(record.timestamp);
  if (consentAge > 24 * 60 * 60 * 1000) {
    errors.push('Consent timestamp is older than 24 hours - may require re-confirmation');
  }
  
  // Check each consent
  record.consents.forEach(consent => {
    if (consent.granted && !consent.evidence) {
      errors.push(`Purpose ${consent.purpose} lacks evidence of affirmative action`);
    }
  });
  
  // Check for pre-ticked boxes (invalid)
  record.consents.forEach(consent => {
    if (consent.evidence === 'pre-selected') {
      errors.push(`Purpose ${consent.purpose} appears pre-selected - invalid consent`);
    }
  });
  
  return {
    valid: errors.length === 0,
    errors: errors
  };
}

// n8n Function Node: Consent Withdrawal Processing
async function processConsentWithdrawal(withdrawalContext) {
  const { dataSubjectId, withdrawalScope, channel } = withdrawalContext;
  
  // Log withdrawal request
  const withdrawalRecord = {
    requestId: generateRequestId(),
    dataSubjectId: dataSubjectId,
    timestamp: new Date().toISOString(),
    channel: channel,
    scope: withdrawalScope // 'all', 'marketing', 'analytics', etc.
  };
  
  // Retrieve current consents
  const currentConsents = await getCurrentConsents(dataSubjectId);
  
  // Determine which consents to withdraw
  const consentsToWithdraw = currentConsents.filter(consent => {
    if (withdrawalScope === 'all') return true;
    if (withdrawalScope === 'marketing') {
      return consent.purpose.includes('marketing');
    }
    if (withdrawalScope === 'analytics') {
      return consent.purpose === 'analytics';
    }
    return consent.purpose === withdrawalScope;
  });
  
  // Update consent records
  const withdrawalResults = await Promise.all(
    consentsToWithdraw.map(async consent => {
      return await withdrawConsent(dataSubjectId, consent.purpose, withdrawalRecord);
    })
  );
  
  // Trigger downstream actions
  await Promise.all([
    updateMarketingPreferences(dataSubjectId, withdrawalScope),
    removeFromEmailLists(dataSubjectId, withdrawalScope),
    stopTracking(dataSubjectId, withdrawalScope),
    notifyThirdParties(dataSubjectId, withdrawalScope)
  ]);
  
  // Send confirmation
  await sendWithdrawalConfirmation(dataSubjectId, {
    withdrawnPurposes: consentsToWithdraw.map(c => c.purpose),
    effectiveDate: withdrawalRecord.timestamp,
    furtherCommunication: 'We will stop processing within 72 hours'
  });
  
  return {
    status: 'completed',
    withdrawnConsents: consentsToWithdraw.length,
    effectiveDate: withdrawalRecord.timestamp,
    processingTime: '72-hours-maximum'
  };
}

// n8n Function Node: Consent Lifecycle Management
async function manageConsentLifecycle() {
  const actions = [];
  
  // 1. Identify consents approaching expiration
  const expiringConsents = await findExpiringConsents(30); // 30 days
  actions.push(...expiringConsents.map(c => ({
    action: 'renewal_reminder',
    consentId: c.id,
    dataSubjectId: c.dataSubjectId,
    expiresIn: c.daysUntilExpiry,
    priority: c.daysUntilExpiry < 7 ? 'high' : 'normal'
  })));
  
  // 2. Identify stale consents (no activity)
  const staleConsents = await findStaleConsents(365); // 1 year no activity
  actions.push(...staleConsents.map(c => ({
    action: 'reconfirmation_required',
    consentId: c.id,
    dataSubjectId: c.dataSubjectId,
    lastActivity: c.lastActivityDate,
    priority: 'low'
  })));
  
  // 3. Check for invalidated consents (service changes)
  const invalidatedConsents = await findInvalidatedConsents();
  actions.push(...invalidatedConsents.map(c => ({
    action: 'consent_invalidated',
    consentId: c.id,
    dataSubjectId: c.dataSubjectId,
    reason: c.invalidationReason,
    newConsentRequired: true,
    priority: 'high'
  })));
  
  // 4. Verify consent evidence integrity
  const integrityIssues = await checkConsentIntegrity();
  actions.push(...integrityIssues.map(c => ({
    action: 'evidence_repair',
    consentId: c.id,
    issue: c.issue,
    priority: 'critical'
  })));
  
  // Execute priority actions
  for (const action of actions.filter(a => a.priority === 'critical')) {
    await executeConsentAction(action);
  }
  
  return {
    totalActions: actions.length,
    critical: actions.filter(a => a.priority === 'critical').length,
    high: actions.filter(a => a.priority === 'high').length,
    normal: actions.filter(a => a.priority === 'normal').length,
    low: actions.filter(a => a.priority === 'low').length,
    summary: actions
  };
}

// n8n Function Node: Comprehensive Audit Logging
async function logComplianceEvent(eventContext) {
  const auditRecord = {
    // Core identification
    eventId: generateEventId(),
    eventType: eventContext.type, // 'data-access', 'decision-made', 'consent-withdrawn', etc.
    eventCategory: eventContext.category, // 'data-subject-right', 'security', 'processing'
    severity: eventContext.severity || 'info',
    
    // Temporal data
    timestamp: new Date().toISOString(),
    timezone: eventContext.timezone || 'UTC',
    
    // Actor information
    actor: {
      type: eventContext.actorType, // 'data-subject', 'system', 'administrator', 'third-party'
      id: pseudonymizeIfNeeded(eventContext.actorId),
      role: eventContext.actorRole,
      authenticationMethod: eventContext.authMethod,
      sessionId: eventContext.sessionId
    },
    
    // Action details
    action: {
      type: eventContext.action,
      description: eventContext.description,
      justification: eventContext.justification,
      legalBasis: eventContext.legalBasis,
      authorization: eventContext.authorization
    },
    
    // Data subject (if applicable)
    dataSubject: eventContext.dataSubjectId ? {
      id: pseudonymize(eventContext.dataSubjectId),
      categories: eventContext.dataCategories,
      rightsInvoked: eventContext.rightsInvoked
    } : null,
    
    // Resources affected
    resources: {
      systems: eventContext.systems || [],
      dataSets: eventContext.dataSets || [],
      records: eventContext.recordCount || 0
    },
    
    // Processing details
    processing: {
      purpose: eventContext.purpose,
      lawfulBasis: eventContext.lawfulBasis,
      retentionPolicy: eventContext.retentionPolicy,
      dataCategories: eventContext.dataCategories,
      recipients: eventContext.recipients,
      crossBorder: eventContext.crossBorder || false
    },
    
    // Outcome
    outcome: {
      status: eventContext.outcome || 'success',
      details: eventContext.outcomeDetails,
      errorCode: eventContext.errorCode,
      errorMessage: eventContext.errorMessage
    },
    
    // Technical context
    technical: {
      workflowId: $execution.id,
      nodeId: $node.name,
      nodeType: $node.type,
      ipAddress: eventContext.ipAddress,
      userAgent: eventContext.userAgent,
      apiVersion: eventContext.apiVersion
    },
    
    // Integrity
    integrity: {
      hash: await calculateRecordHash(eventContext),
      previousHash: eventContext.previousHash,
      chainVerification: 'verified'
    }
  };
  
  // Store with immutability guarantees
  await storeAuditRecord(auditRecord);
  
  // Real-time alerting for critical events
  if (eventContext.severity === 'critical') {
    await alertComplianceTeam(auditRecord);
  }
  
  return auditRecord.eventId;
}

// n8n Function Node: Compliance Report Generation
async function generateComplianceReport(reportContext) {
  const { reportType, period, format = 'pdf' } = reportContext;
  
  const reportGenerators = {
    'gdpr-article30': generateArticle30Report,
    'data-breach-summary': generateBreachSummary,
    'dsar-statistics': generateDSARStatistics,
    'consent-audit': generateConsentAudit,
    'automated-decisions': generateAutomatedDecisionReport,
    'third-party-processors': generateProcessorReport
  };
  
  const generator = reportGenerators[reportType];
  if (!generator) {
    throw new Error(`Unknown report type: ${reportType}`);
  }
  
  const reportData = await generator(period);
  
  // Format report
  let formattedReport;
  switch (format) {
    case 'pdf':
      formattedReport = await generatePDFReport(reportData);
      break;
    case 'excel':
      formattedReport = await generateExcelReport(reportData);
      break;
    case 'json':
      formattedReport = JSON.stringify(reportData, null, 2);
      break;
    default:
      formattedReport = reportData;
  }
  
  // Log report generation
  await logComplianceEvent({
    type: 'report-generated',
    category: 'compliance',
    actorType: 'system',
    action: 'generate-compliance-report',
    outcome: 'success',
    outcomeDetails: { reportType, period, format }
  });
  
  return {
    reportType: reportType,
    period: period,
    generatedAt: new Date().toISOString(),
    format: format,
    size: formattedReport.length,
    downloadUrl: await secureStoreReport(formattedReport, reportType, period),
    summary: reportData.summary
  };
}

// Article 30 Records of Processing
async function generateArticle30Report(period) {
  const processingActivities = await getProcessingActivities(period);
  
  return {
    summary: {
      totalActivities: processingActivities.length,
      highRiskActivities: processingActivities.filter(a => a.riskLevel === 'high').length,
      automatedDecisionMaking: processingActivities.filter(a => a.automated).length,
      crossBorderTransfers: processingActivities.filter(a => a.crossBorder).length
    },
    
    controllerInformation: {
      name: 'Your Company',
      address: 'Company Address',
      contact: '[email protected]',
      dpo: {
        name: 'Data Protection Officer',
        email: '[email protected]'
      }
    },
    
    processingActivities: processingActivities.map(activity => ({
      name: activity.name,
      purpose: activity.purpose,
      categories: {
        dataSubjects: activity.dataSubjectCategories,
        personalData: activity.dataCategories,
        recipients: activity.recipients
      },
      transfers: {
        thirdCountries: activity.thirdCountries,
        safeguards: activity.transferSafeguards
      },
      retention: activity.retentionPeriods,
      securityMeasures: activity.securityMeasures,
      automatedDecisionMaking: activity.automatedDecisionMaking,
      lastReviewed: activity.lastReviewed
    })),
    
    generatedAt: new Date().toISOString(),
    nextReviewDue: calculateNextReviewDate()
  };
}

// DSAR Statistics Report
async function generateDSARStatistics(period) {
  const requests = await getDSARRequests(period);
  
  return {
    summary: {
      totalRequests: requests.length,
      byType: {
        access: requests.filter(r => r.type === 'access').length,
        erasure: requests.filter(r => r.type === 'erasure').length,
        rectification: requests.filter(r => r.type === 'rectification').length,
        portability: requests.filter(r => r.type === 'portability').length,
        restriction: requests.filter(r => r.type === 'restriction').length,
        objection: requests.filter(r => r.type === 'objection').length
      },
      byChannel: {
        email: requests.filter(r => r.channel === 'email').length,
        web: requests.filter(r => r.channel === 'web').length,
        phone: requests.filter(r => r.channel === 'phone').length,
        post: requests.filter(r => r.channel === 'post').length
      }
    },
    
    performance: {
      avgResponseTime: calculateAverageResponseTime(requests),
      withinOneMonth: requests.filter(r => r.responseTime <= 30).length,
      extended: requests.filter(r => r.extended).length,
      rejected: requests.filter(r => r.status === 'rejected').length
    },
    
    trends: {
      monthOverMonth: calculateMonthOverMonthTrend(requests),
      topRequestSources: getTopRequestSources(requests)
    },
    
    recommendations: generateDSARRecommendations(requests)
  };
}