konokenj.cdk-api-mcp-server 0.28.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

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();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/FEATURE_FLAGS.md

@@ -103,6 +103,7 @@ Flags come in three types:
 | [@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions](#aws-cdks3-notificationsadds3trustkeypolicyforsnssubscriptions) | Add an S3 trust policy to a KMS key resource policy for SNS subscriptions. | 2.195.0 | fix |
 | [@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway](#aws-cdkaws-ec2requireprivatesubnetsforegressonlyinternetgateway) | When enabled, the EgressOnlyGateway resource is only created if private subnets are defined in the dual-stack VPC. | 2.196.0 | fix |
 | [@aws-cdk/aws-s3:publicAccessBlockedByDefault](#aws-cdkaws-s3publicaccessblockedbydefault) | When enabled, setting any combination of options for BlockPublicAccess will automatically set true for any options not defined. | 2.196.0 | fix |
+| [@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal](#aws-cdkaws-kmsapplyimportedaliaspermissionstoprincipal) | Enable grant methods on Aliases imported by name to use kms:ResourceAliases condition | 2.202.0 | fix |
 
 <!-- END table -->
 
@@ -146,6 +147,7 @@ The following json shows the current recommended set of flags, as `cdk init` wou
     "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true,
     "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true,
     "@aws-cdk/aws-kms:aliasNameRef": true,
+    "@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal": true,
     "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true,
     "@aws-cdk/core:includePrefixInUniqueNameGeneration": true,
     "@aws-cdk/aws-efs:denyAnonymousAccess": true,
@@ -2175,4 +2177,23 @@ The new behavior from this feature will allow a user, for example, to set 1 of t
 | 2.196.0 | `false` | `true` |
 
 
+### @aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal
+
+*Enable grant methods on Aliases imported by name to use kms:ResourceAliases condition*
+
+Flag type: Backwards incompatible bugfix
+
+This flag enables the grant methods (grant, grantDecrypt, grantEncrypt, etc.) on Aliases imported
+by name to grant permissions based on the 'kms:ResourceAliases' condition rather than no-op grants.
+When disabled, grant calls on imported aliases will be dropped (no-op) to maintain compatibility.
+
+
+| Since | Default | Recommended |
+| ----- | ----- | ----- |
+| (not in v1) |  |  |
+| 2.202.0 | `false` | `true` |
+
+**Compatibility with old behavior:** Remove calls to the grant* methods on the aliases referenced by name
+
+
 <!-- END details -->

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/README.md

@@ -310,6 +310,20 @@ _cdk.json_
 }
 ```
 
+* `@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal`
+
+Enable grant methods on imported KMS Aliases to apply permissions scoped by the alias using the `kms:ResourceAliases` condition key. When this flag is disabled, grant* methods on `Alias.fromAliasName` remain no-ops to preserve existing behavior.
+
+_cdk.json_
+
+```json
+{
+  "context": {
+    "@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal": true
+  }
+}
+```
+
 * `@aws-cdk/aws-eks:nodegroupNameAttribute`
 
 When enabled, nodegroupName attribute of the provisioned EKS NodeGroup will not have the cluster name prefix.

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

@@ -565,6 +565,7 @@ pass in order to promote from the `PreProd` to the `Prod` environment:
 declare const pipeline: pipelines.CodePipeline;
 const preprod = new MyApplicationStage(this, 'PreProd');
 const prod = new MyApplicationStage(this, 'Prod');
+const topic = new sns.Topic(this, 'ChangeApprovalTopic');
 
 pipeline.addStage(preprod, {
   post: [
@@ -574,7 +575,12 @@ pipeline.addStage(preprod, {
   ],
 });
 pipeline.addStage(prod, {
-  pre: [new pipelines.ManualApprovalStep('PromoteToProd')],
+  pre: [new pipelines.ManualApprovalStep('PromoteToProd', {
+    //All options below are optional
+    comment: 'Please validate changes',
+    reviewUrl: 'https://my.webservice.com/',
+    notificationTopic: topic,
+  })],
 });
 ```
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-single-publisher.ts

@@ -0,0 +1,53 @@
+import * as path from 'path';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3_assets from 'aws-cdk-lib/aws-s3-assets';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import * as pipelines from 'aws-cdk-lib/pipelines';
+import { App, RemovalPolicy, Stack, StackProps, Stage, StageProps } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class PipelineStack extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const bucket = new s3.Bucket(this, 'Source', {
+      removalPolicy: RemovalPolicy.DESTROY,
+    });
+    const pipeline = new pipelines.CodePipeline(this, 'Pipeline', {
+      synth: new pipelines.ShellStep('Synth', {
+        input: pipelines.CodePipelineSource.s3(bucket, 'source.zip'),
+        commands: [
+          'npm ci',
+          'npm run build',
+          'npx cdk synth',
+        ],
+      }),
+      publishAssetsInParallel: false,
+    });
+
+    pipeline.addStage(new AppStage(this, 'Beta'));
+  }
+}
+
+class AppStage extends Stage {
+  constructor(scope: Construct, id: string, props?: StageProps) {
+    super(scope, id, props);
+
+    const stack = new Stack(this, 'Stack1');
+    new s3_assets.Asset(stack, 'Asset', {
+      path: path.join(__dirname, 'testhelpers/assets/test-file-asset.txt'),
+    });
+    new s3_assets.Asset(stack, 'Asset2', {
+      path: path.join(__dirname, 'testhelpers/assets/test-file-asset-two.txt'),
+    });
+
+    new sqs.Queue(stack, 'OtherQueue');
+  }
+}
+
+const app = new App();
+const stack = new PipelineStack(app, 'PipelineStackSinglePublisher');
+new IntegTest(app, 'PipelineStackSinglePublisher-integ', {
+  testCases: [stack],
+});

{konokenj_cdk_api_mcp_server-0.28.0.dist-info → konokenj_cdk_api_mcp_server-0.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.28.0
+Version: 0.30.0
 Summary: An MCP server provides AWS CDK API Reference
 Project-URL: Documentation, https://github.com/konokenj/cdk-api-mcp-server#readme
 Project-URL: Issues, https://github.com/konokenj/cdk-api-mcp-server/issues
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/konokenj.cdk-api-mcp-server.svg)](https://pypi.org/project/konokenj.cdk-api-mcp-server)
 
 <!-- DEP-VERSIONS-START -->
-[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.200.2-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
+[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.202.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---