# 通常のLambda
def lambda_handler(event, context):
    result = process_order(event)
    return result

@durable_execution
def lambda_handler(event, context: DurableContext):
    # バリデーション
    validated = context.step(validate(event))
   
    # 金額による動的分岐（実行時に決定！）
    if validated['amount'] > 100000:
        # 高額注文は承認フロー
        callback = context.create_callback("approval")
        context.step(send_approval(callback.callback_id))
        approval = callback.result()  # 待機
       
        if not approval['approved']:
            return {"status": "rejected"}
   
    # 処理実行
    result = context.step(process(validated))
    return result

{
  "States": {
    "Validate": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:validate",
      "Next": "CheckAmount"
    },
    "CheckAmount": {
      "Type": "Choice",
      "Choices": [{
        "Variable": "$.amount",
        "NumericGreaterThan": 100000,
        "Next": "SendApproval"
      }],
      "Default": "Process"
    },
    "SendApproval": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke.waitForTaskToken",
      "Next": "Process"
    },
    "Process": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:process",
      "End": true
    }
  }
}

import json
import logging
import random
from datetime import datetime, timezone
from typing import Dict, Any

from aws_durable_execution_sdk_python import (
    DurableContext,
    StepContext,
    durable_execution,
    durable_step,
)
from aws_durable_execution_sdk_python.config import (
    Duration,
    StepConfig,
    CallbackConfig,
)

logger = logging.getLogger()
logger.setLevel(logging.INFO)

# 各処理を@durable_stepデコレータで修飾します
@durable_step
def validate_order(step_context: StepContext, order_data: Dict[str, Any]) -> Dict[str, Any]:
    """注文確認"""
    step_context.logger.info(f"Validating order: {order_data.get('order_id')}")
   
    required_fields = ['order_id', 'customer_id', 'items', 'total_amount']
    for field in required_fields:
        if field not in order_data:
            raise ValueError(f"Missing required field: {field}")
   
    if order_data['total_amount'] <= 0:
        raise ValueError("Invalid total amount")
   
    step_context.logger.info("Order validation passed")
   
    return {
        "order_id": order_data['order_id'],
        "customer_id": order_data['customer_id'],
        "total_amount": order_data['total_amount'],
        "status": "validated",
        "validated_at": datetime.now(timezone.utc).isoformat()
    }

@durable_step
def check_inventory(step_context: StepContext, order_data: Dict[str, Any]) -> Dict[str, Any]:
    """在庫確認"""
    step_context.logger.info(f"Checking inventory for order: {order_data['order_id']}")
   
    items = order_data.get('items', [])
    reservation_id = f"RSV-{order_data['order_id']}-{datetime.now(timezone.utc).timestamp()}"
   
    step_context.logger.info(f"Inventory available. Reservation ID: {reservation_id}")
   
    return {
        "order_id": order_data['order_id'],
        "reservation_id": reservation_id,
        "items_reserved": len(items),
        "status": "reserved"
    }

@durable_step
def send_approval_request(
    step_context: StepContext,
    callback_id: str,
    order_data: Dict[str, Any]
) -> Dict[str, Any]:
    """承認リクエストの送信"""
    step_context.logger.info(f"Sending approval request for order: {order_data['order_id']}")
    step_context.logger.info(f"Callback ID: {callback_id}")
   
    step_context.logger.info("Approval request sent successfully")
   
    return {
        "order_id": order_data['order_id'],
        "callback_id": callback_id,
        "status": "awaiting_approval",
        "requested_at": datetime.now(timezone.utc).isoformat()
    }

