konokenj.cdk-api-mcp-server 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/README.md

@@ -108,8 +108,8 @@ With the `@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion` disabled, the runt
 
 ## Lock file
 
-The `NodejsFunction` requires a dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or
-`package-lock.json`). When bundling in a Docker container, the path containing this lock file is
+The `NodejsFunction` requires a dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb`,
+`bun.lock` or `package-lock.json`). When bundling in a Docker container, the path containing this lock file is
 used as the source (`/asset-input`) for the volume mounted in the container.
 
 By default, the construct will try to automatically determine your project lock file.
@@ -201,7 +201,7 @@ new nodejs.NodejsFunction(this, 'my-handler', {
 
 The modules listed in `nodeModules` must be present in the `package.json`'s dependencies or
 installed. The same version will be used for installation. The lock file (`yarn.lock`,
-`pnpm-lock.yaml`, `bun.lockb` or `package-lock.json`) will be used along with the right installer (`yarn`,
+`pnpm-lock.yaml`, `bun.lockb`, `bun.lock` or `package-lock.json`) will be used along with the right installer (`yarn`,
 `pnpm`, `bun` or `npm`).
 
 When working with `nodeModules` using native dependencies, you might want to force bundling in a

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/integ.dependencies-bun-lock.ts

@@ -0,0 +1,50 @@
+import * as path from 'path';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const stack = new cdk.Stack(app, 'TestStack');
+
+const handler = new lambda.NodejsFunction(stack, 'Function', {
+  entry: path.join(__dirname, 'integ-handlers/bun_lock/dependencies-bun.ts'),
+  runtime: Runtime.NODEJS_22_X,
+  bundling: {
+    minify: true,
+    // Will be installed, not bundled
+    // (axios is a package with sub-dependencies,
+    // will be used to ensure bun bundling works as expected)
+    nodeModules: ['axios'],
+    forceDockerBundling: true,
+  },
+
+  // To (re-)generate this lockfile:
+  // 1. Ensure your local version of bun matches the version in packages/aws-cdk-lib/aws-lambda-nodejs/lib/Dockerfile
+  // 2. `cd` to `packages/@aws-cdk-testing/framework-integ/test/aws-lambda-nodejs/test/integ-handlers/bun`
+  // 3. Rename the `_package.json` file to `package.json`
+  // 4. Run `bun install`
+  depsLockFilePath: path.join(__dirname, 'integ-handlers/bun_lock/bun.lock'),
+});
+
+const integ = new IntegTest(app, 'BunTest', {
+  testCases: [stack],
+  stackUpdateWorkflow: false, // this will tell the runner to not check in assets.
+});
+
+const response = integ.assertions.invokeFunction({
+  functionName: handler.functionName,
+});
+response.expect(
+  ExpectedResult.objectLike({
+    // expect invoking without error
+    StatusCode: 200,
+    ExecutedVersion: '$LATEST',
+    Payload: 'null',
+  }),
+);

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

@@ -1166,6 +1166,26 @@ const proxy = dbInstance.addProxy('proxy', {
 });
 ```
 
+### Proxy Endpoint
+The following example add additional endpoint to RDS Proxy.
+
+```ts
+declare const vpc: ec2.Vpc;
+declare const secrets: secretsmanager.Secret[];
+declare const dbInstance: rds.DatabaseInstance;
+
+const proxy = dbInstance.addProxy('Proxy', {
+  secrets,
+  vpc,
+});
+
+// Add a reader endpoint
+proxy.addEndpoint('ProxyEndpoint', {
+  vpc,
+  targetRole: rds.ProxyEndpointTargetRole.READ_ONLY,
+});
+```
+
 ## Exporting Logs
 
 You can publish database logs to Amazon CloudWatch Logs. With CloudWatch Logs, you can perform real-time analysis of the log data,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.proxy-endpoint.ts

