konokenj.cdk-api-mcp-server 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-eks/integ.custom-addons.ts

@@ -0,0 +1,48 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, Stack } from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { getClusterVersionConfig } from './integ-tests-kubernetes-version';
+import * as eks from 'aws-cdk-lib/aws-eks';
+
+const app = new App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const stack = new Stack(app, 'eks-custom-addons');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { natGateways: 1, restrictDefaultSecurityGroup: false });
+
+const cluster = new eks.Cluster(stack, 'Cluster', {
+  vpc,
+  ...getClusterVersionConfig(stack, eks.KubernetesVersion.V1_32),
+  defaultCapacity: 0,
+  bootstrapSelfManagedAddons: false,
+});
+
+const calico = new eks.HelmChart(stack, 'Calico', {
+  cluster,
+  release: 'calico',
+  chart: 'tigera-operator',
+  repository: 'https://docs.tigera.io/calico/charts',
+  namespace: 'tigera-operator',
+  version: 'v3.30.1',
+  createNamespace: true,
+});
+
+const cnipatch = new eks.KubernetesPatch(stack, 'cnipatch', {
+  cluster,
+  resourceName: 'installation/default',
+  applyPatch: [{ op: 'replace', path: '/spec/cni', value: { type: 'Calico' } }],
+  restorePatch: [{ op: 'remove', path: '/spec/cni' }],
+  patchType: eks.PatchType.JSON,
+});
+
+cnipatch.node.addDependency(calico);
+
+new IntegTest(app, 'aws-cdk-eks-custom-addons', {
+  testCases: [stack],
+  // Test includes assets that are updated weekly. If not disabled, the upgrade PR will fail.
+  diffAssets: false,
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-logs/README.md

@@ -199,6 +199,7 @@ the name `Namespace/MetricName`.
 
 You can expose a metric on a metric filter by calling the `MetricFilter.metric()` API.
 This has a default of `statistic = 'avg'` if the statistic is not set in the `props`.
+Additionally, if the metric filter was created with a dimension map, those dimensions will be included in the metric.
 
 ```ts
 declare const logGroup: logs.LogGroup;

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-logs/integ.expose-metric-with-dimensions.ts

@@ -0,0 +1,47 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import { FilterPattern, LogGroup, MetricFilter } from 'aws-cdk-lib/aws-logs';
+import { Dashboard, GraphWidget } from 'aws-cdk-lib/aws-cloudwatch';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class ExposeMetricWithDimensions extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const logGroup = new LogGroup(this, 'LogGroup');
+
+    // Create a metric filter with dimensions
+    const mf = new MetricFilter(this, 'MetricFilter', {
+      logGroup,
+      metricName: 'testName',
+      metricNamespace: 'testNamespace',
+      filterPattern: FilterPattern.exists('$.latency'),
+      metricValue: '$.latency',
+      dimensions: {
+        Foo: 'Bar',
+        Bar: 'Baz',
+      },
+    });
+
+    // Expose the metric with dimensions
+    const metric = mf.metric();
+
+    new Dashboard(this, 'Dashboard', {
+      dashboardName: 'ExposeMetricWithDimensionsDashboard',
+      widgets: [[
+        new GraphWidget({
+          title: 'Latency with Dimensions',
+          left: [metric],
+        }),
+      ]],
+    });
+  }
+}
+
+const app = new App();
+const stack = new ExposeMetricWithDimensions(app, 'aws-cdk-expose-metric-with-dimensions-integ');
+
+new IntegTest(stack, 'ExposeMetricWithDimensionsTest', {
+  testCases: [stack],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-opensearchservice/integ.opensearch.gp3.ts

@@ -1,7 +1,7 @@
 import { App, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import * as opensearch from 'aws-cdk-lib/aws-opensearchservice';
-import { EbsDeviceVolumeType } from 'aws-cdk-lib/aws-ec2';
+import { EbsDeviceVolumeType, SubnetType } from 'aws-cdk-lib/aws-ec2';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
 class TestStack extends Stack {
@@ -19,6 +19,21 @@ class TestStack extends Stack {
         throughput: 125,
         iops: 3000,
       },
+      zoneAwareness: {
+        enabled: true,
+        availabilityZoneCount: 3,
+      },
+      vpcSubnets: [
+        { subnetType: SubnetType.PRIVATE_WITH_EGRESS },
+      ],
+      capacity: {
+        dataNodeInstanceType: 'm7g.medium.search',
+        dataNodes: 3,
+        // Add dedicated master node - required for multi-AZ with standby
+        // m7g.large.search has 8GB RAM (minimum for 30 nodes/15K shards)
+        masterNodeInstanceType: 'm7g.large.search',
+        masterNodes: 3,
+      },
     };
 
     new opensearch.Domain(this, 'Domain', domainProps);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-opensearchservice/integ.opensearch.https.ts

@@ -0,0 +1,54 @@
+import { App, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import * as opensearch from 'aws-cdk-lib/aws-opensearchservice';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+/**
+ * After deploying this test, you can verify that the OpenSearch domain using:
+ *
+ * $ aws es describe-elasticsearch-domain \
+ * --region us-east-1 \
+ * --domain-name DOMAIN_NAME \
+ * --query 'DomainStatus.DomainEndpointOptions' \
+ * --output json
+ */
+
+class TestStack extends Stack {
+  public readonly domain: opensearch.Domain;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    // deploy opensearch domain with minimal configuration
+    const domainProps: opensearch.DomainProps = {
+      version: opensearch.EngineVersion.OPENSEARCH_2_17,
+      removalPolicy: RemovalPolicy.DESTROY,
+      capacity: {
+        multiAzWithStandbyEnabled: false,
+      },
+      enforceHttps: true,
+    };
+
+    this.domain = new opensearch.Domain(this, 'domain', domainProps);
+  }
+}
+
+const app = new App();
+const stack = new TestStack(app, 'cdk-integ-opensearch-https');
+
+const integ = new IntegTest(app, 'integ-openseach-https', { testCases: [stack] });
+
+// Assert TLS security policy using AwsApiCall
+const describeResponse = integ.assertions.awsApiCall('OpenSearch', 'describeDomain', {
+  DomainName: stack.domain.domainName,
+});
+
+// Verify domain endpoint configuration
+describeResponse.expect(ExpectedResult.objectLike({
+  DomainStatus: {
+    DomainEndpointOptions: {
+      EnforceHTTPS: true,
+      TLSSecurityPolicy: 'Policy-Min-TLS-1-2-2019-07',
+    },
+  },
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/README.md

@@ -280,9 +280,20 @@ things.
 > *Info* More complete details can be found [in the docs](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2.setting-capacity.html#aurora-serverless-v2-examples-setting-capacity-range-for-cluster)
 
 You can also set minimum capacity to zero ACUs and automatically pause,
-if they don't have any connections initiated by user activity within a specified time period.
+if they don't have any connections initiated by user activity within a time period specified by `serverlessV2AutoPauseDuration` (300 seconds by default).
 For more information, see [Scaling to Zero ACUs with automatic pause and resume for Aurora Serverless v2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2-auto-pause.html).
 
+```ts
+declare const vpc: ec2.Vpc;
+const cluster = new rds.DatabaseCluster(this, 'Database', {
+  engine: rds.DatabaseClusterEngine.auroraMysql({ version: rds.AuroraMysqlEngineVersion.VER_3_08_0 }),
+  writer: rds.ClusterInstance.serverlessV2('writer'),
+  serverlessV2MinCapacity: 0,
+  serverlessV2AutoPauseDuration: Duration.hours(1),
+  vpc,
+});
+```
+
 Another way that you control the capacity/scaling of your serverless v2 reader
 instances is based on the [promotion tier](https://aws.amazon.com/blogs/aws/additional-failover-control-for-amazon-aurora/)
 which can be between 0-15. Any serverless v2 instance in the 0-1 tiers will scale alongside the
@@ -588,6 +599,18 @@ new rds.DatabaseInstanceReadReplica(this, 'ReadReplica', {
 });
 ```
 
+Or you can [restore a DB instance from a Multi-AZ DB cluster snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromMultiAZDBClusterSnapshot.html)
+
+```ts
+declare const vpc: ec2.Vpc;
+
+new rds.DatabaseInstanceFromSnapshot(this, 'Instance', {
+  clusterSnapshotIdentifier: 'my-cluster-snapshot',
+  engine: rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_16_3 }),
+  vpc,
+});
+```
+
 Automatic backups of read replica instances are only supported for MySQL and MariaDB. By default,
 automatic backups are disabled for read replicas and can only be enabled (using `backupRetention`)
 if also enabled on the source instance.
@@ -961,7 +984,7 @@ proxy.grantConnect(role, 'admin'); // Grant the role connection access to the DB
 See <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.DBAccounts.html> for setup instructions.
 
 To specify the details of authentication used by a proxy to log in as a specific database
-user use the `clientPasswordAuthType` property:
+user use the `clientPasswordAuthType` property:
 
 ```ts
 declare const vpc: ec2.Vpc;

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.cluster-serverless-v2-autopause.ts

@@ -0,0 +1,27 @@
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { App, Duration, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib';
+import { Vpc } from 'aws-cdk-lib/aws-ec2';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import { ClusterInstance } from 'aws-cdk-lib/aws-rds';
+import { Construct } from 'constructs';
+
+export class TestStack extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+    const vpc = new Vpc(this, 'Integ-VPC');
+    new rds.DatabaseCluster(this, 'Integ-Cluster', {
+      engine: rds.DatabaseClusterEngine.auroraMysql({ version: rds.AuroraMysqlEngineVersion.VER_3_08_0 }),
+      serverlessV2MaxCapacity: 1,
+      serverlessV2MinCapacity: 0,
+      serverlessV2AutoPauseDuration: Duration.hours(1),
+      writer: ClusterInstance.serverlessV2('writer'),
+      removalPolicy: RemovalPolicy.DESTROY,
+      vpc: vpc,
+    });
+  }
+}
+
+const app = new App();
+new IntegTest(app, 'integ-test-autopause', {
+  testCases: [new TestStack(app, 'integ-aurora-serverlessv2-cluster-autopause')],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.instance-from-cluster-snapshot.ts

@@ -0,0 +1,23 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+const app = new App();
+const stack = new Stack(app, 'cdk-instance-from-cluster-snapshot');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, natGateways: 1, restrictDefaultSecurityGroup: false });
+
+// For simplicity, get a public snapshot
+new rds.DatabaseInstanceFromSnapshot(stack, 'FromSnapshot', {
+  clusterSnapshotIdentifier: 'arn:aws:rds:us-east-1:703671916075:cluster-snapshot:test-cluster-snpa',
+  allocatedStorage: 200,
+  engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_40 }),
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MEDIUM),
+  vpc,
+  removalPolicy: RemovalPolicy.DESTROY,
+});
+
+new IntegTest(app, 'cdk-instance-from-cluster-snapshot-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ssm/README.md

@@ -57,6 +57,22 @@ This method uses AWS API calls to lookup the value from SSM during synthesis.
 const stringValue = ssm.StringParameter.valueFromLookup(this, '/My/Public/Parameter');
 ```
 
+The result of the `StringParameter.valueFromLookup()` operation will be written to a file
+called `cdk.context.json`. You must commit this file to source control so
+that the lookup values are available in non-privileged environments such
+as CI build steps, and to ensure your template builds are repeatable.
+
+To customize the cache key, use the `additionalCacheKey` property of the `options` parameter.
+This allows you to have multiple lookups with the same parameters
+cache their values separately. This can be useful if you want to
+scope the context variable to a construct (ie, using `additionalCacheKey: this.node.path`),
+so that if the value in the cache needs to be updated, it does not need to be updated
+for all constructs at the same time.
+
+```ts
+const stringValue = ssm.StringParameter.valueFromLookup(this, '/My/Public/Parameter', undefined, { additionalCacheKey: this.node.path });
+```
+
 When using `valueFromLookup` an initial value of 'dummy-value-for-${parameterName}'
 (`dummy-value-for-/My/Public/Parameter` in the above example)
 is returned prior to the lookup being performed. This can lead to errors if you are using this

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/README.md

@@ -840,6 +840,27 @@ const definition = choice
 map.itemProcessor(definition);
 ```
 
+When using `JSONata`, the `itemSelector` property in a Map state can be specified in one of two ways. You can provide a valid JSON object containing JSONata expressions for each value:
+
+```ts
+const map = new sfn.Map(this, 'Map State', {
+  maxConcurrency: 1,
+  itemSelector: {
+    id: '{% $states.context.Map.Item.Value.id %}',
+    status: '{% $states.context.Map.Item.Value.status %}',
+  }
+});
+```
+
+Alternatively, you can use the `jsonataItemSelector` field to directly supply a JSONata string that evaluates to a complete JSON object:
+
+```ts
+const map = new sfn.Map(this, 'Map State', {
+  maxConcurrency: 1,
+  jsonataItemSelector: '{% {\"id\": $states.input.id, \"status\": $states.input.status} %}'
+});
+```
+
 To define a distributed `Map` state set `itemProcessors` mode to `ProcessorMode.DISTRIBUTED`.
 An `executionType` must be specified for the distributed `Map` workflow.
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.map-jsonata-itemselector.ts

@@ -0,0 +1,36 @@
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+
+/**
+ * Stack verification steps:
+ *
+ * -- aws stepfunctions describe-state-machine --state-machine-arn <stack-output> has a status of `ACTIVE`
+ */
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'cdk-stepfunctions-map-jsonata-itemselector-stack');
+
+const map = new sfn.Map(stack, 'Map', {
+  queryLanguage: sfn.QueryLanguage.JSONATA,
+  stateName: 'My-Map-State',
+  maxConcurrency: 1,
+  jsonataItemSelector: '{% {\"foo\": \"foo\", \"bar\": $states.input.bar} %}',
+});
+map.itemProcessor(new sfn.Pass(stack, 'Pass State'));
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition: map,
+  timeout: cdk.Duration.seconds(30),
+});
+
+const testCase = new IntegTest(app, 'cdk-stepfunctions-map-itemselector-integ', {
+  testCases: [stack],
+});
+
+testCase.assertions.awsApiCall('StepFunctions', 'describeStateMachine', {
+  stateMachineArn: sm.stateMachineArn,
+}).expect(ExpectedResult.objectLike({
+  status: 'ACTIVE',
+}));
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.invoke-jsonata.ts

@@ -1,119 +1,112 @@
-import { Code, Function } from 'aws-cdk-lib/aws-lambda';
-import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
-import * as cdk from 'aws-cdk-lib';
-import { LambdaInvoke } from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import * as path from 'path';
 import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
-import { STANDARD_NODEJS_RUNTIME } from '../../../config';
+import * as cdk from 'aws-cdk-lib';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { password, username } from './my-lambda-handler';
 
 /*
- * Creates a state machine with a task state to invoke a Lambda function
- * The state machine creates a couple of Lambdas that pass results forward
- * and into a Choice state that validates the output.
- *
- * Stack verification steps:
- * The generated State Machine can be executed from the CLI (or Step Functions console)
- * and runs with an execution status of `Succeeded`.
+ * Creates an API Gateway instance with a GET method and mock integration,
+ * secured with basic auth. It then creates a matching Connection and uses it
+ * in a state machine with a task state to invoke the endpoint.
  *
- * -- aws stepfunctions start-execution --state-machine-arn <state-machine-arn-from-output> provides execution arn
- * -- aws stepfunctions describe-execution --execution-arn <state-machine-arn-from-output> returns a status of `Succeeded`
+ * Stack verification steps :
+ * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
+ * * aws stepfunctions describe-execution --execution-arn <execution-arn generated before> : should return status as SUCCEEDED
  */
 const app = new cdk.App({
   postCliContext: {
     '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
   },
 });
-const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-lambda-invoke-jsonata-integ');
+const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-http-invoke-integ');
 
-const submitJobLambda = new Function(stack, 'submitJobLambda', {
-  code: Code.fromInline(`exports.handler = async (event, context) => {
-        return {
-          statusCode: '200',
-          body: 'hello, world!',
-          ...event,
-        };
-      };`),
-  runtime: STANDARD_NODEJS_RUNTIME,
-  handler: 'index.handler',
+const authorizerHandler = new lambda.NodejsFunction(stack, 'AuthorizerHandler', {
+  entry: path.resolve(__dirname, 'my-lambda-handler', 'index.ts'),
+  handler: 'handler',
 });
 
-const submitJob = LambdaInvoke.jsonata(stack, 'Invoke Handler', {
-  lambdaFunction: submitJobLambda,
-  payload: sfn.TaskInput.fromObject({
-    execId: '{% $states.context.Execution.Id %}',
-    execInput: '{% $states.context.Execution.Input %}',
-    execName: '{% $states.context.Execution.Name %}',
-    execRoleArn: '{% $states.context.Execution.RoleArn %}',
-    execStartTime: '{% $states.context.Execution.StartTime %}',
-    stateEnteredTime: '{% $states.context.State.EnteredTime %}',
-    stateName: '{% $states.context.State.Name %}',
-    stateRetryCount: '{% $states.context.State.RetryCount %}',
-    stateMachineId: '{% $states.context.StateMachine.Id %}',
-    stateMachineName: '{% $states.context.StateMachine.Name %}',
-  }),
-  outputs: '{% $states.result.Payload %}',
+const authorizer = new apigateway.TokenAuthorizer(stack, 'Authorizer', {
+  handler: authorizerHandler,
+  identitySource: 'method.request.header.Authorization',
+  resultsCacheTtl: cdk.Duration.seconds(0),
 });
 
-const checkJobStateLambda = new Function(stack, 'checkJobStateLambda', {
-  code: Code.fromInline(`exports.handler = async function(event, context) {
-        const expectedFields = [
-          'execId', 'execInput', 'execName', 'execRoleArn',
-          'execStartTime', 'stateEnteredTime', 'stateName',
-          'stateRetryCount', 'stateMachineId', 'stateMachineName',
-        ];
-        const fieldsAreSet = expectedFields.every(field => event[field] !== undefined);
-        return {
-          status: event.statusCode === '200' && fieldsAreSet ? 'SUCCEEDED' : 'FAILED'
-        };
-  };`),
-  runtime: STANDARD_NODEJS_RUNTIME,
-  handler: 'index.handler',
-});
+const api = new apigateway.RestApi(stack, 'IntegRestApi');
 
-const checkJobState = LambdaInvoke.jsonata(stack, 'Check the job state', {
-  lambdaFunction: checkJobStateLambda,
-  outputs: {
-    status: '{% $states.result.Payload.status %}',
+api.root.addResource('test').addMethod(
+  'GET',
+  new apigateway.MockIntegration({
+    integrationResponses: [
+      {
+        statusCode: '200',
+        responseTemplates: {
+          'application/json': JSON.stringify({ message: 'Hello, tester!' }),
+        },
+      },
+    ],
+    passthroughBehavior: apigateway.PassthroughBehavior.NEVER,
+    requestTemplates: {
+      'application/json': '{ "statusCode": 200 }',
+    },
+  }),
+  {
+    authorizer,
+    methodResponses: [
+      {
+        statusCode: '200',
+      },
+    ],
   },
-});
+);
 
-const isComplete = sfn.Choice.jsonata(stack, 'Job Complete?');
-const jobFailed = sfn.Fail.jsonata(stack, 'Job Failed', {
-  cause: 'Job Failed',
-  error: 'Received a status that was not 200',
+const connection = new events.Connection(stack, 'Connection', {
+  authorization: events.Authorization.basic(username, cdk.SecretValue.unsafePlainText(password)),
 });
-const finalStatus = sfn.Pass.jsonata(stack, 'Final step');
 
-const chain = sfn.Chain.start(submitJob)
-  .next(checkJobState)
-  .next(
-    isComplete
-      .when(sfn.Condition.jsonata("{% $states.input.status = 'FAILED' %}"), jobFailed)
-      .when(sfn.Condition.jsonata("{% $states.input.status = 'SUCCEEDED' %}"), finalStatus),
-  );
+const httpInvokeTask = tasks.HttpInvoke.jsonata(stack, 'Invoke HTTP Endpoint', {
+  apiRoot: api.urlForPath('/'),
+  apiEndpoint: sfn.TaskInput.fromText('{% $states.input.apiEndpoint %}'),
+  connection,
+  method: sfn.TaskInput.fromText('GET'),
+  outputs: {
+    ResponseBody: '{% $states.result.ResponseBody %}',
+  },
+});
 
 const sm = new sfn.StateMachine(stack, 'StateMachine', {
-  definition: chain,
+  definition: httpInvokeTask,
   timeout: cdk.Duration.seconds(30),
 });
 
-new cdk.CfnOutput(stack, 'stateMachineArn', {
-  value: sm.stateMachineArn,
-});
-
-const integ = new IntegTest(app, 'IntegTest', {
+const testCase = new IntegTest(app, 'HttpInvokeTest', {
   testCases: [stack],
 });
-const res = integ.assertions.awsApiCall('@aws-sdk/client-sfn', 'StartExecution', {
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('@aws-sdk/client-sfn', 'StartExecution', {
   stateMachineArn: sm.stateMachineArn,
+  input: JSON.stringify({
+    apiEndpoint: '/test',
+  }),
 });
-const executionArn = res.getAttString('executionArn');
-integ.assertions.awsApiCall('@aws-sdk/client-sfn', 'DescribeExecution', {
-  executionArn,
-}).expect(ExpectedResult.objectLike({
-  status: 'SUCCEEDED',
-})).waitForAssertions({
-  totalTimeout: cdk.Duration.seconds(10),
-  interval: cdk.Duration.seconds(3),
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('@aws-sdk/client-sfn', 'DescribeExecution', {
+  executionArn: start.getAttString('executionArn'),
 });
 
+// assert the results
+describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+  output: JSON.stringify({
+    ResponseBody: {
+      message: 'Hello, tester!',
+    },
+  }),
+}));
+
 app.synth();