// รูปแบบต้านทาน: เวิร์กโฟลว์เดียวที่ทำทุกอย่าง
// การต้อนรับลูกค้าด้วยโหนด 47 สาขา 12 ส่วน ตัวจัดการข้อผิดพลาด 8 ตัว
// ผลลัพธ์: เป็นไปไม่ได้ที่จะทดสอบ ดีบั๊ก หรือแก้ไขโดยไม่ทำให้เกิดความเสียหาย

// อาการที่คุณถึงเพดานแล้ว:
// - การเพิ่มขั้นตอนใหม่ต้องเลื่อนผ่านหน้าจอ 5 หน้า
// - การเปลี่ยนสาขาหนึ่งทำให้สาขาที่ไม่เกี่ยวข้องสามสาขาเสียหาย
// - การอนุญาตนักพัฒนาใหม่ใช้เวลานานกว่า 3 สัปดาห์
// - "อย่าแตะต้องเวิร์กโฟลว์นั้น มันใช้งานได้บางอย่าง"

// เวิร์กโฟลว์ A แก้ไขข้อมูลที่เวิร์กโฟลว์ B ขึ้นอยู่
// เวิร์กโฟลว์ C เรียกเวิร์กโฟลว์ D ซึ่งอัปเดตระเบียนเดียวกัน
// เวิร์กโฟลว์ E ล้มเหลวอย่างเงียบ ๆ เพราะเวิร์กโฟลว์ F เปลี่ยนรูปแบบเอาต์พุตของมัน

// ผลลัพธ์: การเปลี่ยนแปลงต้องการความเข้าใจระบบทั้งหมด
// ความเสี่ยง: การแก้ไขใด ๆ อาจมีผลกระทบอย่างไม่คาดคิด
// ความจริง: ความเร็วในการพัฒนาชะลอตัวจนหยุดนิ่ง

// คุณจะทดสอบเวิร์กโฟลว์ได้อย่างไรที่มี:
// - การพึ่งพา API ภายนอก 15 รายการ
// - เส้นทางการดำเนินการ 8 เส้นทางที่แตกต่างกัน
// - สถานะที่คงทนข้ามการดำเนินการหลายรายการ
// - ตัวกระตุ้นตามเวลาที่มีเงื่อนไขภายนอก

// คำตอบ: ทีมส่วนใหญ่ไม่ทำ พวกเขาทดสอบในการผลิต
// ผลที่ตามมา: 73% ของอุบัติเหตุการผลิตเกิดจากการเปลี่ยนแปลงที่ไม่ได้ทดสอบ

// ปัญหา: คุณต้องลองอีกครั้งด้วยพารามิเตอร์ที่แก้ไข
// ข้อจำกัด DAG: ไม่สามารถวนกลับไปยังโหนดเดียวกัน
// วิธีแก้ปัญหา: การแตกสาขาที่ซับซ้อนซึ่งทำให้ตรรกะซ้ำซ้อน

// ผลลัพธ์: "เวิร์กโฟลว์สปาเก็ตตี้" ที่ตรรกะถูกทำซ้ำ
// ข้ามหลายสาขาเพื่อจำลองการทำซ้ำ

// แต่ละโหนดมีข้อมูลเอาต์พุตของตนเอง
// การส่งสถานะระหว่างโหนดต้องใช้การเชื่อมต่อที่ชัดเจน
// เวิร์กโฟลว์ที่ซับซ้อนกลายเป็น "แผนภาพการเดินสาย" ที่การไหลของข้อมูล
// บดบังตรรกะทางธุรกิจ

// ตัวอย่าง: เวิร์กโฟลว์ที่มีโหนด 20 โหนดอาจมี
// การเชื่อมต่อข้อมูล 60+ รายการ แต่ละรายการต้องการการบำรุงรักษา

// กฎธุรกิจฝังอยู่ในนิพจน์โหนด IF:
{{ $json.order.total > 1000 && $json.customer.tier === 'premium' && $json.items.length > 5 && !$json.flags.rush_order }}

