konokenj.cdk-api-mcp-server 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

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

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

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

@@ -3,48 +3,38 @@ 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({
-  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 app = new cdk.App();
 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, 'EcsCluster', { vpc });
-cluster.addCapacity('DefaultAutoScalingGroup', {
-  instanceType: new ec2.InstanceType('t2.micro'),
-});
+const cluster = new ecs.Cluster(stack, 'FargateCluster', { vpc });
 
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
-  networkMode: ecs.NetworkMode.AWS_VPC,
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
+  memoryLimitMiB: 1024,
+  cpu: 512,
 });
 
-const container = taskDefinition.addContainer('web', {
+taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 256,
-  environment: {
-    SOME_VARIABLE: 'value',
-  },
+  portMappings: [{
+    containerPort: 80,
+    protocol: ecs.Protocol.TCP,
+  }],
 });
 
-container.addPortMappings({
-  containerPort: 80,
-  protocol: ecs.Protocol.TCP,
-});
-
-const service = new ecs.Ec2Service(stack, 'Service', {
+const service = new ecs.FargateService(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('ECS', {
+listener.addTargets('Fargate', {
   port: 80,
   targets: [service],
 });

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

@@ -3,35 +3,25 @@ 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({
-  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');
+const app = new cdk.App();
+const stack = new cdk.Stack(app, '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 });
-cluster.addCapacity('DefaultAutoScalingGroup', {
-  instanceType: new ec2.InstanceType('t2.micro'),
-});
-
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
-  networkMode: ecs.NetworkMode.AWS_VPC,
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
+  cpu: 256,
+  memoryLimitMiB: 512,
 });
-
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 256,
+  memoryLimitMiB: 512,
+  cpu: 256,
   pseudoTerminal: true,
 });
 
-new ecs.Ec2Service(stack, 'Service', {
+new ecs.FargateService(stack, 'Service', {
   cluster,
   taskDefinition,
 });

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

@@ -1177,7 +1177,7 @@ const version = fn.currentVersion;
 You can use Application AutoScaling to automatically configure the provisioned concurrency for your functions. AutoScaling can be set to track utilization or be based on a schedule. To configure AutoScaling on a function alias:
 
 ```ts
-import * as autoscaling from 'aws-cdk-lib/aws-autoscaling';
+import * as appscaling from 'aws-cdk-lib/aws-applicationautoscaling';
 
 declare const fn: lambda.Function;
 const alias = fn.addAlias('prod');
@@ -1192,7 +1192,7 @@ as.scaleOnUtilization({
 
 // Configure Scheduled Scaling
 as.scaleOnSchedule('ScaleUpInTheMorning', {
-  schedule: autoscaling.Schedule.cron({ hour: '8', minute: '0'}),
+  schedule: appscaling.Schedule.cron({ hour: '8', minute: '0'}),
   minCapacity: 20,
 });
 ```

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53/integ.delete-existing-record-set.ts

@@ -23,7 +23,6 @@ class TestStack extends Stack {
       ttl: Duration.hours(2),
       zone: hostedZone,
       recordName: 'integ',
-      deleteExisting: true,
     });
     newRecord.node.addDependency(existingRecord);
   }

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3-deployment/integ.bucket-deployment-cross-stack-ssm-source.ts

@@ -0,0 +1,91 @@
+import * as cdk from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3deploy from 'aws-cdk-lib/aws-s3-deployment';
+import * as ssm from 'aws-cdk-lib/aws-ssm';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+class SsmStack extends cdk.NestedStack {
+  public readonly ssmParam: ssm.StringListParameter;
+
+  constructor(scope: Construct, id: string, props?: cdk.NestedStackProps) {
+    super(scope, id, props);
+
+    const testSubnets = ['subnet-12345', 'subnet-67890'];
+
+    this.ssmParam = new ssm.StringListParameter(this, 'TestParam', {
+      parameterName: '/repro/subnets',
+      stringListValue: testSubnets,
+      description: 'Test parameter for reproduction',
+    });
+  }
+}
+
+class S3Stack extends cdk.NestedStack {
+  public readonly bucket: s3.Bucket;
+
+  constructor(scope: Construct, id: string, props?: cdk.NestedStackProps) {
+    super(scope, id, props);
+
+    const readParam = ssm.StringListParameter.fromStringListParameterName(
+      this,
+      'ReadParam',
+      '/repro/subnets',
+    );
+
+    this.bucket = new s3.Bucket(this, 'ReproBucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    new s3deploy.BucketDeployment(this, 'ReproDeployment', {
+      sources: [
+        s3deploy.Source.jsonData('config.json', {
+          subnets: readParam.stringListValue,
+          expectedValues: ['subnet-12345', 'subnet-67890'],
+          version: '2.207.0',
+          issue: 'StringListParameter tokens not resolved in Source.jsonData',
+          timestamp: new Date().toISOString(),
+        }),
+      ],
+      destinationBucket: this.bucket,
+    });
+  }
+}
+
+export class MainStack extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const ssmStack = new SsmStack(this, 'SsmStack');
+    const s3Stack = new S3Stack(this, 'S3Stack');
+    s3Stack.addDependency(ssmStack);
+
+    new cdk.CfnOutput(this, 'BucketName', {
+      value: s3Stack.bucket.bucketName,
+      description: 'Check config.json in this bucket',
+    });
+
+    new cdk.CfnOutput(this, 'ParameterName', {
+      value: ssmStack.ssmParam.parameterName,
+      description: 'SSM parameter name',
+    });
+
+    new cdk.CfnOutput(this, 'ExpectedValues', {
+      value: JSON.stringify(['subnet-12345', 'subnet-67890']),
+      description: 'Expected subnet values in config.json',
+    });
+
+    new cdk.CfnOutput(this, 'VerificationCommand', {
+      value: `aws s3 cp s3://${s3Stack.bucket.bucketName}/config.json - | jq .`,
+      description: 'Command to check the deployed JSON',
+    });
+  }
+}
+
+const app = new cdk.App();
+const stack = new MainStack(app, 'integ-bucket-deployment-cross-stack-ssm');
+
+new integ.IntegTest(app, 'integ-bucket-deployment-cross-stack-ssm-source', {
+  testCases: [stack],
+});

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

@@ -1,68 +1,106 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as s3 from 'aws-cdk-lib/aws-s3';
-import * as sqs from 'aws-cdk-lib/aws-sqs';
 import * as cdk from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
+import { STANDARD_NODEJS_RUNTIME } from '../../../config';
+import * as constructs from 'constructs';
+import * as integ from '@aws-cdk/integ-tests-alpha';
 
 const app = new cdk.App({
   postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
     '@aws-cdk/aws-s3:keepNotificationInImportedBucket': false,
   },
 });
 
