konokenj.cdk-api-mcp-server 0.32.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

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

@@ -258,9 +258,73 @@ new codebuild.Project(this, 'Project', {
 });
 ```
 
-Note that two different CodeBuild Projects using the same S3 bucket will *not*
-share their cache: each Project will get a unique file in the S3 bucket to store
-the cache in.
+If you want to [share the same cache between multiple projects](https://docs.aws.amazon.com/codebuild/latest/userguide/caching-s3.html#caching-s3-sharing), you must must do the following:
+
+- Use the same `cacheNamespace`.
+- Specify the same cache key.
+- Define identical cache paths.
+- Use the same Amazon S3 buckets and `pathPrefix` if set.
+
+```ts
+declare const sourceBucket: s3.Bucket;
+declare const myCachingBucket: s3.Bucket;
+
+new codebuild.Project(this, 'ProjectA', {
+  source: codebuild.Source.s3({
+    bucket: sourceBucket,
+    path: 'path/to/source-a.zip',
+  }),
+  // configure the same bucket and path prefix
+  cache: codebuild.Cache.bucket(myCachingBucket, {
+    prefix: 'cache',
+    // use the same cache namespace
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec: codebuild.BuildSpec.fromObject({
+    version: '0.2',
+    phases: {
+      build: {
+        commands: ['...'],
+      },
+    },
+    // specify the same cache key and paths
+    cache: {
+      key: 'unique-key',
+      paths: [
+        '/root/cachedir/**/*',
+      ],
+    },
+  }),
+});
+
+new codebuild.Project(this, 'ProjectB', {
+  source: codebuild.Source.s3({
+    bucket: sourceBucket,
+    path: 'path/to/source-b.zip',
+  }),
+  // configure the same bucket and path prefix
+  cache: codebuild.Cache.bucket(myCachingBucket, {
+    prefix: 'cache',
+    // use the same cache namespace
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec: codebuild.BuildSpec.fromObject({
+    version: '0.2',
+    phases: {
+      build: {
+        commands: ['...'],
+      },
+    },
+    // specify the same cache key and paths
+    cache: {
+      key: 'unique-key',
+      paths: [
+        '/root/cachedir/**/*',
+      ],
+    },
+  }),
+});
+```
 
 ### Local Caching
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-s3-cache.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'codebuild-s3-cache-stack');
+
+const bucket = new s3.Bucket(stack, 'MyBucket', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+  autoDeleteObjects: true,
+});
+
+const buildSpec = codebuild.BuildSpec.fromObject({
+  version: '0.2',
+  phases: {
+    build: {
+      commands: ['echo "Hello, CodeBuild!"'],
+    },
+  },
+  cache: {
+    paths: [
+      '/root/cachedir/**/*',
+    ],
+    key: 'unique-key',
+  },
+});
+
+const projectA = new codebuild.Project(stack, 'ProjectA', {
+  source: codebuild.Source.s3({
+    bucket,
+    path: 'path/to/source-a.zip',
+  }),
+  cache: codebuild.Cache.bucket(bucket, {
+    prefix: 'cache',
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec,
+});
+
+const projectB = new codebuild.Project(stack, 'ProjectB', {
+  source: codebuild.Source.s3({
+    bucket,
+    path: 'path/to/source-b.zip',
+  }),
+  cache: codebuild.Cache.bucket(bucket, {
+    prefix: 'cache',
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec,
+});
+
+const integ = new IntegTest(app, 'codebuild-s3-cache-integ', {
+  testCases: [stack],
+});
+
+[projectA, projectB].forEach((project) => {
+  integ.assertions.awsApiCall('CodeBuild', 'batchGetProjects', {
+    names: [project.projectName],
+  }).expect(ExpectedResult.objectLike({
+    projects: [{
+      cache: {
+        type: 'S3',
+        location: `${bucket.bucketName}/cache`,
+        cacheNamespace: 'cache-namespace',
+      },
+    }],
+  }));
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.availability-zone-rebalancing.ts

@@ -3,20 +3,30 @@ import * as cdk from 'aws-cdk-lib';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
-const app = new cdk.App();
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
 const stack = new cdk.Stack(app, 'aws-ecs-integ-availability-zone-rebalancing');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const cluster = new ecs.Cluster(stack, 'Cluster', { vpc });
+const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
+
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
 
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  memoryLimitMiB: 256,
 });
 
-new ecs.FargateService(stack, 'FargateService', {
+new ecs.Ec2Service(stack, 'FrontendService', {
   cluster,
   taskDefinition,
   availabilityZoneRebalancing: ecs.AvailabilityZoneRebalancing.ENABLED,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.enable-execute-command.ts

@@ -1,30 +1,53 @@
-import * as ec2 from 'aws-cdk-lib/aws-ec2';
-import * as kms from 'aws-cdk-lib/aws-kms';
+
+import * as autoscaling from 'aws-cdk-lib/aws-autoscaling';
 import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
-import { Duration } from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
 const app = new cdk.App({
   postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
     '@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions': true,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
   },
 });
 const stack = new cdk.Stack(app, 'aws-ecs-integ-enable-execute-command');
 
-const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2 });
+
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  memoryReservationMiB: 256,
+  portMappings: [
+    {
+      containerPort: 80,
+      hostPort: 8080,
+      protocol: ecs.Protocol.TCP,
+    },
+  ],
+});
 
-const kmsKey = new kms.Key(stack, 'KmsKey');
+const execBucket = new s3.Bucket(stack, 'EcsExecBucket');
 
-const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
-  encryptionKey: kmsKey,
+const cp = new ecs.AsgCapacityProvider(stack, 'EC2CapacityProvider', {
+  autoScalingGroup: new autoscaling.AutoScalingGroup(stack, 'ASG', {
+    vpc,
+    instanceType: new ec2.InstanceType('t2.micro'),
+    machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
+  }),
+  // This is to allow cdk destroy to work; otherwise deletion will hang bc ASG cannot be deleted
+  enableManagedTerminationProtection: false,
 });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', {
+const cluster = new ecs.Cluster(stack, 'EC2CPCluster', {
   vpc,
   executeCommandConfiguration: {
-    kmsKey,
     logConfiguration: {
       s3Bucket: execBucket,
       s3EncryptionEnabled: true,
@@ -33,19 +56,9 @@ const cluster = new ecs.Cluster(stack, 'FargateCluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
+cluster.addAsgCapacityProvider(cp);
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
-
-taskDefinition.addContainer('web', {
-  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  healthCheck: {
-    command: ['CMD-SHELL', 'curl localhost:8000'],
-    interval: Duration.seconds(60),
-    timeout: Duration.seconds(40),
-  },
-});
-
-new ecs.FargateService(stack, 'FargateService', {
+new ecs.Ec2Service(stack, 'EC2Service', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
@@ -53,12 +66,5 @@ new ecs.FargateService(stack, 'FargateService', {
 
 new integ.IntegTest(app, 'enable-execute-command-test', {
   testCases: [stack],
-  diffAssets: true,
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: true,
-      },
-    },
-  },
 });
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.exec-command.ts

@@ -3,11 +3,16 @@ import * as kms from 'aws-cdk-lib/aws-kms';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
-import { Duration } from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-const app = new cdk.App();
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
 const stack = new cdk.Stack(app, 'aws-ecs-integ-exec-command');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
@@ -22,7 +27,7 @@ const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
   encryptionKey: kmsKey,
 });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', {
+const cluster = new ecs.Cluster(stack, 'Ec2Cluster', {
   vpc,
   executeCommandConfiguration: {
     kmsKey,
@@ -36,32 +41,21 @@ const cluster = new ecs.Cluster(stack, 'FargateCluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
 
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  healthCheck: {
-    command: ['CMD-SHELL', 'curl localhost:8000'],
-    interval: Duration.seconds(60),
-    timeout: Duration.seconds(40),
-  },
+  memoryLimitMiB: 256,
 });
 
-new ecs.FargateService(stack, 'FargateService', {
+new ecs.Ec2Service(stack, 'Ec2Service', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
 });
 
-new integ.IntegTest(app, 'exec-command-integ-test', {
-  testCases: [stack],
-  diffAssets: true,
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: true,
-      },
-    },
-  },
-});
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-awsvpc-nw.ts

@@ -3,38 +3,48 @@ import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
 import * as cdk from 'aws-cdk-lib';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-const app = new cdk.App();
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
 const stack = new cdk.Stack(app, 'aws-ecs-integ');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', { vpc });
+const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
-  memoryLimitMiB: 1024,
-  cpu: 512,
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
+  networkMode: ecs.NetworkMode.AWS_VPC,
 });
 
-taskDefinition.addContainer('web', {
+const container = taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  portMappings: [{
-    containerPort: 80,
-    protocol: ecs.Protocol.TCP,
-  }],
+  memoryLimitMiB: 256,
+  environment: {
+    SOME_VARIABLE: 'value',
+  },
 });
 
-const service = new ecs.FargateService(stack, 'Service', {
+container.addPortMappings({
+  containerPort: 80,
+  protocol: ecs.Protocol.TCP,
+});
+
+const service = new ecs.Ec2Service(stack, 'Service', {
   cluster,
   taskDefinition,
 });
 
-const scaling = service.autoScaleTaskCount({ maxCapacity: 10 });
-// Quite low to try and force it to scale
-scaling.scaleOnCpuUtilization('ReasonableCpu', { targetUtilizationPercent: 10 });
-
 const lb = new elbv2.ApplicationLoadBalancer(stack, 'LB', { vpc, internetFacing: true });
 const listener = lb.addListener('PublicListener', { port: 80, open: true });
-listener.addTargets('Fargate', {
+listener.addTargets('ECS', {
   port: 80,
   targets: [service],
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.pseudo-terminal.ts

@@ -3,25 +3,35 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-const app = new cdk.App();
-const stack = new cdk.Stack(app, 'integ-pseudo-terminal');
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
+const stack = new cdk.Stack(app, 'aws-ecs-integ-pseudo-terminal');
 
 // Create a cluster
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
 const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
-  cpu: 256,
-  memoryLimitMiB: 512,
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
+
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
+  networkMode: ecs.NetworkMode.AWS_VPC,
 });
+
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 512,
-  cpu: 256,
+  memoryLimitMiB: 256,
   pseudoTerminal: true,
 });
 
-new ecs.FargateService(stack, 'Service', {
+new ecs.Ec2Service(stack, 'Service', {
   cluster,
   taskDefinition,
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-events/integ.api-destination.ts

@@ -0,0 +1,42 @@
+import { App, CfnOutput, SecretValue, Stack } from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+
+const app = new App();
+
+const stack = new Stack(app, 'events-api-destination-stack');
+
+const secret = new secretsmanager.Secret(stack, 'Secret', {
+  secretStringValue: SecretValue.unsafePlainText('abc123'),
+});
+
+const connection = new events.Connection(stack, 'Connection', {
+  authorization: events.Authorization.apiKey('x-api-key', secret.secretValue),
+  description: 'Connection with API Key x-api-key',
+  connectionName: 'MyConnection',
+});
+
+const destination = new events.ApiDestination(stack, 'Destination', {
+  connection,
+  endpoint: 'https://httpbin.org/headers',
+  httpMethod: events.HttpMethod.GET,
+  apiDestinationName: 'MyDestination',
+  rateLimitPerSecond: 1,
+  description: 'Calling example.com with API key x-api-key',
+});
+
+// arn:aws:events:{region}:{account}:api-destination/{destination-name}/11111111-1111-1111-1111-111111111111
+new CfnOutput(stack, 'DestinationArn', {
+  value: destination.apiDestinationArn,
+  description: 'The ARN of the API destination',
+});
+// arn:aws:events:{region}:{account}:api-destination/{destination-name}
+new CfnOutput(stack, 'DestinationArnForPolicy', {
+  value: destination.apiDestinationArnForPolicy || '',
+  description: 'The ARN of the API destination in resource format',
+});
+
+new IntegTest(app, 'events-api-destination-integ', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-events-targets/README.md

@@ -369,11 +369,16 @@ const connection = events.Connection.fromEventBusArn(
   'arn:aws:secretsmanager:us-east-1:123456789012:secret:SecretName-f3gDy9',
 );
 
-const apiDestinationArn = 'arn:aws:events:us-east-1:123456789012:api-destination/DestinationName';
+const apiDestinationArn = 'arn:aws:events:us-east-1:123456789012:api-destination/DestinationName/11111111-1111-1111-1111-111111111111';
+const apiDestinationArnForPolicy = 'arn:aws:events:us-east-1:123456789012:api-destination/DestinationName';
 const destination = events.ApiDestination.fromApiDestinationAttributes(
   this,
   'Destination',
-  { apiDestinationArn, connection },
+  {
+    apiDestinationArn,
+    connection,
+    apiDestinationArnForPolicy // optional
+  },
 );
 
 const rule = new events.Rule(this, 'OtherRule', {

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

@@ -102,10 +102,13 @@ will be used for files successfully delivered to S3. `errorOutputPrefix` will be
 failed records before writing them to S3.
 
 ```ts
+import { TimeZone } from 'aws-cdk-lib';
 declare const bucket: s3.Bucket;
 const s3Destination = new firehose.S3Bucket(bucket, {
   dataOutputPrefix: 'myFirehose/DeliveredYear=!{timestamp:yyyy}/anyMonth/rand=!{firehose:random-string}',
   errorOutputPrefix: 'myFirehoseFailures/!{firehose:error-output-type}/!{timestamp:yyyy}/anyMonth/!{timestamp:dd}',
+  // The time zone of timestamps (default UTC)
+  timeZone: TimeZone.ASIA_TOKYO,
 });
 ```
 

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

@@ -56,6 +56,7 @@ const deliveryStream = new firehose.DeliveryStream(stack, 'DeliveryStream', {
     dataOutputPrefix: 'regularPrefix',
     errorOutputPrefix: 'errorPrefix',
     fileExtension: '.log.gz',
+    timeZone: cdk.TimeZone.ASIA_TOKYO,
     bufferingInterval: cdk.Duration.seconds(60),
     bufferingSize: cdk.Size.mebibytes(1),
     encryptionKey: key,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.lambda-policy-with-token-resolution.ts

@@ -0,0 +1,46 @@
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new cdk.Stack(app, 'stack');
+
+const mappingName = 'testmapping';
+const mapping = new cdk.CfnMapping(stack, 'testmapping', {
+  mapping: {
+    us: {
+      regionalModels:
+        'arn:aws:bedrock:us-west-2::foundation-model/amazon.nova-lite-v1:0',
+    },
+  },
+});
+mapping.overrideLogicalId(mappingName);
+
+const func = new lambda.Function(stack, 'test-function', {
+  code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\'statusCode\': 200, \'body\': \'\'}; }'),
+  runtime: lambda.Runtime.NODEJS_20_X,
+  handler: 'index.handler',
+});
+
+// Literal resources in statement
+func.addToRolePolicy(new iam.PolicyStatement({
+  actions: ['bedrock:Invoke*'],
+  resources: [
+    '*',
+  ],
+}));
+
+// Array token resources in statement
+func.addToRolePolicy(new iam.PolicyStatement({
+  actions: ['bedrock:Invoke*'],
+  resources: cdk.Fn.split(',', cdk.Fn.findInMap(mappingName, 'us', 'regionalModels')),
+}));
+
+new integ.IntegTest(app, 'lambda-policy-with-token-resolution', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53-targets/integ.elastic-beanstalk-hostedzoneid.ts

@@ -6,7 +6,7 @@ import * as targets from 'aws-cdk-lib/aws-route53-targets';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as elasticbeanstalk from 'aws-cdk-lib/aws-elasticbeanstalk';
 import * as custom from 'aws-cdk-lib/custom-resources';
-import { RegionInfo } from 'aws-cdk-lib/region-info';
+import { RegionInfo } from '@aws-cdk/region-info';
 
 const app = new App({
   postCliContext: {