// คำถาม: "ลูกค้า premium ที่มีคำสั่งซื้อจำนวนมากได้รับการจัดส่งฟรี" อยู่ที่ไหน
// คำตอบ: ไม่มี มันฝังอยู่ในการกำหนดค่าโหนด
// ผลที่ตามมา: ตรรกะทางธุรกิจกลายเป็นความรู้ของกลุ่ม

// ดี: แต่ละเวิร์กโฟลว์ทำสิ่งหนึ่งได้ดี
// เวิร์กโฟลว์: validate-customer-data
// ความรับผิดชอบ: ตรวจสอบและปกติข้อมูลอินพุตของลูกค้า
// อินพุต: ข้อมูลลูกค้าดิบ
// เอาต์พุต: วัตถุลูกค้าที่ตรวจสอบแล้วหรือข้อผิดพลาดการตรวจสอบ

// ไม่ดี: เวิร์กโฟลว์พยายามทำทุกอย่าง
// เวิร์กโฟลว์: customer-onboarding-complete
// พยายาม: การตรวจสอบ + การสร้าง CRM + การส่งอีเมล +
//           การแจ้งเตือน Slack + การติดตามการวิเคราะห์ + การสร้างเอกสาร
// ผลลัพธ์: โหนด 47 เป็นไปไม่ได้ที่จะทดสอบ การเปลี่ยนแปลงมีความเสี่ยง

// สัญญาสำหรับเวิร์กโฟลว์ customer-validation

// สคีมาอินพุต:
{
  "customer": {
    "email": "string (จำเป็น อีเมลที่ถูกต้อง)",
    "name": "string (จำเป็น ขั้นต่ำ 2 ตัวอักษร)",
    "company": "string (ไม่จำเป็น)",
    "phone": "string (ไม่จำเป็น รูปแบบที่ถูกต้อง)"
  },
  "context": {
    "source": "string (web|api|import)",
    "timestamp": "ISO 8601 datetime"
  }
}

// สคีมาเอาต์พุต (สำเร็จ):
{
  "status": "valid",
  "customer": {
    "id": "generated-uuid",
    "email": "[email protected]",
    "name": "Normalized Name",
    // ... ฟิลด์ที่ปกติ
  },
  "validation": {
    "passed": ["email", "name"],
    "warnings": ["phone format adjusted"]
  }
}

// สคีมาเอาต์พุต (ล้มเหลว):
{
  "status": "invalid",
  "errors": [
    { "field": "email", "code": "INVALID_FORMAT", "message": "..." }
  ],
  "suggestions": ["..."]
}

// เวิร์กโฟลว์ตัวประสานงาน: customer-onboarding-orchestrator
// ไม่ได้มี ตรรกะทางธุรกิจ
// เพียงแค่ ประสานงานเวิร์กโฟลว์อื่น ๆ

// ขั้นตอนที่ 1: ตรวจสอบอินพุต
// เรียก: workflow-validate-customer-data
// เมื่อสำเร็จ: ดำเนินการต่อไปยังขั้นตอนที่ 2
// เมื่อล้มเหลว: ส่งคืนข้อผิดพลาดการตรวจสอบ

// ขั้นตอนที่ 2: ตรวจสอบรายการซ้ำ
// เรียก: workflow-check-duplicate-customer
// เมื่อพบรายการซ้ำ: ผสานหรือเตือน
// เมื่อเป็นลูกค้าใหม่: ดำเนินการต่อไปยังขั้นตอนที่ 3

// ขั้นตอนที่ 3: สร้างระเบียน CRM
// เรียก: workflow-create-crm-record
// เมื่อสำเร็จ: ดำเนินการต่อไปยังขั้นตอนที่ 4
// เมื่อล้มเหลว: ย้อนกลับ แจ้งผู้ดูแลระบบ

// ขั้นตอนที่ 4: ส่งลำดับต้อนรับ
// เรียก: workflow-trigger-welcome-email
// ไม่ต้องรอ: ไม่รอให้เสร็จสมบูรณ์

// ขั้นตอนที่ 5: แจ้งทีม
// เรียก: workflow-send-slack-notification
// ไม่ต้องรอ: fire and forget

