konokenj.cdk-api-mcp-server 0.29.0__py3-none-any.whl → 0.31.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.instance-engine-lifecycle-support.ts

@@ -0,0 +1,53 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { InstanceSnapshoter } from './snapshoter';
+
+const app = new App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': true,
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const stack = new Stack(app, 'cdk-instance-engine-lifecycle-support');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, natGateways: 1, restrictDefaultSecurityGroup: false });
+
+const engine = rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_4_5 });
+const instanceType = ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL);
+
+const sourceInstance = new rds.DatabaseInstance(stack, 'Instance', {
+  engine,
+  instanceType,
+  vpc,
+  removalPolicy: RemovalPolicy.DESTROY,
+  engineLifecycleSupport: rds.EngineLifecycleSupport.OPEN_SOURCE_RDS_EXTENDED_SUPPORT,
+});
+
+const snapshoter = new InstanceSnapshoter(stack, 'Snapshoter', {
+  instance: sourceInstance,
+  snapshotIdentifier: 'cdk-instance-engine-lifecycle-support-snapshot',
+});
+
+const restoredInstance = new rds.DatabaseInstanceFromSnapshot(stack, 'FromSnapshot', {
+  snapshotIdentifier: snapshoter.snapshotArn,
+  engine,
+  instanceType,
+  vpc,
+  removalPolicy: RemovalPolicy.DESTROY,
+  engineLifecycleSupport: rds.EngineLifecycleSupport.OPEN_SOURCE_RDS_EXTENDED_SUPPORT_DISABLED,
+});
+
+new rds.DatabaseInstanceReadReplica(stack, 'ReadReplica', {
+  sourceDatabaseInstance: restoredInstance,
+  instanceType,
+  vpc,
+  removalPolicy: RemovalPolicy.DESTROY,
+  engineLifecycleSupport: rds.EngineLifecycleSupport.OPEN_SOURCE_RDS_EXTENDED_SUPPORT_DISABLED,
+});
+
+new IntegTest(app, 'cdk-instance-engine-lifecycle-support-test', {
+  testCases: [stack],
+});

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

@@ -1,106 +1,68 @@
-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 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';
+import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
 
 const app = new cdk.App({
   postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
     '@aws-cdk/aws-s3:keepNotificationInImportedBucket': false,
   },
 });
 
-const stack = new cdk.Stack(app, 'cdk-integ-lambda-bucket-s3-notifications');
+const stack = new cdk.Stack(app, 'sqs-bucket-notifications');
 
