def lambda_handler(event, context):
    if event["operator"] == "+":
        result = event["operand1"] + event["operand2"]
    elif event["operator"] == "-":
        result = event["operand1"] - event["operand2"]
    elif event["operator"] == "*":
        result = event["operand1"] * event["operand2"]
    elif event["operator"] == "/":
        result = event["operand1"] / event["operand2"]
    else:
        result = event["operand1"]
    return result

{
  "StartAt": "ネストチェック",
  "States": {
    "ネストチェック": {
      "Type": "Choice",
      "Choices": [
        {
          "Next": "両方ネスト",
          "Condition": "{% $states.input.operand1.operator != null and $states.input.operand2.operator != null %}"
        },
        {
          "Next": "Operand1を再帰で計算",
          "Condition": "{% $states.input.operand1.operator != null %}"
        },
        {
          "Next": "Operand2を再帰で計算",
          "Condition": "{% $states.input.operand2.operator != null %}"
        }
      ],
      "Default": "Operand1とOperand2をそのまま演算"
    },
    "両方ネスト": {
      "Type": "Parallel",
      "Branches": [
        {
          "StartAt": "Operand1を再帰で計算(両方ネスト)",
          "States": {
            "Operand1を再帰で計算(両方ネスト)": {
              "Type": "Task",
              "Resource": "arn:aws:states:::states:startExecution.sync:2",
              "Arguments": {
                "StateMachineArn": "${StateMachineArn}",
                "Input": "{% $states.input.operand1 %}"
              },
              "End": true,
              "Output": {
                "operator": "{% $states.input.operator %}",
                "operand1": "{% $states.result.Output %}",
                "operand2": "{% $states.input.operand2 %}"
              }
            }
          }
        },
        {
          "StartAt": "Operand2を再帰で計算(両方ネスト)",
          "States": {
            "Operand2を再帰で計算(両方ネスト)": {
              "Type": "Task",
              "Resource": "arn:aws:states:::states:startExecution.sync:2",
              "Arguments": {
                "StateMachineArn": "${StateMachineArn}",
                "Input": "{% $states.input.operand2 %}"
              },
              "End": true,
              "Output": {
                "operator": "{% $states.input.operator %}",
                "operand1": "{% $states.input.operand1 %}",
                "operand2": "{% $states.result.Output %}"
              }
            }
          }
        }
      ],
      "Next": "再帰計算されたOperand1とOperand2で演算"
    },
    "再帰計算されたOperand1とOperand2で演算": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Output": "{% $states.result.Payload %}",
      "Arguments": {
        "FunctionName": "${FunctionArn}",
        "Payload": {
          "operator": "{% $states.input[0].operator %}",
          "operand1": "{% $states.input[0].operand1 %}",
          "operand2": "{% $states.input[1].operand2 %}"
        }
      },
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException",
            "Lambda.TooManyRequestsException"
          ],
          "IntervalSeconds": 1,
          "MaxAttempts": 3,
          "BackoffRate": 2,
          "JitterStrategy": "FULL"
        }
      ],
      "End": true
    },
    "Operand1を再帰で計算": {
      "Type": "Task",
      "Resource": "arn:aws:states:::states:startExecution.sync:2",
      "Arguments": {
        "StateMachineArn": "${StateMachineArn}",
        "Input": "{% $states.input.operand1 %}"
      },
      "Output": {
        "operator": "{% $states.input.operator %}",
        "operand1": "{% $states.result.Output %}",
        "operand2": "{% $states.input.operand2 %}"
      },
      "Next": "再帰計算されたOperand1で演算"
    },
    "再帰計算されたOperand1で演算": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Output": "{% $states.result.Payload %}",
      "Arguments": {
        "FunctionName": "${FunctionArn}",
        "Payload": "{% $states.input %}"
      },
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException",
            "Lambda.TooManyRequestsException"
          ],
          "IntervalSeconds": 1,
          "MaxAttempts": 3,
          "BackoffRate": 2,
          "JitterStrategy": "FULL"
        }
      ],
      "End": true
    },
    "Operand2を再帰で計算": {
      "Type": "Task",
      "Resource": "arn:aws:states:::states:startExecution.sync:2",
      "Arguments": {
        "StateMachineArn": "${StateMachineArn}",
        "Input": "{% $states.input.operand2 %}"
      },
      "Output": {
        "operator": "{% $states.input.operator %}",
        "operand1": "{% $states.input.operand1 %}",
        "operand2": "{% $states.result.Output %}"
      },
      "Next": "再帰計算されたOperand2で演算"
    },
    "再帰計算されたOperand2で演算": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Output": "{% $states.result.Payload %}",
      "Arguments": {
        "FunctionName": "${FunctionArn}",
        "Payload": "{% $states.input %}"
      },
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException",
            "Lambda.TooManyRequestsException"
          ],
          "IntervalSeconds": 1,
          "MaxAttempts": 3,
          "BackoffRate": 2,
          "JitterStrategy": "FULL"
        }
      ],
      "End": true
    },
    "Operand1とOperand2をそのまま演算": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Output": "{% $states.result.Payload %}",
      "Arguments": {
        "FunctionName": "${FunctionArn}",
        "Payload": "{% $states.input %}"
      },
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException",
            "Lambda.TooManyRequestsException"
          ],
          "IntervalSeconds": 1,
          "MaxAttempts": 3,
          "BackoffRate": 2,
          "JitterStrategy": "FULL"
        }
      ],
    }
  },
  "QueryLanguage": "JSONata",
  "Comment": "Step Functions recursive call sample"
}

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: >
  Step Functionsの再帰呼び出しサンプル