// แต่ละเวิร์กโฟลว์ย่อยสามารถทดสอบได้อย่างอิสระ
// ตรรกะตัวประสานงานมองเห็นได้ในหนึ่งครั้ง
// ขั้นตอนใหม่สามารถเพิ่มได้โดยไม่ต้องแตะโค้ดที่มีอยู่

// เวิร์กโฟลว์ผู้ปกครอง: order-processing-orchestrator

// โหนด: Validate Order Input
// ประเภท: Execute Workflow
// ID เวิร์กโฟลว์: validate-order-data
// ส่ง: {{ $json }}

// โหนด: Check Inventory
// ประเภท: Execute Workflow  
// ID เวิร์กโฟลว์: check-inventory-availability
// ส่ง: {{ $json.order.items }}
// รอ: การตรวจสอบเสร็จสมบูรณ์

// โหนด: Calculate Shipping
// ประเภท: Execute Workflow
// ID เวิร์กโฟลว์: calculate-shipping-rates
// ส่ง: {{ $json.order }}
// รอ: การตรวจสอบสต็อก

// โหนด: Process Payment
// ประเภท: Execute Workflow
// ID เวิร์กโฟลว์: process-payment-gateway
// ส่ง: {{ $json.order.total }}
// รอ: การคำนวณการจัดส่ง

// โหนด: Send Confirmations
// ประเภท: Execute Workflow
// ID เวิร์กโฟลว์: send-order-confirmations
// ส่ง: {{ $json.order }}
// Async: true (ไม่รอ)

// เวิร์กโฟลว์ที่เรียก (ผู้ปกครอง):
// ตั้งค่าโหนดก่อน Execute Workflow:
{
  "orderId": "{{ $json.id }}",
  "customerEmail": "{{ $json.customer.email }}",
  "items": "{{ $json.items }}",
  "metadata": {
    "source": "web",
    "sessionId": "{{ $json.sessionId }}",
    "timestamp": "{{ $now }}"
  }
}

// เวิร์กโฟลว์ที่ถูกเรียก (ลูก) รับสิ่งนี้เป็นอินพุต
// เข้าถึงผ่าน: {{ $json.orderId }}, {{ $json.customerEmail }}, ฯลฯ

// เวิร์กโฟลว์ลูกส่งคืน:
// เอาต์พุตของโหนดสุดท้ายกลายเป็นอินพุตของผู้ปกครองสำหรับโหนดถัดไป
// หรือตั้งค่าอย่างชัดเจนด้วยโหนด Code:
return {
  json: {
    status: "success",
    processedAt: $now,
    result: processedData
  }
};

// รูปแบบการจัดการข้อผิดพลาดเวิร์กโฟลว์ผู้ปกครอง:

// โหนด: Execute Workflow (process-payment)
// เมื่อเกิดข้อผิดพลาด: Continue
// เอาต์พุตข้อผิดพลาด → โหนด: Handle Payment Failure

// โหนด Handle Payment Failure (Code):
const error = items[0].json.error;

// กำหนดประเภทข้อผิดพลาด
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
    }
  };
}

// เวิร์กโฟลว์: utility-format-phone-number
// วัตถุประสงค์: ทำให้หมายเลขโทรศัพท์อยู่ในรูปแบบ E.164
// อินพุต: { "phone": "string", "country": "string (ไม่จำเป็น)" }
// เอาต์พุต: { "formatted": "string", "valid": "boolean" }

// การใช้งานโหนด Code:
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) {
  // หมายเลขไม่ถูกต้อง
}

return {
  json: {
    formatted: null,
    valid: false,
    error: 'Invalid phone number format'
  }
};

// เวิร์กโฟลว์: utility-error-handler
// สร้างการตอบสนองข้อผิดพลาดที่สอดคล้องกันทุกเวิร์กโฟลว์

// อินพุต: { "error": "Error object", "context": "..." }

// โหนด Code:
const error = $json.error;
const context = $json.context;