@durable_step
def process_payment(step_context: StepContext, order_data: Dict[str, Any]) -> Dict[str, Any]:
    """決済処理"""
    step_context.logger.info(f"Processing payment for order: {order_data['order_id']}")
   
    # 不安定なAPI呼び出しを想定
    if random.random() > 0.95:
        step_context.logger.warning("Payment processing failed (simulated), will retry")
        raise Exception("Payment gateway timeout")
   
    transaction_id = f"TXN-{order_data['order_id']}-{datetime.now(timezone.utc).timestamp()}"
   
    step_context.logger.info(f"Payment processed. Transaction ID: {transaction_id}")
   
    return {
        "order_id": order_data['order_id'],
        "transaction_id": transaction_id,
        "amount": order_data['total_amount'],
        "status": "paid",
        "paid_at": datetime.now(timezone.utc).isoformat()
    }
@durable_step
def arrange_shipment(step_context: StepContext, order_data: Dict[str, Any]) -> Dict[str, Any]:
    """配送手配"""
    step_context.logger.info(f"Arranging shipment for order: {order_data['order_id']}")
   
    tracking_number = f"TRACK-{order_data['order_id']}-{datetime.now(timezone.utc).timestamp()}"
   
    step_context.logger.info(f"Shipment arranged. Tracking: {tracking_number}")
   
    return {
        "order_id": order_data['order_id'],
        "tracking_number": tracking_number,
        "status": "shipped",
        "shipped_at": datetime.now(timezone.utc).isoformat()
    }

# メインワークフローを@durable_executionデコレータで修飾。長時間実行とコールバック機能が可能に
@durable_execution
def lambda_handler(event: Dict[str, Any], context: DurableContext) -> Dict[str, Any]:
    """注文処理のメインワークフロー"""
    try:
        context.logger.info("=== Order Processing Workflow Started ===")
        context.logger.info(f"Event: {json.dumps(event)}")
       
        order_data = event.get('order', {})
        if not order_data:
            raise ValueError("Missing 'order' in event")
       
        # Step 1: 注文確認
        validated_order = context.step(validate_order(order_data))
       
        if validated_order["status"] != "validated":
            raise Exception("Order validation failed")
       
        context.logger.info(f"Order validated: {validated_order}")
       
        # Step 2: 在庫確認
        inventory_result = context.step(check_inventory(validated_order))
        context.logger.info(f"Inventory reserved: {inventory_result}")

        # Step 3: 高額注文の場合は承認待ち
        # Lambda Durable Functionsの核心機能！外部イベント(承認)を待ちます
        if validated_order["total_amount"] > 100000:
            context.logger.info("High-value order detected, requesting approval...")


            # コールバックトークンを作成
            callback = context.create_callback(
                name="order-approval",
                config=CallbackConfig(timeout=Duration.from_hours(48))
            )
            context.logger.info(f"Callback created with ID: {callback.callback_id}")

            # 承認依頼を送信
            approval_request = context.step(
                send_approval_request(callback.callback_id, validated_order)
            )
            context.logger.info(f"Approval request sent: {approval_request}")

            # 最重要！この処理で実行が一時停止し、承認を待つ
            # Lambdaは終了するが状態は保持され、外部から承認が来るまで最大48時間待機する
            context.logger.info("Waiting for approval callback...")
            approval_result = callback.result()

            # 承認後、処理が再開
            context.logger.info(f"Approval received: {approval_result}")
           
            if not approval_result.get("approved", False):
                context.logger.warning("Order was rejected")
                return {
                    "status": "rejected",
                    "order_id": validated_order["order_id"],
                    "reason": approval_result.get("reason", "Not approved")
                }
        else:
            context.logger.info("Standard order, no approval needed")
       
        # Step 4: 決済処理
        context.logger.info("Processing payment...")

        payment_result = context.step(process_payment(validated_order))

        if payment_result["status"] != "paid":
            raise Exception("Payment processing failed after retries")

        context.logger.info(f"Payment successful: {payment_result}")
       
        # Step 5: 配送手配
        shipment_result = context.step(arrange_shipment(validated_order))
        context.logger.info(f"Shipment arranged: {shipment_result}")
       
        # 完了
        final_result = {
            "status": "completed",
            "order_id": validated_order["order_id"],
            "transaction_id": payment_result["transaction_id"],
            "tracking_number": shipment_result["tracking_number"],
            "completed_at": datetime.now(timezone.utc).isoformat()
        }
       
        context.logger.info("=== Order Processing Workflow Completed ===")
        context.logger.info(f"Final result: {json.dumps(final_result)}")
       
        return final_result
       
    except Exception as error:
        context.logger.error(f"Workflow failed: {str(error)}")
       
        return {
            "status": "failed",
            "error": str(error),
            "order_id": event.get('order', {}).get('order_id', 'unknown'),
            "failed_at": datetime.now(timezone.utc).isoformat()
        }