-const bucketA = new s3.Bucket(stack, 'MyBucket', {
+const bucket1 = new s3.Bucket(stack, 'Bucket1', {
   removalPolicy: cdk.RemovalPolicy.DESTROY,
 });
+const queue = new sqs.Queue(stack, 'MyQueue');
 
-const fn = new lambda.Function(stack, 'MyFunction', {
-  runtime: STANDARD_NODEJS_RUNTIME,
-  handler: 'index.handler',
-  code: lambda.Code.fromInline(`exports.handler = ${handler.toString()}`),
-});
+bucket1.addObjectCreatedNotification(new s3n.SqsDestination(queue));
 
-const bucketB = new s3.Bucket(stack, 'YourBucket', {
+const bucket2 = new s3.Bucket(stack, 'Bucket2', {
   removalPolicy: cdk.RemovalPolicy.DESTROY,
+  autoDeleteObjects: true,
 });
+bucket2.addObjectCreatedNotification(new s3n.SqsDestination(queue), { suffix: '.png' });
 
-bucketB.addEventNotification(s3.EventType.OBJECT_REMOVED, new s3n.LambdaDestination(fn));
-
-const c1 = new constructs.Construct(stack, 'Construct1');
-const unmanagedBucket = s3.Bucket.fromBucketName(c1, 'IntegUnmanagedBucket1', bucketA.bucketName);
-
-unmanagedBucket.addObjectCreatedNotification(new s3n.LambdaDestination(fn), { prefix: 'TEST1/', suffix: '.png' });
-unmanagedBucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.LambdaDestination(fn), { prefix: 'TEST2/' });
+const encryptedQueue = new sqs.Queue(stack, 'EncryptedQueue', { encryption: sqs.QueueEncryption.KMS });
+bucket1.addObjectRemovedNotification(new s3n.SqsDestination(encryptedQueue));
 
-/* eslint-disable no-console */
-function handler(event: any, _context: any, callback: any) {
-  console.log(JSON.stringify(event, undefined, 2));
-  return callback(null, event);
-}
+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 integTest = new integ.IntegTest(app, 'LambdaBucketNotificationsTest', {
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: false,
-      },
-    },
-  },
+const integTest = new integ.IntegTest(app, 'SQSBucketNotificationsTest', {
   testCases: [stack],
   diffAssets: true,
 });
 
-const getNotifications = integTest.assertions
-  .awsApiCall('S3', 'getBucketNotificationConfiguration', {
-    Bucket: unmanagedBucket.bucketName,
-  });
-getNotifications.provider.addToRolePolicy({
-  Effect: 'Allow',
-  Action: ['s3:GetBucketNotification'],
-  Resource: ['*'],
-});
+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')));
 
-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-stepfunctions-tasks/integ.call-aws-service-cross-region-lambda.ts

@@ -0,0 +1,97 @@
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { ExpectedResult, IntegTest, Match } from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+
+class TestStack extends cdk.Stack {
+  public readonly stateMachine: sfn.StateMachine;
+  constructor(scope: cdk.App, id: string, props: cdk.StackProps = {}) {
+    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,
+      handler: 'index.handler',
+      code: lambda.Code.fromInline(`
+        exports.handler = async (event) => {
+          console.log('Target Lambda received event:', JSON.stringify(event, null, 2));
+          
+          // Return a JSON response that should be properly serialized
+          return {
+            statusCode: 200,
+            body: {
+              status: 'success',
+              message: 'Hello from target Lambda',
+              receivedData: event
+            }
+          };
+        };
+      `),
+      description: 'Target Lambda function for CallAwsServiceCrossRegion testing',
+    });
+
+    // Create a cross-region Lambda invoke task using CallAwsServiceCrossRegion
+    const crossRegionInvokeTask = tasks.CallAwsServiceCrossRegion.jsonata(this, 'CrossRegionLambdaInvoke', {
+      service: 'lambda',
+      action: 'invoke',
+      region: 'us-east-1',
+      parameters: {
+        FunctionName: targetLambda.functionArn,
+        Payload: JSON.stringify({
+          hello: 'world',
+          testData: 'reproduction',
+        }),
+      },
+      iamResources: [targetLambda.functionArn],
+      iamAction: 'lambda:InvokeFunction',
+    });
+
+    // Create a Step Functions state machine to execute the cross-region task
+    this.stateMachine = new sfn.StateMachine(this, 'TestStateMachine', {
+      definitionBody: sfn.DefinitionBody.fromChainable(crossRegionInvokeTask),
+      timeout: cdk.Duration.minutes(5),
+      comment: 'State machine to reproduce issue 34768 - CallAwsServiceCrossRegion byte array bug',
+    });
+  }
+}
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
+
+const stack = new TestStack(app, 'aws-stepfunctions-call-aws-service-cross-region-lambda-integ');
+
+const integ = new IntegTest(app, 'IntegTest', {
+  testCases: [stack],
+});
+
+// Start the Step Functions execution
+const res = integ.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: stack.stateMachine.stateMachineArn,
+});
+
+const executionArn = res.getAttString('executionArn');
+
+// Describe the execution to see the output
+const describe = integ.assertions
+  .awsApiCall('StepFunctions', 'describeExecution', {
+    executionArn,
+  })
+  .expect(ExpectedResult.objectLike({
+    status: 'SUCCEEDED',
+  }))
+  .waitForAssertions({
+    totalTimeout: cdk.Duration.minutes(5),
+    interval: cdk.Duration.seconds(10),
+  });
+
+// Verify that the output contains the expected Lambda response structure as JSON
+// This ensures the response is properly serialized as JSON, not as byte array
+describe.expect(ExpectedResult.objectLike({
+  output: Match.stringLikeRegexp('.*"statusCode":200.*"status":"success".*"message":"Hello from target Lambda".*'),
+}));
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.start-job-run.ts

@@ -1,124 +1,69 @@
-import * as databrew from 'aws-cdk-lib/aws-databrew';
+import * as path from 'path';
+import * as glue from 'aws-cdk-lib/aws-glue';
 import * as iam from 'aws-cdk-lib/aws-iam';
-import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as assets from 'aws-cdk-lib/aws-s3-assets';
 import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
 import * as cdk from 'aws-cdk-lib';
-import { GlueDataBrewStartJobRun } from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { GlueStartJobRun } from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
 /*
  * Stack verification steps:
- * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
- * * aws stepfunctions describe-execution --execution-arn <exection-arn generated before> : should return status as SUCCEEDED
+ * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn>
+ * * aws stepfunctions describe-execution --execution-arn <execution arn created above>
+ * The "describe-execution" call should eventually return status "SUCCEEDED".
+ * NOTE: It will take up to 15 minutes for the step function to complete due to the cold start time
+ * for AWS Glue, which as of 02/2020, is around 10-15 minutes.
  */
 
