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

cdk_api_mcp_server/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Kenji Kono <konoken@amazon.co.jp>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.39.0"
+__version__ = "0.40.0"

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/custom-resource-handlers/README.md

@@ -1,20 +1,83 @@
-# Type definitions copied from 'aws-cdk-lib'
+# CDK Handler Framework
 
-`aws-cdk-lib` depends on this package; but this package depends on some
-types defined in `aws-cdk-lib`.
+The CDK handler framework is an internal framework used to code generate constructs that extend a lambda `Function`, lambda `SingletonFunction`, or core `CustomResourceProvider` construct and prohibit the user from directly configuring the `handler`, `runtime`, `code`, and `codeDirectory` properties.  In doing this, we are able to establish best practices, runtime enforcement, and consistency across all handlers we build and vend within the aws-cdk.
 
-This cyclic dependency leads to a non-executable build graph. In order to
-break the cycle, we're just copying some types over from `aws-cdk-lib`.
+## CDK Handler Framework Concepts
 
-I readily admit this is not a great long-term solution, but those types have
-been stable for years and are unlikely to change. The correct solution would
-probably be to externalize them into a separate package, but even the most
-simple solution of that accord would require bundling the types into
-`aws-cdk-lib` with `bundledDependencies` and that requires us writing a
-replacement for `npm pack`, because by default NPM will refuse to bundle
-`bundledDependencies` that have been symlinked into a local workspace (in fact,
-it will silently ignore them).
+This framework allows for the creation of three component types:
+1. `ComponentType.FUNCTION` - This is a wrapper around the lambda `Function` construct. It offers the same behavior and performance as a lambda `Function`, but it restricts the consumer from configuring the `handler`, `runtime`, and `code` properties.
+2. `ComponentType.SINGLETON_FUNCTION` - This is a wrapper around the lambda `SingletonFunction` construct. It offers the same behavior and performance as a lambda `SingletonFunction`, but it restricts the consumer from configuring the `handler`, `runtime`, and `code` properties.
+3. `ComponentType.CUSTOM_RESOURCE_PROVIDER` - This is a wrapper around the core `CustomResourceProvider` construct. It offers the same behavior and performance as a `CustomResourceProvider` and can be instantiated via the `getOrCreate` or `getOrCreateProvider` methods. This component restricts the consumer from configuring the `runtime` and `codeDirectory` properties.
 
-We can build our own replacement for `npm pack`, or we can do a little
-copy/paste.  I'm opting for the latter.
+Code generating one of these three component types requires adding the component properties to the [config](./config.ts) file by providing `ComponentProps`. The `ComponentProps` are responsible for code generating the specified `ComponentType` with the `handler`, `runtime`, `code`, and `codeDirectory` properties set internally. `ComponentProps` includes the following properties:
+- `type` - the framework component type to generate.
+- `sourceCode` - the source code that will be excuted by the framework component.
+- `runtime` - the runtime that is compatible with the framework component's source code. This is an optional property with a default node runtime that will be the latest available node runtime in the `Stack` deployment region. In general, you should not configure this property unless a `runtime` override is absolutely necessary.
+- `handler` - the name of the method with the source code that the framework component will call. This is an optional property and the default is `index.handler`.
+- `minifyAndBundle` - whether the source code should be minified and bundled. This an optional property and the default is `true`. This should only be set to `false` for python files or for typescript/javascript files with a require import.
 
