konokenj.cdk-api-mcp-server 0.49.0__py3-none-any.whl → 0.51.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.invoke-json-path.ts

@@ -0,0 +1,102 @@
+/// !cdk-integ aws-stepfunctions-tasks-http-invoke-json-path-integ
+
+import * as path from 'path';
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { password, username } from './my-lambda-handler';
+
+/*
+ * Creates an API Gateway instance with a GET method and mock integration,
+ * secured with basic auth. It then creates a matching Connection and uses it
+ * in a state machine with a task state to invoke the endpoint.
+ *
+ * Stack verification steps :
+ * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
+ * * aws stepfunctions describe-execution --execution-arn <execution-arn generated before> : should return status as SUCCEEDED
+ */
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-http-invoke-json-path-integ');
+
+const authorizerHandler = new lambda.NodejsFunction(stack, 'AuthorizerHandler', {
+  entry: path.resolve(__dirname, 'my-lambda-handler', 'index.ts'),
+  handler: 'handler',
+});
+
+const authorizer = new apigateway.TokenAuthorizer(stack, 'Authorizer', {
+  handler: authorizerHandler,
+  identitySource: 'method.request.header.Authorization',
+  resultsCacheTtl: cdk.Duration.seconds(0),
+});
+
+const api = new apigateway.RestApi(stack, 'IntegRestApi');
+
+api.root.addResource('test-json-path').addMethod(
+  'GET',
+  new apigateway.MockIntegration({
+    integrationResponses: [
+      {
+        statusCode: '200',
+        responseTemplates: {
+          'application/json': JSON.stringify({ message: 'Hello, tester!' }),
+        },
+      },
+    ],
+    passthroughBehavior: apigateway.PassthroughBehavior.NEVER,
+    requestTemplates: {
+      'application/json': '{ "statusCode": 200 }',
+    },
+  }),
+  {
+    authorizer,
+    methodResponses: [
+      {
+        statusCode: '200',
+      },
+    ],
+  },
+);
+
+const connection = new events.Connection(stack, 'Connection', {
+  authorization: events.Authorization.basic(username, cdk.SecretValue.unsafePlainText(password)),
+});
+
+const httpInvokeTask = new tasks.HttpInvoke(stack, 'Invoke HTTP Endpoint', {
+  apiRoot: api.urlForPath('/'),
+  apiEndpoint: sfn.TaskInput.fromJsonPathAt('$.endpointPath'),
+  connection,
+  method: sfn.TaskInput.fromText('GET'),
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition: httpInvokeTask,
+  timeout: cdk.Duration.seconds(30),
+});
+
+const testCase = new IntegTest(app, 'HttpInvokeTest', {
+  testCases: [stack],
+});
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+  input: JSON.stringify({
+    endpointPath: 'test-json-path',
+  }),
+});
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+
+// assert the results
+describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+}));
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary.ts

@@ -114,6 +114,7 @@ const selenium41 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_4_1
 const selenium50 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_5_0);
 const selenium51 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1);
 const selenium60 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_6_0);
