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

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

@@ -14,10 +14,13 @@
   - [VPC Link](#vpc-link)
   - [Private Integration](#private-integration)
   - [Generating ARN for Execute API](#generating-arn-for-execute-api)
-  - [Access Logging](#access-logging)
 - [WebSocket API](#websocket-api)
   - [Manage Connections Permission](#manage-connections-permission)
   - [Managing access to WebSocket APIs](#managing-access-to-websocket-apis)
+  - [Usage Plan and API Keys](#usage-plan-and-api-keys)
+- [Common Config](#common-config)
+  - [Route Settings](#route-settings)
+  - [Access Logging](#access-logging)
 
 ## Introduction
 
@@ -374,65 +377,6 @@ const arn = api.arnForExecuteApi('GET', '/myApiPath', 'dev');
 - The 'ANY' method can be used for matching any HTTP methods not explicitly defined.
 - The function gracefully handles undefined parameters by using wildcards, making it flexible for various API configurations.
 
-## Access Logging
-
-You can turn on logging to write logs to CloudWatch Logs.
-Read more at [Configure logging for HTTP APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html)
-
-```ts
-import * as logs from 'aws-cdk-lib/aws-logs';
-
-declare const api: apigwv2.HttpApi;
-declare const logGroup: logs.LogGroup;
-
-const stage = new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(logGroup),
-  },
-});
-```
-
-The following code will generate the access log in the [CLF format](https://en.wikipedia.org/wiki/Common_Log_Format).
-
-```ts
-import * as apigw from 'aws-cdk-lib/aws-apigateway';
-import * as logs from 'aws-cdk-lib/aws-logs';
-
-declare const api: apigwv2.HttpApi;
-declare const logGroup: logs.LogGroup;
-
-const stage = new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(logGroup),
-    format: apigw.AccessLogFormat.clf(),
-  },
-});
-```
-
-You can also configure your own access log format by using the `AccessLogFormat.custom()` API.
-`AccessLogField` provides commonly used fields. The following code configures access log to contain.
-
-```ts
-import * as apigw from 'aws-cdk-lib/aws-apigateway';
-import * as logs from 'aws-cdk-lib/aws-logs';
-
-declare const api: apigwv2.HttpApi;
-declare const logGroup: logs.LogGroup;
-
-const stage = new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(logGroup),
-    format: apigw.AccessLogFormat.custom(
-      `${apigw.AccessLogField.contextRequestId()} ${apigw.AccessLogField.contextErrorMessage()} ${apigw.AccessLogField.contextErrorMessageString()}
-      ${apigw.AccessLogField.contextAuthorizerError()} ${apigw.AccessLogField.contextAuthorizerIntegrationStatus()}`
-    ),
-  },
-});
-```
-
 ## WebSocket API
 
 A WebSocket API in API Gateway is a collection of WebSocket routes that are integrated with backend HTTP endpoints,
@@ -523,6 +467,14 @@ const arn = api.arnForExecuteApiV2('$connect', 'dev');
 
 For a detailed explanation of this function, including usage and examples, please refer to the [Generating ARN for Execute API](#generating-arn-for-execute-api) section under HTTP API.
 
+To disable schema validation, set `disableSchemaValidation` to true.
+
+```ts
+new apigwv2.WebSocketApi(this, 'api', {
+  disableSchemaValidation: true,
+});
+```
+
 You can configure IP address type for the API endpoint using `ipAddressType` property.
 Valid values are `IPV4` (default) and `DUAL_STACK`.
 
@@ -569,6 +521,150 @@ const webSocketApi = new apigwv2.WebSocketApi(this, 'mywsapi',{
 });
 ```
 
+## Usage Plan and API Keys
+
+A usage plan specifies who can access one or more deployed WebSocket API stages, and the rate at which they can be accessed. The plan uses API keys to
+identify API clients and meters access to the associated API stages for each key. Usage plans also allow configuring throttling limits and quota limits that are
+enforced on individual client API keys.
+
+The following example shows how to create and associate a usage plan and an API key for WebSocket APIs:
+
+```ts
+const apiKey = new apigwv2.ApiKey(this, "ApiKey");
+
+const usagePlan = new apigwv2.UsagePlan(this, "UsagePlan", {
+  usagePlanName: "WebSocketUsagePlan",
+  throttle: {
+    rateLimit: 10,
+    burstLimit: 2
+  }
+});
+
+usagePlan.addApiKey(apiKey);
+```
+
+To associate a plan to a given WebSocketAPI stage:
+
+```ts
+const api = new apigwv2.WebSocketApi(this, 'my-api');
+const stage = new apigwv2.WebSocketStage(this, 'my-stage', {
+  webSocketApi: api,
+  stageName: 'dev',
+});
+
+const usagePlan = new apigwv2.UsagePlan(this, 'my-usage-plan', {
+  usagePlanName: 'Basic',
+});
+
+usagePlan.addApiStage({
+  api: api,
+  stage: stage,
+});
+```
+Existing usage plans can be imported into a CDK app using its id.
+
+```ts
+const usagePlan: apigwv2.IUsagePlan = apigwv2.UsagePlan.fromUsagePlanId(this, 'imported-usage-plan', '<usage-plan-id>');
+```
+
+The name and value of the API Key can be specified at creation; if not provided, a name and a value will be automatically generated by API Gateway.
+
+```ts
+// Auto-generated name and value
+const autoKey = new apigwv2.ApiKey(this, 'AutoKey');                                                                                                            
+                                                                                                                                                                     
+// Explicit name and value                                                                                                                                           
+const explicitKey = new apigwv2.ApiKey(this, 'ExplicitKey', {                                                                                                   
+  apiKeyName: 'MyWebSocketApiKey',                                                                                                                                   
+  value: 'MyApiKeyThatIsAtLeast20Characters',                                                                                                                        
+});         
+```
+
+Existing API keys can also be imported into a CDK app using its id.
+
+```ts
+const importedKey = apigwv2.ApiKey.fromApiKeyId(this, 'imported-key', '<api-key-id>');
+```
+
+The "grant" methods can be used to give prepackaged sets of permissions to other resources. The
+following code provides read permission to an API key.
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+
+const user = new iam.User(this, 'User');
+const apiKey = new apigwv2.ApiKey(this, 'ApiKey', {
+  customerId: 'test-customer',
+});
+apiKey.grantRead(user);
+```
+
+### Adding an API Key to an imported WebSocketApi
+
+API Keys for WebSocket APIs are associated through Usage Plans, not directly to stages. When you import a WebSocketApi, you need to create a Usage Plan that references the
+imported stage and then associate the API key with that Usage Plan.
+
+```ts
+declare const webSocketApi: apigwv2.IWebSocketApi;
+                                                                                                                                                                                   
+const importedStage = apigwv2.WebSocketStage.fromWebSocketStageAttributes(this, 'imported-stage', {                                                                           
+  stageName: 'myStage',                                                                                                                                                            
+  api: webSocketApi,                                                                                                                                                               
+});                                                                                                                                                                                
+                                                                                                                                                                                   
+const apiKey = new apigwv2.ApiKey(this, 'MyApiKey');                                                                                                                          
+                                                                                                                                                                                   
+const usagePlan = new apigwv2.UsagePlan(this, 'MyUsagePlan', {                                                                                                                
+  apiStages: [{ api: webSocketApi, stage: importedStage }],                                                                                                                        
+});                                                                                                                                                                                
+                                                                                                                                                                                   
+usagePlan.addApiKey(apiKey);
+```
+
+### Multiple API Keys
+
+It is possible to specify multiple API keys for a given Usage Plan, by calling `usagePlan.addApiKey()`.
+
+When using multiple API keys, you may need to ensure that the CloudFormation logical ids of the API keys remain consistent across deployments. You can set the logical id as part of the `addApiKey()` method
+
+```ts
+declare const usagePlan: apigwv2.UsagePlan;
+declare const apiKey: apigwv2.ApiKey;
+
+usagePlan.addApiKey(apiKey, {
+ overrideLogicalId: 'MyCustomLogicalId',
+});
+```
+
+### Rate Limited API Key
+
+In scenarios where you need to create a single api key and configure rate limiting for it, you can use `RateLimitedApiKey`.
+This construct lets you specify rate limiting properties which should be applied only to the api key being created.
+The API key created has the specified rate limits, such as quota and throttles, applied.
+
+The following example shows how to use a rate limited api key :
+
+```ts
+declare const api: apigwv2.WebSocketApi;
+declare const stage: apigwv2.WebSocketStage;
+
+const key = new apigwv2.RateLimitedApiKey(this, 'rate-limited-api-key', {
+  customerId: 'test-customer',
+  apiStages: [{
+    api: api,
+    stage: stage
+  }],
+  quota: {
+    limit: 10000,
+    period: apigwv2.Period.MONTH
+  },
+  throttle: {
+    rateLimit: 100,
+    burstLimit: 200
+  }
+});            
+```
+
 ## Common Config
 
 Common config for both HTTP API and WebSocket API
@@ -589,3 +685,71 @@ new apigwv2.HttpStage(this, 'Stage', {
   detailedMetricsEnabled: true,
 });
 ```
+
+### Access Logging
+
+You can turn on logging to write logs to CloudWatch Logs.
+Read more at Configure logging for [HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html) or [WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-api-logging.html)
+
+```ts
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+declare const httpApi: apigwv2.HttpApi;
+declare const webSocketApi : apigwv2.WebSocketApi;
+declare const logGroup: logs.LogGroup;
+
+new apigwv2.HttpStage(this, 'HttpStage', {
+  httpApi,
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+  },
+});
+
+new apigwv2.WebSocketStage(this, 'WebSocketStage', {
+  webSocketApi,
+  stageName: 'dev',
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+  },
+});
+```
+
+The following code will generate the access log in the [CLF format](https://en.wikipedia.org/wiki/Common_Log_Format).
+
+```ts
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+declare const api: apigwv2.HttpApi;
+declare const logGroup: logs.LogGroup;
+
+const stage = new apigwv2.HttpStage(this, 'Stage', {
+  httpApi: api,
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+    format: apigw.AccessLogFormat.clf(),
+  },
+});
+```
+
+You can also configure your own access log format by using the `AccessLogFormat.custom()` API.
+`AccessLogField` provides commonly used fields. The following code configures access log to contain.
+
+```ts
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+declare const api: apigwv2.HttpApi;
+declare const logGroup: logs.LogGroup;
+
+const stage = new apigwv2.HttpStage(this, 'Stage', {
+  httpApi: api,
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+    format: apigw.AccessLogFormat.custom(
+      `${apigw.AccessLogField.contextRequestId()} ${apigw.AccessLogField.contextErrorMessage()} ${apigw.AccessLogField.contextErrorMessageString()}
+      ${apigw.AccessLogField.contextAuthorizerError()} ${apigw.AccessLogField.contextAuthorizerIntegrationStatus()}`
+    ),
+  },
+});
+```

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

@@ -4,14 +4,13 @@ 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, 'DualStackHttpApiStack');
+const stack = new cdk.Stack(app, 'DualStackWebsocketApiStack');
 
-new apigw.HttpApi(stack, 'HttpApi', {
-  routeSelectionExpression: true,
+new apigw.WebSocketApi(stack, 'WebSocketApi', {
   ipAddressType: apigw.IpAddressType.DUAL_STACK,
 });
 
-new IntegTest(app, 'DualStackHttpApiInteg', {
+new IntegTest(app, 'DualStackWebsocketApiInteg', {
   testCases: [stack],
 });
 

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

@@ -6,11 +6,13 @@ 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.HttpApi(stack, 'HttpApi', {
-  routeSelectionExpression: true,
+new apigw.WebSocketApi(stack, 'WebSocketApi');
+
+new apigw.WebSocketApi(stack, 'WebSocketApiWithProps', {
+  disableSchemaValidation: true,
 });
 
-new IntegTest(app, 'http-api', {
+new IntegTest(app, 'web-socket-api', {
   testCases: [stack],
 });
 

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

@@ -6,13 +6,16 @@ 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-http-stage');
+const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-stage');
 
-const testLogGroup = new logs.LogGroup(stack, 'MyLogGroup');
+const logGroup = new logs.LogGroup(stack, 'MyLogGroup', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
 
-const httpApi = new apigwv2.HttpApi(stack, 'HttpApi', { createDefaultStage: false });
-new apigwv2.HttpStage(stack, 'HttpStageWithProperties', {
-  httpApi,
+const webSocketApi = new apigwv2.WebSocketApi(stack, 'WebSocketApi');
+new apigwv2.WebSocketStage(stack, 'WebSocketStage', {
+  webSocketApi,
+  stageName: 'dev',
   throttle: {
     rateLimit: 1000,
     burstLimit: 1000,
@@ -20,7 +23,7 @@ new apigwv2.HttpStage(stack, 'HttpStageWithProperties', {
   detailedMetricsEnabled: true,
   description: 'My Stage',
   accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(testLogGroup),
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
     format: apigw.AccessLogFormat.custom(JSON.stringify({
       extendedRequestId: apigw.AccessLogField.contextExtendedRequestId(),
       requestTime: apigw.AccessLogField.contextRequestTime(),
@@ -28,6 +31,6 @@ new apigwv2.HttpStage(stack, 'HttpStageWithProperties', {
   },
 });
 
-new IntegTest(app, 'aws-cdk-aws-apigatewayv2-http-stage-test', {
+new IntegTest(app, 'aws-cdk-aws-apigatewayv2-websocket-stage-test', {
   testCases: [stack],
 });

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

@@ -0,0 +1,80 @@
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import { WebSocketApi, WebSocketStage, UsagePlan, ApiKey, RateLimitedApiKey, Period } from 'aws-cdk-lib/aws-apigatewayv2';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-usage-plan');
+
+const webSocketApi = new WebSocketApi(stack, 'WebSocketApi');
+
+const webSocketStage = new WebSocketStage(stack, 'WebSocketStage', {
+  webSocketApi,
+  stageName: 'dev',
+});
+
+const apiKey = new ApiKey(stack, 'ApiKey', {
+  apiKeyName: 'my-api-key',
+  value: 'MyApiKeyThatIsAtLeast20Characters',
+  description: 'Basic api-key',
+  customerId: 'my-customer',
+  enabled: true,
+  generateDistinctId: true,
+});
+
+const usagePlan = new UsagePlan(stack, 'UsagePlan', {
+  apiStages: [{
+    api: webSocketApi,
+    stage: webSocketStage,
+  }],
+  description: 'Basic usage plan',
+  quota: {
+    limit: 10000,
+    offset: 1,
+    period: Period.MONTH,
+  },
+  throttle: {
+    rateLimit: 100,
+    burstLimit: 200,
+  },
+  usagePlanName: 'WebSocketUsagePlan',
+});
+
+const webSocketStage2 = new WebSocketStage(stack, 'WebSocketStage2', {
+  webSocketApi,
+  stageName: 'dev2',
+});
+
+usagePlan.addApiKey(apiKey);
+usagePlan.addApiStage({ api: webSocketApi, stage: webSocketStage2 });
+
+const webSocketStage3 = new WebSocketStage(stack, 'WebSocketStage3', {
+  webSocketApi,
+  stageName: 'dev3',
+});
+
+new RateLimitedApiKey(stack, 'RateLimitedApiKey', {
+  apiKeyName: 'my-rate-limited-api-key',
+  value: 'MyRateLimitedApiKeyThatIsAtLeast20Characters',
+  description: 'Basic rate-limited-api-key',
+  customerId: 'my-customer',
+  enabled: true,
+  generateDistinctId: true,
+  apiStages: [{
+    api: webSocketApi,
+    stage: webSocketStage3,
+  }],
+  quota: {
+    limit: 10000,
+    offset: 1,
+    period: Period.MONTH,
+  },
+  throttle: {
+    rateLimit: 100,
+    burstLimit: 200,
+  },
+});
+
+new integ.IntegTest(app, 'WebSocketUsagePlanInteg', {
+  testCases: [stack],
+});

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

@@ -1,46 +1,53 @@
 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 { HttpIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
+import { Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { WebSocketIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
 
-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 app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
 const stack = new cdk.Stack(app, 'IntegApiGatewayV2Iam');
 const user = new iam.User(stack, 'User');
 const userAccessKey = new iam.AccessKey(stack, 'UserAccess', {
   user,
 });
 
-const httpApi = new apigatewayv2.HttpApi(stack, 'HttpApi', {
-  defaultAuthorizer: new HttpIamAuthorizer(),
+const handler = new Function(stack, 'auth-function', {
+  runtime: Runtime.NODEJS_20_X,
+  code: Code.fromInline('exports.handler = () => {return true}'),
+  handler: 'index.handler',
 });
 
-const [fooRoute] = httpApi.addRoutes({
-  integration: new ExampleComIntegration('examplecom'),
-  path: '/foo',
+const webSocketApi = new apigatewayv2.WebSocketApi(stack, 'WebSocketApi', {
+  connectRouteOptions: {
+    integration: new WebSocketLambdaIntegration('WebSocketLambdaIntegration', handler),
+    authorizer: new WebSocketIamAuthorizer(),
+  },
 });
 
-fooRoute.grantInvoke(user);
-
-const [booksRoute] = httpApi.addRoutes({
-  integration: new ExampleComIntegration('examplecom'),
-  path: '/books/{book}',
+const arn = Stack.of(stack).formatArn({
+  service: 'execute-api',
+  resource: webSocketApi.apiId,
 });
 
-booksRoute.grantInvoke(user);
+user.attachInlinePolicy(new iam.Policy(stack, 'AllowInvoke', {
+  statements: [
+    new iam.PolicyStatement({
+      actions: ['execute-api:Invoke'],
+      effect: iam.Effect.ALLOW,
+      resources: [arn],
+    }),
+  ],
+}));
 
-new cdk.CfnOutput(stack, 'API', {
-  value: httpApi.url!,
+new integ.IntegTest(app, 'ApiGatewayV2WebSocketIamTest', {
+  testCases: [stack],
 });
 
 new cdk.CfnOutput(stack, 'TESTACCESSKEYID', {
@@ -55,15 +62,4 @@ new cdk.CfnOutput(stack, 'TESTREGION', {
   value: stack.region,
 });
 
-/*
- * 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"
- */
+app.synth();

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

@@ -20,7 +20,7 @@ const app = new App({
 const stack = new Stack(app, 'AuthorizerInteg');
 
 const authHandler = new lambda.Function(stack, 'auth-function', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: lambda.Code.fromAsset(path.join(__dirname, '..', 'auth-handler'), { exclude: ['*.ts'] }),
 });
@@ -43,7 +43,7 @@ const httpApiWithDefaultAuthorizer = new HttpApi(stack, 'MyHttpApiWithDefaultAut
 });
 
 const handler = new lambda.Function(stack, 'lambda', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: lambda.AssetCode.fromAsset(path.join(__dirname, '..', 'integ.lambda.handler'), { exclude: ['*.ts'] }),
 });

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

@@ -33,7 +33,7 @@ const httpApiWithDefaultAuthorizer = new HttpApi(stack, 'MyHttpApiWithDefaultAut
 });
 
 const handler = new lambda.Function(stack, 'lambda', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: lambda.AssetCode.fromAsset(path.join(__dirname, '..', 'integ.user-pool.handler'), { exclude: ['*.ts'] }),
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/README.md

@@ -47,6 +47,41 @@ httpApi.addRoutes({
 });
 ```
 
+#### Lambda Integration Permissions
+
+By default, creating a `HttpLambdaIntegration` will add a permission for API Gateway to invoke your AWS Lambda function, scoped to the specific route which uses the integration.
+
+If you reuse the same AWS Lambda function for many integrations, the AWS Lambda permission policy size can be exceeded by adding a separate policy statement for each route which invokes the AWS Lambda function. To avoid this, you can opt to scope permissions to any route on the API by setting `scopePermissionToRoute` to `false`, and this will ensure only a single policy statement is added to the AWS Lambda permission policy.
+
+```ts
+import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+
+declare const booksDefaultFn: lambda.Function;
+
+const httpApi = new apigwv2.HttpApi(this, 'HttpApi');
+
+const getBooksIntegration = new HttpLambdaIntegration('GetBooksIntegration', booksDefaultFn, {
+  scopePermissionToRoute: false,
+});
+const createBookIntegration = new HttpLambdaIntegration('CreateBookIntegration', booksDefaultFn, {
+  scopePermissionToRoute: false,
+});
+
+httpApi.addRoutes({
+  path: '/books',
+  methods: [ apigwv2.HttpMethod.GET ],
+  integration: getBooksIntegration,
+});
+
+httpApi.addRoutes({
+  path: '/books',
+  methods: [ apigwv2.HttpMethod.POST ],
+  integration: createBookIntegration,
+});
+```
+
+In the above example, a single permission is added, shared by both `getBookIntegration` and `createBookIntegration`.
+
 ### HTTP Proxy
 
 HTTP Proxy integrations enables connecting an HTTP API route to a publicly routable HTTP endpoint. When a client

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.add-subroute-integration.ts

@@ -15,7 +15,7 @@ const httpApi = new HttpApi(stack, 'test-apigwv2-add-subroute-integration');
 
 // Regular Lambda Function
 const lambdaHandler = new lambda.Function(stack, 'first-lambda-function', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { return { statusCode: 200, body: \'success-hit-first-lambda\' }; };'),
 });
@@ -23,7 +23,7 @@ const lambdaHandlerIntegration = new HttpLambdaIntegration('my-lambda-integratio
 
 // Lambda created with Function.fromFunctionAttributes()
 const secondLambdaHandler = new lambda.Function(stack, 'second-lambda-function', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { return { statusCode: 200, body: \'success-hit-second-lambda\' }; };'),
 });
@@ -35,8 +35,8 @@ const lambdaFromFunctionAttributesIntegration = new HttpLambdaIntegration('my-re
 
 // Lambda created with Function.fromFunctionName()
 const thirdLambdaName = 'third-lambda-function';
-new lambda.Function(stack, thirdLambdaName, {
-  runtime: lambda.Runtime.NODEJS_18_X,
+const thirdLambdaFunction = new lambda.Function(stack, thirdLambdaName, {
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { return { statusCode: 200, body: \'success-hit-third-lambda\' }; };'),
   functionName: thirdLambdaName,
@@ -83,6 +83,9 @@ httpApi.addRoutes({
   integration: lambdaFromFunctionNameIntegration,
 });
 
+httpApi.node.addDependency(secondLambdaHandler);
+httpApi.node.addDependency(thirdLambdaFunction);
+
 // Integ Test Assertions
 const integ = new IntegTest(app, 'Integ', { testCases: [stack] });