konokenj.cdk-api-mcp-server 0.48.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3-deployment/integ.bucket-deployment.ts

@@ -1,5 +1,4 @@
 import * as path from 'path';
-import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
@@ -7,115 +6,93 @@ import { Match } from '@aws-cdk/integ-tests-alpha';
 import { Construct } from 'constructs';
 import * as s3deploy from 'aws-cdk-lib/aws-s3-deployment';
 
+/**
+ * Integration test for core bucket deployment features:
+ * - Basic deployment functionality
+ * - Prune behavior (deleting files not in source)
+ * - Exclude filters
+ * - Extract behavior (extracting vs keeping zip files)
+ * - addSource() method for dynamically adding sources
+ * - objectKeys output property and outputObjectKeys flag
+ */
 class TestBucketDeployment extends cdk.Stack {
-  public readonly bucket5: s3.IBucket;
+  public readonly bucketWithAddSource: s3.IBucket;
   constructor(scope: Construct, id: string, props?: cdk.StackProps) {
     super(scope, id, props);
 
-    const destinationBucket = new s3.Bucket(this, 'Destination', {
-      websiteIndexDocument: 'index.html',
-      publicReadAccess: false,
+    const commonBucketProps = {
       removalPolicy: cdk.RemovalPolicy.DESTROY,
       autoDeleteObjects: true, // needed for integration test cleanup
-    });
+    };
 
-    new s3deploy.BucketDeployment(this, 'DeployMe', {
-      sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
-      destinationBucket,
-      retainOnDelete: false, // default is true, which will block the integration test cleanup
+    const destinationBucket = new s3.Bucket(this, 'Destination', {
+      ...commonBucketProps,
     });
 
-    new s3deploy.BucketDeployment(this, 'DeployMeWithEfsStorage', {
+    // Test basic deployment functionality
+    new s3deploy.BucketDeployment(this, 'DeployWithBasic', {
       sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
       destinationBucket,
-      destinationKeyPrefix: 'efs/',
-      useEfs: true,
-      vpc: new ec2.Vpc(this, 'InlineVpc', { restrictDefaultSecurityGroup: false }),
-      retainOnDelete: false, // default is true, which will block the integration test cleanup
-    });
-
-    const bucket2 = new s3.Bucket(this, 'Destination2', {
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-      autoDeleteObjects: true, // needed for integration test cleanup
-    });
-
-    new s3deploy.BucketDeployment(this, 'DeployWithPrefix', {
-      sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
-      destinationBucket: bucket2,
-      destinationKeyPrefix: 'deploy/here/',
-      retainOnDelete: false, // default is true, which will block the integration test cleanup
-    });
-
-    const bucket3 = new s3.Bucket(this, 'Destination3', {
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-      autoDeleteObjects: true, // needed for integration test cleanup
-    });
-
-    new s3deploy.BucketDeployment(this, 'DeployWithMetadata', {
-      sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
-      destinationBucket: bucket3,
-      retainOnDelete: false, // default is true, which will block the integration test cleanup
-      cacheControl: [s3deploy.CacheControl.setPublic(), s3deploy.CacheControl.maxAge(cdk.Duration.minutes(1))],
-      contentType: 'text/html',
-      metadata: { A: 'aaa', B: 'bbb', C: 'ccc' },
+      retainOnDelete: false,
     });
 
-    new s3deploy.BucketDeployment(this, 'DeployMeWithoutDeletingFilesOnDestination', {
+    // Test that files not in source are preserved when prune is disabled
+    new s3deploy.BucketDeployment(this, 'DeployWithPruneDisabled', {
       sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
       destinationBucket,
       prune: false,
       retainOnDelete: false,
     });
 
-    new s3deploy.BucketDeployment(this, 'DeployMeWithExcludedFilesOnDestination', {
+    // Test exclude filters to skip certain files from deployment
+    new s3deploy.BucketDeployment(this, 'DeployWithExclude', {
       sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
       destinationBucket,
       exclude: ['*.gif'],
       retainOnDelete: false,
     });
 
-    const bucket4 = new s3.Bucket(this, 'Destination4', {
-      publicReadAccess: false,
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-      autoDeleteObjects: true, // needed for integration test cleanup
+    const bucketWithoutExtract = new s3.Bucket(this, 'BucketWithoutExtract', {
+      ...commonBucketProps,
     });
 
-    new s3deploy.BucketDeployment(this, 'DeployMeWithoutExtractingFilesOnDestination', {
+    // Test that zip files are uploaded as-is when extract is disabled
+    new s3deploy.BucketDeployment(this, 'DeployWithoutExtract', {
       sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
-      destinationBucket: bucket4,
+      destinationBucket: bucketWithoutExtract,
       extract: false,
       retainOnDelete: false,
     });
 
-    this.bucket5 = new s3.Bucket(this, 'Destination5', {
-      publicReadAccess: false,
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-      autoDeleteObjects: true, // needed for integration test cleanup
+    this.bucketWithAddSource = new s3.Bucket(this, 'BucketWithAddSource', {
+      ...commonBucketProps,
     });
 
-    const deploy5 = new s3deploy.BucketDeployment(this, 'DeployMe5', {
+    // Test addSource() method for dynamically adding sources after construction
+    // and validate objectKeys output property returns both asset files and added sources
+    const deployWithAddSource = new s3deploy.BucketDeployment(this, 'DeployWithAddSource', {
       sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website-second'))],
-      destinationBucket: this.bucket5,
-      retainOnDelete: false, // default is true, which will block the integration test cleanup
+      destinationBucket: this.bucketWithAddSource,
+      retainOnDelete: false,
     });
-    deploy5.addSource(s3deploy.Source.data('some-key', 'helloworld'));
+    deployWithAddSource.addSource(s3deploy.Source.data('some-key', 'helloworld'));
 
+    // Output objectKeys to validate they are returned in CloudFormation outputs
     new cdk.CfnOutput(this, 'customResourceData', {
       value: cdk.Fn.sub('Object Keys are ${keys}', {
-        keys: cdk.Fn.join(',', deploy5.objectKeys),
+        keys: cdk.Fn.join(',', deployWithAddSource.objectKeys),
       }),
     });
 
-    const bucket6 = new s3.Bucket(this, 'Destination6', {
-      publicReadAccess: false,
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-      autoDeleteObjects: true, // needed for integration test cleanup
+    const bucketWithoutObjectKeys = new s3.Bucket(this, 'BucketWithoutObjectKeys', {
+      ...commonBucketProps,
     });
 
-    new s3deploy.BucketDeployment(this, 'DeployMe6', {
+    // Test that objectKeys are not returned when outputObjectKeys is disabled
+    new s3deploy.BucketDeployment(this, 'DeployWithoutObjectKeys', {
       sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website-second'))],
-      destinationBucket: bucket6,
-      retainOnDelete: false, // default is true, which will block the integration test cleanup
+      destinationBucket: bucketWithoutObjectKeys,
+      retainOnDelete: false,
       outputObjectKeys: false,
     });
   }
@@ -128,13 +105,14 @@ const app = new cdk.App({
 });
 const testCase = new TestBucketDeployment(app, 'test-bucket-deployments');
 
-// Assert that DeployMeWithoutExtractingFilesOnDestination deploys a zip file to bucket4
 const integTest = new integ.IntegTest(app, 'integ-test-bucket-deployments', {
   testCases: [testCase],
   diffAssets: true,
 });
+
+// Assert that addSource() successfully adds the data source alongside the asset source
 const listObjectsCall = integTest.assertions.awsApiCall('S3', 'listObjects', {
-  Bucket: testCase.bucket5.bucketName,
+  Bucket: testCase.bucketWithAddSource.bucketName,
 });
 listObjectsCall.provider.addToRolePolicy({
   Effect: 'Allow',
@@ -154,12 +132,12 @@ listObjectsCall.expect(integ.ExpectedResult.objectLike({
   ),
 }));
 
-// Assert that there is one object key returned from the custom resource
+// Assert that objectKeys output contains the deployed object keys when outputObjectKeys is enabled (default)
 const describe = integTest.assertions.awsApiCall('CloudFormation', 'describeStacks', {
   StackName: 'test-bucket-deployments',
 });
 
 describe.assertAtPath('Stacks.0.Outputs.0.OutputKey', integ.ExpectedResult.stringLikeRegexp('customResourceData'));
-describe.assertAtPath('Stacks.0.Outputs.0.OutputValue', integ.ExpectedResult.stringLikeRegexp('Object Keys are ([0-9a-f])+\.zip'));
+describe.assertAtPath('Stacks.0.Outputs.0.OutputValue', integ.ExpectedResult.stringLikeRegexp('Object Keys are ([0-9a-f])+\\.zip(,([0-9a-f])+\\.zip)*'));
 
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-secretsmanager/integ.secret.dynamic-reference-key.ts

@@ -0,0 +1,38 @@
+import * as cdk from 'aws-cdk-lib';
+import { SecretValue } from 'aws-cdk-lib';
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+
+    // Create a default secret
+    const secret = new secretsmanager.Secret(this, 'Secret');
+
+    // Create a JSON secret containing cfnDynamicReferenceKey values extracted from the default secret
+    new secretsmanager.Secret(this, 'JSONSecret', {
+      secretObjectValue: {
+        cfnDynamicReferenceKeyWithDefaults: SecretValue.unsafePlainText(secret.cfnDynamicReferenceKey()),
+        cfnDynamicReferenceKeyWithJsonFieldAndVersionStage: SecretValue.unsafePlainText(secret.cfnDynamicReferenceKey({
+          jsonField: 'json-key',
+          versionStage: 'version-stage',
+        })),
+        cfnDynamicReferenceKeyWithJsonFieldAndVersionId: SecretValue.unsafePlainText(secret.cfnDynamicReferenceKey({
+          jsonField: 'json-key',
+          versionId: 'version-id',
+        })),
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+
+const stack = new TestStack(app, 'cdk-integ-secrets-dynamic-reference-key');
+
+new integ.IntegTest(app, 'cdk-integ-secrets-dynamic-reference-key-test', {
+  testCases: [stack],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.sm-jsonpath-with-distributed-map-jsonata.ts

@@ -0,0 +1,105 @@
+import * as cdk from 'aws-cdk-lib/core';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { STEPFUNCTIONS_USE_DISTRIBUTED_MAP_RESULT_WRITER_V2 } from 'aws-cdk-lib/cx-api';
+
+const CSV_KEY = 'my-key.csv';
+const RESULT_BUCKET_PREFIX = 'my-prefix';
+
+class DistributedMapStack extends cdk.Stack {
+  readonly stateMachine: sfn.StateMachine;
+  readonly bucket: s3.Bucket;
+
+  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const distributedMap = sfn.DistributedMap.jsonata(this, 'DistributedMap', {
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+      resultWriterV2: new sfn.ResultWriterV2({
+        bucket: this.bucket,
+        prefix: RESULT_BUCKET_PREFIX,
+      }),
+    });
+
+    distributedMap.itemProcessor(sfn.Pass.jsonata(this, 'Pass'), {
+      mode: sfn.ProcessorMode.DISTRIBUTED,
+      executionType: sfn.ProcessorType.STANDARD,
+    });
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definition: distributedMap,
+    });
+  }
+}
+
+const app = new cdk.App({
+  context: {
+    [STEPFUNCTIONS_USE_DISTRIBUTED_MAP_RESULT_WRITER_V2]: true,
+  },
+});
+const stack = new DistributedMapStack(app, 'sm-jsonpath-with-distributed-map-jsonata');
+
+const testCase = new IntegTest(app, 'integ-sm-jsonpath-with-distributed-map-jsonata', {
+  testCases: [stack],
+});
+
+testCase.assertions
+  .awsApiCall('StepFunctions', 'describeStateMachine', {
+    stateMachineArn: stack.stateMachine.stateMachineArn,
+  })
+  .expect(ExpectedResult.objectLike({ status: 'ACTIVE' }))
+  .waitForAssertions({
+    interval: cdk.Duration.seconds(10),
+    totalTimeout: cdk.Duration.minutes(5),
+  });
+
+// Put an object in the bucket
+const putObject = testCase.assertions.awsApiCall('S3', 'putObject', {
+  Bucket: stack.bucket.bucketName,
+  Key: CSV_KEY,
+  Body: 'a,b,c\n1,2,3\n4,5,6',
+});
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: stack.stateMachine.stateMachineArn,
+});
+putObject.next(start);
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+start.next(describe);
+
+// assert the results
+const describeExecution = describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+})).waitForAssertions({
+  interval: cdk.Duration.seconds(10),
+  totalTimeout: cdk.Duration.minutes(5),
+});
+
+const s3ApiCall = testCase.assertions.awsApiCall('S3', 'listObjectsV2', {
+  Bucket: stack.bucket.bucketName,
+  MaxKeys: 2,
+  Prefix: RESULT_BUCKET_PREFIX,
+}).expect(ExpectedResult.objectLike({
+  KeyCount: 2,
+}));
+s3ApiCall.provider.addToRolePolicy({
+  Effect: 'Allow',
+  Action: ['s3:GetObject', 's3:ListBucket'],
+  Resource: ['*'],
+});
+describeExecution.next(s3ApiCall);

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

@@ -141,6 +141,17 @@ The `EvaluateExpression` supports a `runtime` prop to specify the Lambda
 runtime to use to evaluate the expression. Currently, only runtimes
 of the Node.js family are supported.
 
+The `EvaluateExpression` also supports an `architecture` prop to specify the Lambda
+architecture. This can be useful when migrating to ARM64 or when running integration
+tests on ARM64 systems.
+
+```ts
+const convertToSecondsArm64 = new tasks.EvaluateExpression(this, 'Convert to seconds', {
+  expression: '$.waitMilliseconds / 1000',
+  architecture: lambda.Architecture.ARM_64,
+});
+```
+
 ## API Gateway
 
 Step Functions supports [API Gateway](https://docs.aws.amazon.com/step-functions/latest/dg/connect-api-gateway.html) through the service integration pattern.
@@ -1374,12 +1385,12 @@ The following code snippet includes a Task state that uses eks:call to list the
 
 ```ts
 import * as eks from 'aws-cdk-lib/aws-eks';
-import { KubectlV33Layer } from '@aws-cdk/lambda-layer-kubectl-v33';
+import { KubectlV34Layer } from '@aws-cdk/lambda-layer-kubectl-v34';
 
 const myEksCluster = new eks.Cluster(this, 'my sample cluster', {
-  version: eks.KubernetesVersion.V1_32,
+  version: eks.KubernetesVersion.V1_34,
   clusterName: 'myEksCluster',
-  kubectlLayer: new KubectlV33Layer(this, 'kubectl'),
+  kubectlLayer: new KubectlV34Layer(this, 'kubectl'),
 });
 
 new tasks.EksCall(this, 'Call a EKS Endpoint', {
@@ -1582,7 +1593,7 @@ const connection = new events.Connection(this, 'Connection', {
 
 new tasks.HttpInvoke(this, 'Invoke HTTP API', {
   apiRoot: 'https://api.example.com',
-  apiEndpoint: sfn.TaskInput.fromText('path/to/resource'),
+  apiEndpoint: sfn.TaskInput.fromText(sfn.JsonPath.format('resource/{}/details', sfn.JsonPath.stringAt('$.resourceId'))),
   body: sfn.TaskInput.fromObject({ foo: 'bar' }),
   connection,
   headers: sfn.TaskInput.fromObject({ 'Content-Type': 'application/json' }),

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.call-aws-service-cross-region-lambda.ts

@@ -10,7 +10,7 @@ class TestStack extends cdk.Stack {
     super(scope, id, props);
     // Create a target Lambda function that returns JSON response
     const targetLambda = new lambda.Function(this, 'TargetLambda', {
-      runtime: lambda.Runtime.NODEJS_18_X,
+      runtime: lambda.Runtime.NODEJS_20_X,
       handler: 'index.handler',
       code: lambda.Code.fromInline(`
         exports.handler = async (event) => {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-arm64.ts

@@ -0,0 +1,27 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-arm64-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+  architecture: lambda.Architecture.ARM_64,
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionArm64Test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-default.ts

@@ -0,0 +1,25 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-default-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionDefaultTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-mixed-arch.ts

@@ -0,0 +1,35 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-sfn-evaluate-expression-mixed-arch-integ');
+
+const evalTaskArm = new tasks.EvaluateExpression(stack, 'EvalExpressionArm', {
+  expression: '$.a + $.b',
+  runtime: lambda.Runtime.NODEJS_20_X,
+  architecture: lambda.Architecture.ARM_64,
+});
+
+const evalTaskX86 = new tasks.EvaluateExpression(stack, 'EvalExpressionX86', {
+  expression: '$.a * $.b',
+  runtime: lambda.Runtime.NODEJS_20_X,
+  architecture: lambda.Architecture.X86_64,
+});
+
+const definition = new sfn.Pass(stack, 'Start', {
+  result: sfn.Result.fromObject({ a: 3, b: 4 }),
+}).next(new sfn.Parallel(stack, 'ParallelEval')
+  .branch(evalTaskArm)
+  .branch(evalTaskX86),
+);
+
+new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(definition),
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionMixedArchTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-x86.ts

@@ -0,0 +1,27 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-x86-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+  architecture: lambda.Architecture.X86_64,
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionX86Test', {
+  testCases: [stack],
+});

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

@@ -0,0 +1,102 @@
+/// !cdk-integ aws-stepfunctions-tasks-http-invoke-json-path-integ
+
+import * as path from 'path';
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+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 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.
+ *
+ * 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();
+const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-http-invoke-json-path-integ');
+
+const authorizerHandler = new lambda.NodejsFunction(stack, 'AuthorizerHandler', {
+  entry: path.resolve(__dirname, 'my-lambda-handler', 'index.ts'),
+  handler: 'handler',
+});
+
+const authorizer = new apigateway.TokenAuthorizer(stack, 'Authorizer', {
+  handler: authorizerHandler,
+  identitySource: 'method.request.header.Authorization',
+  resultsCacheTtl: cdk.Duration.seconds(0),
+});
+
+const api = new apigateway.RestApi(stack, 'IntegRestApi');
+
+api.root.addResource('test-json-path').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 connection = new events.Connection(stack, 'Connection', {
+  authorization: events.Authorization.basic(username, cdk.SecretValue.unsafePlainText(password)),
+});
+
+const httpInvokeTask = new tasks.HttpInvoke(stack, 'Invoke HTTP Endpoint', {
+  apiRoot: api.urlForPath('/'),
+  apiEndpoint: sfn.TaskInput.fromJsonPathAt('$.endpointPath'),
+  connection,
+  method: sfn.TaskInput.fromText('GET'),
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition: httpInvokeTask,
+  timeout: cdk.Duration.seconds(30),
+});
+
+const testCase = new IntegTest(app, 'HttpInvokeTest', {
+  testCases: [stack],
+});
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+  input: JSON.stringify({
+    endpointPath: 'test-json-path',
+  }),
+});
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+
+// assert the results
+describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+}));
+
+app.synth();

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

@@ -267,7 +267,7 @@ new synthetics.Canary(this, 'Bucket Canary', {
 ```
 
 > **Note:** Synthetics have a specified folder structure for canaries.
-> For Node with puppeteer scripts supplied via `code.fromAsset()` or `code.fromBucket()`, the canary resource requires the following folder structure:
+> For Node with puppeteer scripts supplied via `code.fromAsset()` or `code.fromBucket()`, the canary resource requires the following folder structure for runtime versions older than `syn-nodejs-puppeteer-11.0`:
 >
 > ```plaintext
 > canary/
@@ -276,6 +276,22 @@ new synthetics.Canary(this, 'Bucket Canary', {
 >         ├── <filename>.js
 > ```
 >
+> For puppeteer based runtime versions newer than or equal to `syn-nodejs-puppeteer-11.0`, `nodjs/node_modules` is not necessary but supported. 
+>
+> Both
+> ```plaintext
+> canary/
+> ├── nodejs/
+>    ├── node_modules/
+>         ├── <filename>.js
+> ```
+> And 
+> ```plaintext
+> canary/
+>  ├── <filename>.js
+> ```
+> are supported.
+>
 > For Node with playwright scripts supplied via `code.fromAsset()` or `code.fromBucket()`, the canary resource requires the following folder structure:
 >
 > ```plaintext