@@ -0,0 +1,36 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as rds from 'aws-cdk-lib/aws-rds';
+
+const app = new App();
+const stack = new Stack(app, 'cdk-rds-proxy-endpoint');
+
+const vpc = new ec2.Vpc(stack, 'vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+const dbInstance = new rds.DatabaseInstance(stack, 'dbInstance', {
+  engine: rds.DatabaseInstanceEngine.postgres({
+    version: rds.PostgresEngineVersion.VER_17_5,
+  }),
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MEDIUM),
+  vpc,
+  removalPolicy: RemovalPolicy.DESTROY,
+});
+
+const dbProxy = new rds.DatabaseProxy(stack, 'dbProxy', {
+  secrets: [dbInstance.secret!],
+  proxyTarget: rds.ProxyTarget.fromInstance(dbInstance),
+  vpc,
+});
+
+const securityGroup = ec2.SecurityGroup.fromSecurityGroupId(stack, 'SecurityGroup', vpc.vpcDefaultSecurityGroup);
+
+dbProxy.addEndpoint('dbProxyEndpoint', {
+  vpc,
+  targetRole: rds.ProxyEndpointTargetRole.READ_ONLY,
+  securityGroups: [securityGroup],
+});
+
+new integ.IntegTest(app, 'cdk-rds-proxy-endpoint-integ', {
+  testCases: [stack],
+});

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

@@ -134,6 +134,30 @@ new route53.AaaaRecord(this, 'Alias', {
 });
 ```
 
+To add an HTTPS record:
+
+``` ts
+import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
+
+declare const myZone: route53.HostedZone;
+declare const distribution: cloudfront.CloudFrontWebDistribution;
+// Alias to CloudFront target
+new route53.HttpsRecord(this, 'HttpsRecord-CloudFrontAlias', {
+  zone: myZone,
+  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+});
+// ServiceMode (priority >= 1)
+new route53.HttpsRecord(this, 'HttpsRecord-ServiceMode', {
+  zone: myZone,
+  values: [route53.HttpsRecordValue.service({ alpn: [route53.Alpn.H3, route53.Alpn.H2] })],
+});
+// AliasMode (priority = 0)
+new route53.HttpsRecord(this, 'HttpsRecord-AliasMode', {
+  zone: myZone,
+  values: [route53.HttpsRecordValue.alias('service.example.com')],
+});
+```
+
 [Geolocation routing](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-geo.html) can be enabled for continent, country or subdivision:
 
 ```ts

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53/integ.route53.ts

@@ -1,6 +1,6 @@
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
-import { ARecord, CaaAmazonRecord, CnameRecord, Continent, GeoLocation, PrivateHostedZone, PublicHostedZone, RecordTarget, TxtRecord } from 'aws-cdk-lib/aws-route53';
+import { Alpn, ARecord, CaaAmazonRecord, CnameRecord, Continent, GeoLocation, HttpsRecord, HttpsRecordValue, PrivateHostedZone, PublicHostedZone, RecordTarget, SvcbRecord, SvcbRecordValue, TxtRecord } from 'aws-cdk-lib/aws-route53';
 
 const app = new cdk.App();
 
@@ -92,6 +92,56 @@ new TxtRecord(stack, 'TXT', {
   ],
 });
 
