konokenj.cdk-api-mcp-server 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

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

@@ -0,0 +1,66 @@
+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';
+import { Construct } from 'constructs';
+import * as s3deploy from 'aws-cdk-lib/aws-s3-deployment';
+
+/**
+ * Integration test for bucket deployment with VPC and EFS storage:
+ * - Lambda function runs in VPC with EFS filesystem mounted
+ * - Tests useEfs flag for large file deployments requiring persistent storage
+ */
+class TestBucketDeploymentVpcEfs extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    // VPC with EFS storage enabled
+    // Use isolated subnets with S3 VPC endpoint - no NAT Gateway or Elastic IP needed
+    const vpc = new ec2.Vpc(this, 'EfsVpc', {
+      restrictDefaultSecurityGroup: false,
+      natGateways: 0,
+      subnetConfiguration: [
+        {
+          cidrMask: 24,
+          name: 'Isolated',
+          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
+        },
+      ],
+    });
+
+    // Add S3 Gateway endpoint so Lambda can access S3 without NAT Gateway
+    vpc.addGatewayEndpoint('S3Endpoint', {
+      service: ec2.GatewayVpcEndpointAwsService.S3,
+    });
+
+    const bucket = new s3.Bucket(this, 'Destination', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    new s3deploy.BucketDeployment(this, 'DeployWithEfsVpc', {
+      sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
+      destinationBucket: bucket,
+      destinationKeyPrefix: 'efs-vpc/',
+      vpc: vpc,
+      useEfs: true,
+      retainOnDelete: false,
+    });
+  }
+}
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const testCase = new TestBucketDeploymentVpcEfs(app, 'test-bucket-deployment-vpc-efs');
+
+new integ.IntegTest(app, 'integ-test-bucket-deployment-vpc-efs', {
+  testCases: [testCase],
+  diffAssets: false,
+});
+
+app.synth();

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

@@ -0,0 +1,72 @@
+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';
+import { Construct } from 'constructs';
+import * as s3deploy from 'aws-cdk-lib/aws-s3-deployment';
+
+/**
+ * Integration test for bucket deployment with VPC and custom security groups:
+ * - Lambda function runs in VPC with custom security group
+ * - Security group allows all outbound traffic for S3 access
+ */
+class TestBucketDeploymentVpcSecurityGroups extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    // VPC with specific security groups
+    // Use isolated subnets with S3 VPC endpoint - no NAT Gateway or Elastic IP needed
+    const vpc = new ec2.Vpc(this, 'SgVpc', {
+      restrictDefaultSecurityGroup: false,
+      natGateways: 0,
+      subnetConfiguration: [
+        {
+          cidrMask: 24,
+          name: 'Isolated',
+          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
+        },
+      ],
+    });
+
+    // Add S3 Gateway endpoint so Lambda can access S3 without NAT Gateway
+    vpc.addGatewayEndpoint('S3Endpoint', {
+      service: ec2.GatewayVpcEndpointAwsService.S3,
+    });
+
+    const securityGroup = new ec2.SecurityGroup(this, 'CustomSecurityGroup', {
+      vpc: vpc,
+      description: 'Custom security group for bucket deployment',
+      allowAllOutbound: true,
+    });
+
+    const bucket = new s3.Bucket(this, 'Destination', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    new s3deploy.BucketDeployment(this, 'DeployWithVpcAndSecurityGroup', {
+      sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
+      destinationBucket: bucket,
+      destinationKeyPrefix: 'sg-vpc/',
+      vpc: vpc,
+      securityGroups: [securityGroup],
+      retainOnDelete: false,
+    });
+  }
+}
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const testCase = new TestBucketDeploymentVpcSecurityGroups(app, 'test-bucket-deployment-vpc-security-groups');
+
+new integ.IntegTest(app, 'integ-test-bucket-deployment-vpc-security-groups', {
+  testCases: [testCase],
+  diffAssets: false,
+});
+
+app.synth();

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

@@ -0,0 +1,70 @@
+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';
+import { Construct } from 'constructs';
+import * as s3deploy from 'aws-cdk-lib/aws-s3-deployment';
+
+/**
+ * Integration test for bucket deployment with VPC and explicit subnet selection:
+ * - Lambda function runs in VPC with explicit subnet type selection
+ * - Tests vpcSubnets property for controlling which subnets Lambda uses
+ */
+class TestBucketDeploymentVpcSubnetSelection extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    // VPC with specific subnets
+    // Use isolated subnets with S3 VPC endpoint - no NAT Gateway or Elastic IP needed
+    // Use a different CIDR to avoid conflicts with existing stacks
+    const vpc = new ec2.Vpc(this, 'SubnetVpc', {
+      restrictDefaultSecurityGroup: false,
+      natGateways: 0,
+      ipAddresses: ec2.IpAddresses.cidr('10.1.0.0/16'),
+      subnetConfiguration: [
+        {
+          cidrMask: 24,
+          name: 'Isolated',
+          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
+        },
+      ],
+    });
+
+    // Add S3 Gateway endpoint so Lambda can access S3 without NAT Gateway
+    vpc.addGatewayEndpoint('S3Endpoint', {
+      service: ec2.GatewayVpcEndpointAwsService.S3,
+    });
+
+    const bucket = new s3.Bucket(this, 'Destination', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    new s3deploy.BucketDeployment(this, 'DeployWithVpcAndSubnets', {
+      sources: [s3deploy.Source.asset(path.join(__dirname, 'my-website'))],
+      destinationBucket: bucket,
+      destinationKeyPrefix: 'subnet-vpc/',
+      vpc: vpc,
+      vpcSubnets: {
+        subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
+      },
+      retainOnDelete: false,
+    });
+  }
+}
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const testCase = new TestBucketDeploymentVpcSubnetSelection(app, 'test-bucket-deployment-vpc-subnet-selection');
+
+new integ.IntegTest(app, 'integ-test-bucket-deployment-vpc-subnet-selection', {
+  testCases: [testCase],
+  diffAssets: false,
+});
+
+app.synth();

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', {

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],
+});