const standardizedError = {
  error: {
    code: error.code || 'UNKNOWN_ERROR',
    message: error.message || 'An unexpected error occurred',
    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) {
  // ส่งคืนขั้นตอนถัดไปที่สามารถดำเนินการได้ตามประเภทข้อผิดพลาด
  // ...
}

return { json: standardizedError };

// ใช้ตารางการตัดสินใจที่มีโครงสร้างแทนโหนด IF ที่ซ้อนกัน

// เวิร์กโฟลว์: calculate-discount
// ใช้: โหนด Code พร้อมตารางการตัดสินใจ

const decisionTable = [
  // ระดับลูกค้า มูลค่าคำสั่งซื้อ ฤดูกาล ส่วนลด %
  { 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;
});

// ใช้ส่วนลดสูงสุด
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
  }
};

// สำหรับกระบวนการที่ซับซ้อนที่มีหลายสถานะและการเปลี่ยนผ่าน
// เวิร์กโฟลว์: 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' }
  }
  // ... สถานะเพิ่มเติม
};

// สถานะปัจจุบันและการเปลี่ยนผ่านที่ร้องขอ
const currentState = $json.currentState;
const requestedState = $json.requestedState;

// ตรวจสอบการเปลี่ยนผ่าน
const allowed = validTransitions[currentState]?.includes(requestedState);

if (!allowed) {
  return {
    json: {
      success: false,
      error: `Invalid transition from ${currentState} to ${requestedState}`,
      validTransitions: validTransitions[currentState] || []
    }
  };
}

// ดำเนินการการกระทำตามสถานะ
const actions = stateActions[requestedState]?.onEnter || [];

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

// กฎธุรกิจเชิงประกาศที่ผู้ไม่ใช่นักพัฒนาสามารถเข้าใจได้

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
  }
];

// ประเมินกฎทั้งหมด
const orderData = $json;
const matchedRules = rules
  .filter(rule => rule.condition(orderData))
  .sort((a, b) => a.priority - b.priority);

// ดำเนินการการกระทำตามลำดับความสำคัญ
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))
  }
};

// เลือกกลยุทธ์การประมวลผลตามลักษณะของคำสั่งซื้อ

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,
    // เอาต์พุตกำหนดเวิร์กโฟลว์ย่อยที่จะเรียก
    nextWorkflow: `process-order-${strategy}`
  }
};

// ประมวลผลคำสั่งซื้อผ่านตัวจัดการหลายตัวจนกว่าหนึ่งตัวจะจัดการกับมัน

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, // ตัวจัดการเริ่มต้น
    handle: (order) => ({ action: 'process_normally', reason: 'standard_flow' })
  }
];

const order = $json.order;

// ค้นหาตัวจัดการตัวแรกที่สามารถประมวลผลคำสั่งซื้อนี้ได้
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'
  }
};

// เวิร์กโฟลว์: expense-approval-process

// ขั้นตอนที่ 1: รับการส่งค่าใช้จ่าย
// อินพุต: { expense: {...}, submitter: {...} }

// ขั้นตอนที่ 2: การอนุมัติอัตโนมัติสำหรับจำนวนน้อย
// โหนด Code:
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'
    }
  };
}

// ขั้นตอนที่ 3: กำหนดเส้นทางไปยังผู้อนุมัติที่เหมาะสมตามจำนวนเงิน
let approverLevel;
if (expense.amount <= 500) approverLevel = 'manager';
else if (expense.amount <= 2000) approverLevel = 'director';
else approverLevel = 'vp';

// ขั้นตอนที่ 4: สร้างงานการอนุมัติในเครื่องมือการจัดการโครงการ
// ใช้โหนด HTTP เพื่อสร้างงานใน Asana/Monday/ฯลฯ

// ขั้นตอนที่ 5: รอการอนุมัติ (โดยใช้โหนด Wait)
// ตัวกระตุ้น Webhook สำหรับการตอบสนองการอนุมัติ

// ขั้นตอนที่ 6: ประมวลผลตามการตัดสินใจการอนุมัติ
// เมื่ออนุมัติ: process_payment workflow
// เมื่อปฏิเสธ: notify_submitter workflow