+new SvcbRecord(stack, 'SVCB-AliasMode', {
+  zone: publicZone,
+  recordName: '_8080._svcb-alias',
+  values: [SvcbRecordValue.alias('service.example.com')],
+});
+new SvcbRecord(stack, 'SVCB-ServiceMode', {
+  zone: publicZone,
+  recordName: '_8080._svcb-service',
+  values: [SvcbRecordValue.service({ alpn: [Alpn.H3, Alpn.H2] })],
+});
+new SvcbRecord(stack, 'SVCB-ServiceMode-FullParams', {
+  zone: publicZone,
+  recordName: '_8080._svcb-service-fullparams',
+  values: [SvcbRecordValue.service({
+    priority: 2,
+    targetName: 'service.example.com',
+    mandatory: ['alpn'],
+    alpn: [Alpn.H3, Alpn.H2, Alpn.HTTP1_1, Alpn.of('h3-29')],
+    noDefaultAlpn: true,
+    port: 8443,
+    ipv4hint: ['127.0.0.1'],
+    ipv6hint: ['::1'],
+  })],
+});
+
+new HttpsRecord(stack, 'HTTPS-AliasMode', {
+  zone: publicZone,
+  recordName: 'https-alias',
+  values: [HttpsRecordValue.alias('service.example.com')],
+});
+new HttpsRecord(stack, 'HTTPS-ServiceMode', {
+  zone: publicZone,
+  recordName: 'https-service',
+  values: [HttpsRecordValue.service({ alpn: [Alpn.H3, Alpn.H2] })],
+});
+new HttpsRecord(stack, 'HTTPS-ServiceMode-FullParams', {
+  zone: publicZone,
+  recordName: 'https-service-fullparams',
+  values: [HttpsRecordValue.service({
+    priority: 2,
+    targetName: 'service.example.com',
+    mandatory: ['alpn'],
+    alpn: [Alpn.H3, Alpn.H2, Alpn.HTTP1_1, Alpn.of('h3-29')],
+    noDefaultAlpn: true,
+    port: 8443,
+    ipv4hint: ['127.0.0.1'],
+    ipv6hint: ['::1'],
+  })],
+});
+
 new cdk.CfnOutput(stack, 'PrivateZoneId', { value: privateZone.hostedZoneId });
 new cdk.CfnOutput(stack, 'PublicZoneId', { value: publicZone.hostedZoneId });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53-targets/integ.cloudfront-alias-target.ts

@@ -3,6 +3,7 @@ import * as route53 from 'aws-cdk-lib/aws-route53';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
 import * as targets from 'aws-cdk-lib/aws-route53-targets';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
 const app = new cdk.App();
 
@@ -31,4 +32,18 @@ new route53.ARecord(zone, 'Alias', {
   target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
 });
 
