Skip to content
v2.277.0

WaitProps Struct ​

Properties for defining a Wait state.

Example ​

ts
const convertToSeconds = new tasks.EvaluateExpression(this, 'Convert to seconds', {
  expression: '$.waitMilliseconds / 1000',
  resultPath: '$.waitSeconds',
});

const createMessage = new tasks.EvaluateExpression(this, 'Create message', {
  // Note: this is a string inside a string.
  expression: '`Now waiting ${$.waitSeconds} seconds...`',
  runtime: lambda.Runtime.NODEJS_LATEST,
  resultPath: '$.message',
});

const publishMessage = new tasks.SnsPublish(this, 'Publish message', {
  topic: new sns.Topic(this, 'cool-topic'),
  message: sfn.TaskInput.fromJsonPathAt('$.message'),
  resultPath: '$.sns',
});

const wait = new sfn.Wait(this, 'Wait', {
  time: sfn.WaitTime.secondsPath('$.waitSeconds'),
});

new sfn.StateMachine(this, 'StateMachine', {
  definition: convertToSeconds
    .next(createMessage)
    .next(publishMessage)
    .next(wait),
});
python
convert_to_seconds = tasks.EvaluateExpression(self, "Convert to seconds",
    expression="$.waitMilliseconds / 1000",
    result_path="$.waitSeconds"
)

create_message = tasks.EvaluateExpression(self, "Create message",
    # Note: this is a string inside a string.
    expression="`Now waiting ${$.waitSeconds} seconds...`",
    runtime=lambda_.Runtime.NODEJS_LATEST,
    result_path="$.message"
)

publish_message = tasks.SnsPublish(self, "Publish message",
    topic=sns.Topic(self, "cool-topic"),
    message=sfn.TaskInput.from_json_path_at("$.message"),
    result_path="$.sns"
)

wait = sfn.Wait(self, "Wait",
    time=sfn.WaitTime.seconds_path("$.waitSeconds")
)

sfn.StateMachine(self, "StateMachine",
    definition=convert_to_seconds.next(create_message).next(publish_message).next(wait)
)
java
EvaluateExpression convertToSeconds = EvaluateExpression.Builder.create(this, "Convert to seconds")
        .expression("$.waitMilliseconds / 1000")
        .resultPath("$.waitSeconds")
        .build();

EvaluateExpression createMessage = EvaluateExpression.Builder.create(this, "Create message")
        // Note: this is a string inside a string.
        .expression("`Now waiting ${$.waitSeconds} seconds...`")
        .runtime(Runtime.NODEJS_LATEST)
        .resultPath("$.message")
        .build();

SnsPublish publishMessage = SnsPublish.Builder.create(this, "Publish message")
        .topic(new Topic(this, "cool-topic"))
        .message(TaskInput.fromJsonPathAt("$.message"))
        .resultPath("$.sns")
        .build();

Wait wait = Wait.Builder.create(this, "Wait")
        .time(WaitTime.secondsPath("$.waitSeconds"))
        .build();

StateMachine.Builder.create(this, "StateMachine")
        .definition(convertToSeconds.next(createMessage).next(publishMessage).next(wait))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
var convertToSeconds = new EvaluateExpression(this, "Convert to seconds", new EvaluateExpressionProps {
    Expression = "$.waitMilliseconds / 1000",
    ResultPath = "$.waitSeconds"
});

var createMessage = new EvaluateExpression(this, "Create message", new EvaluateExpressionProps {
    // Note: this is a string inside a string.
    Expression = "`Now waiting ${$.waitSeconds} seconds...`",
    Runtime = Runtime.NODEJS_LATEST,
    ResultPath = "$.message"
});

var publishMessage = new SnsPublish(this, "Publish message", new SnsPublishProps {
    Topic = new Topic(this, "cool-topic"),
    Message = TaskInput.FromJsonPathAt("$.message"),
    ResultPath = "$.sns"
});

var wait = new Wait(this, "Wait", new WaitProps {
    Time = WaitTime.SecondsPath("$.waitSeconds")
});

new StateMachine(this, "StateMachine", new StateMachineProps {
    Definition = convertToSeconds.Next(createMessage).Next(publishMessage).Next(wait)
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
convertToSeconds := tasks.NewEvaluateExpression(this, jsii.String("Convert to seconds"), &EvaluateExpressionProps{
	Expression: jsii.String("$.waitMilliseconds / 1000"),
	ResultPath: jsii.String("$.waitSeconds"),
})

createMessage := tasks.NewEvaluateExpression(this, jsii.String("Create message"), &EvaluateExpressionProps{
	// Note: this is a string inside a string.
	Expression: jsii.String("`Now waiting ${$.waitSeconds} seconds...`"),
	Runtime: lambda.Runtime_NODEJS_LATEST(),
	ResultPath: jsii.String("$.message"),
})

publishMessage := tasks.NewSnsPublish(this, jsii.String("Publish message"), &SnsPublishProps{
	Topic: sns.NewTopic(this, jsii.String("cool-topic")),
	Message: sfn.TaskInput_FromJsonPathAt(jsii.String("$.message")),
	ResultPath: jsii.String("$.sns"),
})

wait := sfn.NewWait(this, jsii.String("Wait"), &WaitProps{
	Time: sfn.WaitTime_SecondsPath(jsii.String("$.waitSeconds")),
})

sfn.NewStateMachine(this, jsii.String("StateMachine"), &StateMachineProps{
	Definition: convertToSeconds.Next(createMessage).Next(publishMessage).*Next(wait),
})

Properties ​

assignoptional{ [key: string]: any }assignoptionaltyping.Mapping[str, Any]assignoptionalMap<String, Object>AssignoptionalIDictionary<string, object>Assignoptional*map[string]interface{}#
Workflow variables to store in this step.

Default: Not assign variables

Using workflow variables, you can store data in a step and retrieve that data in future steps.

commentoptionalstringcommentoptionalstrcommentoptionalStringCommentoptionalstringCommentoptional*string#
A comment describing this state.

Default: No comment

queryLanguageoptionalQueryLanguagequery_languageoptionalQueryLanguagequeryLanguageoptionalQueryLanguageQueryLanguageoptionalQueryLanguageQueryLanguageoptionalQueryLanguage= JSONPath#
The name of the query language used by the state.

If the state does not contain a queryLanguage field, then it will use the query language specified in the top-level queryLanguage field.

stateNameoptionalstringstate_nameoptionalstrstateNameoptionalStringStateNameoptionalstringStateNameoptional*string#
Optional name for this state.

Default: The construct ID will be used as state name

timeWaitTimetimeWaitTimetimeWaitTimeTimeWaitTimeTimeWaitTimerequired#
Wait duration.