// เวิร์กโฟลว์: customer-support-triage

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

// ระบบการให้คะแนนสำหรับการจัดการอัตโนมัติกับการจัดการด้วยตนเอง
const riskScore = calculateRiskScore(ticket, customer);

function calculateRiskScore(ticket, customer) {
  let score = 0;
  
  // ปัจจัยความเร่งด่วน
  if (ticket.priority === 'urgent') score += 30;
  if (ticket.tags.includes('billing')) score += 20;
  if (ticket.tags.includes('security')) score += 40;
  
  // ปัจจัยลูกค้า
  if (customer.tier === 'enterprise') score += 25;
  if (customer.lifetimeValue > 50000) score += 15;
  
  // การวิเคราะห์ความรู้สึก
  if (ticket.sentiment === 'angry') score += 20;
  if (ticket.previousTickets > 3) score += 10;
  
  return score;
}

// การกำหนดเส้นทางการตัดสินใจ
if (riskScore < 30) {
  // ความเสี่ยงต่ำ: การตอบสนองอัตโนมัติ
  return {
    json: {
      action: 'auto_respond',
      template: 'standard_response',
      score: riskScore
    }
  };
} else if (riskScore < 60) {
  // ความเสี่ยงปานกลาง: คิวสำหรับการตรวจสอบของมนุษย์ภายใน 4 ชั่วโมง
  return {
    json: {
      action: 'queue_for_agent',
      priority: 'normal',
      sla: '4_hours',
      score: riskScore
    }
  };
} else {
  // ความเสี่ยงสูง: ความสนใจจากมนุษย์ทันที
  return {
    json: {
      action: 'immediate_escalation',
      priority: 'critical',
      notify: ['support_manager', 'customer_success'],
      score: riskScore,
      reason: 'High-value customer or sensitive issue'
    }
  };
}

// เวิร์กโฟลว์: content-moderation-pipeline

const content = $json.content;

// ขั้นตอนที่ 1: การคัดกรองล่วงหน้าด้วย AI
const aiScore = await callModerationAPI(content);

// ขั้นตอนที่ 2: กำหนดเส้นทางตามความมั่นใจ
if (aiScore.confidence > 0.95 && aiScore.category === 'safe') {
  // ความมั่นใจสูงปลอดภัย: อนุมัติอัตโนมัติ
  return { json: { action: 'auto_approve', confidence: aiScore.confidence } };
} else if (aiScore.confidence > 0.9 && aiScore.category === 'violating') {
  // ความมั่นใจสูงละเมิด: ปฏิเสธอัตโนมัติ
  return { json: { action: 'auto_reject', confidence: aiScore.confidence, reason: aiScore.reason } };
} else {
  // ไม่แน่ใจ: คิวสำหรับการตรวจสอบของมนุษย์
  // สร้างงานการตรวจสอบด้วยบริบท AI
  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'
  };
  
  // ส่งไปยังคิวการตรวจสอบ (Redis, ฐานข้อมูล หรือคิวงาน)
  await sendToReviewQueue(reviewTask);
  
  return {
    json: {
      action: 'queued_for_review',
      queuePosition: await getQueuePosition(),
      estimatedReviewTime: await getEstimatedTime(),
      contentId: content.id
    }
  };
}

// เวิร์กโฟลว์: send-approval-request

const request = $json.request;

// สร้างบริบทที่ครอบคลุมสำหรับผู้อนุมัติ
const approvalContext = {
  // สิ่งที่ต้องการการอนุมัติ
  requestType: request.type,
  title: request.title,
  description: request.description,
  amount: request.amount,
  currency: request.currency,
  
  // ทำไมจึงสำคัญ
  businessJustification: request.justification,
  expectedRoi: request.roi,
  riskLevel: request.risk,
  
  // ใครเกี่ยวข้อง
  requester: {
    name: request.requester.name,
    department: request.requester.department,
    history: request.requester.approvalHistory
  },
  
  // บริบทประวัติศาสตร์
  similarRequests: await getSimilarRequests(request),
  departmentBudget: await getDepartmentBudget(request.requester.department),
  remainingBudget: await getRemainingBudget(request.requester.department),
  
  // คำแนะนำ AI (ถ้าใช้ได้)
  aiRecommendation: request.aiAnalysis?.recommendation,
  aiConfidence: request.aiAnalysis?.confidence,
  aiRationale: request.aiAnalysis?.rationale,
  
  // การกระทำด่วน
  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' }
  ],
  
  // กลไกการตอบสนอง
  respondUrl: `https://approvals.example.com/respond/${request.id}`,
  expiresAt: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString()
};