+The [config](./config.ts) file is structured with the top level mapping to an aws-cdk module, i.e., aws-s3, aws-dynamodb, etc. Each service can contain one or more component modules. Component modules are containers for handler framework components and will be rendered as a code generated file. Each component module can contain one or more `ComponentProps` objects. The following example shows a more structural breakdown of how the [config](./config.ts) file is configured:
+
+```ts
+const config = {
+  'aws-s3': { // the aws-cdk-lib module
+    'replica-provider': [ // the component module
+      // handler framework component defined as a `ComponentProps` object
+      {
+        // the handler framework component type
+        type: ComponentType.FUNCTION,
+        // the source code that the component will use
+        sourceCode: path.resolve(__dirname, '..', 'aws-dynamodb', 'replica-handler', 'index.ts'),
+        // the handler in the source code that the component will execute
+        handler: 'index.onEventHandler',
+      },
+    ],
+  },
+  'aws-stepfunctions-tasks': {
+    // contains multiple component modules
+    'eval-nodejs-provider': [
+      {
+        type: ComponentType.SINGLETON_FUNCTION,
+        sourceCode: path.resolve(__dirname, '..', 'aws-stepfunctions-tasks', 'eval-nodejs-handler', 'index.ts'),
+      },
+    ],
+    'role-policy-provider': [
+      {
+        type: ComponentType.SINGLETON_FUNCTION,
+        sourceCode: path.resolve(__dirname, '..', 'aws-stepfunctions-tasks', 'role-policy-handler', 'index.py'),
+        runtime: Runtime.PYTHON_3_9,
+        // prevent minify and bundle since the source code is a python file
+        minifyAndBundle: false,
+      },
+    ],
+  },
+};
+```
+
+Code generation for the component modules is triggered when this package - `@aws-cdk/custom-resource-handlers` - is built. Importantly, this framework is also responsible for minifying and bundling the custom resource providers' source code and dependencies. A flag named `minifyAndBundle` can be configured as part of the `ComponentProps` to prevent minifying and bundling the source code for a specific provider. This flag is only needed for python files or for typescript/javascript files containing require imports.
+
+Once built, all generated code and bundled source code will be written to `@aws-cdk/custom-resource-handlers/dist`. The top level field in the [config](./config.ts) file defining individual aws-cdk modules will be used to create specific directories within `@aws-cdk/custom-resource-handlers/dist` and each component module will be a separate code generated file within these directories named `<component-module>.generated.ts`. As an example, the sample [config](./config.ts) file above would create the following file structure:
+
+|--- @aws-cdk
+|   |--- custom-resource-handlers
+|   |   |--- dist
+|   |   |   |--- aws-s3
+|   |   |   |   |--- replica-handler
+|   |   |   |   |   |--- index.js
+|   |   |   |   |--- replica-provider.generated.ts
+|   |   |   |--- aws-stepfunctions-tasks
+|   |   |   |   |--- eval-nodejs-handler
+|   |   |   |   |   |--- index.js
+|   |   |   |   |--- role-policy-handler
+|   |   |   |   |   |--- index.py
+|   |   |   |   |--- eval-nodejs-provider.generated.ts
+|   |   |   |   |--- role-policy-provider.generated.ts
+
+The code generated handler framework components are consumable from `aws-cdk-lib/custom-resource-handlers/dist` once `aws-cdk-lib` is built. The file structure of `aws-cdk-lib/custom-resource-handlers/dist` will have the same structure as `@aws-cdk/custom-resource-handlers/dist` with the exception of `core`. To prevent circular dependencies, all handler framework components defined in `core`and any associated source code will be consumable from `aws-cdk-lib/core/dist/core`.
+
+## Creating a Handler Framework Component
+
+Creating a new handler framework component involves three steps:
+1. Add the source code to `@aws-cdk/custom-resource-handlers/lib/<aws-cdk-lib-module>`
+2. Update the [config](./config.ts) file by specifying all required `ComponentProps`.
+3. At this point you can directly build `@aws-cdk/custom-resource-handlers` with `yarn build` to view the generated component in `@aws-cdk/custom-resource-handlers/dist`. Alternatively, you can build `aws-cdk-lib` with `npx lerna run build --scope=aws-cdk-lib --skip-nx-cache` to make the generated component available for use within `aws-cdk-lib`

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-dualstack.ts

@@ -4,13 +4,14 @@ import * as cdk from 'aws-cdk-lib';
 import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 
 const app = new cdk.App();
-const stack = new cdk.Stack(app, 'DualStackWebsocketApiStack');
+const stack = new cdk.Stack(app, 'DualStackHttpApiStack');
 