# Lambda初期化
{
    "time": "2025-12-12T09:47:40.432Z",
    "type": "platform.initStart",
    "record": {
        "initializationType": "on-demand",
        "phase": "init",
        "runtimeVersion": "python:3.13.DurableFunction.v6",
        "runtimeVersionArn": "arn:aws:lambda:us-east-2::...",
        "functionName": "durable-order-processing",
        "functionVersion": "$LATEST",
        "instanceId": "2025/12/12/[$LATEST]1c19f9987529483484899cdb3e559f85",
        "instanceMaxMemory": 536870912
    }
}

# ワークフロー開始
{
"timestamp": "2025-12-12T09:47:41Z",
"level": "INFO",
"message": "=== Order Processing Workflow Started ===",
"logger": "root",
"requestId": "142df71e-3238-4cf7-bb88-ec6ff5eb0f63",
"executionArn": "arn:aws:lambda:us-east-2:************:function:durable-order-processing:..."
}

# 注文確認
{
"timestamp": "2025-12-12T09:47:41Z",
"level": "INFO",
"message": "Validating order: ORD-2025-004",
"logger": "root",
"requestId": "142df71e-3238-4cf7-bb88-ec6ff5eb0f63",
"executionArn": "arn:aws:lambda:us-east-2:************:function:durable-order-processing:..."
"operationName": "validate_order",
"attempt": 1,
"operationId": "1ced8f5be2db23a6513eba4d819c73806424748a7bc6fa0d792cc1c7d1775a97"
}

# 承認(少額注文なので承認がスキップされています)
{
"timestamp": "2025-12-12T09:47:42Z",
"level": "INFO",
"message": "Standard order, no approval needed",
"logger": "root",
"requestId": "142df71e-3238-4cf7-bb88-ec6ff5eb0f63",
"executionArn": "arn:aws:lambda:us-east-2:************:function:durable-order-processing:..."
}

# 完了
{
"timestamp": "2025-12-12T09:47:42Z",
"level": "INFO",
"message": "=== Order Processing Workflow Completed ===",
"logger": "root",
"requestId": "142df71e-3238-4cf7-bb88-ec6ff5eb0f63",
"executionArn": "arn:aws:lambda:us-east-2:************:function:durable-order-processing:..."
}

# レポート(課金対象の実行時間が2.338秒であることが確認できる)
{
  "time": "2025-12-12T09:47:42.774Z",
  "type": "platform.report",
  "record": {
      "requestId": "142df71e-3238-4cf7-bb88-ec6ff5eb0f63",
      "metrics": {
          "durationMs": 1447.982,
          "billedDurationMs": 2338,
          "memorySizeMB": 512,
          "maxMemoryUsedMB": 89,
          "initDurationMs": 889.95
      },
      "status": "success"
    }
}

# Lambdaの実行はここで一度終了されます。
{
    "time": "2025-12-12T09:53:59.164Z",
    "type": "platform.report",
    "record": {
        "requestId": "e8dac2cd-7b94-45ac-8e73-2882e3243387",
        "metrics": {
            "durationMs": 1003.52,
            "billedDurationMs": 1004,
            "memorySizeMB": 512,
            "maxMemoryUsedMB": 91
        },
        "status": "success"
    }
}