Parameters:
  # 自分自身で循環参照(Circular Dependency)になるため、
  # Step Functionsの名称はCloudFormationで自動生成できない
  StateMachineName:
    Description: Step Functions Name
    Type: String
    Default: RecursiveSample

Resources:
  StateMachine:
    Type: AWS::Serverless::StateMachine
    Properties:
      Name: !Ref StateMachineName
      DefinitionUri: statemachine/recursive.asl.json
      DefinitionSubstitutions:
        FunctionArn: !GetAtt CalculateFunction.Arn
        StateMachineArn: !Sub "arn:aws:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${StateMachineName}"
      Role: !GetAtt StateMachineRole.Arn

  StateMachineRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service: states.amazonaws.com
            Action: sts:AssumeRole
      Path: /
      Policies:
        - PolicyName: CloudWatchLogsDeliveryFullAccessPolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - logs:CreateLogDelivery
                  - logs:GetLogDelivery
                  - logs:UpdateLogDelivery
                  - logs:DeleteLogDelivery
                  - logs:ListLogDeliveries
                  - logs:PutResourcePolicy
                  - logs:DescribeResourcePolicies
                  - logs:DescribeLogGroups
                Resource: "*"
        - PolicyName: LambdaInvokePolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - lambda:InvokeFunction
                Resource:
                  - !GetAtt CalculateFunction.Arn
        - PolicyName: StepFunctionsStartExecutionPolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - states:StartExecution
                  - states:DescribeExecution
                  - states:StopExecution
                Resource:
                  # StateMachineと循環参照になるためNG
                  # - !GetAtt StateMachine.Arn
                  - !Sub "arn:aws:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${StateMachineName}"
              - Effect: Allow
                Action:
                  - events:PutTargets
                  - events:PutRule
                  - events:DescribeRule
                Resource:
                  - !Sub "arn:aws:events:${AWS::Region}:${AWS::AccountId}:rule/StepFunctionsGetEventsForStepFunctionsExecutionRule"

  CalculateFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/
      Handler: calculate.lambda_handler
      Runtime: python3.12
      Architectures:
        - arm64

  FunctionLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${CalculateFunction}"
      RetentionInDays: 7

Outputs:
  StateMachineArn:
    Description: "State machine ARN"
    Value: !Ref StateMachine
  StateMachineRoleArn:
    Description: "IAM Role created for State machine"
    Value: !GetAtt StateMachineRole.Arn