// ส่งผ่าน Slack ด้วยรูปแบบที่สวยงาม
// หรือ Email ด้วย CTA ที่ชัดเจน
// หรือ Microsoft Teams ด้วย adaptive cards

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

// เวิร์กโฟลว์: daily-expense-batch-review

// ทำงานทุกวันเวลา 9 โมงเช้า
// รวบรวมค่าใช้จ่ายที่รอดำเนินการทั้งหมดและสร้างการตรวจสอบแบบชุด

const pendingExpenses = await getPendingExpenses();

// จัดกลุ่มตามแผนกเพื่อการตรวจสอบที่มีประสิทธิภาพ
const byDepartment = pendingExpenses.reduce((acc, exp) => {
  const dept = exp.department;
  if (!acc[dept]) acc[dept] = [];
  acc[dept].push(exp);
  return acc;
}, {});

// สร้างการตรวจสอบแบบชุดสำหรับหัวหน้าแผนกแต่ละคน
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)
  }
};

// เวิร์กโฟลว์: long-running-document-processing

const documentId = $json.documentId;

// ขั้นตอนที่ 1: โหลด checkpoint ถ้ามีอยู่
const checkpoint = await loadCheckpoint(documentId);

if (checkpoint) {
  // ดำเนินการต่อจาก checkpoint
  $json.resumeFrom = checkpoint.step;
  $json.partialResults = checkpoint.results;
}

// ขั้นตอนที่ 2: ประมวลผลเป็นขั้นตอนพร้อม checkpoints
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 หลังจากแต่ละขั้นตอน
    await saveCheckpoint(documentId, {
      step: stage.name,
      results: result,
      completedAt: $now
    });
    
  } catch (error) {
    // บันทึกสถานะที่ล้มเหลวสำหรับการกู้คืน
    await saveCheckpoint(documentId, {
      step: stage.name,
      error: error.message,
      failedAt: $now,
      retryCount: (checkpoint?.retryCount || 0) + 1
    });
    
    throw error; // ให้ n8n จัดการ retry/error workflow
  }
}

// ขั้นตอนที่ 3: ล้าง checkpoint เมื่อสำเร็จ
await deleteCheckpoint(documentId);

// เวิร์กโฟลว์: order-saga-orchestrator
// ประสานงานหลายบริการด้วยการกระทำที่ชดเชย

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 // อีเมลไม่สามารถยกเลิกได้ แต่ไม่สำคัญ
  }
];

const completedSteps = [];

for (const step of sagaSteps) {
  try {
    const result = await step.execute();
    completedSteps.push({ name: step.name, result: result });
    
    // บันทึกความคืบหน้า
    await logSagaProgress(sagaId, step.name, 'completed');
    
  } catch (error) {
    // บันทึกความล้มเหลว
    await logSagaProgress(sagaId, step.name, 'failed', error);
    
    // ชดเชยขั้นตอนที่เสร็จสมบูรณ์ตามลำดับย้อนกลับ
    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);
          // แจ้งเตือนเพื่อการแทรกแซงด้วยตนเอง
          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'
  }
};

// เวิร์กโฟลว์: api-call-with-circuit-breaker

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

// ตรวจสอบสถานะวงจร
if (circuitState.status === 'OPEN') {
  // วงจรเปิด - ล้มเหลวอย่างรวดเร็ว
  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 {
    // ลองสถานะครึ่งเปิด
    await setCircuitState(serviceName, 'HALF_OPEN');
  }
}