-const stack = new cdk.Stack(app, 'sqs-bucket-notifications');
+const stack = new cdk.Stack(app, 'cdk-integ-lambda-bucket-s3-notifications');
 
-const bucket1 = new s3.Bucket(stack, 'Bucket1', {
+const bucketA = new s3.Bucket(stack, 'MyBucket', {
   removalPolicy: cdk.RemovalPolicy.DESTROY,
 });
-const queue = new sqs.Queue(stack, 'MyQueue');
 
-bucket1.addObjectCreatedNotification(new s3n.SqsDestination(queue));
+const fn = new lambda.Function(stack, 'MyFunction', {
+  runtime: STANDARD_NODEJS_RUNTIME,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline(`exports.handler = ${handler.toString()}`),
+});
 
-const bucket2 = new s3.Bucket(stack, 'Bucket2', {
+const bucketB = new s3.Bucket(stack, 'YourBucket', {
   removalPolicy: cdk.RemovalPolicy.DESTROY,
-  autoDeleteObjects: true,
 });
-bucket2.addObjectCreatedNotification(new s3n.SqsDestination(queue), { suffix: '.png' });
 
-const encryptedQueue = new sqs.Queue(stack, 'EncryptedQueue', { encryption: sqs.QueueEncryption.KMS });
-bucket1.addObjectRemovedNotification(new s3n.SqsDestination(encryptedQueue));
+bucketB.addEventNotification(s3.EventType.OBJECT_REMOVED, new s3n.LambdaDestination(fn));
 
-const bucket3 = new s3.Bucket(stack, 'Bucket3WithSkipDestinationValidation', {
-  notificationsSkipDestinationValidation: true,
-  removalPolicy: cdk.RemovalPolicy.DESTROY,
-});
-const queueWithIncorrectS3Permissions = new sqs.Queue(stack, 'MyQueueWithIncorrectS3Permissions');
-queueWithIncorrectS3Permissions.addToResourcePolicy(
-  new cdk.aws_iam.PolicyStatement({
-    effect: cdk.aws_iam.Effect.DENY,
-    actions: ['sqs:SendMessage'],
-    principals: [new cdk.aws_iam.ServicePrincipal('s3.amazonaws.com')],
-    resources: [queueWithIncorrectS3Permissions.queueArn],
-  }));
-bucket3.addEventNotification(s3.EventType.OBJECT_TAGGING_PUT, new s3n.SqsDestination(queueWithIncorrectS3Permissions));
+const c1 = new constructs.Construct(stack, 'Construct1');
+const unmanagedBucket = s3.Bucket.fromBucketName(c1, 'IntegUnmanagedBucket1', bucketA.bucketName);
 
-const integTest = new integ.IntegTest(app, 'SQSBucketNotificationsTest', {
+unmanagedBucket.addObjectCreatedNotification(new s3n.LambdaDestination(fn), { prefix: 'TEST1/', suffix: '.png' });
+unmanagedBucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.LambdaDestination(fn), { prefix: 'TEST2/' });
+
+/* eslint-disable no-console */
+function handler(event: any, _context: any, callback: any) {
+  console.log(JSON.stringify(event, undefined, 2));
+  return callback(null, event);
+}
+
+const integTest = new integ.IntegTest(app, 'LambdaBucketNotificationsTest', {
+  cdkCommandOptions: {
+    deploy: {
+      args: {
+        rollback: false,
+      },
+    },
+  },
   testCases: [stack],
   diffAssets: true,
 });
 
-integTest.assertions
-  // First remove the test notifications
-  .awsApiCall('SQS', 'purgeQueue', {
-    QueueUrl: queue.queueUrl,
-  })
-  .next(integTest.assertions
-    .awsApiCall('S3', 'putObject', {
-      Bucket: bucket2.bucketName,
-      Key: 'image.png',
-      Body: 'Some content',
-    }))
-  .next(integTest.assertions
-    .awsApiCall('SQS', 'receiveMessage', {
-      QueueUrl: queue.queueUrl,
-      WaitTimeSeconds: 20,
-    })
-    .assertAtPath('Messages.0.Body.Records.0.s3.object.key', integ.ExpectedResult.stringLikeRegexp('image\\.png')));
+const getNotifications = integTest.assertions
+  .awsApiCall('S3', 'getBucketNotificationConfiguration', {
+    Bucket: unmanagedBucket.bucketName,
+  });
+getNotifications.provider.addToRolePolicy({
+  Effect: 'Allow',
+  Action: ['s3:GetBucketNotification'],
+  Resource: ['*'],
+});
 
+getNotifications.expect(integ.ExpectedResult.objectLike({
+  LambdaFunctionConfigurations: [
+    {
+      Events: [
+        's3:ObjectCreated:*',
+      ],
+      Filter: {
+        Key: {
+          FilterRules: [
+            {
+              Name: 'Prefix',
+              Value: 'TEST1/',
+            },
+            {
+              Name: 'Suffix',
+              Value: '.png',
+            },
+          ],
+        },
+      },
+    },
+    {
+      Events: [
+        's3:ObjectCreated:*',
+      ],
+      Filter: {
+        Key: {
+          FilterRules: [
+            {
+              Name: 'Prefix',
+              Value: 'TEST2/',
+            },
+          ],
+        },
+      },
+    },
+  ],
+}));
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-signer/integ.signing-profile.ts

@@ -16,6 +16,11 @@ new signer.SigningProfile(stack, 'SigningProfileOCI', {
   signatureValidity: cdk.Duration.days(60),
 });
 
+new signer.SigningProfile(stack, 'SigningProfileWithName', {
+  platform: signer.Platform.AWS_LAMBDA_SHA384_ECDSA,
+  signingProfileName: 'test-signing-profile-name',
+});
+
 new IntegTest(app, 'cdk-integ-signer-signing-profile', {
   testCases: [stack],
 });

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

@@ -34,6 +34,8 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [SubmitJob](#submitjob)
   - [Bedrock](#bedrock)
     - [InvokeModel](#invokemodel)
+    - [Using Input Path for S3 URI](#using-input-path-for-s3-uri)
+    - [Using Input Path](#using-input-path)
     - [createModelCustomizationJob](#createmodelcustomizationjob)
   - [CodeBuild](#codebuild)
     - [StartBuild](#startbuild)
@@ -47,6 +49,7 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [RunTask](#runtask)
       - [EC2](#ec2)
       - [Fargate](#fargate)
+      - [Override CPU and Memory Parameter](#override-cpu-and-memory-parameter)
       - [ECS enable Exec](#ecs-enable-exec)
   - [EMR](#emr)
     - [Create Cluster](#create-cluster)
@@ -64,15 +67,18 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [Call](#call)
   - [EventBridge](#eventbridge)
     - [Put Events](#put-events)
+  - [EventBridge Scheduler](#eventbridge-scheduler)
+    - [Create Scheduler](#create-scheduler)
   - [Glue](#glue)
     - [StartJobRun](#startjobrun)
     - [StartCrawlerRun](#startcrawlerrun)
   - [Glue DataBrew](#glue-databrew)
     - [Start Job Run](#start-job-run-1)
+  - [Invoke HTTP API](#invoke-http-api)
   - [Lambda](#lambda)
     - [Invoke](#invoke)
   - [MediaConvert](#mediaconvert)
-    - [Create Job](#create-job)
+    - [CreateJob](#createjob)
   - [SageMaker](#sagemaker)
     - [Create Training Job](#create-training-job)
     - [Create Transform Job](#create-transform-job)
@@ -1315,12 +1321,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 { KubectlV32Layer } from '@aws-cdk/lambda-layer-kubectl-v32';
+import { KubectlV33Layer } from '@aws-cdk/lambda-layer-kubectl-v33';
 
 const myEksCluster = new eks.Cluster(this, 'my sample cluster', {
   version: eks.KubernetesVersion.V1_32,
   clusterName: 'myEksCluster',
-  kubectlLayer: new KubectlV32Layer(this, 'kubectl'),
+  kubectlLayer: new KubectlV33Layer(this, 'kubectl'),
 });
 
 new tasks.EksCall(this, 'Call a EKS Endpoint', {