terraform {
  required_version = ">= 1.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.0"
    }
  }
}

provider "aws" {
  region  = "us-east-2"
}

data "archive_file" "lambda" {
  type        = "zip"
  source_dir  = "${path.module}/src"
  output_path = "${path.module}/lambda.zip"
}

#--------------------------------------------------
# IAM: Lambda Execution Role
# Lambda関数の実行に必要なロール
#--------------------------------------------------

data "aws_iam_policy_document" "lambda_assume_role" {
  statement {
    effect = "Allow"

    principals {
      type        = "Service"
      identifiers = ["lambda.amazonaws.com"]
    }

    actions = ["sts:AssumeRole"]
  }
}

resource "aws_iam_role" "lambda_execution" {
  name               = "lambda-durable-functions-execution"
  assume_role_policy = data.aws_iam_policy_document.lambda_assume_role.json
}

resource "aws_iam_role_policy_attachment" "lambda_basic_execution" {
  role       = aws_iam_role.lambda_execution.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

# Durable Functions用の追加権限
data "aws_iam_policy_document" "durable_execution" {
  statement {
    sid    = "DurableExecutionPermissions"
    effect = "Allow"
    actions = [
      "lambda:CheckpointDurableExecution",
      "lambda:GetDurableExecutionState"
    ]
    resources = ["${aws_lambda_function.main.arn}:*"]
  }
}

resource "aws_iam_role_policy" "durable_execution" {
  name   = "durable-execution-policy"
  role   = aws_iam_role.lambda_execution.id
  policy = data.aws_iam_policy_document.durable_execution.json
}

#--------------------------------------------------
# Lambda Function
# durable_configを指定することでDurable Functionsとして動作
#--------------------------------------------------

resource "aws_lambda_function" "main" {
  filename         = data.archive_file.lambda.output_path
  function_name    = "example-durable-function"
  role             = aws_iam_role.lambda_execution.arn
  handler          = "lambda_function.lambda_handler"
  source_code_hash = data.archive_file.lambda.output_base64sha256

  runtime     = "python3.14"
  timeout     = 30
  memory_size = 256

  # エイリアス作成のためバージョン発行が必要
  publish = true

  # このブロックを指定することでDurable Functionsとして動作する
  durable_config {
    execution_timeout = 900
    retention_period  = 7
  }

  # Durable Functionsの削除には最大60分かかる場合がある
  # https://registry.terraform.io/providers/hashicorp/aws/6.25.0/docs/resources/lambda_function#function-with-durable-configuration
  timeouts {
    delete = "60m"
  }

  depends_on = [
    aws_iam_role_policy_attachment.lambda_basic_execution,
  ]
}

#--------------------------------------------------
# Lambda Alias
# Durable Functionsは修飾されたARN（バージョン/エイリアス付き）が必要
#--------------------------------------------------

resource "aws_lambda_alias" "prod" {
  name             = "prod"
  function_name    = aws_lambda_function.main.function_name
  function_version = aws_lambda_function.main.version
}

#--------------------------------------------------
# Outputs
#--------------------------------------------------

output "function_arn" {
  description = "Lambda function ARN"
  value       = aws_lambda_function.main.arn
}

output "alias_arn" {
  description = "Lambda alias ARN (use this for invocations)"
  value       = aws_lambda_alias.prod.arn
}

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

@durable_step
def validate_order(step_context, order_id):
    step_context.logger.info(f"Validating order {order_id}")
    return {"orderId": order_id, "status": "validated"}

@durable_step
def process_payment(step_context, order_id):
    step_context.logger.info(f"Processing payment for order {order_id}")
    return {"orderId": order_id, "status": "paid", "amount": 99.99}

@durable_step
def confirm_order(step_context, order_id):
    step_context.logger.info(f"Confirming order {order_id}")
    return {"orderId": order_id, "status": "confirmed"}

@durable_execution
def lambda_handler(event, context: DurableContext):
    order_id = event['orderId']

    # Step 1: Validate order
    validation_result = context.step(validate_order(order_id))

    # Step 2: Process payment
    payment_result = context.step(process_payment(order_id))

    # Wait for 10 seconds to simulate external confirmation
    context.wait(Duration.from_seconds(10))

    # Step 3: Confirm order
    confirmation_result = context.step(confirm_order(order_id))

    return {
        "orderId": order_id,
        "status": "completed",
        "steps": [validation_result, payment_result, confirmation_result]
    }

aws lambda invoke \
  --function-name example-durable-function:prod \
  --payload '{"orderId": "order-12345"}' \
  --region us-east-2 \
  --cli-binary-format raw-in-base64-out \
  response.json

{
    "orderId": "order-12345",
    "status": "completed",
    "steps": [
        {
            "orderId": "order-12345",
            "status": "validated"
        },
        {
            "orderId": "order-12345",
            "status": "paid",
            "amount": 99.99
        },
        {
            "orderId": "order-12345",
            "status": "confirmed"
        }
    ]
}

# OK: エイリアス付き
aws lambda invoke --function-name example-durable-function:prod ...

# OK: バージョン番号付き
aws lambda invoke --function-name example-durable-function:1 ...

# 開発時のみ: $LATEST
aws lambda invoke --function-name example-durable-function:$LATEST ...