// ทำการเรียก API
try {
  const response = await makeAPICall($json);
  
  // สำเร็จ - บันทึก
  await recordSuccess(serviceName);
  
  // ถ้าอยู่ในสถานะครึ่งเปิด ปิดวงจร
  if (circuitState.status === 'HALF_OPEN') {
    await setCircuitState(serviceName, 'CLOSED', { consecutiveSuccesses: 0 });
  }
  
  return { json: { success: true, data: response } };
  
} catch (error) {
  // บันทึกความล้มเหลว
  await recordFailure(serviceName);
  
  const consecutiveFailures = await getConsecutiveFailures(serviceName);
  const threshold = circuitState.failureThreshold || 5;
  
  if (consecutiveFailures >= threshold) {
    // เปิดวงจร
    await setCircuitState(serviceName, 'OPEN', {
      openedAt: Date.now(),
      reason: error.message,
      consecutiveFailures: consecutiveFailures
    });
  }
  
  return {
    json: {
      success: false,
      error: error.message,
      circuitState: await getCircuitState(serviceName)
    }
  };
}

// เวิร์กโฟลว์: 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);
    
    // บันทึกความสำเร็จหลังจาก retry
    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) {
      // ยอมแพ้
      return {
        json: {
          success: false,
          attempts: attempt + 1,
          error: error.message,
          retryable: false
        }
      };
    }
    
    // คำนวณความล่าช้าด้วย exponential backoff และ jitter
    const delay = Math.min(
      baseDelay * Math.pow(2, attempt) + Math.random() * 1000,
      30000 // สูงสุด 30 วินาที
    );
    
    await logEvent('retry_scheduled', {
      operation: operation.name,
      attempt: attempt + 1,
      nextAttemptDelay: delay,
      error: error.message
    });
    
    // รอก่อน retry
    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
  );
}

// เวิร์กโฟลว์: process-with-dlq

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

try {
  // ตั้งค่า timeout
  const timeoutPromise = new Promise((_, reject) => 
    setTimeout(() => reject(new Error('Processing timeout')), timeoutMs)
  );
  
  // แข่งขันระหว่างการประมวลผลและ timeout
  const result = await Promise.race([
    processMessage(message),
    timeoutPromise
  ]);
  
  return {
    json: {
      success: true,
      processingTime: Date.now() - processingStartTime,
      result: result
    }
  };
  
} catch (error) {
  // ส่งไปยัง Dead Letter Queue สำหรับการวิเคราะห์ในภายหลัง
  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);
  
  // แจ้งเตือนหากสิ่งนี้เกิดขึ้นบ่อยครั้ง
  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
    }
  };
}

// เวิร์กโฟลว์: batch-processor

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

// ประมวลผลเป็นชุด
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);
  
  // ประมวลผลชุด
  const batchResults = await Promise.all(
    batch.map(item => processItem(item))
  );
  
  results.push(...batchResults);
  
  // บันทึกความคืบหน้า
  await logProgress({
    batch: batchNumber,
    totalBatches: totalBatches,
    processed: results.length,
    total: items.length,
    percentComplete: Math.round((results.length / items.length) * 100)
  });
  
  // หยุดชั่วขณะระหว่างชุดเพื่อป้องกันการจำกัดอัตรา
  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
  }
};

// เวิร์กโฟลว์: enqueue-for-async-processing

const request = $json.request;

// ไม่ประมวลผลแบบซิงโครนัส - เข้าคิวเพื่อประมวลผลเบื้องหลัง
const job = {
  id: generateUUID(),
  type: request.type,
  payload: request.payload,
  priority: request.priority || 'normal',
  submittedAt: $now,
  estimatedDuration: estimateDuration(request),
  dependencies: request.dependencies || []
};

// เพิ่มเข้าไปในคิวการประมวลผล
await enqueueJob(job);

// ส่งคืนทันทีด้วยรหัสงาน
return {
  json: {
    accepted: true,
    jobId: job.id,
    status: 'queued',
    estimatedStartTime: await getEstimatedStartTime(job),
    statusUrl: `https://api.example.com/jobs/${job.id}/status`
  }
};