-class GlueDataBrewJobStack extends cdk.Stack {
-  constructor(scope: cdk.App, id: string, props: cdk.StackProps = {}) {
-    super(scope, id, props);
-
-    const region = this.region;
-
-    const outputBucket = new s3.Bucket(this, 'JobOutputBucket', {
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-    });
-
-    const role = new iam.Role(this, 'DataBrew Role', {
-      managedPolicies: [{
-        managedPolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSGlueDataBrewServiceRole',
-      }],
-      path: '/',
-      assumedBy: new iam.ServicePrincipal('databrew.amazonaws.com'),
-      inlinePolicies: {
-        DataBrewPolicy: iam.PolicyDocument.fromJson({
-          Statement: [{
-            Effect: 'Allow',
-            Action: [
-              's3:GetObject',
-              's3:PutObject',
-              's3:DeleteObject',
-              's3:ListBucket',
-            ],
-            Resource: [
-              `arn:aws:s3:::databrew-public-datasets-${region}/*`,
-              `arn:aws:s3:::databrew-public-datasets-${region}`,
-              `${outputBucket.bucketArn}/*`,
-              `${outputBucket.bucketArn}`,
-            ],
-          }],
-        }),
-      },
-    });
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-stepfunctions-integ');
 
-    const recipe = new databrew.CfnRecipe(this, 'DataBrew Recipe', {
-      name: 'recipe-1',
-      steps: [
-        {
-          action: {
-            operation: 'UPPER_CASE',
-            parameters: {
-              sourceColumn: 'description',
-            },
-          },
-        },
-        {
-          action: {
-            operation: 'DELETE',
-            parameters: {
-              sourceColumn: 'doc_id',
-            },
-          },
-        },
-      ],
-    });
+const codeAsset = new assets.Asset(stack, 'Glue Job Script', {
+  path: path.join(__dirname, 'my-glue-script/job.py'),
+});
 
-    const dataset = new databrew.CfnDataset(this, 'DataBrew Dataset', {
-      input: {
-        s3InputDefinition: {
-          bucket: `databrew-public-datasets-${region}`,
-          key: 'votes.csv',
-        },
-      },
-      name: 'dataset-1',
-    });
+const jobRole = new iam.Role(stack, 'Glue Job Role', {
+  assumedBy: new iam.ServicePrincipal('glue'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSGlueServiceRole'),
+  ],
+});
+codeAsset.grantRead(jobRole);
 
-    const project = new databrew.CfnProject(this, 'DataBrew Project', {
-      name: 'project-1',
-      roleArn: role.roleArn,
-      datasetName: dataset.name,
-      recipeName: recipe.name,
-    });
-    project.addDependency(dataset);
-    project.addDependency(recipe);
+const job = new glue.CfnJob(stack, 'Glue Job', {
+  name: 'My Glue Job',
+  glueVersion: '1.0',
+  command: {
+    name: 'glueetl',
+    pythonVersion: '3',
+    scriptLocation: `s3://${codeAsset.s3BucketName}/${codeAsset.s3ObjectKey}`,
+  },
+  role: jobRole.roleArn,
+});
 
-    const job = new databrew.CfnJob(this, 'DataBrew Job', {
-      name: 'job-1',
-      type: 'RECIPE',
-      projectName: project.name,
-      roleArn: role.roleArn,
-      outputs: [{
-        location: {
-          bucket: outputBucket.bucketName,
-        },
-      }],
-    });
-    job.addDependency(project);
+const jobTask = new GlueStartJobRun(stack, 'Glue Job Task', {
+  glueJobName: job.name!,
+  integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+  arguments: sfn.TaskInput.fromObject({
+    '--enable-metrics': 'true',
+  }),
+});
 
-    const startGlueDataBrewJob = new GlueDataBrewStartJobRun(this, 'Start DataBrew Job run', {
-      name: job.name,
-    });
+const startTask = new sfn.Pass(stack, 'Start Task');
+const endTask = new sfn.Pass(stack, 'End Task');
 
-    const chain = sfn.Chain.start(startGlueDataBrewJob);
+const stateMachine = new sfn.StateMachine(stack, 'State Machine', {
+  definition: sfn.Chain.start(startTask).next(jobTask).next(endTask),
+});
 
-    const sm = new sfn.StateMachine(this, 'StateMachine', {
-      definition: chain,
-      timeout: cdk.Duration.seconds(30),
-    });
+new cdk.CfnOutput(stack, 'State Machine ARN Output', {
+  value: stateMachine.stateMachineArn,
+});
 
-    new cdk.CfnOutput(this, 'stateMachineArn', {
-      value: sm.stateMachineArn,
-    });
-  }
-}
+new IntegTest(app, 'AwsSfnIntegTest', {
+  testCases: [stack],
+  diffAssets: true,
+});
 
-const app = new cdk.App();
-new GlueDataBrewJobStack(app, 'aws-stepfunctions-tasks-databrew-start-job-run-integ');
 app.synth();