-app.synth();
+new route53.AaaaRecord(zone, 'AaaaAlias', {
+  zone,
+  recordName: '_foo',
+  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+});
+
+new route53.HttpsRecord(zone, 'HttpsAlias', {
+  zone,
+  recordName: '_foo',
+  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+});
+
+new IntegTest(app, 'aws-cdk-route53-cloudfront-alias-integ-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3/integ.bucket.notifications-scoped-permissions.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as sns from 'aws-cdk-lib/aws-sns';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
+import { Match, Template } from 'aws-cdk-lib/assertions';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-s3-notifications-scoped-permissions');
+
+// Create multiple buckets to test consolidated policy with scoped permissions
+const bucket1 = new s3.Bucket(stack, 'Bucket1', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+const bucket2 = new s3.Bucket(stack, 'Bucket2', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+const topic = new sns.Topic(stack, 'Topic');
+const queue = new sqs.Queue(stack, 'Queue', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+// Add notifications to multiple buckets with different event types - this should create scoped IAM permissions
+bucket1.addEventNotification(s3.EventType.OBJECT_CREATED_PUT, new s3n.SnsDestination(topic));
+bucket1.addEventNotification(s3.EventType.OBJECT_CREATED_POST, new s3n.SqsDestination(queue));
+bucket2.addEventNotification(s3.EventType.OBJECT_REMOVED_DELETE, new s3n.SnsDestination(topic));
+bucket2.addEventNotification(s3.EventType.OBJECT_REMOVED_DELETE_MARKER_CREATED, new s3n.SnsDestination(topic));
+
+// Create integration test with snapshot comparison enabled
+new integ.IntegTest(app, 'ScopedPermissionsTest', {
+  testCases: [stack],
+  diffAssets: true,
+});
+
+// Add assertions to verify IAM policies are scoped to specific bucket ARNs
+const template = Template.fromStack(stack);
+
+// Verify that IAM policies do not contain wildcard permissions
+template.hasResourceProperties('AWS::IAM::Policy', {
+  PolicyDocument: {
+    Statement: Match.arrayWith([
+      Match.objectLike({
+        Effect: 'Allow',
+        Action: 's3:PutBucketNotification',
+        Resource: Match.not('*'), // Ensure no wildcard permissions
+      }),
+    ]),
+  },
+});
+
+// Verify that the IAM policy contains specific bucket ARNs
+template.hasResourceProperties('AWS::IAM::Policy', {
+  PolicyDocument: {
+    Statement: Match.arrayWith([
+      Match.objectLike({
+        Effect: 'Allow',
+        Action: 's3:PutBucketNotification',
+        Resource: Match.arrayWith([
+          Match.objectLike({
+            'Fn::GetAtt': Match.arrayWith([Match.stringLikeRegexp('Bucket[12]'), 'Arn']),
+          }),
+        ]),
+      }),
+    ]),
+  },
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.distributed-map-parallel.ts

@@ -0,0 +1,82 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+
+const CSV_KEY = 'my-key.csv';
+
+class DistributedMapParallelStack extends cdk.Stack {
+  readonly bucket: s3.Bucket;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const parallel = new sfn.Parallel(this, 'Parallel');
+
+    const distributedMap = new sfn.DistributedMap(this, 'DistributedMap', {
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+    }).itemProcessor(new sfn.Pass(this, 'Pass'));
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definitionBody: sfn.ChainDefinitionBody.fromChainable(parallel.branch(distributedMap)),
+    });
+  }
+}
+
+function setupAssertions(testCaseStack: DistributedMapParallelStack, assertions: integ.IDeployAssert) {
+  const waitForStateMachineActive = assertions
+    .awsApiCall('StepFunctions', 'describeStateMachine', {
+      stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'ACTIVE' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(5),
+    });
+
+  // Upload the input to the DistributedMap
+  const uploadInput = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: CSV_KEY,
+    Body: 'a,b,c\n1,2,3\n4,5,6',
+  });
+
+  // Start an execution
+  const startExecution = assertions.awsApiCall('StepFunctions', 'startExecution', {
+    stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+  });
+
+  const executionArn = startExecution.getAttString('executionArn');
+
+  const expectSucceededExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', { executionArn: executionArn })
+    .expect(integ.ExpectedResult.objectLike({ status: 'SUCCEEDED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  waitForStateMachineActive
+    .next(uploadInput)
+    .next(startExecution)
+    .next(expectSucceededExecution);
+}
+
+const app = new cdk.App();
+const parallelStack = new DistributedMapParallelStack(app, 'DistributedMapParallelStack');
+
+const testCase = new integ.IntegTest(app, 'DistributedMapParallel', {
+  testCases: [parallelStack],
+});
+
+setupAssertions(parallelStack, testCase.assertions);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.distributed-map-redrive.ts

@@ -0,0 +1,130 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as aws_stepfunction_tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const CSV_KEY = 'my-key.csv';
+const SUCCESS_MARKER_KEY = 'pass-flag.txt';
+
+interface DistributedMapRedriveStackProps extends cdk.StackProps {
+  readonly mapRunLabel?: string;
+}
+
+class DistributedMapRedriveStack extends cdk.Stack {
+  readonly bucket: s3.Bucket;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: cdk.App, id: string, props?: DistributedMapRedriveStackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const distributedMap = new sfn.DistributedMap(this, 'DistributedMap', {
+      label: props?.mapRunLabel,
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+    });
+
+    // Existence of the success marker object determines if the distributed map succeeds or fails
+    const getSuccessMarker = new aws_stepfunction_tasks.CallAwsService(this, 'GetData', {
+      action: 'getObject',
+      iamResources: [this.bucket.arnForObjects('*')],
+      parameters: {
+        Bucket: this.bucket.bucketName,
+        Key: SUCCESS_MARKER_KEY,
+      },
+      service: 's3',
+    });
+
+    distributedMap.itemProcessor(getSuccessMarker);
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definitionBody: sfn.ChainDefinitionBody.fromChainable(distributedMap),
+    });
+  }
+}
+
+function setupAssertions(testCaseStack: DistributedMapRedriveStack, assertions: integ.IDeployAssert) {
+  const waitForStateMachineActive = assertions
+    .awsApiCall('StepFunctions', 'describeStateMachine', {
+      stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'ACTIVE' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(5),
+    });
+
+  // Upload the input to the DistributedMap
+  const uploadInput = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: CSV_KEY,
+    Body: 'a,b,c\n1,2,3\n4,5,6',
+  });
+
+  // Start an execution
+  const startExecution = assertions.awsApiCall('StepFunctions', 'startExecution', {
+    stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+  });
+
+  const executionArn = startExecution.getAttString('executionArn');
+
+  // describe the results of the execution
+  const expectFailedExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', {
+      executionArn: executionArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'FAILED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  // Upload the success marker, so that the next execution succeeds
+  const uploadSucceedMarker = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: SUCCESS_MARKER_KEY,
+    Body: '',
+  });
+
+  const redriveExecution = assertions.awsApiCall('StepFunctions', 'redriveExecution', {
+    executionArn: executionArn,
+  });
+
+  const expectRedrivenExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', { executionArn: executionArn })
+    .expect(integ.ExpectedResult.objectLike({ status: 'SUCCEEDED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  waitForStateMachineActive
+    .next(uploadInput)
+    .next(startExecution)
+    .next(expectFailedExecution)
+    .next(uploadSucceedMarker)
+    .next(redriveExecution)
+    .next(expectRedrivenExecution);
+}
+
+const app = new cdk.App();
+
+const unlabeledDistributedMapStack = new DistributedMapRedriveStack(app, 'UnlabeledDistributedMapRedrive');
+const labeledDistributedMapStack = new DistributedMapRedriveStack(app, 'LabeledDistributedMapRedrive', {
+  mapRunLabel: 'myLabel',
+});
+
+const testCase = new integ.IntegTest(app, 'DistributedMap', {
+  testCases: [unlabeledDistributedMapStack, labeledDistributedMapStack],
+});
+
+setupAssertions(labeledDistributedMapStack, testCase.assertions);
+setupAssertions(unlabeledDistributedMapStack, testCase.assertions);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.map-with-catch.ts

@@ -13,6 +13,7 @@ class DistributedMapStack extends cdk.Stack {
     super(scope, id, props);
 
     this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
       removalPolicy: cdk.RemovalPolicy.DESTROY,
     });
 

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

@@ -962,6 +962,18 @@ new tasks.EmrCreateCluster(this, 'SpotSpecification', {
 });
 ```
 
+You can [customize EBS root device volume](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html).
+
+```ts
+new tasks.EmrCreateCluster(this, 'Create Cluster', {
+  instances: {},
+  name: 'ClusterName',
+  ebsRootVolumeIops: 4000,
+  ebsRootVolumeSize: Size.gibibytes(20),
+  ebsRootVolumeThroughput: 200,
+});
+```
+
 If you want to run multiple steps in [parallel](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-concurrent-steps.html),
 you can specify the `stepConcurrencyLevel` property. The concurrency range is between 1
 and 256 inclusive, where the default concurrency of 1 means no step concurrency is allowed.
@@ -987,6 +999,47 @@ new tasks.EmrCreateCluster(this, 'Create Cluster', {
 });
 ```
 
+If you want to use [managed scaling](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-scaling.html),
+you can specify the `managedScalingPolicy` property.
+
+```ts
+new tasks.EmrCreateCluster(this, 'CreateCluster', {
+  instances: {
+    instanceFleets: [
+      {
+        instanceFleetType: tasks.EmrCreateCluster.InstanceRoleType.CORE,
+        instanceTypeConfigs: [
+          {
+            instanceType: 'm5.xlarge',
+          },
+        ],
+        targetOnDemandCapacity: 1,
+      },
+      {
+        instanceFleetType: tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+        instanceTypeConfigs: [
+          {
+            instanceType: 'm5.xlarge',
+          },
+        ],
+        targetOnDemandCapacity: 1,
+      },
+    ],
+  },
+  name: 'ClusterName',
+  releaseLabel: 'emr-7.9.0',
+  managedScalingPolicy: {
+    computeLimits: {
+      unitType: tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+      maximumCapacityUnits: 4,
+      minimumCapacityUnits: 1,
+      maximumOnDemandCapacityUnits: 4,
+      maximumCoreCapacityUnits: 2,
+    },
+  },
+});
+```
+
 ### Termination Protection
 
 Locks a cluster (job flow) so the EC2 instances in the cluster cannot be