+const selenium70 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_7_0);
 
 const test = new IntegTest(app, 'IntegCanaryTest', {
   testCases: [stack],
@@ -142,6 +143,7 @@ const test = new IntegTest(app, 'IntegCanaryTest', {
   selenium50,
   selenium51,
   selenium60,
+  selenium70,
 ].forEach((canary) => test.assertions
   .awsApiCall('Synthetics', 'getCanaryRuns', {
     Name: canary.canaryName,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.aws-custom-resource.ts

@@ -121,7 +121,7 @@ const app = new cdk.App({
   },
 });
 const testStack = new AwsCdkSdkJsStack(app, 'aws-cdk-sdk-js-v3', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
 });
 const integTest = new integ.IntegTest(app, 'AwsCustomResourceTest', {
   testCases: [testStack],

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.custom-resource-config-lambda-node-runtime.ts

@@ -29,7 +29,7 @@ new lambda.Function(stack, 'nonCrLambda', {
   runtime: lambda.Runtime.NODEJS_20_X,
 });
 
-CustomResourceConfig.of(app).addLambdaRuntime(lambda.Runtime.NODEJS_18_X);
+CustomResourceConfig.of(app).addLambdaRuntime(lambda.Runtime.NODEJS_20_X);
 
 new integ.IntegTest(app, 'integ-test-custom-resource-config-lambda-node-runtime', {
   testCases: [stack],

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.invoke-function-payload.ts

@@ -15,7 +15,7 @@ const stack = new cdk.Stack(app, 'AwsCustomResourceInvokePayloadStack');
 const fn = new lambda.Function(stack, 'Function', {
   code: lambda.Code.fromInline("exports.handler = async () => { return { statusCode: 200, body: 'Hello World' }; };"),
   handler: 'index.handler',
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
 });
 
 const testCr = new cr.AwsCustomResource(stack, 'ListLambdaFunctions', {

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

@@ -107,6 +107,9 @@ Flags come in three types:
 | [@aws-cdk/core:explicitStackTags](#aws-cdkcoreexplicitstacktags) | When enabled, stack tags need to be assigned explicitly on a Stack. | 2.205.0 | new default |
 | [@aws-cdk/aws-signer:signingProfileNamePassedToCfn](#aws-cdkaws-signersigningprofilenamepassedtocfn) | Pass signingProfileName to CfnSigningProfile | 2.212.0 | fix |
 | [@aws-cdk/aws-ecs-patterns:secGroupsDisablesImplicitOpenListener](#aws-cdkaws-ecs-patternssecgroupsdisablesimplicitopenlistener) | Disable implicit openListener when custom security groups are provided | 2.214.0 | new default |
+| [@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId](#aws-cdkaws-ecs-patternsuniquetargetgroupid) | When enabled, ECS patterns will generate unique target group IDs to prevent conflicts during load balancer replacement | 2.221.0 | fix |
+| [@aws-cdk/aws-stepfunctions-tasks:httpInvokeDynamicJsonPathEndpoint](#aws-cdkaws-stepfunctions-taskshttpinvokedynamicjsonpathendpoint) | When enabled, allows using a dynamic apiEndpoint with JSONPath format in HttpInvoke tasks. | 2.221.0 | fix |
+| [@aws-cdk/aws-elasticloadbalancingv2:networkLoadBalancerWithSecurityGroupByDefault](#aws-cdkaws-elasticloadbalancingv2networkloadbalancerwithsecuritygroupbydefault) | When enabled, Network Load Balancer will be created with a security group by default. | V2NEXT | new default |
 
 <!-- END table -->
 
@@ -197,7 +200,9 @@ The following json shows the current recommended set of flags, as `cdk init` wou
     "@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions": true,
     "@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway": true,
     "@aws-cdk/aws-s3:publicAccessBlockedByDefault": true,
-    "@aws-cdk/aws-lambda:useCdkManagedLogGroup": true
+    "@aws-cdk/aws-lambda:useCdkManagedLogGroup": true,
+    "@aws-cdk/aws-elasticloadbalancingv2:networkLoadBalancerWithSecurityGroupByDefault": true,
+    "@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId": true
   }
 }
 ```
@@ -245,6 +250,7 @@ are migrating a v1 CDK project to v2, explicitly set any of these flags which do
 | [@aws-cdk/core:aspectStabilization](#aws-cdkcoreaspectstabilization) | When enabled, a stabilization loop will be run when invoking Aspects during synthesis. | config |  | `false` | `true` |
 | [@aws-cdk/pipelines:reduceStageRoleTrustScope](#aws-cdkpipelinesreducestageroletrustscope) | Remove the root account principal from Stage addActions trust policy | new default |  | `false` | `true` |
 | [@aws-cdk/pipelines:reduceCrossAccountActionRoleTrustScope](#aws-cdkpipelinesreducecrossaccountactionroletrustscope) | When enabled, scopes down the trust policy for the cross-account action role | new default |  | `false` | `true` |
+| [@aws-cdk/aws-stepfunctions-tasks:httpInvokeDynamicJsonPathEndpoint](#aws-cdkaws-stepfunctions-taskshttpinvokedynamicjsonpathendpoint) | When enabled, allows using a dynamic apiEndpoint with JSONPath format in HttpInvoke tasks. | fix |  | `false` | `true` |
 
 <!-- END diff -->
 
@@ -2277,4 +2283,59 @@ override this behavior.
 **Compatibility with old behavior:** You can pass `openListener: true` explicitly to maintain the old behavior.
 
 
+### @aws-cdk/aws-ecs-patterns:uniqueTargetGroupId
+
+*When enabled, ECS patterns will generate unique target group IDs to prevent conflicts during load balancer replacement*
+
+Flag type: Backwards incompatible bugfix
+
+When this feature flag is enabled, ECS patterns will generate unique target group IDs that include
+both the load balancer type (public/private) and load balancer name. This prevents CloudFormation
+conflicts when switching between public and private load balancers or when changing load balancer names.
+
+Without this flag, target groups use generic IDs like 'ECS' which can cause conflicts when the
+underlying load balancer is replaced due to changes in internetFacing or loadBalancerName properties.
+
+This is a breaking change as it will cause target group replacement when the flag is enabled.
+
+
+| Since | Unset behaves like | Recommended value |
+| ----- | ----- | ----- |
+| (not in v1) |  |  |
+| 2.221.0 | `false` | `true` |
+
+
+### @aws-cdk/aws-stepfunctions-tasks:httpInvokeDynamicJsonPathEndpoint
+
+*When enabled, allows using a dynamic apiEndpoint with JSONPath format in HttpInvoke tasks.*
+
+Flag type: Backwards incompatible bugfix
+
+When this feature flag is enabled, the JSONPath apiEndpoint value will be resolved dynamically at runtime, while slightly increasing the size of the state machine definition.
+When disabled, the JSONPath apiEndpoint property will only support a static string value.
+
+
+| Since | Unset behaves like | Recommended value |
+| ----- | ----- | ----- |
+| (not in v1) |  |  |
+| 2.221.0 | `true` | `true` |
+
+
+### @aws-cdk/aws-elasticloadbalancingv2:networkLoadBalancerWithSecurityGroupByDefault
+
+*When enabled, Network Load Balancer will be created with a security group by default.*
+
+Flag type: New default behavior
+
+When this feature flag is enabled, Network Load Balancer will be created with a security group by default.
+
+
+| Since | Unset behaves like | Recommended value |
+| ----- | ----- | ----- |
+| (not in v1) |  |  |
+| V2NEXT | `false` | `true` |
+
+**Compatibility with old behavior:** Disable the feature flag to create Network Load Balancer without a security group by default.
+
+
 <!-- END details -->

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

@@ -763,6 +763,21 @@ _cdk.json_
 }
 ```
 
+* `@aws-cdk/aws-stepfunctions-tasks:httpInvokeDynamicJsonPathEndpoint`
+
+When this feature flag is enabled, the JSONPath apiEndpoint value will be resolved dynamically at runtime, while slightly increasing the size of the state machine definition.
+When disabled, the JSONPath apiEndpoint property will only support a static string value.
+
+_cdk.json
+
+```json
+{
+  "context": {
+    "@aws-cdk/aws-stepfunctions-tasks:httpInvokeDynamicJsonPathEndpoint": true
+  }
+}
+```
+
 * `@aws-cdk/aws-signer:signingProfileNamePassedToCfn`
 
 When this feature flag is enabled, the `signingProfileName` property is passed to the L1 `CfnSigningProfile` construct,
@@ -783,4 +798,20 @@ _cdk.json_
     "@aws-cdk/aws-signer:signingProfileNamePassedToCfn": true
   }
 }
-```
+```
+
+* `@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId`
+
+When enabled, ECS patterns will generate unique target group IDs that include the load balancer name and type (public/private). This prevents CloudFormation conflicts when switching between public and private load balancers.
+
+Without this flag, switching an ApplicationLoadBalancedFargateService from public to private (or vice versa) fails with "target group cannot be associated with more than one load balancer" error.
+
+_cdk.json_
+
+```json
+{
+  "context": {
+    "@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId": true
+  }
+}
+```

{konokenj_cdk_api_mcp_server-0.49.0.dist-info → konokenj_cdk_api_mcp_server-0.51.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.49.0
+Version: 0.51.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.219.0-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.221.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---