-new apigw.WebSocketApi(stack, 'WebSocketApi', {
+new apigw.HttpApi(stack, 'HttpApi', {
+  routeSelectionExpression: true,
   ipAddressType: apigw.IpAddressType.DUAL_STACK,
 });
 
-new IntegTest(app, 'DualStackWebsocketApiInteg', {
+new IntegTest(app, 'DualStackHttpApiInteg', {
   testCases: [stack],
 });
 

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

@@ -6,9 +6,11 @@ import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2');
 
-new apigw.WebSocketApi(stack, 'WebSocketApi');
+new apigw.HttpApi(stack, 'HttpApi', {
+  routeSelectionExpression: true,
+});
 
-new IntegTest(app, 'web-socket-api', {
+new IntegTest(app, 'http-api', {
   testCases: [stack],
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.stage.ts

@@ -1,20 +1,33 @@
 #!/usr/bin/env node
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as cdk from 'aws-cdk-lib';
-import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
 
 const app = new cdk.App();
-const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-stage');
+const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-http-stage');
 
-const webSocketApi = new apigw.WebSocketApi(stack, 'WebSocketApi');
-new apigw.WebSocketStage(stack, 'WebSocketStage', {
-  webSocketApi,
-  stageName: 'dev',
+const testLogGroup = new logs.LogGroup(stack, 'MyLogGroup');
+
+const httpApi = new apigwv2.HttpApi(stack, 'HttpApi', { createDefaultStage: false });
+new apigwv2.HttpStage(stack, 'HttpStageWithProperties', {
+  httpApi,
   throttle: {
     rateLimit: 1000,
     burstLimit: 1000,
   },
   detailedMetricsEnabled: true,
   description: 'My Stage',
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(testLogGroup),
+    format: apigw.AccessLogFormat.custom(JSON.stringify({
+      extendedRequestId: apigw.AccessLogField.contextExtendedRequestId(),
+      requestTime: apigw.AccessLogField.contextRequestTime(),
+    })),
+  },
 });
 
-app.synth();
+new IntegTest(app, 'aws-cdk-aws-apigatewayv2-http-stage-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-authorizers/integ.iam.ts

@@ -1,53 +1,46 @@
 import * as apigatewayv2 from 'aws-cdk-lib/aws-apigatewayv2';
-import { WebSocketLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
 import * as iam from 'aws-cdk-lib/aws-iam';
-import { Code, Function, Runtime } from 'aws-cdk-lib/aws-lambda';
 import * as cdk from 'aws-cdk-lib';
-import { Stack } from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
-import { WebSocketIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
+import { HttpIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-  },
-});
+class ExampleComIntegration extends apigatewayv2.HttpRouteIntegration {
+  public bind(): apigatewayv2.HttpRouteIntegrationConfig {
+    return {
+      type: apigatewayv2.HttpIntegrationType.HTTP_PROXY,
+      payloadFormatVersion: apigatewayv2.PayloadFormatVersion.VERSION_1_0,
+      method: apigatewayv2.HttpMethod.GET,
+      uri: 'https://www.example.com/',
+    };
+  }
+}
+
+const app = new cdk.App();
 const stack = new cdk.Stack(app, 'IntegApiGatewayV2Iam');
 const user = new iam.User(stack, 'User');
 const userAccessKey = new iam.AccessKey(stack, 'UserAccess', {
   user,
 });
 
-const handler = new Function(stack, 'auth-function', {
-  runtime: Runtime.NODEJS_18_X,
-  code: Code.fromInline('exports.handler = () => {return true}'),
-  handler: 'index.handler',
+const httpApi = new apigatewayv2.HttpApi(stack, 'HttpApi', {
+  defaultAuthorizer: new HttpIamAuthorizer(),
 });
 
-const webSocketApi = new apigatewayv2.WebSocketApi(stack, 'WebSocketApi', {
-  connectRouteOptions: {
-    integration: new WebSocketLambdaIntegration('WebSocketLambdaIntegration', handler),
-    authorizer: new WebSocketIamAuthorizer(),
-  },
+const [fooRoute] = httpApi.addRoutes({
+  integration: new ExampleComIntegration('examplecom'),
+  path: '/foo',
 });
 
-const arn = Stack.of(stack).formatArn({
-  service: 'execute-api',
-  resource: webSocketApi.apiId,
+fooRoute.grantInvoke(user);
+
+const [booksRoute] = httpApi.addRoutes({
+  integration: new ExampleComIntegration('examplecom'),
+  path: '/books/{book}',
 });
 
-user.attachInlinePolicy(new iam.Policy(stack, 'AllowInvoke', {
-  statements: [
-    new iam.PolicyStatement({
-      actions: ['execute-api:Invoke'],
-      effect: iam.Effect.ALLOW,
-      resources: [arn],
-    }),
-  ],
-}));
+booksRoute.grantInvoke(user);
 
-new integ.IntegTest(app, 'ApiGatewayV2WebSocketIamTest', {
-  testCases: [stack],
+new cdk.CfnOutput(stack, 'API', {
+  value: httpApi.url!,
 });
 
 new cdk.CfnOutput(stack, 'TESTACCESSKEYID', {
@@ -62,4 +55,15 @@ new cdk.CfnOutput(stack, 'TESTREGION', {
   value: stack.region,
 });
 
-app.synth();
+/*
+ * Stack verification steps:
+ * * Get cURL version 7.75.0 or later so you can use the --aws-sigv4 option
+ * * Curl <url>/foo without sigv4 and expect a 403
+ * * Curl <url>/books/something without sigv4 and expect a 403
+ * * Curl <url>/foo with sigv4 from the authorized user and expect 200
+ * * Curl <url>/books/something with sigv4 from the authorized user and expect 200
+ *
+ * Reference:
+ * * Using cURL 7.75.0 or later via the official docker image: docker run --rm curlimages/curl -s -o/dev/null -w"%{http_code}" <url>
+ * * Args to enable sigv4 with authorized credentials: --user "$TESTACCESSKEYID:$TESTSECRETACCESSKEY" --aws-sigv4 "aws:amz:$TESTREGION:execute-api"
+ */

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.sqs.ts

@@ -1,72 +1,85 @@
-import { HttpMethod, PassthroughBehavior, WebSocketApi, WebSocketStage } from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
-import * as iam from 'aws-cdk-lib/aws-iam';
-import { App, Stack, Aws } from 'aws-cdk-lib';
-import { WebSocketAwsIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
-import { IntegTest } from '@aws-cdk/integ-tests-alpha';
-
-/*
- * Stack verification steps:
- * 1. Verify manually that the integration has type "AWS"
- */
+import { App, Stack } from 'aws-cdk-lib';
+import { HttpSqsIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import * as integ from '@aws-cdk/integ-tests-alpha';
 
 const app = new App();
-const stack = new Stack(app, 'integ-aws-websocket-sqs-integration');
+const stack = new Stack(app, 'sqs-integration');
 
-const sqsMessageQueue = new sqs.Queue(stack, 'MessageSQSQueue', {
-  fifo: true,
-  queueName: 'MessageSQSQueue.fifo',
-});
+const queue = new sqs.Queue(stack, 'Queue');
 
-// API Gateway WebSocket API
-const webSocketApi = new WebSocketApi(stack, 'webSocketApi', {
-  description: 'Send websocket data to SQS which is then processed by a Lambda 2',
-  routeSelectionExpression: '$request.body.action',
+const httpApi = new apigwv2.HttpApi(stack, 'Api');
+httpApi.addRoutes({
+  path: '/default',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('defaultIntegration', {
+    queue,
+  }),
 });
-
-// Optionally, create a WebSocket stage
-new WebSocketStage(stack, 'DevStage', {
-  webSocketApi: webSocketApi,
-  stageName: 'dev',
-  autoDeploy: true,
+httpApi.addRoutes({
+  path: '/send-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('sendMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_SEND_MESSAGE,
+  }),
 });
-
-// IAM Role for API Gateway
-const webSocketApiRole = new iam.Role(stack, 'webSocketApiRole', {
-  assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),
+httpApi.addRoutes({
+  path: '/receive-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('receiveMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_RECEIVE_MESSAGE,
+  }),
 });
-
-webSocketApiRole.addToPolicy(
-  new iam.PolicyStatement({
-    actions: ['sqs:SendMessage'],
-    effect: iam.Effect.ALLOW,
-    resources: [sqsMessageQueue.queueArn],
+httpApi.addRoutes({
+  path: '/delete-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('deleteMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_DELETE_MESSAGE,
   }),
-);
-
-webSocketApi.addRoute('$default', {
-  integration: new WebSocketAwsIntegration('SQSSendMessage', {
-    integrationUri: `arn:aws:apigateway:${Aws.REGION}:sqs:path/${Aws.ACCOUNT_ID}/${sqsMessageQueue.queueName}`,
-    integrationMethod: HttpMethod.POST,
-    credentialsRole: webSocketApiRole,
-    passthroughBehavior: PassthroughBehavior.NEVER,
-    templateSelectionExpression: '\\$default',
-    requestTemplates: {
-      $default: 'Action=SendMessage&MessageGroupId=$input.path(\'$.MessageGroupId\')&MessageDeduplicationId=$context.requestId&MessageAttribute.1.Name=connectionId&MessageAttribute.1.Value.StringValue=$context.connectionId&MessageAttribute.1.Value.DataType=String&MessageAttribute.2.Name=requestId&MessageAttribute.2.Value.StringValue=$context.requestId&MessageAttribute.2.Value.DataType=String&MessageBody=$input.json(\'$\')',
-    },
-    requestParameters: {
-      'integration.request.header.Content-Type': '\'application/x-www-form-urlencoded\'',
-    },
+});
+httpApi.addRoutes({
+  path: '/purge-queue',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('purgeQueueIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_PURGE_QUEUE,
   }),
 });
 
-new IntegTest(app, 'apigatewayv2-aws-integration-sqs-integ-test', {
+const integTest = new integ.IntegTest(app, 'SqsIntegrationIntegTest', {
   testCases: [stack],
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: true,
-      },
-    },
-  },
 });
+
+const defaultAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/default`, {
+    body: JSON.stringify({ MessageBody: 'Hello World!' }),
+    method: 'POST',
+  },
+);
+defaultAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+
+const sendMessageAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/send-message`, {
+    body: JSON.stringify({ MessageBody: 'Hello World!' }),
+    method: 'POST',
+  },
+);
+sendMessageAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+
+const receiveMessageAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/receive-message`, {
+    method: 'POST',
+  },
+);
+receiveMessageAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+
+const purgeQueueAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/purge-queue`, {
+    method: 'POST',
+  },
+);
+purgeQueueAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));

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

@@ -531,7 +531,7 @@ about allowing connections between resources backed by instances.
 ## Max Instance Lifetime
 
 To enable the max instance lifetime support, specify `maxInstanceLifetime` property
-for the `AutoscalingGroup` resource. The value must be between 7 and 365 days(inclusive).
+for the `AutoscalingGroup` resource. The value must be between 1 and 365 days(inclusive).
 To clear a previously set value, leave this property undefined.
 
 ## Instance Monitoring

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codedeploy/integ.deployment-config.ts

@@ -2,17 +2,28 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codedeploy from 'aws-cdk-lib/aws-codedeploy';
 
-const app = new cdk.App();
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-config');
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda-config');
 
-new codedeploy.EcsDeploymentConfig(stack, 'LinearConfig', {
+new codedeploy.LambdaDeploymentConfig(stack, 'LinearConfig', {
   trafficRouting: codedeploy.TrafficRouting.timeBasedLinear({
     interval: cdk.Duration.minutes(1),
     percentage: 5,
   }),
 });
 
-new integ.IntegTest(app, 'EcsDeploymentConfigTest', {
+new codedeploy.CustomLambdaDeploymentConfig(stack, 'CustomConfig', {
+  interval: cdk.Duration.minutes(1),
+  percentage: 5,
+  type: cdk.aws_codedeploy.CustomLambdaDeploymentConfigType.LINEAR,
+  deploymentConfigName: 'hello',
+});
+
+new integ.IntegTest(app, 'LambdaDeploymentConfigTest', {
   testCases: [stack],
 });