// เวิร์กโฟลว์แยก: async-job-processor
// กระตุ้นโดยคิว ประมวลผลงานเบื้องหลัง
// อัปเดตสถานะที่สามารถสอบถามได้ผ่าน statusUrl

// เวิร์กโฟลว์: stream-large-dataset

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

// เปิดสตรีมเอาต์พุต (เช่น ไปยังไฟล์ S3 หรือ webhook)
const outputStream = await createOutputStream($json.destination);

while (hasMore) {
  // ดึงหน้า
  const pageData = await fetchPage(query, page, pageSize);
  
  if (pageData.length === 0) {
    hasMore = false;
    break;
  }
  
  // แปลงหน้า
  const transformed = pageData.map(transformRecord);
  
  // เขียนลงสตรีม (ไม่เก็บไว้ในหน่วยความจำ)
  await outputStream.write(transformed);
  
  totalProcessed += pageData.length;
  page++;
  
  // บันทึกความคืบหน้า
  if (page % 10 === 0) {
    await logProgress({
      page: page,
      totalProcessed: totalProcessed,
      memoryUsage: process.memoryUsage()
    });
  }
  
  // ตรวจสอบว่าถึงขีดจำกัดหรือไม่
  if ($json.maxRecords && totalProcessed >= $json.maxRecords) {
    hasMore = false;
  }
}

// ปิดสตรีม
await outputStream.close();

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

// เวิร์กโฟลว์: rotate-api-credentials

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

// ตรวจสอบว่าจำเป็นต้องหมุนเวียนหรือไม่
const lastRotation = await getLastRotation(service);
const daysSinceRotation = daysBetween(lastRotation, $now);

if (daysSinceRotation < rotationPolicy.days) {
  return {
    json: {
      rotated: false,
      reason: 'Rotation not yet due',
      nextRotation: addDays(lastRotation, rotationPolicy.days)
    }
  };
}

// ดำเนินการหมุนเวียน
const newCredentials = await generateNewCredentials(service);

// อัปเดตในร้านเก็บข้อมูลประจำตัว (การปรับใช้แบบค่อยเป็นค่อยไป)
await updateCredentialStore(service, {
  primary: newCredentials,
  secondary: await getCurrentCredentials(service), // เก็บเก่าไว้เป็นสำรอง
  rotationTime: $now
});

// แจ้งระบบที่เกี่ยวข้อง
await notifyCredentialRotation(service, {
  rotationTime: $now,
  affectedWorkflows: await getWorkflowsUsingCredential(service)
});

// กำหนดเวลาหมดอายุของข้อมูลประจำตัวเก่า
await scheduleCredentialExpiration(service, {
  expireAt: addHours($now, rotationPolicy.gracePeriodHours)
});

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

// เวิร์กโฟลว์: process-with-full-audit

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

// บันทึก Audit ก่อนการดำเนินการ
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);
  
  // บันทึก Audit ความสำเร็จ
  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) {
  // บันทึก Audit ความล้มเหลว
  await updateAuditRecord(auditId, {
    status: 'failed',
    failedAt: $now,
    error: sanitizeForAudit(error.message),
    stackTrace: sanitizeForAudit(error.stack)
  });
  
  throw error;
}

function sanitizeForAudit(data) {
  // ลบ PII และข้อมูลที่ละเอียดอ่อนก่อนบันทึก
  const sensitiveFields = ['password', 'ssn', 'creditCard', 'apiKey'];
  const sanitized = { ...data };
  
  for (const field of sensitiveFields) {
    if (sanitized[field]) {
      sanitized[field] = '[REDACTED]';
    }
  }
  
  return sanitized;
}

// เวิร์กโฟลว์: 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 {
    // ดำเนินการเวิร์กโฟลว์ที่ทดสอบ
    const actual = await executeWorkflow('workflow-under-test', testCase.input);
    
    // เปรียบเทียบกับที่คาดหวัง
    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
    });
  }
}

// สร้างรายงานการทดสอบ
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 };